py_worksheet_clustering/py_worksheet_clustering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e5dead7fc7680eb07223a7d6346bbd79",
     "grade": false,
     "grade_id": "cell-4e13769a31cd3f6c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Worksheet 10 - Clustering\n",
    "\n",
    "### Lecture and Tutorial Learning Goals:\n",
    "\n",
    "After completing this week's lecture and tutorial work, you will be able to:\n",
    "\n",
    "* Describe a case where clustering would be an appropriate tool, and what insight it would bring from the data.\n",
    "* Explain the k-means clustering algorithm.\n",
    "* Interpret the output of a k-means cluster analysis.\n",
    "* Perform k-means clustering in Python using `scikit-learn`\n",
    "* Visualize the output of k-means clustering in Python using a coloured scatter plot \n",
    "* Identify when it is necessary to scale variables before clustering and do this using Python\n",
    "* Use the elbow method to choose the number of clusters for k-means\n",
    "* Describe advantages, limitations and assumptions of the kmeans clustering algorithm.\n",
    "\n",
    "This worksheet covers parts of [Chapter 9](https://python.datasciencebook.ca/clustering) of the online textbook. You should read this chapter before attempting this assignment. Any place you see `___`, you must fill in the function, variable, or data to complete the code. Substitute the `raise NotImplementedError` with your completed code and answers then proceed to run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dfe7be68b97f1b6ad4e404043f05a976",
     "grade": false,
     "grade_id": "cell-692894fcc96c281b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "### Run this cell before continuing.\n",
    "import altair as alt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.compose import make_column_transformer\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn import set_config\n",
    "\n",
    "# Simplify working with large datasets in Altair\n",
    "alt.data_transformers.disable_max_rows()\n",
    "\n",
    "# Output dataframes instead of arrays\n",
    "set_config(transform_output=\"pandas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8a168dfd7621ff711e52ec453e00df98",
     "grade": false,
     "grade_id": "cell-353d89a0c34b681a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 0.0** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "In which of the following scenarios would clustering methods likely be appropriate?\n",
    "\n",
    "A. Identifying sub-groups of houses according to their house type, value, and geographical location\n",
    "\n",
    "B. Predicting whether a given user will click on an ad on a website\n",
    "\n",
    "C. Segmenting customers based on their preferences to target advertising\n",
    "\n",
    "D. Both A. and B.\n",
    "\n",
    "E. Both A. and C. \n",
    "\n",
    "*Assign your answer to an object called `answer0_0`. Your answer should be a single upper-case character surrounded by quotes.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c5e9fbea61cf802b845c6207b5fc087f",
     "grade": false,
     "grade_id": "cell-5dbd8978b6a0a44c",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3630b25ce3d96a184ec0eeb91af3ee37",
     "grade": true,
     "grade_id": "cell-13f71e2d909892e4",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer0_0)).encode(\"utf-8\")+b\"3eeb15eedcd9f462\").hexdigest() == \"a0ffd2da4d5937f079f681b1586960a25c672270\", \"type of answer0_0 is not str. answer0_0 should be an str\"\n",
    "assert sha1(str(len(answer0_0)).encode(\"utf-8\")+b\"3eeb15eedcd9f462\").hexdigest() == \"541d08881c17f6c643bb15dbaa5223f7342aeac2\", \"length of answer0_0 is not correct\"\n",
    "assert sha1(str(answer0_0.lower()).encode(\"utf-8\")+b\"3eeb15eedcd9f462\").hexdigest() == \"1a7c272141e5753d9e8db2f69618f16fb23380c1\", \"value of answer0_0 is not correct\"\n",
    "assert sha1(str(answer0_0).encode(\"utf-8\")+b\"3eeb15eedcd9f462\").hexdigest() == \"d243c897dbd8534ae3bb69d3dd1d285464217b70\", \"correct string value of answer0_0 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0053e7f45ff18daa0120cb0401913788",
     "grade": false,
     "grade_id": "cell-ba0b77eef45527d2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 0.1** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "Which step in the description of the Kmeans algorithm below is incorrect?\n",
    "\n",
    "0. Choose the number of clusters\n",
    "\n",
    "1. Randomly assign each of the points to one of the clusters\n",
    "\n",
    "2. Calculate the position for the cluster centre (centroid) for each of the clusters (this is the middle of the points in the cluster, as measured by straight-line distance)\n",
    "\n",
    "3. Re-assign each of the points to the cluster who's centroid is furthest from that point\n",
    "\n",
    "4. Repeat steps 1 - 2 until the cluster centroids don't change very much between iterations\n",
    "\n",
    "*Assign your answer to an object called `answer0_1`. Your answer should be a single numerical character surrounded by quotes.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "521a09779823482304c1dea7e9f61e79",
     "grade": false,
     "grade_id": "cell-4c524a7e35eb23bb",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e684aaca00f07b906e3429b021aa6837",
     "grade": true,
     "grade_id": "cell-4ac8aab3f8626a82",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer0_1)).encode(\"utf-8\")+b\"20ffccbe34ae31e3\").hexdigest() == \"8612140753158dc889b1702c6ebbec3c364190b4\", \"type of answer0_1 is not str. answer0_1 should be an str\"\n",
    "assert sha1(str(len(answer0_1)).encode(\"utf-8\")+b\"20ffccbe34ae31e3\").hexdigest() == \"3d894f0bad1c46f50afddd76185b6ff0194d94d1\", \"length of answer0_1 is not correct\"\n",
    "assert sha1(str(answer0_1.lower()).encode(\"utf-8\")+b\"20ffccbe34ae31e3\").hexdigest() == \"f52c49617956c20fde6a4279ba739a747b09198f\", \"value of answer0_1 is not correct\"\n",
    "assert sha1(str(answer0_1).encode(\"utf-8\")+b\"20ffccbe34ae31e3\").hexdigest() == \"f52c49617956c20fde6a4279ba739a747b09198f\", \"correct string value of answer0_1 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a82fcf4d840b36c74f8dd08e52acece2",
     "grade": false,
     "grade_id": "cell-3b5cd50b0518b4d1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Hoppy Craft Beer\n",
    "\n",
    "Craft beer is a strong market in Canada and the US, and is expanding to other countries as well. If you wanted to get into the craft beer brewing market, you might want to better understand the product landscape. One popular craft beer product is hopped craft beer. Breweries create/label many different kinds of hopped craft beer, but how many different kinds of hopped craft beer are there really when you look at the chemical properties instead of the human labels? \n",
    "\n",
    "We will start to look at the question by looking at a [craft beer data set from Kaggle](https://www.kaggle.com/nickhould/craft-cans#beers.csv). In this data set, we will use the alcoholic content by volume  (`abv` column) and the International bittering units (`ibu` column) as variables to try to cluster the beers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ad257945a043aa22f305f516a9eceb42",
     "grade": false,
     "grade_id": "cell-97bd85f0599a8d9d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.0** \n",
    "<br> {points: 1}\n",
    "\n",
    "Read in the `beers.csv` data using `pd.read_csv` and assign it to an object called `beer`. The data is located within the `data/` folder. \n",
    "\n",
    "*Assign your dataframe answer to an object called `beer`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fdb3daf32f1f64c3d9a4aef563814ddf",
     "grade": false,
     "grade_id": "cell-b15ec51dce472f41",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "525f956f8a953782dd019e382fdd5a23",
     "grade": true,
     "grade_id": "cell-7afc19b7bc727fc8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer is None)).encode(\"utf-8\")+b\"171dedfd70e35dcd\").hexdigest() == \"0f8f32ebbc48f136e650852c5214083312be9636\", \"type of beer is None is not bool. beer is None should be a bool\"\n",
    "assert sha1(str(beer is None).encode(\"utf-8\")+b\"171dedfd70e35dcd\").hexdigest() == \"36cd5c4ed784cb290038bd742962c1170e35ffd2\", \"boolean value of beer is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer)).encode(\"utf-8\")+b\"30a4af9d11f5329a\").hexdigest() == \"09d0523581645d309e703288494e1e0fd76291e3\", \"type of type(beer) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer.shape)).encode(\"utf-8\")+b\"ea4714df34242b77\").hexdigest() == \"5ea651e1952c9fa4722153ee520e8c2174ad871f\", \"type of beer.shape is not tuple. beer.shape should be a tuple\"\n",
    "assert sha1(str(len(beer.shape)).encode(\"utf-8\")+b\"ea4714df34242b77\").hexdigest() == \"40afbebe32c86917d6580b431d233f69b34cd592\", \"length of beer.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, beer.shape))).encode(\"utf-8\")+b\"ea4714df34242b77\").hexdigest() == \"e0bd91be10d9be5c461142ba8484cc625d420727\", \"values of beer.shape are not correct\"\n",
    "assert sha1(str(beer.shape).encode(\"utf-8\")+b\"ea4714df34242b77\").hexdigest() == \"6c1a96e6f0db2617b0dd2cec44c9c66a4f5df69b\", \"order of elements of beer.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"abv\" in beer.columns)).encode(\"utf-8\")+b\"e64a84809b832807\").hexdigest() == \"e9138a87025ed338402d1dcc11a984e4cfe5f72c\", \"type of \\\"abv\\\" in beer.columns is not bool. \\\"abv\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"abv\" in beer.columns).encode(\"utf-8\")+b\"e64a84809b832807\").hexdigest() == \"0d2ab08d06b1027ab10114744b0c5b6f6b687b50\", \"boolean value of \\\"abv\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"ibu\" in beer.columns)).encode(\"utf-8\")+b\"143e2de13a8e48bf\").hexdigest() == \"793eca8e270c8ab91735a8dddef8fdf55ca1da6b\", \"type of \\\"ibu\\\" in beer.columns is not bool. \\\"ibu\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"ibu\" in beer.columns).encode(\"utf-8\")+b\"143e2de13a8e48bf\").hexdigest() == \"51a9a8dcef69129a7450a1c137adeb4da60cb91e\", \"boolean value of \\\"ibu\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"id\" in beer.columns)).encode(\"utf-8\")+b\"41df0b70c943515b\").hexdigest() == \"39e7df2e458cc0fb3c865ca7b3c5c9ffea02a4f7\", \"type of \\\"id\\\" in beer.columns is not bool. \\\"id\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"id\" in beer.columns).encode(\"utf-8\")+b\"41df0b70c943515b\").hexdigest() == \"1a1c9a9c48ed5017310ba7d8e2a9e8feaaa91a01\", \"boolean value of \\\"id\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"name\" in beer.columns)).encode(\"utf-8\")+b\"c2238676b39c8e6a\").hexdigest() == \"befa123d005f05119cce76400ab391cf69fb4549\", \"type of \\\"name\\\" in beer.columns is not bool. \\\"name\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"name\" in beer.columns).encode(\"utf-8\")+b\"c2238676b39c8e6a\").hexdigest() == \"321153df8aef0ad4ec6a5ad64f9b558cb48244d0\", \"boolean value of \\\"name\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"style\" in beer.columns)).encode(\"utf-8\")+b\"88860a5e9385c880\").hexdigest() == \"c9a7cd1600eb4cdda03589af9796cfa79d8f38f0\", \"type of \\\"style\\\" in beer.columns is not bool. \\\"style\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"style\" in beer.columns).encode(\"utf-8\")+b\"88860a5e9385c880\").hexdigest() == \"de3661446b2e6440dbd4c567feeb4a56de102cb1\", \"boolean value of \\\"style\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"brewery_id\" in beer.columns)).encode(\"utf-8\")+b\"e46303b79a057d07\").hexdigest() == \"6c6124274453e335b5826b6b91f72554c968f42f\", \"type of \\\"brewery_id\\\" in beer.columns is not bool. \\\"brewery_id\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"brewery_id\" in beer.columns).encode(\"utf-8\")+b\"e46303b79a057d07\").hexdigest() == \"88ec9bfa6c66916ea1ccda6a1165783399af3fb3\", \"boolean value of \\\"brewery_id\\\" in beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"ounces\" in beer.columns)).encode(\"utf-8\")+b\"6da09585784639d9\").hexdigest() == \"7ceb76c8f8d3af8c0915a06cf4898893d89817e9\", \"type of \\\"ounces\\\" in beer.columns is not bool. \\\"ounces\\\" in beer.columns should be a bool\"\n",
    "assert sha1(str(\"ounces\" in beer.columns).encode(\"utf-8\")+b\"6da09585784639d9\").hexdigest() == \"e3c893e9d70a02e585735539cc38125dae9707df\", \"boolean value of \\\"ounces\\\" in beer.columns is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "98e3ca3260da4165ed38c279f6bf3145",
     "grade": false,
     "grade_id": "cell-eaefcd87f19fdf96",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.1**\n",
    "<br> {points: 1}\n",
    "\n",
    "Let's start by visualizing the variables we are going to use in our cluster analysis as a scatter plot. Put `ibu` on the horizontal axis, and `abv` on the vertical axis. Name the plot object `beer_scatter`. \n",
    "\n",
    "*Remember to follow the best visualization practices, including adding human-readable labels to your plot.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bf829402ecd0680df98e706fd404f8da",
     "grade": false,
     "grade_id": "cell-685ad4bcdc753cbf",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_scatter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "92c4117f4a80c1b494683b24c5d6edfc",
     "grade": true,
     "grade_id": "cell-a38c885f90300a1b",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_scatter is None)).encode(\"utf-8\")+b\"8d13c24947350405\").hexdigest() == \"9518c778b4bd38073e46ef4ca66519c14224b25d\", \"type of beer_scatter is None is not bool. beer_scatter is None should be a bool\"\n",
    "assert sha1(str(beer_scatter is None).encode(\"utf-8\")+b\"8d13c24947350405\").hexdigest() == \"6069e27bc18c9b95672fc5746741d81bccfbc138\", \"boolean value of beer_scatter is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_scatter.encoding.x['shorthand'])).encode(\"utf-8\")+b\"0431a439b7043a32\").hexdigest() == \"ff15565a57519a46b3dc5aa0c28a16f7e88b48e1\", \"type of beer_scatter.encoding.x['shorthand'] is not str. beer_scatter.encoding.x['shorthand'] should be an str\"\n",
    "assert sha1(str(len(beer_scatter.encoding.x['shorthand'])).encode(\"utf-8\")+b\"0431a439b7043a32\").hexdigest() == \"816c38733ac115a5344727a74af0c5ff6813893b\", \"length of beer_scatter.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(beer_scatter.encoding.x['shorthand'].lower()).encode(\"utf-8\")+b\"0431a439b7043a32\").hexdigest() == \"643372288bfa3b71a0184d7e107630e9bd5128c4\", \"value of beer_scatter.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(beer_scatter.encoding.x['shorthand']).encode(\"utf-8\")+b\"0431a439b7043a32\").hexdigest() == \"643372288bfa3b71a0184d7e107630e9bd5128c4\", \"correct string value of beer_scatter.encoding.x['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(beer_scatter.encoding.y['shorthand'])).encode(\"utf-8\")+b\"efb982be9f00f620\").hexdigest() == \"00bc95af591887d9b9a76b4b6a2a7b4c753148a2\", \"type of beer_scatter.encoding.y['shorthand'] is not str. beer_scatter.encoding.y['shorthand'] should be an str\"\n",
    "assert sha1(str(len(beer_scatter.encoding.y['shorthand'])).encode(\"utf-8\")+b\"efb982be9f00f620\").hexdigest() == \"f0de65c1100220afc7a87063a6cabfb87705db96\", \"length of beer_scatter.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(beer_scatter.encoding.y['shorthand'].lower()).encode(\"utf-8\")+b\"efb982be9f00f620\").hexdigest() == \"4943725e5d30750b04b5498e5559f19d5d5fde42\", \"value of beer_scatter.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(beer_scatter.encoding.y['shorthand']).encode(\"utf-8\")+b\"efb982be9f00f620\").hexdigest() == \"4943725e5d30750b04b5498e5559f19d5d5fde42\", \"correct string value of beer_scatter.encoding.y['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(beer_scatter.to_dict()['mark']['type'] in ['circle', 'point'])).encode(\"utf-8\")+b\"56696361310befc4\").hexdigest() == \"adad62e62523ae075fd6db3f6a3d8f2900149cb7\", \"type of beer_scatter.to_dict()['mark']['type'] in ['circle', 'point'] is not bool. beer_scatter.to_dict()['mark']['type'] in ['circle', 'point'] should be a bool\"\n",
    "assert sha1(str(beer_scatter.to_dict()['mark']['type'] in ['circle', 'point']).encode(\"utf-8\")+b\"56696361310befc4\").hexdigest() == \"62b3de410bdeb35fc36983526f7c206f74a45f78\", \"boolean value of beer_scatter.to_dict()['mark']['type'] in ['circle', 'point'] is not correct\"\n",
    "\n",
    "assert sha1(str(type('opacity' in beer_scatter.mark.to_dict())).encode(\"utf-8\")+b\"be1e9f23bf7274b1\").hexdigest() == \"e2d1db3940fbceaf640e606350cd0c84e2612673\", \"type of 'opacity' in beer_scatter.mark.to_dict() is not bool. 'opacity' in beer_scatter.mark.to_dict() should be a bool\"\n",
    "assert sha1(str('opacity' in beer_scatter.mark.to_dict()).encode(\"utf-8\")+b\"be1e9f23bf7274b1\").hexdigest() == \"f5cb64ba05ac1b44321b457634d0aa6302d152b8\", \"boolean value of 'opacity' in beer_scatter.mark.to_dict() is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(beer_scatter.encoding.x['title'], str))).encode(\"utf-8\")+b\"028c4fc230c057eb\").hexdigest() == \"1ea5a64935bf4c7ee5e24cc4cc7d18b3a1d61883\", \"type of isinstance(beer_scatter.encoding.x['title'], str) is not bool. isinstance(beer_scatter.encoding.x['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(beer_scatter.encoding.x['title'], str)).encode(\"utf-8\")+b\"028c4fc230c057eb\").hexdigest() == \"4189bd17f9032986f5b6c8af30f7d668f1ef8fdb\", \"boolean value of isinstance(beer_scatter.encoding.x['title'], str) is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(beer_scatter.encoding.y['title'], str))).encode(\"utf-8\")+b\"c60dd0971b455d0c\").hexdigest() == \"8e70e2a91db9713447f0703b167c3b3a3f42ae1a\", \"type of isinstance(beer_scatter.encoding.y['title'], str) is not bool. isinstance(beer_scatter.encoding.y['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(beer_scatter.encoding.y['title'], str)).encode(\"utf-8\")+b\"c60dd0971b455d0c\").hexdigest() == \"0276c8852491dc18da2cb0cb418da059f53061a9\", \"boolean value of isinstance(beer_scatter.encoding.y['title'], str) is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e82bb63dbe071d7818eaeda39ccac782",
     "grade": false,
     "grade_id": "cell-4826275eec3db51a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.2**\n",
    "<br> {points: 1}\n",
    "\n",
    "KMeans clustering in scikit learn does not handle missing value. Therefore, we need to drop any rows that contain missing values in the columns we are using in the clustering, which are `ibu` and `abv`. Remember that you can use the `subset` parameter with `dropna` to specify which column to look at.\n",
    "\n",
    "Do not select/drop any columns at this point, only remove rows that contain missing values in the columns `ibu` and `abv`.\n",
    "\n",
    "*Assign your answer to an object named `clean_beer`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b23517fff612dc02967d60d62eeca7b1",
     "grade": false,
     "grade_id": "cell-77a1b2827a0e31a3",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "clean_beer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0b1554f0b884449a3b9c631acb86b081",
     "grade": true,
     "grade_id": "cell-1ed1c760a10e3e9d",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(clean_beer is None)).encode(\"utf-8\")+b\"08d2531c1401e392\").hexdigest() == \"625fd63ce3fc932e31ffc8ed5ad4956cd68bfe74\", \"type of clean_beer is None is not bool. clean_beer is None should be a bool\"\n",
    "assert sha1(str(clean_beer is None).encode(\"utf-8\")+b\"08d2531c1401e392\").hexdigest() == \"0946af4daa231e3c78498c8aa0c425392bc94ceb\", \"boolean value of clean_beer is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(clean_beer)).encode(\"utf-8\")+b\"78412a1b510ea93b\").hexdigest() == \"5a1001e2e19ac5280203d413280b593ba66cd6f7\", \"type of type(clean_beer) is not correct\"\n",
    "\n",
    "assert sha1(str(type(clean_beer.shape)).encode(\"utf-8\")+b\"b457f2cb0160695b\").hexdigest() == \"2e91f671399026cc405f9341fd98d1c966194564\", \"type of clean_beer.shape is not tuple. clean_beer.shape should be a tuple\"\n",
    "assert sha1(str(len(clean_beer.shape)).encode(\"utf-8\")+b\"b457f2cb0160695b\").hexdigest() == \"6454cbc0952017f46aeab79a3289857693d7b838\", \"length of clean_beer.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, clean_beer.shape))).encode(\"utf-8\")+b\"b457f2cb0160695b\").hexdigest() == \"1ddd9c5c57dcbb8bbbdf3fa9fab7b380918cd2c5\", \"values of clean_beer.shape are not correct\"\n",
    "assert sha1(str(clean_beer.shape).encode(\"utf-8\")+b\"b457f2cb0160695b\").hexdigest() == \"ddc14a7c43b1781eae448bc6cdf96a06d6147350\", \"order of elements of clean_beer.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"abv\" in clean_beer.columns)).encode(\"utf-8\")+b\"e2d084dc49b67423\").hexdigest() == \"9ae8ee30ef06e2f7cfa0d0de438d5cbec3040b14\", \"type of \\\"abv\\\" in clean_beer.columns is not bool. \\\"abv\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"abv\" in clean_beer.columns).encode(\"utf-8\")+b\"e2d084dc49b67423\").hexdigest() == \"4e015465736219d178796fd463e9368a8f7fe50e\", \"boolean value of \\\"abv\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"ibu\" in clean_beer.columns)).encode(\"utf-8\")+b\"66d8bdd4e4932404\").hexdigest() == \"7668d4b21066d57d467f7c04f4d5b9f34136c63c\", \"type of \\\"ibu\\\" in clean_beer.columns is not bool. \\\"ibu\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"ibu\" in clean_beer.columns).encode(\"utf-8\")+b\"66d8bdd4e4932404\").hexdigest() == \"e7f0fb90af609e91350acb7493da366cbe2bc0a3\", \"boolean value of \\\"ibu\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"id\" in clean_beer.columns)).encode(\"utf-8\")+b\"c66abd00d7a62768\").hexdigest() == \"ac08061ba8275db4dc771efe7ae4b2e0eeb75a4b\", \"type of \\\"id\\\" in clean_beer.columns is not bool. \\\"id\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"id\" in clean_beer.columns).encode(\"utf-8\")+b\"c66abd00d7a62768\").hexdigest() == \"88d05b33d367da5fd035adc7679c595a4bd0d71b\", \"boolean value of \\\"id\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"name\" in clean_beer.columns)).encode(\"utf-8\")+b\"7746b6beee73423d\").hexdigest() == \"f5024fc9446d2df5dc0619f7710b2946015079ca\", \"type of \\\"name\\\" in clean_beer.columns is not bool. \\\"name\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"name\" in clean_beer.columns).encode(\"utf-8\")+b\"7746b6beee73423d\").hexdigest() == \"05d553b71a4d09e91ad002daa167c84f24921e64\", \"boolean value of \\\"name\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"style\" in clean_beer.columns)).encode(\"utf-8\")+b\"b57798ce55c5ce79\").hexdigest() == \"96a352274437f512602f1794e1800bc3873eecb1\", \"type of \\\"style\\\" in clean_beer.columns is not bool. \\\"style\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"style\" in clean_beer.columns).encode(\"utf-8\")+b\"b57798ce55c5ce79\").hexdigest() == \"a05874b2ff9c918cb179c4851c2ebbfa61e27fd5\", \"boolean value of \\\"style\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"brewery_id\" in clean_beer.columns)).encode(\"utf-8\")+b\"ccfeaf4232b72054\").hexdigest() == \"1d5bedf747dca60734f0d815a91aaa4a0b246830\", \"type of \\\"brewery_id\\\" in clean_beer.columns is not bool. \\\"brewery_id\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"brewery_id\" in clean_beer.columns).encode(\"utf-8\")+b\"ccfeaf4232b72054\").hexdigest() == \"24e1b2acdc621b63cfbf83f4ab79064d1e30e7f3\", \"boolean value of \\\"brewery_id\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"ounces\" in clean_beer.columns)).encode(\"utf-8\")+b\"32cec534ddba143e\").hexdigest() == \"7dc5d97325429839d54ac6c295521ba71303c149\", \"type of \\\"ounces\\\" in clean_beer.columns is not bool. \\\"ounces\\\" in clean_beer.columns should be a bool\"\n",
    "assert sha1(str(\"ounces\" in clean_beer.columns).encode(\"utf-8\")+b\"32cec534ddba143e\").hexdigest() == \"e49efbf14e2f0abef86955531d15eb2497dc4d05\", \"boolean value of \\\"ounces\\\" in clean_beer.columns is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ae748129080a5a39ddc0a1a56e9d474e",
     "grade": false,
     "grade_id": "cell-98c23f6aa556be8b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.3**\n",
    "<br>{points: 1}\n",
    "\n",
    "Why do we need to scale the variables when using k-means clustering?\n",
    "\n",
    "A. k-means uses the Euclidean distance to compute how similar data points are to each cluster centre\n",
    "\n",
    "B. k-means is an iterative algorithm\n",
    "\n",
    "C. Some variables might be more important for prediction than others\n",
    "\n",
    "D. To make sure their mean is 0\n",
    "\n",
    "*Assign your answer to an object named `answer1_3`. Make sure your answer is a single upper-case character surrounded by quotes.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3a356511c5f324fe6e30184a6682e2a6",
     "grade": false,
     "grade_id": "cell-dabeb5fe0dacbc55",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d13415eb95407a05f917c00fc8a2d942",
     "grade": true,
     "grade_id": "cell-cee046b5d47ebb72",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer1_3)).encode(\"utf-8\")+b\"0a0ec45eb01130fa\").hexdigest() == \"c9ecca07e859780f26a45feb4415a25185f337e9\", \"type of answer1_3 is not str. answer1_3 should be an str\"\n",
    "assert sha1(str(len(answer1_3)).encode(\"utf-8\")+b\"0a0ec45eb01130fa\").hexdigest() == \"b78cd99b9616428d05e2b9264e55b1ae84973359\", \"length of answer1_3 is not correct\"\n",
    "assert sha1(str(answer1_3.lower()).encode(\"utf-8\")+b\"0a0ec45eb01130fa\").hexdigest() == \"b4293bb4129cec53a9e674cdde21c32340bc8817\", \"value of answer1_3 is not correct\"\n",
    "assert sha1(str(answer1_3).encode(\"utf-8\")+b\"0a0ec45eb01130fa\").hexdigest() == \"a61ed0a1231f8484971861510f69a3ac9d708afb\", \"correct string value of answer1_3 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e7895db76075f7b0142189397da2b6e8",
     "grade": false,
     "grade_id": "cell-b44ed52f8fdc5336",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.4**\n",
    "<br> {points: 1}\n",
    "\n",
    "Let's setup that scaling now. Use `make_column_transformer` to specify that we want to apply a `StandardScaler()` to the columns `ibu` and `abv` (in that order), and that we want to drop any other columns.\n",
    "\n",
    "*Assign your answer to an object named `beer_preprocessor`. Use the scaffolding provided.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a9d81aac9ff846cfbf8129744068e2b4",
     "grade": false,
     "grade_id": "cell-db7d5a769e2ede77",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# ___ = ___(\n",
    "#     (___(), [___, ___]),\n",
    "#     ___='drop',\n",
    "#     verbose_feature_names_out=False,\n",
    "# )\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "77e1b1eded2d130d3e827c313c2bcaf9",
     "grade": true,
     "grade_id": "cell-f4fa609002e00099",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_preprocessor is None)).encode(\"utf-8\")+b\"67b50986091a428a\").hexdigest() == \"596b9ae882f053320d5345ffaed27f3c2efa063b\", \"type of beer_preprocessor is None is not bool. beer_preprocessor is None should be a bool\"\n",
    "assert sha1(str(beer_preprocessor is None).encode(\"utf-8\")+b\"67b50986091a428a\").hexdigest() == \"cccf725770736cffa62057429c41cf2516607101\", \"boolean value of beer_preprocessor is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(type(beer_preprocessor))).encode(\"utf-8\")+b\"888ae1bcfcd3d084\").hexdigest() == \"3a51c270dcfb28a93050e8b03e3e6b7f1024f6e0\", \"type of type(beer_preprocessor) is not correct\"\n",
    "assert sha1(str(type(beer_preprocessor)).encode(\"utf-8\")+b\"888ae1bcfcd3d084\").hexdigest() == \"1cf718cc5805abd70db4e376cfaa915922847556\", \"value of type(beer_preprocessor) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_preprocessor.get_feature_names_out)).encode(\"utf-8\")+b\"e4c072e4b70efc31\").hexdigest() == \"708c2d9204bf1307b1bcaa0223db629723b5b561\", \"type of beer_preprocessor.get_feature_names_out is not correct\"\n",
    "assert sha1(str(beer_preprocessor.get_feature_names_out).encode(\"utf-8\")+b\"e4c072e4b70efc31\").hexdigest() == \"ba97f1e2a7aa1527ac06a1241c2f0d963a00f125\", \"value of beer_preprocessor.get_feature_names_out is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6b086a7705ad7c51b91976f5e2ab98d3",
     "grade": false,
     "grade_id": "cell-8c5a413f54e55216",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.5**\n",
    "<br> {points: 1}\n",
    "\n",
    "The next step in our clustering workflow is to create a model that specifies how we want to cluster the data. From our exploratory data visualization, it seems like we will start simple with only 2 clusters. Use the `KMeans` function with `n_clusters=2` to perform clustering with this choice of K. \n",
    "\n",
    "*Assign your model to an object named `beer_cluster_k2`. Note that since k-means uses a random initialization, we need to set the random_state; don't change the value!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dfd89e4a645fa3b6e9669de013095e1e",
     "grade": false,
     "grade_id": "cell-59fd6cac5b722485",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# ___ = KMeans(n_clusters=2, random_state=1234)  # Don't change the random_state value\n",
    "# ___.fit(___)\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_cluster_k2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "11a31e09e5e95e74d66f13132d6b84a9",
     "grade": true,
     "grade_id": "cell-b9995d961e6abdd4",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(type(beer_cluster_k2))).encode(\"utf-8\")+b\"7380a391f7f9cb02\").hexdigest() == \"c421e2dfd009f9d841f50d311e812740d2afc5f1\", \"type of type(beer_cluster_k2) is not correct\"\n",
    "assert sha1(str(type(beer_cluster_k2)).encode(\"utf-8\")+b\"7380a391f7f9cb02\").hexdigest() == \"6236ac449ed5dbd185acb3198be66e7790a58e75\", \"value of type(beer_cluster_k2) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_cluster_k2.n_clusters)).encode(\"utf-8\")+b\"39dfc924db070288\").hexdigest() == \"8a35d423f86a79a7f8a36d26272dbb36ecf42175\", \"type of beer_cluster_k2.n_clusters is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(beer_cluster_k2.n_clusters).encode(\"utf-8\")+b\"39dfc924db070288\").hexdigest() == \"d7d6179225f34adad33c4e72e11ab2a4af6eee4a\", \"value of beer_cluster_k2.n_clusters is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a30fcc0c8efdb6aa6a3280f3d81ff649",
     "grade": false,
     "grade_id": "cell-8f40f7466f1af319",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.6**\n",
    "<br> {points: 1}\n",
    "\n",
    "Combine the preprocessor and model specification into a pipeline, and fit the pipeline on the `clean_beer` data.\n",
    "\n",
    "*Assign your model to an object named beer_pipe.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "944b9d2012336cfcefc59549fec1297a",
     "grade": false,
     "grade_id": "cell-0e9e69241f6ca49f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4801d9e47a9efb5420fa3025e487515b",
     "grade": true,
     "grade_id": "cell-b591dcea6f451d18",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_pipe is None)).encode(\"utf-8\")+b\"3b82488c04dfc8c1\").hexdigest() == \"93df9150b6c001fce75aa536ede84f2e41f4970d\", \"type of beer_pipe is None is not bool. beer_pipe is None should be a bool\"\n",
    "assert sha1(str(beer_pipe is None).encode(\"utf-8\")+b\"3b82488c04dfc8c1\").hexdigest() == \"f9cc035b72432af1b2bcd19af2c11001d98cbcac\", \"boolean value of beer_pipe is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(type(beer_pipe))).encode(\"utf-8\")+b\"6ee24abb9f972512\").hexdigest() == \"490177b78d35c04da349a2fdbe63d57f15a53eae\", \"type of type(beer_pipe) is not correct\"\n",
    "assert sha1(str(type(beer_pipe)).encode(\"utf-8\")+b\"6ee24abb9f972512\").hexdigest() == \"6ae4029fcc9318034f7a6145577121241699d49c\", \"value of type(beer_pipe) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_pipe.named_steps.kmeans.n_clusters)).encode(\"utf-8\")+b\"512a92592b65048b\").hexdigest() == \"f79ba675eb5a60988cc37b58b1ee0f5944f2cf40\", \"type of beer_pipe.named_steps.kmeans.n_clusters is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(beer_pipe.named_steps.kmeans.n_clusters).encode(\"utf-8\")+b\"512a92592b65048b\").hexdigest() == \"d973b41733a77636950a5cac3d961dade692ebc6\", \"value of beer_pipe.named_steps.kmeans.n_clusters is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c1170fec768f3f44eb45c692967f5140",
     "grade": false,
     "grade_id": "cell-b40335391796b8bc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.7**\n",
    "<br> {points: 1}\n",
    "\n",
    "Use the `labels_` attribute of KMeans model inside `beer_pipe` to get the cluster assignment for each point in the `clean_beer` data. Create a new dataframe called `clustered_beer` and assign the cluster labels to a column named `cluster`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a76bdeb5f4484c48fd4ab3e9d8320ef8",
     "grade": false,
     "grade_id": "cell-09a5a07201a2f1e3",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# ___ = ___.assign(\n",
    "#     cluster=___[1].___  # The KMeans model is in the second position of the pipeline\n",
    "# )\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError\n",
    "clustered_beer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fb319526fe9102a5d919c7e340d63e42",
     "grade": true,
     "grade_id": "cell-46d87f5ee36a932c",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(\"abv\" in clustered_beer.columns)).encode(\"utf-8\")+b\"909a74265ac584b8\").hexdigest() == \"40f496d5c3fd191c1fb87c9f7150bc7a0940c689\", \"type of \\\"abv\\\" in clustered_beer.columns is not bool. \\\"abv\\\" in clustered_beer.columns should be a bool\"\n",
    "assert sha1(str(\"abv\" in clustered_beer.columns).encode(\"utf-8\")+b\"909a74265ac584b8\").hexdigest() == \"3c6ba1b3e796e7a4c11bf8f1dfeb6ba9fa8a696a\", \"boolean value of \\\"abv\\\" in clustered_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"ibu\" in clustered_beer.columns)).encode(\"utf-8\")+b\"4813755519c31439\").hexdigest() == \"5f9918361d4f07fe9a74b0009d62b283af515655\", \"type of \\\"ibu\\\" in clustered_beer.columns is not bool. \\\"ibu\\\" in clustered_beer.columns should be a bool\"\n",
    "assert sha1(str(\"ibu\" in clustered_beer.columns).encode(\"utf-8\")+b\"4813755519c31439\").hexdigest() == \"26e4dc174c96079f7411a8cf884270188341daea\", \"boolean value of \\\"ibu\\\" in clustered_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"cluster\" in clustered_beer.columns)).encode(\"utf-8\")+b\"09404ece9d87ddd7\").hexdigest() == \"ddfb14052219aa4387b4de9e77c46781e668c5bc\", \"type of \\\"cluster\\\" in clustered_beer.columns is not bool. \\\"cluster\\\" in clustered_beer.columns should be a bool\"\n",
    "assert sha1(str(\"cluster\" in clustered_beer.columns).encode(\"utf-8\")+b\"09404ece9d87ddd7\").hexdigest() == \"0e6205109e62f74317c8919153a8f6f83a89a31d\", \"boolean value of \\\"cluster\\\" in clustered_beer.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer.shape[0])).encode(\"utf-8\")+b\"c9691cb9ee0c65db\").hexdigest() == \"481a2a4b4e6899c9997faf2121f96b4b5b1b7cba\", \"type of clustered_beer.shape[0] is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(clustered_beer.shape[0]).encode(\"utf-8\")+b\"c9691cb9ee0c65db\").hexdigest() == \"dbb54379940da8dc3747e52a09790f518c6ada0f\", \"value of clustered_beer.shape[0] is not correct\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer.shape[1])).encode(\"utf-8\")+b\"dc023dde26eb1b26\").hexdigest() == \"f6557943f5bc3f4216277e03f3c57fc3dde6bdce\", \"type of clustered_beer.shape[1] is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(clustered_beer.shape[1]).encode(\"utf-8\")+b\"dc023dde26eb1b26\").hexdigest() == \"2996fef32d29094f46d0a97ee6785b3605082117\", \"value of clustered_beer.shape[1] is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4a65045613bf36bab9c6b6872a4503a6",
     "grade": false,
     "grade_id": "cell-6adf5ec5d9d2f3ef",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.8**\n",
    "<br> {points: 1}\n",
    "\n",
    "Create a scatter plot of `abv` on the y-axis versus `ibu` on the x-axis (using the data in `clustered_beer`) where the points are labelled by their cluster assignment. Add the `:N` suffix to the column name to ensure that altair will treat the `cluster` column as a categorical variable, and hence use a suitable color scheme. Name the plot object `clustered_beer_chart`.\n",
    "\n",
    "*Remember to follow the best visualization practices, including adding human-readable labels to your plot.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "db435c0f76261d3a60b20bcc16ec03f2",
     "grade": false,
     "grade_id": "cell-70d2a62ba35172b0",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "clustered_beer_chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c166854f5d84ab8bb6f83297a949dfd0",
     "grade": true,
     "grade_id": "cell-f8a27de5ec7f09e6",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(clustered_beer_chart is None)).encode(\"utf-8\")+b\"24891128b83d038e\").hexdigest() == \"e046575fe2ab816c7da500f7bfc73732932ee024\", \"type of clustered_beer_chart is None is not bool. clustered_beer_chart is None should be a bool\"\n",
    "assert sha1(str(clustered_beer_chart is None).encode(\"utf-8\")+b\"24891128b83d038e\").hexdigest() == \"c8cde9640020652bed7a6721230d86621839323b\", \"boolean value of clustered_beer_chart is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer_chart.to_dict()['mark']['type'] in ['circle', 'point'])).encode(\"utf-8\")+b\"73d6670f1fa001ea\").hexdigest() == \"490a76d75bf1daf6a00eb16cfac4345c950700d6\", \"type of clustered_beer_chart.to_dict()['mark']['type'] in ['circle', 'point'] is not bool. clustered_beer_chart.to_dict()['mark']['type'] in ['circle', 'point'] should be a bool\"\n",
    "assert sha1(str(clustered_beer_chart.to_dict()['mark']['type'] in ['circle', 'point']).encode(\"utf-8\")+b\"73d6670f1fa001ea\").hexdigest() == \"4f182e4dfdace100df5e68e0d3ea74dd70bb47c3\", \"boolean value of clustered_beer_chart.to_dict()['mark']['type'] in ['circle', 'point'] is not correct\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer_chart.data.equals(clustered_beer_chart))).encode(\"utf-8\")+b\"d7db536e34a00f36\").hexdigest() == \"1cfeb3369292690b3bbb11af5f7b46de2721ad5c\", \"type of clustered_beer_chart.data.equals(clustered_beer_chart) is not bool. clustered_beer_chart.data.equals(clustered_beer_chart) should be a bool\"\n",
    "assert sha1(str(clustered_beer_chart.data.equals(clustered_beer_chart)).encode(\"utf-8\")+b\"d7db536e34a00f36\").hexdigest() == \"8160a2c0099f8ee92fb58b0417255b263f2d05b9\", \"boolean value of clustered_beer_chart.data.equals(clustered_beer_chart) is not correct\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer_chart.encoding.x['shorthand'])).encode(\"utf-8\")+b\"a3612270743fdb2f\").hexdigest() == \"95bd95600e418bc31e8dd706c3484d6c496b7727\", \"type of clustered_beer_chart.encoding.x['shorthand'] is not str. clustered_beer_chart.encoding.x['shorthand'] should be an str\"\n",
    "assert sha1(str(len(clustered_beer_chart.encoding.x['shorthand'])).encode(\"utf-8\")+b\"a3612270743fdb2f\").hexdigest() == \"93029971be9391bfb809d649abe3202954c8f318\", \"length of clustered_beer_chart.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.x['shorthand'].lower()).encode(\"utf-8\")+b\"a3612270743fdb2f\").hexdigest() == \"d6c1686bc8e6dfbb3c307b9f5e5ce2935c92b891\", \"value of clustered_beer_chart.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.x['shorthand']).encode(\"utf-8\")+b\"a3612270743fdb2f\").hexdigest() == \"d6c1686bc8e6dfbb3c307b9f5e5ce2935c92b891\", \"correct string value of clustered_beer_chart.encoding.x['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer_chart.encoding.y['shorthand'])).encode(\"utf-8\")+b\"7541ba2c9ba682b2\").hexdigest() == \"33651035fe2e4bd9e9d3bbd7bcd64dab2099dbd3\", \"type of clustered_beer_chart.encoding.y['shorthand'] is not str. clustered_beer_chart.encoding.y['shorthand'] should be an str\"\n",
    "assert sha1(str(len(clustered_beer_chart.encoding.y['shorthand'])).encode(\"utf-8\")+b\"7541ba2c9ba682b2\").hexdigest() == \"205b0a5feddf2348a15ceb779a4f4b5cb5e80bb4\", \"length of clustered_beer_chart.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.y['shorthand'].lower()).encode(\"utf-8\")+b\"7541ba2c9ba682b2\").hexdigest() == \"4eef8a52359977de6ec2da1b61015b9b12783b26\", \"value of clustered_beer_chart.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.y['shorthand']).encode(\"utf-8\")+b\"7541ba2c9ba682b2\").hexdigest() == \"4eef8a52359977de6ec2da1b61015b9b12783b26\", \"correct string value of clustered_beer_chart.encoding.y['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(clustered_beer_chart.encoding.color['shorthand'])).encode(\"utf-8\")+b\"d8a12b59fed483ff\").hexdigest() == \"12f33ab54b6de1772d5c13cc67ee88ca1eba400c\", \"type of clustered_beer_chart.encoding.color['shorthand'] is not str. clustered_beer_chart.encoding.color['shorthand'] should be an str\"\n",
    "assert sha1(str(len(clustered_beer_chart.encoding.color['shorthand'])).encode(\"utf-8\")+b\"d8a12b59fed483ff\").hexdigest() == \"405a1c25a8629ded99ea0dd2efa2ec214f0c3ee6\", \"length of clustered_beer_chart.encoding.color['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.color['shorthand'].lower()).encode(\"utf-8\")+b\"d8a12b59fed483ff\").hexdigest() == \"92b8775f3a2497e71d046d18cce26209b72637ae\", \"value of clustered_beer_chart.encoding.color['shorthand'] is not correct\"\n",
    "assert sha1(str(clustered_beer_chart.encoding.color['shorthand']).encode(\"utf-8\")+b\"d8a12b59fed483ff\").hexdigest() == \"e28816355df21076791b5dd702bd0fd3ed5b619c\", \"correct string value of clustered_beer_chart.encoding.color['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(isinstance(clustered_beer_chart.encoding.x['title'], str))).encode(\"utf-8\")+b\"5791f756e114cc9b\").hexdigest() == \"23b8c45d0496bed504f4f893c570a2a546f8fda2\", \"type of isinstance(clustered_beer_chart.encoding.x['title'], str) is not bool. isinstance(clustered_beer_chart.encoding.x['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(clustered_beer_chart.encoding.x['title'], str)).encode(\"utf-8\")+b\"5791f756e114cc9b\").hexdigest() == \"1442013ef1f286e28367ca33a2a4621a71320dca\", \"boolean value of isinstance(clustered_beer_chart.encoding.x['title'], str) is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(clustered_beer_chart.encoding.y['title'], str))).encode(\"utf-8\")+b\"5089e7c003460664\").hexdigest() == \"0604a946817d989ff70ab3ef5748836b4bcdbac7\", \"type of isinstance(clustered_beer_chart.encoding.y['title'], str) is not bool. isinstance(clustered_beer_chart.encoding.y['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(clustered_beer_chart.encoding.y['title'], str)).encode(\"utf-8\")+b\"5089e7c003460664\").hexdigest() == \"8afc4ccbdf04b78548faedafdb3a7f0c57de6caa\", \"boolean value of isinstance(clustered_beer_chart.encoding.y['title'], str) is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(clustered_beer_chart.encoding.color['title'], str))).encode(\"utf-8\")+b\"285f3bc97e6beafc\").hexdigest() == \"5e595a61941b9adb06052888d0272603ddd3659f\", \"type of isinstance(clustered_beer_chart.encoding.color['title'], str) is not bool. isinstance(clustered_beer_chart.encoding.color['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(clustered_beer_chart.encoding.color['title'], str)).encode(\"utf-8\")+b\"285f3bc97e6beafc\").hexdigest() == \"bd41fc795bd29db61e27e6fd79b8dc4ecd85c450\", \"boolean value of isinstance(clustered_beer_chart.encoding.color['title'], str) is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6e1146ceef60eb85d62b48190ab2db39",
     "grade": false,
     "grade_id": "cell-97f33922ed0d39e8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.9.1** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "We do not know, however, that two clusters (K = 2) is the best choice for this data set. What can we do to choose the best K?\n",
    "\n",
    "A. Perform *cross-validation* for a variety of possible Ks. Choose the one where within-cluster sum of squares distance starts to *decrease less*.\n",
    "\n",
    "B. Perform *cross-validation* for a variety of possible Ks. Choose the one where the within-cluster sum of squares distance starts to *decrease more*. \n",
    "\n",
    "C. Perform *clustering* for a variety of possible Ks. Choose the one where within-cluster sum of squares distance starts to *decrease less*.\n",
    "\n",
    "D. Perform *clustering* for a variety of possible Ks. Choose the one where the within-cluster sum of squares distance starts to *decrease more*. \n",
    "\n",
    "*Assign your answer to an object called `answer1_9_1`. Make sure it is a single upper-case character surrounded by quotes.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2d0a7d34cee9e032ab1c27e6016d652a",
     "grade": false,
     "grade_id": "cell-61e001fe5e991523",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "646f2e3624d56d190174eaea49650cfd",
     "grade": true,
     "grade_id": "cell-693552f36c9a4230",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer1_9_1)).encode(\"utf-8\")+b\"01828366e7f1251d\").hexdigest() == \"9d3b997a8e03f25bcb5ee6c880f63eba518f28bb\", \"type of answer1_9_1 is not str. answer1_9_1 should be an str\"\n",
    "assert sha1(str(len(answer1_9_1)).encode(\"utf-8\")+b\"01828366e7f1251d\").hexdigest() == \"951e702cc3854fc4dcfe0f1e9258a37ddc1659fd\", \"length of answer1_9_1 is not correct\"\n",
    "assert sha1(str(answer1_9_1.lower()).encode(\"utf-8\")+b\"01828366e7f1251d\").hexdigest() == \"f7f0f091b6b0565ba2711aaeaa57c17ac458cd46\", \"value of answer1_9_1 is not correct\"\n",
    "assert sha1(str(answer1_9_1).encode(\"utf-8\")+b\"01828366e7f1251d\").hexdigest() == \"5b6b30121c6499aaefcfd18ff590d2845b722bab\", \"correct string value of answer1_9_1 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "03783593c6aa7850d0cd6e0e8f046c48",
     "grade": false,
     "grade_id": "cell-d884f2f1c5ea8b43",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.9.2**\n",
    "<br> {points: 1}\n",
    "\n",
    "Let's check the total within-cluster sum of squares for our K=2 model. Remember that scikit-learn already computes this for us and has stored it in an attribute of the model object. Find out the name of the attribute and store its value as a new variable called `beer_cluster_k2_wssd`. Remember that you need to access the model through its numerical position in the `beer_pipe` list.\n",
    "\n",
    "*Hint: Check the textbook if you don't remember the name of the attribute.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c326ea94856fb56f285acfe36eb6aafd",
     "grade": false,
     "grade_id": "cell-868cebb3f86944d1",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_cluster_k2_wssd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "78ea636e1aae34c8f3064abca40d4ef3",
     "grade": true,
     "grade_id": "cell-31427d5e0afe53be",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_cluster_k2_wssd is None)).encode(\"utf-8\")+b\"c835e2e0f2b14c3a\").hexdigest() == \"b514e0414ed30f64360de48b4d0a05de3e7ecda5\", \"type of beer_cluster_k2_wssd is None is not bool. beer_cluster_k2_wssd is None should be a bool\"\n",
    "assert sha1(str(beer_cluster_k2_wssd is None).encode(\"utf-8\")+b\"c835e2e0f2b14c3a\").hexdigest() == \"6dce7c4cb47b05c94a0310ab90350ccf47875853\", \"boolean value of beer_cluster_k2_wssd is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_cluster_k2_wssd)).encode(\"utf-8\")+b\"5cc6d5bef7c6173b\").hexdigest() == \"6dcbee6a34bc35fbcf978c800928e74b116c9485\", \"type of type(beer_cluster_k2_wssd) is not correct\"\n",
    "\n",
    "assert sha1(str(type(round(beer_cluster_k2_wssd, 2))).encode(\"utf-8\")+b\"8c0a616d3069279f\").hexdigest() == \"4862e066731d31e5603a35b095d39a6be1090b74\", \"type of round(beer_cluster_k2_wssd, 2) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(round(beer_cluster_k2_wssd, 2), 2)).encode(\"utf-8\")+b\"8c0a616d3069279f\").hexdigest() == \"b266ae9f8e7fe7f6daecd6a15514f0367d2cb5d6\", \"value of round(beer_cluster_k2_wssd, 2) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b226e8ff4520720e1dd820bc67e4efd7",
     "grade": false,
     "grade_id": "cell-42cd7e853af98bb1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.0**\n",
    "<br> {points: 1}\n",
    "\n",
    "Let's now choose the best $K$ for this clustering problem by computing the total within-cluster sum of squares for multiple values of $K$ and selecting the $K$ with the lowest value. To do this we need to first create a `range` of values to test; in this case we are interesting in all the integers from 1 to 10 (both inclusive).\n",
    "\n",
    "*Assign your answer to an object named `beer_ks`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3037c826b7d57169cdaa2985cb050cc8",
     "grade": false,
     "grade_id": "cell-2291e50c08f701d2",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_ks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5e1aad57d91f7e956d70ac9295fdae70",
     "grade": true,
     "grade_id": "cell-58c958b24994d60d",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_ks)).encode(\"utf-8\")+b\"e8286285d0b1da7c\").hexdigest() == \"966c41d51be9c9d29402a80976488f66e21fe123\", \"type of type(beer_ks) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_ks.start)).encode(\"utf-8\")+b\"ce28b3c4a8dc17a8\").hexdigest() == \"2e342f65816ada9b5e7ef421dbbe5a7a5d2aed72\", \"type of beer_ks.start is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(beer_ks.start).encode(\"utf-8\")+b\"ce28b3c4a8dc17a8\").hexdigest() == \"1dbaa137ee9615274c78fde22f1f65245ce5eab8\", \"value of beer_ks.start is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_ks.stop)).encode(\"utf-8\")+b\"9319825dc7ac0b02\").hexdigest() == \"856c4843d8f322d68a7a1af10667817746ad5925\", \"type of beer_ks.stop is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(beer_ks.stop).encode(\"utf-8\")+b\"9319825dc7ac0b02\").hexdigest() == \"61dbc5ad4e486814b6987febba9d661eaf85da20\", \"value of beer_ks.stop is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "de3669e4e9bc543472eed3f10922d128",
     "grade": false,
     "grade_id": "cell-39c29b9969ea902b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.1**\n",
    "<br> {points: 1}\n",
    "\n",
    "Next, we want to compute the WSSD for each value of $K$.\n",
    "\n",
    "Use a list comprehension to create a KMeans clustering model with $K$ clusters for each value of $K$ in the `beer_ks` range you just created. Each model should be wrapped in a pipeline together with the `beer_preprocessor` we created earlier. Train the pipeline on the `clean_beer` data and output the WSSD value for each value of $K$ as a list.\n",
    "\n",
    "*Assign your answer to an object named `beer_wssds`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8df4ef65cf2d6fc98555dcca3c361a44",
     "grade": false,
     "grade_id": "cell-0789a9131f5cf925",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ___ = [\n",
    "#     ___(\n",
    "#         beer_preprocessor, \n",
    "#         ___(n_clusters=___, random_state=1234)  # Create a new model with `k` clusters\n",
    "#     ).fit(___)[1].___  # Fit the pipeline and compute its WSSD\n",
    "#     for k in ___\n",
    "# ]\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_wssds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9ca26e2bfd157ea84a9328945de295d4",
     "grade": true,
     "grade_id": "cell-ed0f2e1a31372296",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(len(beer_wssds))).encode(\"utf-8\")+b\"8f7b490861283aaa\").hexdigest() == \"fb9d6cbc4808a8f82d01a5efe48a9f55af3ca75f\", \"type of len(beer_wssds) is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(len(beer_wssds)).encode(\"utf-8\")+b\"8f7b490861283aaa\").hexdigest() == \"e1780e3982c0ae77f6d493217c02b0af3a1a5920\", \"value of len(beer_wssds) is not correct\"\n",
    "\n",
    "assert sha1(str(type(round(sum(beer_wssds), 2))).encode(\"utf-8\")+b\"fabd8116f24666a6\").hexdigest() == \"2f44cea7d7973fab3f071978f985105f9c18d1fc\", \"type of round(sum(beer_wssds), 2) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(round(sum(beer_wssds), 2), 2)).encode(\"utf-8\")+b\"fabd8116f24666a6\").hexdigest() == \"d18e7a0ecf0ca427b843d32e51aa5b7220038cf2\", \"value of round(sum(beer_wssds), 2) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f7b631349edb5766ab0f7b4f4014226e",
     "grade": false,
     "grade_id": "cell-712c5d5bf721ba07",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.2**\n",
    "<br> {points: 1}\n",
    "\n",
    "Before visualizing our results, we need to create a dataframe that holds the values of $K$ in a column called `k` and the WSSD values in a column called `wssd`.\n",
    "\n",
    "*Assign your answer to an object named `beer_model_stats`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "39de1e9695b5759df5ef024592ae8051",
     "grade": false,
     "grade_id": "cell-e5550ab0d15e904b",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "beer_model_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ccaab27ae73ef5ed61de7207611fb015",
     "grade": true,
     "grade_id": "cell-a3574637a73eada8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(beer_model_stats.shape)).encode(\"utf-8\")+b\"75b6aaf11dbb3b9d\").hexdigest() == \"7b4838d47d9016275f330d9889e48ec986c1216c\", \"type of beer_model_stats.shape is not tuple. beer_model_stats.shape should be a tuple\"\n",
    "assert sha1(str(len(beer_model_stats.shape)).encode(\"utf-8\")+b\"75b6aaf11dbb3b9d\").hexdigest() == \"ad469e46be3e928c24efd15f6c1b45a865f2b8cc\", \"length of beer_model_stats.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, beer_model_stats.shape))).encode(\"utf-8\")+b\"75b6aaf11dbb3b9d\").hexdigest() == \"8e945949270a3faffcaa2c06be41fe8a19c0a9df\", \"values of beer_model_stats.shape are not correct\"\n",
    "assert sha1(str(beer_model_stats.shape).encode(\"utf-8\")+b\"75b6aaf11dbb3b9d\").hexdigest() == \"9193f774ef838e33549c17e4c1ae94bc4d43cfb2\", \"order of elements of beer_model_stats.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"k\" in beer_model_stats.columns.values)).encode(\"utf-8\")+b\"457bec0e5e6185d3\").hexdigest() == \"8e16b1d00a5d8c6ab19a6eee007e7a4adb582923\", \"type of \\\"k\\\" in beer_model_stats.columns.values is not bool. \\\"k\\\" in beer_model_stats.columns.values should be a bool\"\n",
    "assert sha1(str(\"k\" in beer_model_stats.columns.values).encode(\"utf-8\")+b\"457bec0e5e6185d3\").hexdigest() == \"5cb80111644f657258108836e0c73a7dee6ca3fe\", \"boolean value of \\\"k\\\" in beer_model_stats.columns.values is not correct\"\n",
    "\n",
    "assert sha1(str(type(\"wssd\" in beer_model_stats.columns)).encode(\"utf-8\")+b\"634706d643ce45c4\").hexdigest() == \"8a37c2ce99d4d5eca0bda7f55c49a5b68ed9f71a\", \"type of \\\"wssd\\\" in beer_model_stats.columns is not bool. \\\"wssd\\\" in beer_model_stats.columns should be a bool\"\n",
    "assert sha1(str(\"wssd\" in beer_model_stats.columns).encode(\"utf-8\")+b\"634706d643ce45c4\").hexdigest() == \"61cbb8d7dff2844b47c8edee5799de6e45106518\", \"boolean value of \\\"wssd\\\" in beer_model_stats.columns is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_model_stats['k'][0])).encode(\"utf-8\")+b\"ac371f488661f3b1\").hexdigest() == \"bad26c167a5f066b8aa56ef1ca28a63ceddbad0b\", \"type of type(beer_model_stats['k'][0]) is not correct\"\n",
    "\n",
    "assert sha1(str(type(beer_model_stats['wssd'][0])).encode(\"utf-8\")+b\"8c7f2fb80886185b\").hexdigest() == \"14c4327a720d51783f20a7ee40f1cddcb3ba1a54\", \"type of type(beer_model_stats['wssd'][0]) is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "11ea1c49fce372bc429e9053108c6d76",
     "grade": false,
     "grade_id": "cell-888915107f007211",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.3**\n",
    "<br> {points: 1}\n",
    "\n",
    "Create a line plot of total within-cluster sum of squares (y-axis) versus the number of clusters (x-axis), so that we can choose the best number of clusters to use. Use the correct parameter inside `mark_line` to include a point in the chart for each data point.\n",
    "\n",
    "*Assign your plot to an object called `elbow_plot`. Remember to follow the best visualization practices, including adding human-readable labels to your plot.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1de78504573ec117849a8ce679fb10f5",
     "grade": false,
     "grade_id": "cell-8a414509ff54b5ec",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "elbow_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a2325c7b8693478f9aa46996096b1401",
     "grade": true,
     "grade_id": "cell-3e758ca8ceea0217",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(elbow_plot is None)).encode(\"utf-8\")+b\"47f42b435d1d39eb\").hexdigest() == \"f103d337ba9b9c7bce6bb1ad04612c5352dc8ff0\", \"type of elbow_plot is None is not bool. elbow_plot is None should be a bool\"\n",
    "assert sha1(str(elbow_plot is None).encode(\"utf-8\")+b\"47f42b435d1d39eb\").hexdigest() == \"5059e6aaa0f5e5f385881f7f9dda869e11efb459\", \"boolean value of elbow_plot is None is not correct\"\n",
    "\n",
    "assert sha1(str(type(elbow_plot.encoding.x['shorthand'])).encode(\"utf-8\")+b\"05d57a336332b75c\").hexdigest() == \"82a36be728739c9da6cb6f6ba5e7a9bbb3da1df0\", \"type of elbow_plot.encoding.x['shorthand'] is not str. elbow_plot.encoding.x['shorthand'] should be an str\"\n",
    "assert sha1(str(len(elbow_plot.encoding.x['shorthand'])).encode(\"utf-8\")+b\"05d57a336332b75c\").hexdigest() == \"cd98c4ac5d868c86394165ef2a94f290a0a090fd\", \"length of elbow_plot.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(elbow_plot.encoding.x['shorthand'].lower()).encode(\"utf-8\")+b\"05d57a336332b75c\").hexdigest() == \"d4e9214ab86c107a4561969512af76ea9654c38e\", \"value of elbow_plot.encoding.x['shorthand'] is not correct\"\n",
    "assert sha1(str(elbow_plot.encoding.x['shorthand']).encode(\"utf-8\")+b\"05d57a336332b75c\").hexdigest() == \"d4e9214ab86c107a4561969512af76ea9654c38e\", \"correct string value of elbow_plot.encoding.x['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(elbow_plot.encoding.y['shorthand'])).encode(\"utf-8\")+b\"2d4ca50fb1fab664\").hexdigest() == \"6957e941e4d7007e49fab58c7cb55bf4fe6d1451\", \"type of elbow_plot.encoding.y['shorthand'] is not str. elbow_plot.encoding.y['shorthand'] should be an str\"\n",
    "assert sha1(str(len(elbow_plot.encoding.y['shorthand'])).encode(\"utf-8\")+b\"2d4ca50fb1fab664\").hexdigest() == \"b10dfb95e83dba4c1d322052c769b7dbc0742bef\", \"length of elbow_plot.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(elbow_plot.encoding.y['shorthand'].lower()).encode(\"utf-8\")+b\"2d4ca50fb1fab664\").hexdigest() == \"6270d8486427272f99e51aea0f96d58ff1a7cb3a\", \"value of elbow_plot.encoding.y['shorthand'] is not correct\"\n",
    "assert sha1(str(elbow_plot.encoding.y['shorthand']).encode(\"utf-8\")+b\"2d4ca50fb1fab664\").hexdigest() == \"6270d8486427272f99e51aea0f96d58ff1a7cb3a\", \"correct string value of elbow_plot.encoding.y['shorthand'] but incorrect case of letters\"\n",
    "\n",
    "assert sha1(str(type(elbow_plot.mark)).encode(\"utf-8\")+b\"718d174924fe6c8b\").hexdigest() == \"3235a3be08702f71233b4e383221d390e4155efe\", \"type of elbow_plot.mark is not correct\"\n",
    "assert sha1(str(elbow_plot.mark).encode(\"utf-8\")+b\"718d174924fe6c8b\").hexdigest() == \"d655b8f724d56bef9fef9c055aff628a36a2b210\", \"value of elbow_plot.mark is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(elbow_plot.encoding.x['title'], str))).encode(\"utf-8\")+b\"47909fc6994178d5\").hexdigest() == \"30b3accd704da5f4aa5b6434c94fe03d2fbca2e2\", \"type of isinstance(elbow_plot.encoding.x['title'], str) is not bool. isinstance(elbow_plot.encoding.x['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(elbow_plot.encoding.x['title'], str)).encode(\"utf-8\")+b\"47909fc6994178d5\").hexdigest() == \"e3a7224e936403160c3179c8196a1c0db9c961af\", \"boolean value of isinstance(elbow_plot.encoding.x['title'], str) is not correct\"\n",
    "\n",
    "assert sha1(str(type(isinstance(elbow_plot.encoding.y['title'], str))).encode(\"utf-8\")+b\"271a56b81692b96e\").hexdigest() == \"8ec4439100302bf8f3bf63e857c7db5c6e8cf4ac\", \"type of isinstance(elbow_plot.encoding.y['title'], str) is not bool. isinstance(elbow_plot.encoding.y['title'], str) should be a bool\"\n",
    "assert sha1(str(isinstance(elbow_plot.encoding.y['title'], str)).encode(\"utf-8\")+b\"271a56b81692b96e\").hexdigest() == \"9499693bc242dbed63750352fc43cf695423efcd\", \"boolean value of isinstance(elbow_plot.encoding.y['title'], str) is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "042ad4e259f974f2c3d71f212a018df0",
     "grade": false,
     "grade_id": "cell-790ae1331636b0f3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.4**\n",
    "<br> {points: 1}\n",
    "\n",
    "From the plot above, which $K$ should we choose? \n",
    "\n",
    "*Assign your answer to an object called `answer2_2`. Make sure your answer is a single numerical character surrounded by quotation marks, e.g. `'3'`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "da25f64e7911b9a8c12af5c270ef0536",
     "grade": false,
     "grade_id": "cell-bd38240a36b3d416",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bdc0654efc8d7bb6b74913d647b28361",
     "grade": true,
     "grade_id": "cell-62328bcd821daea9",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer2_4 in ['2', '3', '4'])).encode(\"utf-8\")+b\"a97064261029b4d0\").hexdigest() == \"5f990ef2b29421586ff26bc0fcc6f5bc3c49b007\", \"type of answer2_4 in ['2', '3', '4'] is not bool. answer2_4 in ['2', '3', '4'] should be a bool\"\n",
    "assert sha1(str(answer2_4 in ['2', '3', '4']).encode(\"utf-8\")+b\"a97064261029b4d0\").hexdigest() == \"88e844ca041e2861c65b1e415bc25ccc753da2dd\", \"boolean value of answer2_4 in ['2', '3', '4'] is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "336d087eafaf72d5a59a87db4284d7da",
     "grade": false,
     "grade_id": "cell-ef050c1e9d2e38a3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.5**\n",
    "<br> {points: 1}\n",
    "\n",
    "Why did we choose the $K$ we chose above?\n",
    "\n",
    "A. It had the greatest total within-cluster sum of squares\n",
    "\n",
    "B. It had the smallest total within-cluster sum of squares\n",
    "\n",
    "C. Increasing $k$ further than this only decreased the total within-cluster sum of squares a small amount\n",
    "\n",
    "D. Increasing $k$ further than this only increased the total within-cluster sum of squares a small amount\n",
    "\n",
    "*Assign your answer to an object called `answer2_5`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d3501b6ff21babadba8f8d1ee9303cdf",
     "grade": false,
     "grade_id": "cell-454ac5179dfb68f9",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "94d291e1abb874b07595a646a87668d1",
     "grade": true,
     "grade_id": "cell-e82ea147802752c4",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer2_5)).encode(\"utf-8\")+b\"a8049ffb16dad39e\").hexdigest() == \"2d109df5e2b3df0476cca9fd7702c9439f701839\", \"type of answer2_5 is not str. answer2_5 should be an str\"\n",
    "assert sha1(str(len(answer2_5)).encode(\"utf-8\")+b\"a8049ffb16dad39e\").hexdigest() == \"96757f8e61ecb94ecc6cd792c0bc7115c6bb6202\", \"length of answer2_5 is not correct\"\n",
    "assert sha1(str(answer2_5.lower()).encode(\"utf-8\")+b\"a8049ffb16dad39e\").hexdigest() == \"948c9256d68cccd570b21bc553db90864fea1e47\", \"value of answer2_5 is not correct\"\n",
    "assert sha1(str(answer2_5).encode(\"utf-8\")+b\"a8049ffb16dad39e\").hexdigest() == \"1d2260c23f41f60eecdf6b5535ecf0819d6ee19f\", \"correct string value of answer2_5 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c6d5dd98cc8630b3c4640f3dde1cafa0",
     "grade": false,
     "grade_id": "cell-e28e4f23066bcf9a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.6** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "What can we conclude from our analysis? How many different types of hoppy craft beer are there in this data set using the two variables we have? \n",
    "\n",
    "\n",
    "A. 1\n",
    "\n",
    "B. 2 to 4\n",
    "\n",
    "C. 5 to 7\n",
    "\n",
    "D. more than 7\n",
    "\n",
    "*Assign your answer to an object called `answer2_7`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a12c3e1271570e30f1d0c0623a6b731b",
     "grade": false,
     "grade_id": "cell-ab13466619677bd8",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "81bb49345ec42fb4b71a64e315fc9798",
     "grade": true,
     "grade_id": "cell-c9f898df0442578e",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer2_6)).encode(\"utf-8\")+b\"a3316332b8650055\").hexdigest() == \"ba2586abd6b7bb2df55264ac0d7557a9aa9a4878\", \"type of answer2_6 is not str. answer2_6 should be an str\"\n",
    "assert sha1(str(len(answer2_6)).encode(\"utf-8\")+b\"a3316332b8650055\").hexdigest() == \"f5d67f96dc76f2e9ed8f45a8f7388ef202160b8d\", \"length of answer2_6 is not correct\"\n",
    "assert sha1(str(answer2_6.lower()).encode(\"utf-8\")+b\"a3316332b8650055\").hexdigest() == \"063c711dd9ff7b5c7e90f33ef2ba3ff48184f7f0\", \"value of answer2_6 is not correct\"\n",
    "assert sha1(str(answer2_6).encode(\"utf-8\")+b\"a3316332b8650055\").hexdigest() == \"be20d6c3724fbbd2c329200ac99ebc4c0b18af0a\", \"correct string value of answer2_6 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "61ba7244a2d656819972ae1b501c6b4c",
     "grade": false,
     "grade_id": "cell-91d519c3b41719e6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 2.7** True or false:\n",
    "<br> {points: 1}\n",
    "\n",
    "Our analysis might change if we added additional variables, true or false?\n",
    "\n",
    "*Assign your answer to an object called `answer2_7`. Make sure your answer is a boolean. i.e. `True` or `False`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ab48926dec272b00e0ec221e71784509",
     "grade": false,
     "grade_id": "cell-182ada6e6a903e48",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cf22f13fd752294664a51afdfb13ca86",
     "grade": true,
     "grade_id": "cell-db3c4a1fcf69226e",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer2_7)).encode(\"utf-8\")+b\"ec7c31afad0f10db\").hexdigest() == \"aac0a2ef1e47f9ca45c45afdf25ad0e2f98ef099\", \"type of answer2_7 is not bool. answer2_7 should be a bool\"\n",
    "assert sha1(str(answer2_7).encode(\"utf-8\")+b\"ec7c31afad0f10db\").hexdigest() == \"09f88cbde5930704dc759acf931273bdbaf3c7df\", \"boolean value of answer2_7 is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}