KNN_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PcZRyi72D8Zs"
   },
   "source": [
    "# KNN Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IUI5NZc6D_pM"
   },
   "source": [
    "## ANTICIPATED TIME\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4SCB63abFDeb"
   },
   "source": [
    "2 hour\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2hApi_hNFEKw"
   },
   "source": [
    "## BEFORE YOU BEGIN\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZeGZOre-FFOQ"
   },
   "source": [
    "[Clustering](Clustering.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "78MRfbiiFHcu"
   },
   "source": [
    "## WHAT YOU WILL LEARN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eNSC9WoGFKQ-"
   },
   "source": [
    "\n",
    "- What is the K-Nearest Neighbors (KNN) algorithm and how does it work?\n",
    "- How do you choose the value of 'k' in KNN, and what impact does it have on the model's performance?\n",
    "- What distance metrics are commonly used in KNN, and how do they affect classification?\n",
    "- How do you handle categorical data in KNN?\n",
    "- What are the advantages and disadvantages of using KNN for classification?\n",
    "- How do you evaluate the performance of a KNN classifier?\n",
    "- Can you implement KNN in Python using libraries like scikit-learn?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6G3qeFhxFQWx"
   },
   "source": [
    "## DEFINITIONS YOU’LL NEED TO KNOW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f7rPZLW1FRCC"
   },
   "source": [
    "\n",
    "- Confusion Matrix - a contingency table for classifier performance. It shows how often the classifier was correct and the kinds of mistakes it made.\n",
    "- Accuracy - a measurement of how many times a classifier was correct.\n",
    "- Recall - is the ratio of true positives to the total number of actual positives.\n",
    "- Precision - is the number of true positives divided by all the times true is predicted.\n",
    "- Specificity - a ratio that uses the number of true negatives to the total number of actual negatives to test how good the classifier is.\n",
    "- KNN - a commonly used classifier; also known as k-nearest neighbors.\n",
    "- Classification - the process of predicting a class for a new observation.\n",
    "- Classifier - a tool used to predict classes from data; the predictions are based on features of the data.\n",
    "- Standardize - putting the data on the same scale\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4iMt706KFZKj"
   },
   "source": [
    "## SCENARIO:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "html": "<iframe class='metadata-html' width='560' height='315' src='https://video.olney.ai/6-knn-c.mp4' title='YouTube video player' frameborder='0' allow='accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share' referrerpolicy='strict-origin-when-cross-origin' allowfullscreen></iframe>",
    "id": "npqY6ZiSbavX",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Angelia and Diego have thought of different ways to understand the data they collected to help solve their pollution problem in the city. They used measures of association to understand the relationship and patterns of their datasets and used clustering to group areas with similar pollution levels. Clustering did not give them clear information about what areas had the worst pollution problems. They needed a method that could make better predictions and not just group certain areas with each other. Kiana suggested using KNN, which will help them predict pollution levels in one city by looking at pollution levels in nearby cities that they have already collected data about. Using this method will help make it easier for the group to predict which cities need the most air improvement to provide cleaner air to the entire city.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xzRPbafWG-xR"
   },
   "source": [
    "**So what even is KNN?**\n",
    "\n",
    "In the last notebook, we learned about clustering and putting data together so we can label them, which is really helpful when we don’t know the groups ahead of time.\n",
    "\n",
    "But what if we knew the groups ahead of time? This is where ***K-nearest neighbors (KNN)*** is super helpful because it will help us ‘classify’ what groups to put the data in based on the groups are already known. This kind of classification means we know and name the groups, so we use a model to predict the label for any new data point. In other words, when we know some of the features or something about the data, we can use those pieces of information to tell the model (calculations of your data) to classify the data into labels.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gIdcGPeWG_VZ"
   },
   "source": [
    "\n",
    "**Diving Deeper into KNN**\n",
    "\n",
    "Let’s think through how KNN works.\n",
    "\n",
    "Remember that idea of distance we introduced in the clustering notebook? Well, KNN classifies (labels) new items based on their distance to other datapoints. Actually, KNN uses a specific number of closest data points to predict the label of the new unknown item that we are considering. To make it simple, we’ll call that number k.\n",
    "\n",
    "If our k = 2, then we are looking for the two closest data points to predict the label for the new data point the model considers. If k = 3, we’ll look at the three closest data points to predict the label.\n",
    "\n",
    "How simple is that?!\n",
    "\n",
    "This can be pretty useful most of the time, but we still have to be careful because we don't know the best value k to use. It turns out that different values of k make a big difference in how accurate our classifier will be.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AgWRox1tHTN1"
   },
   "source": [
    "**Standardization**\n",
    "\n",
    "Another thing you might need to think about is standardizing the dataset if you have different scales. Imagine you have two things you’d like to compare: the weight of someone (weight) and how tall someone is (height). The weight of someone in pounds is usually a bigger number than the height of someone in feet. If you only look at the bigger number (weight), it might look more important than the smaller number (height), even though it is also important.\n",
    "\n",
    "Yikes.\n",
    "\n",
    "You can imagine how confusing that could get if we only thought the biggest number was the most important.  To fix this, we can take each number and do a special math trick called “standardizing.” This means we put them all on the same scale. This way, weight, and height can be compared better to make the KNN model make smarter choices.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k51sYdaZH3ue"
   },
   "source": [
    "**Tools to Test Classifiers (How to put data into the labels)**\n",
    "\n",
    "To begin, first, we have to standardize by putting them on the same scale. When we say “standardize” or put the data on the \"same scale,\" we mean making sure big numbers don't affect the distance more than small numbers.\n",
    "\n",
    "How can we have a model that can predict how to assign the labels? A simple way is to just create two models that we can compare against each other - one where we train and another where we test out our predictions. So now KNN uses classified (labeled) items ahead of time that help us classify new data points we find in the testing data\n",
    "\n",
    "We can check if the classifier is learning properly by splitting the data into training and testing.\n",
    ". When we do this, all of the data is shuffled together (almost like a deck of cards) and then split into new rows - one for use with the classifier and one for testing the classifier later. Once we get that, the classifier will help us generalize for new data that we come across.\n",
    "\n",
    "If a classifier chooses the same label each time we use it, the model isn’t working properly. If you overfit (memorize training data), it won't work on new. If you can generalize well enough (ie - learn about the structure of data), performance on new data will be the same as training data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2_CQe3suID8R"
   },
   "source": [
    "\n",
    "**How do we know if we have a good classifier?**\n",
    "\n",
    "A confusion matrix is a table that compares the class we predict and the true class. So this really helps us know how good or bad our classifier actually is.\n",
    "\n",
    "First, let's think about how our classifier can be right and how it can be wrong. There are two ways it can be right:\n",
    "- ***True Positive (TP)***: When you say something is there and it actually is. I think there is a UFO and there is actually one out out there.\n",
    "- ***True Negative (TN)***: When you say something is not there, and it actually isn’t. I say there isn’t a UFO out there, but there actually is one out there.\n",
    "\n",
    "There are also two ways the classifier can be wrong:\n",
    "- ***False Positive (FP)***: When you say something is there, but it actually isn’t. I say there is a UFO, but there isn’t one out there.\n",
    "- ***False Negative (FN)***: When you say something is not there, but it actually is. I say there isn’t a UFO, but there is actually one out there.\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ4srLXMAAiPt2?format=png&name=small)\n",
    "\n",
    "A good classifier will have a large number of TP and TN (correct data) and a small number of FP and FN (errors or incorrect data).\n",
    "\n",
    "Consider a COVID test as an example. A true positive means the test is positive and you have COVID, and a true negative means the test is negative and you don't have COVID. False positives and false negatives are when the test is wrong: either it says you have COVID when you don't (FP) or it says you don't have COVID when you do (FN).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uT_fDG_QIcvu"
   },
   "source": [
    "\n",
    "**What are the Measures of a Good Classifier?**\n",
    "\n",
    "The confusion matrix is a great tool by itself, but there are a few more tools we can use to understand how well our classifier is doing.\n",
    "\n",
    "- ***Accuracy*** - accuracy helps us understand how many times we were right! With this metric, we are measuring true positives and true negatives against the number of everything in the matrix. To do this, we add TP and TN and then divide that number by the total of every classification in the confusion matrix. This number will be between 0 (bad) or 1 (great).\n",
    "\n",
    "- ***Recall*** - is the ratio of true positives to total number of actual positives. In other words, in order to understand how large or small the recall is, we divide the number of times you said something was predicted to be positive by the times the data was actually positive. Recall will always be a number between 0 and 1. The closer the number is to 1, the better the classifier is.\n",
    "\n",
    "- ***Precision*** - is the number of true positives divided by all the times we predicted true (first row above added together…TP + FP). With precision, the number will always be between 0 and 1. The closer the number is to 1, the better the classifier is.\n",
    "\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ4xssXYAAvG4L?format=png&name=small\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6RgvO5JVIZCK"
   },
   "source": [
    "## YOUR TURN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "swF1q0CMIs2x"
   },
   "source": [
    "\n",
    "\n",
    "Now that you understand the basics of KNN and its classification power, it’s time to practice applying these concepts! As you go through this, think about how metrics like accuracy and specificity help you determine how well your model is performing and how you can adjust it for better results.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4U3KOAWDI6Ql"
   },
   "source": [
    "### Goal 1: Importing the Pandas Library\n",
    "\n",
    "Need extra tools to help solve this problem? Well, we can bring in extra ‘libraries’ to help us do extra data science stuff. You can think of it as an ‘add-on’. In this case, we bring in pandas, which is a popular library for doing data science stuff.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MNd7pV54I90i"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z8OYy7WEJB-l"
   },
   "source": [
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in.\n",
    "\n",
    "Bring in the IMPORT menu, which can be helpful to bring in other data tools. In this case, we're bringing in the **import** block.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dkPNqP6zJEXR"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out **pandas**, which will bring in some cool data manipulation features.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FU3GRPMlJFJZ"
   },
   "source": [
    "\n",
    "**Step 3 - Renaming the library so it’s easy to remember**\n",
    "\n",
    "Once you are done, put the **import** and **package** together in a single variable. This handy feature helps cut down on all the typing later on. You can call it whatever is easiest for you to remember. In the example below, we’ve put everything into **pd**, and we type it in the open area.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DbikYzJ4JGHl"
   },
   "source": [
    "\n",
    "**Step 4 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GcxNkjYXkAAlpKD?format=png&name=240x240)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M3FhLm3sJUbg"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-rl0_61gJWnB"
   },
   "source": [
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z2G-pJrAJaQm"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out pandas, which will bring in some cool data manipulation features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xH1AIYGmJbRt"
   },
   "source": [
    "\n",
    "**Step 3 - Renaming the library so it’s easy to remember**\n",
    "\n",
    "Once you are done, put the ‘import’ and ‘package’ together in a single variable. This handy feature helps cut down on all the typing later on. Feel free to use whatever name you want that will help you remember it later on. In the example below, we’ve put everything into **pd**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oRX85ApiJcUj"
   },
   "source": [
    "\n",
    "**Step 4 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GZmkVCYWEA4oGso?format=jpg&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mg7AUyH1JlTZ"
   },
   "source": [
    "**Your Turn**: Now it’s your turn! We’re going to dive into the pandas package, which helps us with some really cool data science things. First, let’s import the package and assign it to the variable “pd” to make it easier to use throughout our notebook.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "JHoqoveFJpVf"
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RD60QuNHJq7-"
   },
   "source": [
    "**Explanation**: *Congrats!  Your attempts finally made it!  Now you have successfully imported the \"pandas\" package as the variable \"pd\"*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U9fPLU8IJs69"
   },
   "source": [
    "### Goal 2: Bringing in the Dataframe\n",
    "\n",
    "Let’s bring in the data that we want to look at.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I20y-R_XJv_k"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rtYwajtNKC8K"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the variable name you want to use**\n",
    "\n",
    "Now that we’re all set with our new package to help us to do cool things, let’s bring the data into a variable and call it **train**. Think of it as a digital spreadsheet with much more power to analyze and manipulate the data!\n",
    "\n",
    "In Blockly, bring in the VARIABLES menu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CnY05_DcKN6K"
   },
   "source": [
    "\n",
    "\n",
    "Step 2 - Assign the dataframe to the variable you created\n",
    "Just like we did before, let’s type out a variable name. Rather than type out the full file name for our data, this easy to remember name will hold the data we bring in.\n",
    "\n",
    "In Blockly, go to the Variables and drag the Set block for the **train** variable. This will allow us to assign the result of a function call to the variable. A function is basically code that does a specific task for us.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tgUBd-zqKQgB"
   },
   "source": [
    "\n",
    "**Step 3 - Bring in the data**\n",
    "\n",
    "Now we need to look at the file that has all our data. To load our dataframe, we’ll use a simple command to bring in the file we need (CSV….Comma Separated Values). Let’s say we have a file called ‘datasets/AirQualityTrain.csv' in the folder **‘datasets’**. We’re telling Python to read the CSV file and store it in a variable called **train**.\n",
    "\n",
    "From the Variable menu, drag a DO block using the **pd** variable, go ahead with the do operation **read_csv**. The read_csv function reads a CSV file and returns a DataFrame object.\n",
    "\n",
    "In our case, let’s bring in the “datasets/AirQualityTrain.csv\" (use the Quotes from the TEXT menu) because that is what Kiana is working with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SDoyQ_aSKSJ-"
   },
   "source": [
    "\n",
    "\n",
    "**Step 4 - Display the variable**\n",
    "\n",
    "Let’s see it now by ‘displaying’ and showing our work.\n",
    "\n",
    "Drag the **train** variable to the workspace, making it available for further use in our program. This step is more of a visualization step, as it allows us to see the variable in the Blockly workspace\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3bpw8j_iKTfb"
   },
   "source": [
    "\n",
    "**Step 5 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQOYi_WsAAG6u8?format=png&name=small)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cJsXw3WmK_YY"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jqWsYV4VLFbo"
   },
   "source": [
    "**Step 1 - Write out the variable name you want to use**\n",
    "\n",
    "Now that we’re all set with our new package to help us  do cool things, let’s bring the data into a variable called train. Think of it as a digital spreadsheet with much more power to analyze and manipulate the data!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YdEQ2dsULHnW"
   },
   "source": [
    "\n",
    "\n",
    "**Step 2 - Assign the dataframe to the variable you created**\n",
    "\n",
    "Just like we did before, let’s type out a variable name. Rather than type out the full file name for our data, this easy to remember name will hold the data we bring in.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nd1POMUpLJO4"
   },
   "source": [
    "\n",
    "**Step 3 - Bring in the data**\n",
    "\n",
    "Now we need to look at the file that has all our data.\n",
    "\n",
    "To load our dataframe, we’ll use a simple command to bring in the file we need (CSV….Comma Separated Values). Let’s say we have a file called “datasets/AirQualityTrain.csv” folder **‘datasets’**. We’re telling Python to read the CSV file and store it in a variable called **train**. For this function, we need to specify the code as “pd.read_csv”, which makes the code read the csv file. This variable is now our dataframe!\n",
    "\n",
    "In our case, let’s bring in the “datasets/AirQualityTrain.csv” (user the Quotes from the TEXT menu) because that is what we are working with.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j846FW6DLKdI"
   },
   "source": [
    "\n",
    "**Step 4 - Print the variable**\n",
    "\n",
    "Let’s see it now by ‘printing’ and showing our work. Retype the variable name underneath the code and it will print the code. In this case, we will type out the variable name **train**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OEXivwy_LLM4"
   },
   "source": [
    "\n",
    "**Step 5 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQObPkWAAAKRNW?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u_qaMi-gLges"
   },
   "source": [
    "**Your Turn**: Now it’s your turn!  Let’s dive in and start working with the data! We’ll begin by loading it into a dataframe, which will allow us to easily interact with and analyze the dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 423
    },
    "id": "NIrqF3R8Li_L",
    "outputId": "311c4f97-2af6-4041-eb28-61cec2e75cee"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "summary": "{\n  \"name\": \"train\",\n  \"rows\": 1291,\n  \"fields\": [\n    {\n      \"column\": \"Contaminated\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 1,\n        \"num_unique_values\": 2,\n        \"samples\": [\n          0,\n          1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Methane\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 192,\n        \"min\": 263,\n        \"max\": 1266,\n        \"num_unique_values\": 570,\n        \"samples\": [\n          346,\n          386\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"NOxEmissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 173,\n        \"min\": 346,\n        \"max\": 1388,\n        \"num_unique_values\": 545,\n        \"samples\": [\n          452,\n          467\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"PM2.5Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 210,\n        \"min\": 753,\n        \"max\": 1738,\n        \"num_unique_values\": 630,\n        \"samples\": [\n          1516,\n          1244\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"VOCEmissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 118,\n        \"min\": 1323,\n        \"max\": 1926,\n        \"num_unique_values\": 420,\n        \"samples\": [\n          1562,\n          1431\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"SO2Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 280,\n        \"min\": 773,\n        \"max\": 1930,\n        \"num_unique_values\": 729,\n        \"samples\": [\n          1707,\n          1520\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"CO2Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 181,\n        \"min\": 1814,\n        \"max\": 2703,\n        \"num_unique_values\": 572,\n        \"samples\": [\n          1865,\n          2317\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
       "type": "dataframe",
       "variable_name": "train"
      },
      "text/html": [
       "\n",
       "  <div id=\"df-2c1f2c4f-47b4-4629-9508-16215f499349\" class=\"colab-df-container\">\n",
       "    <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Contaminated</th>\n",
       "      <th>Methane</th>\n",
       "      <th>NOxEmissions</th>\n",
       "      <th>PM2.5Emissions</th>\n",
       "      <th>VOCEmissions</th>\n",
       "      <th>SO2Emissions</th>\n",
       "      <th>CO2Emissions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>848</td>\n",
       "      <td>960</td>\n",
       "      <td>1367</td>\n",
       "      <td>1784</td>\n",
       "      <td>1745</td>\n",
       "      <td>2445</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1063</td>\n",
       "      <td>968</td>\n",
       "      <td>1627</td>\n",
       "      <td>1736</td>\n",
       "      <td>1785</td>\n",
       "      <td>1888</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>771</td>\n",
       "      <td>765</td>\n",
       "      <td>1391</td>\n",
       "      <td>1692</td>\n",
       "      <td>1523</td>\n",
       "      <td>2106</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>536</td>\n",
       "      <td>624</td>\n",
       "      <td>1224</td>\n",
       "      <td>1594</td>\n",
       "      <td>1171</td>\n",
       "      <td>2158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>782</td>\n",
       "      <td>789</td>\n",
       "      <td>1333</td>\n",
       "      <td>1732</td>\n",
       "      <td>1529</td>\n",
       "      <td>2213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1286</th>\n",
       "      <td>1</td>\n",
       "      <td>694</td>\n",
       "      <td>729</td>\n",
       "      <td>1396</td>\n",
       "      <td>1568</td>\n",
       "      <td>1492</td>\n",
       "      <td>2106</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1287</th>\n",
       "      <td>0</td>\n",
       "      <td>377</td>\n",
       "      <td>482</td>\n",
       "      <td>1010</td>\n",
       "      <td>1466</td>\n",
       "      <td>935</td>\n",
       "      <td>2242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1288</th>\n",
       "      <td>1</td>\n",
       "      <td>737</td>\n",
       "      <td>685</td>\n",
       "      <td>1292</td>\n",
       "      <td>1659</td>\n",
       "      <td>1436</td>\n",
       "      <td>2308</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1289</th>\n",
       "      <td>0</td>\n",
       "      <td>369</td>\n",
       "      <td>478</td>\n",
       "      <td>890</td>\n",
       "      <td>1471</td>\n",
       "      <td>1003</td>\n",
       "      <td>2232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1290</th>\n",
       "      <td>1</td>\n",
       "      <td>513</td>\n",
       "      <td>577</td>\n",
       "      <td>1162</td>\n",
       "      <td>1589</td>\n",
       "      <td>1155</td>\n",
       "      <td>2161</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1291 rows × 7 columns</p>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-2c1f2c4f-47b4-4629-9508-16215f499349')\"\n",
       "            title=\"Convert this dataframe to an interactive table.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\n",
       "      gap: 12px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert {\n",
       "      background-color: #E8F0FE;\n",
       "      border: none;\n",
       "      border-radius: 50%;\n",
       "      cursor: pointer;\n",
       "      display: none;\n",
       "      fill: #1967D2;\n",
       "      height: 32px;\n",
       "      padding: 0 0 0 0;\n",
       "      width: 32px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert:hover {\n",
       "      background-color: #E2EBFA;\n",
       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "      fill: #174EA6;\n",
       "    }\n",
       "\n",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert {\n",
       "      background-color: #3B4455;\n",
       "      fill: #D2E3FC;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert:hover {\n",
       "      background-color: #434B5C;\n",
       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "      fill: #FFFFFF;\n",
       "    }\n",
       "  </style>\n",
       "\n",
       "    <script>\n",
       "      const buttonEl =\n",
       "        document.querySelector('#df-2c1f2c4f-47b4-4629-9508-16215f499349 button.colab-df-convert');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      async function convertToInteractive(key) {\n",
       "        const element = document.querySelector('#df-2c1f2c4f-47b4-4629-9508-16215f499349');\n",
       "        const dataTable =\n",
       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
       "                                                    [key], {});\n",
       "        if (!dataTable) return;\n",
       "\n",
       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
       "          + ' to learn more about interactive tables.';\n",
       "        element.innerHTML = '';\n",
       "        dataTable['output_type'] = 'display_data';\n",
       "        await google.colab.output.renderOutput(dataTable, element);\n",
       "        const docLink = document.createElement('div');\n",
       "        docLink.innerHTML = docLinkHtml;\n",
       "        element.appendChild(docLink);\n",
       "      }\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "\n",
       "<div id=\"df-dccdd9a7-feb2-4d51-8b94-82c52940a395\">\n",
       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-dccdd9a7-feb2-4d51-8b94-82c52940a395')\"\n",
       "            title=\"Suggest charts\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "     width=\"24px\">\n",
       "    <g>\n",
       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
       "    </g>\n",
       "</svg>\n",
       "  </button>\n",
       "\n",
       "<style>\n",
       "  .colab-df-quickchart {\n",
       "      --bg-color: #E8F0FE;\n",
       "      --fill-color: #1967D2;\n",
       "      --hover-bg-color: #E2EBFA;\n",
       "      --hover-fill-color: #174EA6;\n",
       "      --disabled-fill-color: #AAA;\n",
       "      --disabled-bg-color: #DDD;\n",
       "  }\n",
       "\n",
       "  [theme=dark] .colab-df-quickchart {\n",
       "      --bg-color: #3B4455;\n",
       "      --fill-color: #D2E3FC;\n",
       "      --hover-bg-color: #434B5C;\n",
       "      --hover-fill-color: #FFFFFF;\n",
       "      --disabled-bg-color: #3B4455;\n",
       "      --disabled-fill-color: #666;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart {\n",
       "    background-color: var(--bg-color);\n",
       "    border: none;\n",
       "    border-radius: 50%;\n",
       "    cursor: pointer;\n",
       "    display: none;\n",
       "    fill: var(--fill-color);\n",
       "    height: 32px;\n",
       "    padding: 0;\n",
       "    width: 32px;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart:hover {\n",
       "    background-color: var(--hover-bg-color);\n",
       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "    fill: var(--button-hover-fill-color);\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart-complete:disabled,\n",
       "  .colab-df-quickchart-complete:disabled:hover {\n",
       "    background-color: var(--disabled-bg-color);\n",
       "    fill: var(--disabled-fill-color);\n",
       "    box-shadow: none;\n",
       "  }\n",
       "\n",
       "  .colab-df-spinner {\n",
       "    border: 2px solid var(--fill-color);\n",
       "    border-color: transparent;\n",
       "    border-bottom-color: var(--fill-color);\n",
       "    animation:\n",
       "      spin 1s steps(1) infinite;\n",
       "  }\n",
       "\n",
       "  @keyframes spin {\n",
       "    0% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "      border-left-color: var(--fill-color);\n",
       "    }\n",
       "    20% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    30% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    40% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    60% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    80% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "    90% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "  }\n",
       "</style>\n",
       "\n",
       "  <script>\n",
       "    async function quickchart(key) {\n",
       "      const quickchartButtonEl =\n",
       "        document.querySelector('#' + key + ' button');\n",
       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
       "      try {\n",
       "        const charts = await google.colab.kernel.invokeFunction(\n",
       "            'suggestCharts', [key], {});\n",
       "      } catch (error) {\n",
       "        console.error('Error during call to suggestCharts:', error);\n",
       "      }\n",
       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
       "    }\n",
       "    (() => {\n",
       "      let quickchartButtonEl =\n",
       "        document.querySelector('#df-dccdd9a7-feb2-4d51-8b94-82c52940a395 button');\n",
       "      quickchartButtonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "    })();\n",
       "  </script>\n",
       "</div>\n",
       "\n",
       "  <div id=\"id_50a9549f-af5a-4545-97c7-9e020b8a86f8\">\n",
       "    <style>\n",
       "      .colab-df-generate {\n",
       "        background-color: #E8F0FE;\n",
       "        border: none;\n",
       "        border-radius: 50%;\n",
       "        cursor: pointer;\n",
       "        display: none;\n",
       "        fill: #1967D2;\n",
       "        height: 32px;\n",
       "        padding: 0 0 0 0;\n",
       "        width: 32px;\n",
       "      }\n",
       "\n",
       "      .colab-df-generate:hover {\n",
       "        background-color: #E2EBFA;\n",
       "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "        fill: #174EA6;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate {\n",
       "        background-color: #3B4455;\n",
       "        fill: #D2E3FC;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate:hover {\n",
       "        background-color: #434B5C;\n",
       "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "        fill: #FFFFFF;\n",
       "      }\n",
       "    </style>\n",
       "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('train')\"\n",
       "            title=\"Generate code using this dataframe.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "       width=\"24px\">\n",
       "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "    <script>\n",
       "      (() => {\n",
       "      const buttonEl =\n",
       "        document.querySelector('#id_50a9549f-af5a-4545-97c7-9e020b8a86f8 button.colab-df-generate');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      buttonEl.onclick = () => {\n",
       "        google.colab.notebook.generateWithVariable('train');\n",
       "      }\n",
       "      })();\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "text/plain": [
       "      Contaminated  Methane  NOxEmissions  PM2.5Emissions  VOCEmissions  \\\n",
       "0                1      848           960            1367          1784   \n",
       "1                1     1063           968            1627          1736   \n",
       "2                1      771           765            1391          1692   \n",
       "3                1      536           624            1224          1594   \n",
       "4                1      782           789            1333          1732   \n",
       "...            ...      ...           ...             ...           ...   \n",
       "1286             1      694           729            1396          1568   \n",
       "1287             0      377           482            1010          1466   \n",
       "1288             1      737           685            1292          1659   \n",
       "1289             0      369           478             890          1471   \n",
       "1290             1      513           577            1162          1589   \n",
       "\n",
       "      SO2Emissions  CO2Emissions  \n",
       "0             1745          2445  \n",
       "1             1785          1888  \n",
       "2             1523          2106  \n",
       "3             1171          2158  \n",
       "4             1529          2213  \n",
       "...            ...           ...  \n",
       "1286          1492          2106  \n",
       "1287           935          2242  \n",
       "1288          1436          2308  \n",
       "1289          1003          2232  \n",
       "1290          1155          2161  \n",
       "\n",
       "[1291 rows x 7 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train = pd.read_csv('datasets/AirQualityTrain.csv')\n",
    "train\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GfZLliImLkFE"
   },
   "source": [
    "**Explanation**: *The dataset could be used to train a classification model (KNN) that predicts whether conditions will result in contamination based on various emission levels. Alternatively, if all entries are contaminated, the data could support regression models to predict specific emission levels under contaminated conditions or clustering methods to identify patterns in emission profiles among contaminated sites*.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oNKnT5pqLwRP"
   },
   "source": [
    "### Goal 3: Bring in SkLearn Package to Help with KNN Classification.\n",
    "\n",
    "Remember how we bring in packages to help with extra data science things we come across? Now that we are doing KNN classification, we are going to bring in the SkLearn to help us classify the new data point based on nearest neighbors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f9q0U-HNL1Hh"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EEbSyZPxL5ma"
   },
   "source": [
    "\n",
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in.\n",
    "\n",
    "Bring in the IMPORT menu, which can be helpful to bring in other data tools. In this case, we're bringing in the **import** block.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GpbgG9bLMAgQ"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out **sklearn.neighbors**, which finds the closest data points to a new data point, and then classifies the new data point based on the majority class of its nearest neighbors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1pxdN3osMBYy"
   },
   "source": [
    "\n",
    "**Step 3 - Renaming the library so it’s easy to remember**\n",
    "\n",
    "Once you are done, put the **import** and **package** together in a single variable. This handy feature helps cut down on all the typing later on. You can call it whatever is easiest for you to remember. In the example below, we’ve put everything into **neighbors**, and we type it in the open area.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_9UKZj5iMB_u"
   },
   "source": [
    "\n",
    "**Step 4 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQP_vjXcAABeTu?format=png&name=360x360)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bPKEdVM-MUT0"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bk_a-o-DMfZA"
   },
   "source": [
    "\n",
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n681W7x6Ml7P"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out **sklearn.neighbors**, which will provide us with some cool data manipulation features.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-LirkY1YMmsw"
   },
   "source": [
    "\n",
    "**Step 3 - Import package as acronym**\n",
    "\n",
    "Once you are done, put the ‘import’ and ‘package’ together in a single variable. This handy feature helps cut down on all the typing later on. You can call it whatever is easiest for you to remember. In the example below, we’ve put everything into **neighbors**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eOqWA8G7MnTk"
   },
   "source": [
    "\n",
    "**Step 4 - Run**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQP4lLXYAAMJIq?format=png&name=360x360)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vKkeT6ZgMy5h"
   },
   "source": [
    "**Your Turn**: So let’s bring in SKLearn and let’s get started!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "y9df2M8OM36p"
   },
   "outputs": [],
   "source": [
    "import sklearn.neighbors as neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J-9rh905M5ZD"
   },
   "source": [
    "**Explanation**: *Congrats! Your attempts finally made it! Now you have successfully imported the **sklearn.neighbors** package as the variable neighbors* **bold text**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x6Q2hJYGM8sp"
   },
   "source": [
    "### Goal 4: Create the Model Object.\n",
    "\n",
    "Let’s get started with KNN classification and tell how many neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u6QKESAYNAou"
   },
   "source": [
    "### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MwF7hzDZNFy-"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the name of a variable you want to use for the classifier**\n",
    "\n",
    "We setup a variable to store the classifier model in a variable for later use. In this case, we will call it **knn**.\n",
    "\n",
    "On the \"Variables\" menu, click Create Variable, type a name for our model, **knn**. Then, drag a \"SET\" block to the workspace for the created variable. This block allows us to create a new variable and assign a value to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "heJG9k9SNHNN"
   },
   "source": [
    "\n",
    "\n",
    "**Step 2 - Create the KNN classifier model**\n",
    "\n",
    "Using the neighbors library, we call the KNeighborsClassifier() to create the KNN model.\n",
    "\n",
    "From the Variable menu, drag a Create block for the **neighbors** variable. On the create listbox select the option **KNeighborsClassifier**. This specifies the type (class) of object we want to create, which is the KNeighborsClassifier from the neighbors module.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pTPLweE_NIJ4"
   },
   "source": [
    "\n",
    "**Step 3 - Define the hyperparameters**\n",
    "\n",
    "Inside the method, we say how many neighbors to explore for our classifier. We use 5 neighbors in this case.\n",
    "\n",
    "Drag a Freestyle block, and type **n_neighbors=5**. This specifies the number of neighbors to consider when making predictions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OvX6bQTPNJKe"
   },
   "source": [
    "\n",
    "**Step 4 - Assign the classifier model to the variable you created**\n",
    "\n",
    "We can now connect the **knn** variable with the **KNeighborsClassifier** model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q6srhD3ENJyK"
   },
   "source": [
    "\n",
    "**Step 5 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQesefWgAARv5o?format=png&name=small)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ug6w26H3N186"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zrhxw6QkN3vb"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the name for a variable you want to use for the classifier**\n",
    "\n",
    "We setup a variable to store the classifier model in a variable for later use. In this case, we will call it **knn**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L7JAb9FDOC5Y"
   },
   "source": [
    "\n",
    "**Step 2 - Create the KNN classifier model**\n",
    "\n",
    "Using the neighbors library, we call the KNeighborsClassifier() method.\n",
    "\n",
    "`neighbors.KNeighborsClassifier()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5P7vBOYZODoM"
   },
   "source": [
    "\n",
    "**Step 3 - Define the hyperparameters**\n",
    "\n",
    "Inside the method, we say how many neighbors to explore for our classifier. We use 5 neighbors in this case. We use 5 neighbors in this case.\n",
    "\n",
    "`neighbors.KNeighborsClassifier(n_neighbors=5)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O5QFNuOdOEUJ"
   },
   "source": [
    "\n",
    "**Step 4 - Assign the classifier model to the variable you created**\n",
    "\n",
    "We set up a variable to store the classifier model in a variable for later use. In this case, we will call it **knn**.\n",
    "\n",
    "`knn = neighbors.KNeighborsClassifier(n_neighbors=5)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QBKlhK4-OFBG"
   },
   "source": [
    "\n",
    "\n",
    "**Step 5 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQevIqX0AAXDSS?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8-pemr9zOTwn"
   },
   "source": [
    "**Your Turn**: Ready! Set! Code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "Z2aZ3fq6OZ6v"
   },
   "outputs": [],
   "source": [
    "knn = neighbors.KNeighborsClassifier(n_neighbors=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "piVfLSmDOboB"
   },
   "source": [
    "**Explanation**: *You have created a K-Nearest Neighbors (KNN) classifier. The KNN classifier is a machine learning model that classifies data points based on the closest data points (neighbors) around them. Here, the model will look at the 5 nearest neighbors to decide the class of a new data point*.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UjEihwrzOdGr"
   },
   "source": [
    "### Goal 5: Train and Score the Classifier Model.\n",
    "\n",
    "Now that we’ve brought in our KNN model, let’s train the model to see how it will learn from the data points that we have in the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IQpkM8fOOxlj"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vLDl8DJTOytu"
   },
   "source": [
    "**Step 1 - Prepare to train the model**\n",
    "\n",
    "To train data using the classifier model, we use the model and call the fit() method from it. This will use the ‘fit’ method to train the model that we want to train on.  \n",
    "\n",
    "From the Variable menu, drag the DO block for the **knn** variable, and select the **fit** function as the do operation. This specifies the function we want to call, which is the fit method of the knn object.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vnnoCRrlO1IA"
   },
   "source": [
    "\n",
    "**Step 2 - Have the training features ready**\n",
    "\n",
    "The next step for training the model is to select the features to train the classifier. In this step, we select the features and add them as a dataframe in the parameter. In this case, the model will train (learn) the classifier based on these 6 variables and use it to predict the label\n",
    "\n",
    "From the Lists menu, drag a dictVariable, and select the \"train\" variable from the list of available variables. Also, from the Lists menu, you will get a Create List block. Using the Gear icon, add up to 6 items. For each one of the items, add a Text (a Quote “” from the Text menu), as follows:  \"Methane\", \"NOxEmissions\", \"PM2.5Emissions\", \"VOCEmissions\", \"SO2Emissions\", and \"CO2Emissions\". These are the feature names applied to train (fit) the model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hyqcuuLCO3aT"
   },
   "source": [
    "\n",
    "**Step 3 - Have the training label ready**\n",
    "\n",
    "So what is the label that we are trying to predict? Next, we need to add the data labels for the selected features. We add the data labels (**Contaminated**) as a parameter in the fit() method.\n",
    "\n",
    "From the Lists menu, drag a dictVariable, and select the **train** variable from the list of available variables. From the Text menu, get a Quote “” block and add a Text \"**Contaminated**\". This is the target value applied to train (fit) the model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LpBCebNCO44d"
   },
   "source": [
    "\n",
    "**Step 4 - Measure the correctness on the training dataset**\n",
    "\n",
    "To measure the correctness of the model, we will use the score method() from the **knn** library. Just as the previous step, we will just replace the fit() method with the score() method. Based on the ‘fit’, we will try to see how much we were able to predict in our training dataset.\n",
    "\n",
    "This will give us the **knn** models correctness score. A good score will be closer to 1 (ie - 100). Medium might be more like .95 (95% accurate). Not great would be .90 (90%). It depends on the topic you are looking at.\n",
    "\n",
    "Right-click on the \"knn.**fit**\" block and select \"Duplicate\" from the context menu. This creates a copy of the block. Within the duplicated block, click on the method dropdown menu and select \"**score**\" from the list of available methods. The score method will work similarly to fit, and will use the training features and label to measure how much of the training data was learned.   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_7RmUyNSO5ru"
   },
   "source": [
    "\n",
    "**Step 5 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQzqqPWsAAdMhn?format=png&name=small)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rNV_S4HjPYfQ"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SgFZPwDsPh8a"
   },
   "source": [
    "\n",
    "**Step 1 - Prepare to train the model**\n",
    "\n",
    "To train data using the classifier model, we use the model and call the fit() method from it. This will use the ‘fit’ method to train the model that we want to train on.  \n",
    "\n",
    "`knn.fit()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bCDrBzW_PkEw"
   },
   "source": [
    "\n",
    "**Step 2 - Have the training features ready**\n",
    "\n",
    "The next step for training the model is to select the features to train the classifier. In this step, we select the features and add them as a dataframe in the parameter. In this case, the model will train (learn) the classifier based on these 6 variables and use it to predict the label\n",
    "\n",
    "`knn.fit(train[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "14CZpBsePmHK"
   },
   "source": [
    "\n",
    "**Step 3 -  Have the training label ready**\n",
    "\n",
    "So what is the label that we are trying to predict? Next, we need to add the data labels for the selected features. We add the data labels (**Contaminated**) as a parameter in the fit() method.\n",
    "knn.fit(train[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']],train['Contaminated'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5w6iV9Q6Pnmb"
   },
   "source": [
    "\n",
    "**Step 4 - Measure the correctness on the training dataset**\n",
    "\n",
    "To measure the correctness of the model, we will use the score method() from the knn library. Just as in the previous step, we will just replace the **fit**() method with the **score**() method. Based on the ‘fit’, we will try to see how much we were able to predict in our training dataset.\n",
    "\n",
    "This will give us the knn models correctness score. A good score will be closer to 1 (ie - 100). Medium might be more like .95 (95% accurate). Not great would be .90 (90%). It depends on the topic you are looking at.\n",
    "\n",
    "`knn.score(train[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']],train['Contaminated'])`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DbcmfWvIPoor"
   },
   "source": [
    "\n",
    "**Step 5 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQznuXXwAEzVd9?format=jpg&name=medium)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NhZk3CUXP8wu"
   },
   "source": [
    "**Your Turn**: Try to see if you can recreate the code to train and score your own classifier model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "G-90y9MvQOPm",
    "outputId": "656e5428-3dc9-4340-91ff-02f6ae420049"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9907048799380326"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn.fit(train[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']],train['Contaminated'])\n",
    "knn.score(train[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']],train['Contaminated'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6nPOsg01QSFW"
   },
   "source": [
    "**Explanation**:  *You have trained a KNN model that can predict if something is \"Contaminated\" (the label) based on several types of emissions, the features: Methane, NOxEmissions, PM2.5Emissions, VOCEmissions, SO2Emissions, and CO2Emissions.  You have also calculated the score, which tells us the model's accuracy on this data. A higher score means the model is better at making correct predictions based on the given emissions*.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JObc3bmPQVOk"
   },
   "source": [
    "### Goal 6: Bringing in the Test Data.\n",
    "\n",
    "So we’ve looked at the training dataset to learn something about our data. How about applying it to the rest of the dataset and ‘test’ to see how good our predictions are?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CIihScn0QXx7"
   },
   "source": [
    "#### Blockly\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H01i6Vs7QZ4k"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the variable name you want to use**\n",
    "\n",
    "Now that we’re all set with our new package to help us to do cool things, let’s bring the data into a **test**. Think of it as a digital spreadsheet with much more power to analyze and manipulate the data!\n",
    "\n",
    "To do this, bring in the VARIABLES menu.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gwJ8oavBQjj8"
   },
   "source": [
    "\n",
    "**Step 2 - Assign the dataframe to the variable you created**\n",
    "\n",
    "From the Variables menu, drag the Set block for the **test** variable. This will allow us to assign the result of a function call to the variable.\n",
    "\n",
    "In Blockly, go to the Variables and drag the Set block for the **test** variable. This will allow us to assign the result of a function call to the variable. A function is basically code that does a specific task for us.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H9hb4-guQlj_"
   },
   "source": [
    "\n",
    "\n",
    "**Step 3 - Bring in the data**\n",
    "\n",
    "From the Variable menu, drag a DO block using the **pd** variable, go ahead with the do operation **read_csv**. The read_csv function reads a CSV file and returns a DataFrame object. In our case, let’s bring in the \"datasets/AirQualityTest.csv\" (user the Quotes from the TEXT menu) because that is what Kiana is working with.\n",
    "\n",
    "From the Variable menu, drag a DO block using the **pd** variable, go ahead with the do operation **read_csv**. The read_csv function reads a CSV file and returns a DataFrame object.\n",
    "\n",
    "In our case, let’s bring in the \"datasets/AirQualityTest.csv\"  (use the Quotes from the TEXT menu) because that is what Angelina is working with.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vB3QSF7iQmzO"
   },
   "source": [
    "\n",
    "\n",
    "**Step 4 - Display the variable**\n",
    "\n",
    "Let’s see it now by ‘displaying’ and showing our work.\n",
    "\n",
    "Drag the **test** variable to the workspace, making it available for further use in our program. This step is more of a visualization step, as it allows us to see the variable in the Blockly workspace.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LHqBJWytQnd-"
   },
   "source": [
    "\n",
    "**Step 5 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ0zDqWUAAzB82?format=png&name=small)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XwgQJgR9RR_c"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OSdaBCh3RTRm"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the variable name you want to use**\n",
    "\n",
    "Now that we’re all set with our new package to help us to do cool things, let’s bring the data into a variable called **test**. Think of it as a digital spreadsheet with much more power to analyze and manipulate the data!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7oB3K6ujRV4T"
   },
   "source": [
    "\n",
    "**Step 2 - Assign the dataframe to the variable you created**\n",
    "\n",
    "Just like we did before, let’s type out a variable name. Rather than type out the full file name for our data, this easy to remember name will hold the data we bring in.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BV1BZVmnRXof"
   },
   "source": [
    "\n",
    "**Step 3 - Bring in the data**\n",
    "\n",
    "Now we need to look at the file that has all our data.\n",
    "\n",
    "To load our dataframe, we’ll use a simple command to bring in the file we need (CSV….Comma Separated Values). Let’s say we have a file called ‘AirQualityTest.csv' in the folder **‘datasets’**. We’re telling Python to read the CSV file and store it in a variable called **test**. For this function, we need to specify the code as “pd.read_csv”, which makes the code read the csv file. This variable is now our dataframe!\n",
    "\n",
    "In our case, let’s bring in the “datasets/AirQualityTest.csv” (user the Quotes from the TEXT menu) because that is what the group is working with.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z6XeP0sLRY5T"
   },
   "source": [
    "\n",
    "**Step 4 - Print the variable**\n",
    "\n",
    "Let’s see it now by ‘printing’ and showing our work. Retype the variable name underneath the code and it will print the code. In this case, we will type out the variable name **test**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qti6fgP3RZk_"
   },
   "source": [
    "\n",
    "**Step 5 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ0w41WMAA60B_?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DsgEMq1kSAa1"
   },
   "source": [
    "**Your Turn**: Let’s try it! Now we can apply our predictions to the rest of the dataset and ‘test’ to see how good our predictions are!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 423
    },
    "id": "lre3iORJSBN2",
    "outputId": "2471c658-8f26-483b-997f-15f81ac4d79e"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "summary": "{\n  \"name\": \"test\",\n  \"rows\": 554,\n  \"fields\": [\n    {\n      \"column\": \"Contaminated\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 1,\n        \"num_unique_values\": 2,\n        \"samples\": [\n          1,\n          0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Methane\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 186,\n        \"min\": 263,\n        \"max\": 1254,\n        \"num_unique_values\": 368,\n        \"samples\": [\n          418,\n          799\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"NOxEmissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 174,\n        \"min\": 365,\n        \"max\": 1367,\n        \"num_unique_values\": 356,\n        \"samples\": [\n          724,\n          470\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"PM2.5Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 205,\n        \"min\": 758,\n        \"max\": 1715,\n        \"num_unique_values\": 390,\n        \"samples\": [\n          1332,\n          1277\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"VOCEmissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 120,\n        \"min\": 1341,\n        \"max\": 1925,\n        \"num_unique_values\": 308,\n        \"samples\": [\n          1754,\n          1800\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"SO2Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 277,\n        \"min\": 792,\n        \"max\": 1948,\n        \"num_unique_values\": 426,\n        \"samples\": [\n          1548,\n          1203\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"CO2Emissions\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 180,\n        \"min\": 1797,\n        \"max\": 2700,\n        \"num_unique_values\": 360,\n        \"samples\": [\n          2278,\n          2541\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
       "type": "dataframe",
       "variable_name": "test"
      },
      "text/html": [
       "\n",
       "  <div id=\"df-b7337195-6266-4443-abc8-b39b51cffff2\" class=\"colab-df-container\">\n",
       "    <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Contaminated</th>\n",
       "      <th>Methane</th>\n",
       "      <th>NOxEmissions</th>\n",
       "      <th>PM2.5Emissions</th>\n",
       "      <th>VOCEmissions</th>\n",
       "      <th>SO2Emissions</th>\n",
       "      <th>CO2Emissions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>355</td>\n",
       "      <td>433</td>\n",
       "      <td>917</td>\n",
       "      <td>1472</td>\n",
       "      <td>947</td>\n",
       "      <td>2245</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>749</td>\n",
       "      <td>832</td>\n",
       "      <td>1438</td>\n",
       "      <td>1740</td>\n",
       "      <td>1492</td>\n",
       "      <td>1866</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>556</td>\n",
       "      <td>635</td>\n",
       "      <td>1166</td>\n",
       "      <td>1599</td>\n",
       "      <td>1282</td>\n",
       "      <td>2144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>479</td>\n",
       "      <td>594</td>\n",
       "      <td>1192</td>\n",
       "      <td>1534</td>\n",
       "      <td>1243</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>373</td>\n",
       "      <td>435</td>\n",
       "      <td>867</td>\n",
       "      <td>1416</td>\n",
       "      <td>912</td>\n",
       "      <td>2286</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>549</th>\n",
       "      <td>1</td>\n",
       "      <td>543</td>\n",
       "      <td>654</td>\n",
       "      <td>1268</td>\n",
       "      <td>1642</td>\n",
       "      <td>1192</td>\n",
       "      <td>2099</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>550</th>\n",
       "      <td>1</td>\n",
       "      <td>459</td>\n",
       "      <td>572</td>\n",
       "      <td>1060</td>\n",
       "      <td>1543</td>\n",
       "      <td>1185</td>\n",
       "      <td>2124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>551</th>\n",
       "      <td>1</td>\n",
       "      <td>520</td>\n",
       "      <td>633</td>\n",
       "      <td>1218</td>\n",
       "      <td>1627</td>\n",
       "      <td>1103</td>\n",
       "      <td>2137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>552</th>\n",
       "      <td>0</td>\n",
       "      <td>387</td>\n",
       "      <td>489</td>\n",
       "      <td>850</td>\n",
       "      <td>1486</td>\n",
       "      <td>1005</td>\n",
       "      <td>2262</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>553</th>\n",
       "      <td>1</td>\n",
       "      <td>542</td>\n",
       "      <td>619</td>\n",
       "      <td>1063</td>\n",
       "      <td>1581</td>\n",
       "      <td>1429</td>\n",
       "      <td>2300</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>554 rows × 7 columns</p>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b7337195-6266-4443-abc8-b39b51cffff2')\"\n",
       "            title=\"Convert this dataframe to an interactive table.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\n",
       "      gap: 12px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert {\n",
       "      background-color: #E8F0FE;\n",
       "      border: none;\n",
       "      border-radius: 50%;\n",
       "      cursor: pointer;\n",
       "      display: none;\n",
       "      fill: #1967D2;\n",
       "      height: 32px;\n",
       "      padding: 0 0 0 0;\n",
       "      width: 32px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert:hover {\n",
       "      background-color: #E2EBFA;\n",
       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "      fill: #174EA6;\n",
       "    }\n",
       "\n",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert {\n",
       "      background-color: #3B4455;\n",
       "      fill: #D2E3FC;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert:hover {\n",
       "      background-color: #434B5C;\n",
       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "      fill: #FFFFFF;\n",
       "    }\n",
       "  </style>\n",
       "\n",
       "    <script>\n",
       "      const buttonEl =\n",
       "        document.querySelector('#df-b7337195-6266-4443-abc8-b39b51cffff2 button.colab-df-convert');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      async function convertToInteractive(key) {\n",
       "        const element = document.querySelector('#df-b7337195-6266-4443-abc8-b39b51cffff2');\n",
       "        const dataTable =\n",
       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
       "                                                    [key], {});\n",
       "        if (!dataTable) return;\n",
       "\n",
       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
       "          + ' to learn more about interactive tables.';\n",
       "        element.innerHTML = '';\n",
       "        dataTable['output_type'] = 'display_data';\n",
       "        await google.colab.output.renderOutput(dataTable, element);\n",
       "        const docLink = document.createElement('div');\n",
       "        docLink.innerHTML = docLinkHtml;\n",
       "        element.appendChild(docLink);\n",
       "      }\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "\n",
       "<div id=\"df-8c06f73f-cd18-49d5-8f91-65ef3a133318\">\n",
       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-8c06f73f-cd18-49d5-8f91-65ef3a133318')\"\n",
       "            title=\"Suggest charts\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "     width=\"24px\">\n",
       "    <g>\n",
       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
       "    </g>\n",
       "</svg>\n",
       "  </button>\n",
       "\n",
       "<style>\n",
       "  .colab-df-quickchart {\n",
       "      --bg-color: #E8F0FE;\n",
       "      --fill-color: #1967D2;\n",
       "      --hover-bg-color: #E2EBFA;\n",
       "      --hover-fill-color: #174EA6;\n",
       "      --disabled-fill-color: #AAA;\n",
       "      --disabled-bg-color: #DDD;\n",
       "  }\n",
       "\n",
       "  [theme=dark] .colab-df-quickchart {\n",
       "      --bg-color: #3B4455;\n",
       "      --fill-color: #D2E3FC;\n",
       "      --hover-bg-color: #434B5C;\n",
       "      --hover-fill-color: #FFFFFF;\n",
       "      --disabled-bg-color: #3B4455;\n",
       "      --disabled-fill-color: #666;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart {\n",
       "    background-color: var(--bg-color);\n",
       "    border: none;\n",
       "    border-radius: 50%;\n",
       "    cursor: pointer;\n",
       "    display: none;\n",
       "    fill: var(--fill-color);\n",
       "    height: 32px;\n",
       "    padding: 0;\n",
       "    width: 32px;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart:hover {\n",
       "    background-color: var(--hover-bg-color);\n",
       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "    fill: var(--button-hover-fill-color);\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart-complete:disabled,\n",
       "  .colab-df-quickchart-complete:disabled:hover {\n",
       "    background-color: var(--disabled-bg-color);\n",
       "    fill: var(--disabled-fill-color);\n",
       "    box-shadow: none;\n",
       "  }\n",
       "\n",
       "  .colab-df-spinner {\n",
       "    border: 2px solid var(--fill-color);\n",
       "    border-color: transparent;\n",
       "    border-bottom-color: var(--fill-color);\n",
       "    animation:\n",
       "      spin 1s steps(1) infinite;\n",
       "  }\n",
       "\n",
       "  @keyframes spin {\n",
       "    0% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "      border-left-color: var(--fill-color);\n",
       "    }\n",
       "    20% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    30% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    40% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    60% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    80% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "    90% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "  }\n",
       "</style>\n",
       "\n",
       "  <script>\n",
       "    async function quickchart(key) {\n",
       "      const quickchartButtonEl =\n",
       "        document.querySelector('#' + key + ' button');\n",
       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
       "      try {\n",
       "        const charts = await google.colab.kernel.invokeFunction(\n",
       "            'suggestCharts', [key], {});\n",
       "      } catch (error) {\n",
       "        console.error('Error during call to suggestCharts:', error);\n",
       "      }\n",
       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
       "    }\n",
       "    (() => {\n",
       "      let quickchartButtonEl =\n",
       "        document.querySelector('#df-8c06f73f-cd18-49d5-8f91-65ef3a133318 button');\n",
       "      quickchartButtonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "    })();\n",
       "  </script>\n",
       "</div>\n",
       "\n",
       "  <div id=\"id_a6fbbde5-1a7b-4430-b8dc-57f6c911dbbf\">\n",
       "    <style>\n",
       "      .colab-df-generate {\n",
       "        background-color: #E8F0FE;\n",
       "        border: none;\n",
       "        border-radius: 50%;\n",
       "        cursor: pointer;\n",
       "        display: none;\n",
       "        fill: #1967D2;\n",
       "        height: 32px;\n",
       "        padding: 0 0 0 0;\n",
       "        width: 32px;\n",
       "      }\n",
       "\n",
       "      .colab-df-generate:hover {\n",
       "        background-color: #E2EBFA;\n",
       "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "        fill: #174EA6;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate {\n",
       "        background-color: #3B4455;\n",
       "        fill: #D2E3FC;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate:hover {\n",
       "        background-color: #434B5C;\n",
       "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "        fill: #FFFFFF;\n",
       "      }\n",
       "    </style>\n",
       "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('test')\"\n",
       "            title=\"Generate code using this dataframe.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "       width=\"24px\">\n",
       "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "    <script>\n",
       "      (() => {\n",
       "      const buttonEl =\n",
       "        document.querySelector('#id_a6fbbde5-1a7b-4430-b8dc-57f6c911dbbf button.colab-df-generate');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      buttonEl.onclick = () => {\n",
       "        google.colab.notebook.generateWithVariable('test');\n",
       "      }\n",
       "      })();\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "text/plain": [
       "     Contaminated  Methane  NOxEmissions  PM2.5Emissions  VOCEmissions  \\\n",
       "0               0      355           433             917          1472   \n",
       "1               1      749           832            1438          1740   \n",
       "2               1      556           635            1166          1599   \n",
       "3               1      479           594            1192          1534   \n",
       "4               0      373           435             867          1416   \n",
       "..            ...      ...           ...             ...           ...   \n",
       "549             1      543           654            1268          1642   \n",
       "550             1      459           572            1060          1543   \n",
       "551             1      520           633            1218          1627   \n",
       "552             0      387           489             850          1486   \n",
       "553             1      542           619            1063          1581   \n",
       "\n",
       "     SO2Emissions  CO2Emissions  \n",
       "0             947          2245  \n",
       "1            1492          1866  \n",
       "2            1282          2144  \n",
       "3            1243          2012  \n",
       "4             912          2286  \n",
       "..            ...           ...  \n",
       "549          1192          2099  \n",
       "550          1185          2124  \n",
       "551          1103          2137  \n",
       "552          1005          2262  \n",
       "553          1429          2300  \n",
       "\n",
       "[554 rows x 7 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = pd.read_csv('datasets/AirQualityTest.csv')\n",
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RFcGzgM_SEA6"
   },
   "source": [
    "**Explanation**: You have loaded now a testing dataset. A test dataset is necessary because it allows us to check how well our model or analysis works on new, unseen data. When we train a model, we use one set of data to learn from (called the training dataset), but we also need to make sure it performs well on different data (the test dataset). This helps us know if the model can generalize to real-world situations, not just the data it was trained on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gr-GoiXMSE3T"
   },
   "source": [
    "### Goal 7: Predict Labels for Testing Dataset (ie - rest of the data).\n",
    "\n",
    "So far we’ve taken a smaller part of all our data to train and try and learn something about it. Can we take what we’ve learned from the training and use it to predict the rest of our dataset?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HqAvqle0SdWe"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "l8-2Ihk1Si0I"
   },
   "source": [
    "\n",
    "**Step 1 - Write out the variable name you want to use**\n",
    "\n",
    "Now that we’re all set with our new package to help us to do cool things, let’s bring the data into a variable and call it **predictions**.\n",
    "\n",
    "From the Variables menu, click Create Variable, and type **predictions**. On the same menu, drag the Set block of the prediction variable. This variable will hold the result of the prediction.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jiB7Jp5eSk_3"
   },
   "source": [
    "\n",
    "**Step 2 - Prepare the predict operation**\n",
    "\n",
    "So let’s take the **knn** variable from before and try to predict the label of the new dataset (contaminated, not contaminated). Let’s start by using the predict() method from the knn model.\n",
    "\n",
    "From the Variables menu, get a DO block, for the **knn** variable. With that select the operation **predict**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fHQBuJejSm03"
   },
   "source": [
    "\n",
    "**Step 3 - Set the test features**\n",
    "\n",
    "Inside the predict() method, we provide the test features from the test data. This will use the 6 features (ie - columns) to predict the labels.\n",
    "\n",
    "From the Lists menu, drag a dictVariable, and select the \"test\" variable from the list of available variables. Also, from the Lists menu, you will get a Create List block. Using the Gear icon, add up to 6 items. For each one of the items, add a Text (a Quote “” from the Text menu), as follows:  \"Methane\", \"NOxEmissions\", \"PM2.5Emissions\", \"VOCEmissions\", \"SO2Emissions\", and \"CO2Emissions\". These are the feature names applied to predict the target label on the testing dataset. Store the output of the KNN prediction in the \"predictions\" variable. This variable will now hold the result of the prediction.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H7fjuwgeSoYX"
   },
   "source": [
    "\n",
    "**Step 4 - Assign the predictions to the variable you created**\n",
    "\n",
    "Just like we did before, let’s type out a variable name. Rather than type out the full file name for our data, this easy to remember name will hold the data we bring in.\n",
    "\n",
    "Next, we store the prediction labels into a variable **‘predictions’**. To do that we have to connect the SET predictions variable to the **knn.predict**() block.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "117I1n6eSqiX"
   },
   "source": [
    "\n",
    "**Step 5 - Display the predictions**\n",
    "\n",
    "Finally, we display the prediction labels using ‘predictions’\n",
    "\n",
    "From the Variables menu, drag the \"**predictions**\" variable. This will show the result of the KNN predictions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pIkU0Z5_SrTI"
   },
   "source": [
    "\n",
    "**Step 6 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ3yDQWAAAD16J?format=png&name=900x900)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "URJaFQjTTHp1"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PDwLY2TtTPuF"
   },
   "source": [
    "\n",
    "**Step 1 - Prepare the predict operation**\n",
    "\n",
    "So let’s take the **knn** variable from before and try to predict the label of the new dataset (contaminated, not contaminated. Let’s start by using the predict() method from the knn model.\n",
    "\n",
    "`knn.predict()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ncCCcLtbTRaT"
   },
   "source": [
    "\n",
    "**Step 2 - Set the test features**\n",
    "\n",
    "Inside the predict() method, we provide the test features from the test data. This will use the 6 features (ie - columns) to predict the labels.\n",
    "\n",
    "`knn.predict(test[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']])`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0_Xt__OSTStO"
   },
   "source": [
    "\n",
    "**Step 3 - Assign the predictions to the variable you created**\n",
    "\n",
    "Next, we store the prediction labels into a variable ‘predictions’ Just like we did before, let’s type out a variable name. Rather than type out the full file name for our data, this easy to remember name will hold the data we bring in.\n",
    "\n",
    "`predictions = knn.predict(test[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']])`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H4kcT-JJTUga"
   },
   "source": [
    "**Step 4 - Print the predictions**\n",
    "\n",
    "Finally, we print the the prediction labels using ‘predictions’\n",
    "\n",
    "`predictions`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bglk03BmTVT3"
   },
   "source": [
    "\n",
    "**Step 5 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ3vx7WAAA30Q4?format=jpg&name=medium\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "msm5xAGgjoas"
   },
   "source": [
    "**Your Turn**:  Give it a go! Let’s see what our results are once we display them!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QkyQKBxBjp3w",
    "outputId": "e0b96ccc-c50d-42f4-fef6-5c9a7256652a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1,\n",
       "       0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n",
       "       0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n",
       "       1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0,\n",
       "       1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n",
       "       1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0,\n",
       "       0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1,\n",
       "       1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n",
       "       1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1,\n",
       "       1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n",
       "       0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "       1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0,\n",
       "       1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1,\n",
       "       1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1,\n",
       "       1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "       1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n",
       "       1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n",
       "       1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 0, 1])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions = knn.predict(test[['Methane', 'NOxEmissions', 'PM2.5Emissions', 'VOCEmissions', 'SO2Emissions', 'CO2Emissions']])\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9GsRHL6Vjrh8"
   },
   "source": [
    "**Explanation**: *Now with the test dataset, with the same features (\"Methane,\" \"NOxEmissions,\" \"PM2.5Emissions,\" \"VOCEmissions,\" \"SO2Emissions,\" and \"CO2Emissions), you were able to make predictions about each data point in the test set. Each prediction shows which cluster or category the `knn` model thinks each data point belongs to*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UlUB8JvZjtyG"
   },
   "source": [
    "### Goal 8: Bringing in SKLearn metrics to help look at the performance of predictions.\n",
    "\n",
    "So we’ve tried to predict on our new dataset. How well did we do? Let’s use SKLearn Metrics to help us think through that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DnrC9YUijwoE"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j5meaTafjyPr"
   },
   "source": [
    "\n",
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in.\n",
    "\n",
    "Bring in the IMPORT menu, which can be helpful to bring in other data tools. In this case, we're bringing in the **import** block.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lqqovqDFj3vZ"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out **sklearn.metrics**, which is a tool that grades your machine learning model's performance, telling you how well it did on its test.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q2ju35j3j-zy"
   },
   "source": [
    "\n",
    "**Step 3 - Renaming the library so it’s easy to remember**\n",
    "\n",
    "Once you are done, put the **import** and **package** together in a single variable. This handy feature helps cut down on all the typing later on. You can call it whatever is easiest for you to remember. In the example below, we’ve put everything into **metrics**, and we type it in the open area.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Th4XFL0SkC7r"
   },
   "source": [
    "\n",
    "**Step 4 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ5swrXUAAEJ-D?format=png&name=360x360)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U7OAywVpkKSQ"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WzwF9oM6kLkO"
   },
   "source": [
    "**Step 1 - Starting the import**\n",
    "\n",
    "First, we need to set up a “command” to tell the computer what to do. In this case, “command” is to “import” to bring the add-on package in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ertgHTG5kN9y"
   },
   "source": [
    "\n",
    "**Step 2 - Telling what library to import**\n",
    "\n",
    "In the text area, we type the name of the library we want to import. A library is like an extra thing we bring in to give us more coding abilities. In our case, we will type out **sklearn.metrics**, which is a tool that grades your machine learning model's performance, telling you how well it did on its test."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DVgfqRIzkPDe"
   },
   "source": [
    "\n",
    "**Step 3 - Renaming the library so it’s easy to remember**\n",
    "\n",
    "Once you are done, put the ‘import’ and ‘package’ together in a single variable. This handy feature helps cut down on all the typing later on. Feel free to use whatever name you want that will help you remember it later on. In the example below, we’ve put everything into **metrics**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oNZHZDqAkQA9"
   },
   "source": [
    "**Step 4 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ5u3ZWsAA_df1?format=png&name=360x360)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KcpFeJS2kbes"
   },
   "source": [
    "Your Turn: Test it out yourself! We set up a command to tell our computer what to do and after our hard work, we’ll run what we have to see our data science major at work!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "5DoQ5EZskeKz"
   },
   "outputs": [],
   "source": [
    "import sklearn.metrics as metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Omq6rbkjkfmx"
   },
   "source": [
    "**Explanation**: *The metrics library provides tools to measure and evaluate the performance of machine learning models. By using `metrics`, we can check how well our model is working, like seeing how accurate it is or how well it groups data in clustering. This helps us understand if our model is doing a good job or if it needs improvement*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p4U0pq6ipR_U"
   },
   "source": [
    "## Assessing the performance of the classifier\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "07COHq9QpSRJ"
   },
   "source": [
    "\n",
    "So how well did our predictions do? Let’s calculate three steps here performance of predictions on testing dataset - accuracy, confusion matrix, and precision/recall."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yGhUsCcKpS0Y"
   },
   "source": [
    "\n",
    "\n",
    "### Goal 9: Assessing the Performance of the Predictions on Test Dataset Using Accuracy Score.\n",
    "\n",
    "So how well did our predictions do on our test data? Let’s calculate the accuracy score to give us an idea."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0_yA1B6zpcUt"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OxZQkRZ8pdtb"
   },
   "source": [
    "**Step 1 - Call the accuracy_score() method using the metrics library**\n",
    "\n",
    "To calculate the accuracy of the model predictions, we will use the **accuracy_score**() function from the metrics library.  \n",
    "\n",
    "From the Variables menu, drag a DO block for the metrics variable. Select the accuracy_score function from the metrics list of operations. This function takes two inputs: the true labels and the predicted labels.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pfgrGhJbpkur"
   },
   "source": [
    "\n",
    "**Step 2 - Calculate KNN model’s accuracy**\n",
    "\n",
    "The accuracy_score() function takes 2 parameters to calculate the accuracy score and help measure the percentage of correct predictions. So let’s compare contaminated from the test dataset and predictions from the model we just created.\n",
    "\n",
    "From the Lists menu get a dictVariable block and select the test variable. From the Text menu get a Quote “” block to inform the label name **”Contaminated”**. This list will be used as the true labels for the accuracy calculation.\n",
    "\n",
    "As the second parameter of the **accuracy_score** get the variable **predictions**.  The accuracy score function will calculate the accuracy of the model by comparing the true labels with the predicted labels. The result will be a score that indicates the performance of the model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-9yJ9-1xpl8A"
   },
   "source": [
    "\n",
    "**Step 3 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ8AdSWIAEPAL_?format=png&name=small)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tbHlc-PVp21S"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HB5Jd-VQp4Ds"
   },
   "source": [
    "**Step 1 - Call the accuracy_score() method using the metrics library**\n",
    "\n",
    "To calculate the accuracy of the model predictions, we will use the accuracy_score() method from the metrics library.  This accuracy score will measure the percentage of correct predictions.\n",
    "\n",
    "`metrics.accuracy_score()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MC_fzHSaqCNx"
   },
   "source": [
    "\n",
    "**Step 2 - Calculate KNN model’s accuracy**\n",
    "\n",
    "The **accuracy_score**() function takes 2 parameters to calculate the accuracy score and help measure the percentage of correct predictions. So let’s compare **contaminated** from the test dataset and predictions from the model we just created.\n",
    "\n",
    "`metrics.accuracy_score(test['Contaminated'],predictions)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DrQn0Cs4qJJy"
   },
   "source": [
    "\n",
    "**Step 3 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ7bb5WMAAad1n?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m7GcV5ANqMHe"
   },
   "source": [
    "**Your Turn**:  Have a go at it! Once you begin you’ll be able to assess the performance of the predictions!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e1hhUa4GqRP7",
    "outputId": "e7877ffb-f293-4ddb-cf56-7579dd543136"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9927797833935018"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.accuracy_score(test['Contaminated'],predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YAbQJRLWqTXD"
   },
   "source": [
    "**Explanation**: *The accuracy score tells us the percentage of correct predictions out of the total. A higher accuracy score means the model is doing a good job matching the actual labels*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lXhSYHlqqVu4"
   },
   "source": [
    "### Goal 10: Assessing the Performance of the Predictions on Test Dataset Using the Confusion Matrix.\n",
    "\n",
    "So before we looked at the accuracy score to give us an idea about how well our predictions did on the test data. How about let’s look at the errors (false positives and false negatives) in the confusion matrix to explore further."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xvXvwKTQqZwm"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PU5_2rPxqa-G"
   },
   "source": [
    "**Step 1 - Call the confusion_matrix() function using the metrics library**\n",
    "\n",
    "To break down the accuracy, let’s get the numbers from the confusion matrix using the **confusion_matrix**() function from the metrics library.  \n",
    "\n",
    "From the Variables menu, drag a DO block for the metrics variable. Select the **confusion_matrix** function from the metrics list of operations. This function takes two inputs: the true labels and the predicted labels.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-4RWHRfAqiS2"
   },
   "source": [
    "\n",
    "**Step 2 - Calculate KNN model’s confusion matrix**\n",
    "\n",
    "The confusion_matrix () function takes 2 parameters to explore different parts of the confusion matrix. So let’s compare **Contaminated** from the test dataset and **predictions** from the model we just created. The confusion matrix will tell us these numbers - TP (true positive), TN (true negative), FP (false positive), and FN (false negative).\n",
    "\n",
    "From the Lists menu, get a dictVariable block and select the test variable. From the Text menu get a Quote “” block to inform the label name **”Contaminated”**. This list will be used as the true labels for the confusion matrix calculation. As the second parameter of the **confusion_matrix** get the variable **predictions**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NSLbPBqeqzbC"
   },
   "source": [
    "\n",
    "**Step 3 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ-UXxWgAAwYlY?format=png&name=small)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IywP_2-yq3UD"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Aq2ojVbwq4Yw"
   },
   "source": [
    "**Step 1 - Call the confuction_matrix() method from the metrics library**\n",
    "\n",
    "To calculate the confuction_matrix() of the model predictions, we will use the confusion_matrix() function from the metrics library.\n",
    "\n",
    "`metrics.confusion_matrix()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xyxf4j__rAhS"
   },
   "source": [
    "\n",
    "Step 2 - Calculate KNN model’s confusion matrix\n",
    "The confusion_matrix () function takes 2 parameters to explore different parts of the confusion matrix. So let’s compare **Contaminated** from the test dataset and **predictions** from the model we just created. The confusion matrix will tell us these numbers - TP (true positive), TN (true negative), FP (false positive), and FN (false negative).\n",
    "\n",
    "Test data labels: *test[‘Contaminated’]*\n",
    "\n",
    "The predicted labels: *predictions*\n",
    "\n",
    "`metrics.confusion_matrix(test['Contaminated'],predictions)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sS2UKWdHrHLT"
   },
   "source": [
    "\n",
    "**Step 3 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaQ-R7IW8AA9YQw?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vpEJDiuvrTMg"
   },
   "source": [
    "**Your Turn**: Let’s type in the code and see what our performance looks like! What do you see?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "j6wtH88yrUWB",
    "outputId": "d6d64563-a502-45a5-e59c-6f0d2645afb2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[169,   3],\n",
       "       [  1, 381]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.confusion_matrix(test['Contaminated'],predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v61Y5MU4rVvs"
   },
   "source": [
    "**Explanation**: *This matrix indicates that the model correctly identified 169 instances as \"Not Contaminated\" and 381 instances as \"Contaminated.\" However, it made 3 false positive errors (predicting \"Contaminated\" when it was actually \"Not Contaminated\") and 1 false negative error (predicting \"Not Contaminated\" when it was actually \"Contaminated\"). This breakdown helps understand the model's accuracy and the types of mistakes it makes*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Af2UErBgrYcV"
   },
   "source": [
    "### Goal 11: Assessing the Performance of the Predictions on Test Dataset using recall and precision.\n",
    "\n",
    "Let’s look further to compare how many we predicted true positives and compare it with our false positives (precision). Also, let’s look at true positives with false negatives (recall)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1iBZiVHprdnG"
   },
   "source": [
    "#### Blockly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cnCPIT-NritO"
   },
   "source": [
    "\n",
    "**Step 1 - Call the classification_report() function from the metrics library**\n",
    "\n",
    "To calculate the classification_report() for the model, we will use the **classification_report**() function from the metrics library.\n",
    "\n",
    "From the Variables menu, drag a DO block for the metrics variable. Select the **classification_report** function from the metrics list of operations. This function takes two inputs: the true labels and the predicted labels.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3jkfMGijrjpR"
   },
   "source": [
    "\n",
    "**Step 2 - Saying what parameters to use for the classification report**\n",
    "\n",
    "The classification_report() method takes 2 parameters to calculate the classification report.\n",
    "\n",
    "From the Lists menu, get a dictVariable block and select the test variable. From the Text menu, get a Quote “” block to inform the label name **”Contaminated”**. This list will be used as the true labels for the accuracy calculation. As the second parameter of the **classification_report** function, get the variable **predictions**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "13_v_hplrtyz"
   },
   "source": [
    "\n",
    "**Step 3 - Print the classification report**\n",
    "\n",
    "Connect the metrics block to a Print block (from the Text menu). The classification report will include other metrics like precision and recall.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AePk-aWzrv_R"
   },
   "source": [
    "\n",
    "**Step 4 - Connect the blocks to run the code**\n",
    "\n",
    "Connect the blocks and run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaRCnOcX0AAPsn4?format=png&name=small)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blocks code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q86_19QQryjq"
   },
   "source": [
    "#### Freehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9lNUzpR-r0_O"
   },
   "source": [
    "**Step 1 - Call the classification_report() function from the metrics library**\n",
    "\n",
    "To calculate the classification_report() for the model, we will use the classification_report() function from the metrics library.\n",
    "\n",
    "`metrics.classification_report()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9_jppl7Fr66V"
   },
   "source": [
    "\n",
    "\n",
    "**Step 2 - Saying what parameters to use for the classification report**\n",
    "\n",
    "The classification_report() method takes 2 parameters to calculate the classification report.\n",
    "\n",
    "`metrics.classification_report(test['Contaminated'],predictions)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DF830KLJr94m"
   },
   "source": [
    "\n",
    "**Step 3 - Print the classification report**\n",
    "\n",
    "Use the print function to show the results of the classification report.\n",
    "\n",
    "`print(metrics.classification_report(test['Contaminated'],predictions))`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ntNM2P1gsAd6"
   },
   "source": [
    "\n",
    "**Step 4 - Run the code**\n",
    "\n",
    "Hit ‘control’ and ‘enter’ at the same time to run the code!\n",
    "\n",
    "![](https://pbs.twimg.com/media/GaRClCEWAAAMfW3?format=png&name=small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YGrXDaTdsDZR"
   },
   "source": [
    "**Your Turn**: Let’s try it! First we tried accuracy score, confusion matrix, and now we have recall and precision. The possibilities are endless!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RlWlBiyJsI_7",
    "outputId": "67f94511-543e-4080-aba6-a56a88746e77"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99       172\n",
      "           1       0.99      1.00      0.99       382\n",
      "\n",
      "    accuracy                           0.99       554\n",
      "   macro avg       0.99      0.99      0.99       554\n",
      "weighted avg       0.99      0.99      0.99       554\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(test['Contaminated'],predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HEEBx5H0sKV2"
   },
   "source": [
    "**Explanation**: *The classification report provides some metrics, particularly precision and recall. Precision measures how many of the samples the model labeled as contaminated were actually contaminated, essentially showing the accuracy of its positive predictions. Recall, on the other hand, reflects the model's ability to detect all actual contaminated samples, indicating how well it \"found\" the true cases. In this report, the precision and recall scores are both high, at 0.99 or 99% for each class, which demonstrates that the model is highly accurate in identifying both contaminated and non-contaminated samples. These scores mean that nearly all positive predictions made by the model were correct, and it missed almost none of the actual contaminated cases*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JNuihK3ZsPBe"
   },
   "source": [
    "## WHAT DID YOU LEARN?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_O-Si4mKsPg4"
   },
   "source": [
    "\n",
    "In this notebook, we learned about [K-Nearest Neighbors](## \"a commonly used classifier; also known as k-nearest neighbors\") and how it works. It helps classify data by looking at nearby data points and picking the most common label for them. Choosing how many neighbors (K) is important because it helps to decide how many neighbors the algorithm should check. Too many neighbors being checked makes the data more sensitive and too many might make our results look a bit funky."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oZA59dNYsgUp"
   },
   "source": [
    "## WHAT’S NEXT?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TYO6YPcksiJ4"
   },
   "source": [
    "[KNN Regression](KNN_Regression.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BG1sVYf8sPmc"
   },
   "source": [
    "## TELL ME MORE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ouaEQomNsPp_"
   },
   "source": [
    "\n",
    "- [Datawhys KNN Classification Notebook](https://github.com/memphis-iis/datawhys-content-notebooks-python/blob/master/KNN-classification.ipynb)\n",
    "- [Datawhys KNN Classification Problem-Solving Notebook](https://github.com/memphis-iis/datawhys-content-notebooks-python/blob/master/KNN-classification-PS.ipynb)\n",
    "- [K Nearest Neighbors](https://youtu.be/0p0o5cmgLdE?si=V8336jEKrVF_aLJc) - Machine Learning Basics (video)\n",
    "- [K-nearest neighbors](https://youtu.be/HVXime0nQeI?si=WjFinXnxVm1CJhX5) - StatQuest (video)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}