02 Naive Bayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Naïve Bayes\n",
    "source: Wikipedia\n",
    "\n",
    "In machine learning, Naïve Bayes classifiers are a family of simple \"probabilistic classifiers\" based on applying Bayes' theorem with strong (naïve) independence assumptions between the features. They are among the simplest Bayesian network models.\n",
    "\n",
    "Naïve Bayes has been studied extensively since the 1960s. It was introduced (though not under that name) into the text retrieval community in the early 1960s, and remains a popular (baseline) method for text categorization, the problem of judging documents as belonging to one category or the other (such as spam or legitimate, sports or politics, etc.) with word frequencies as the features. With appropriate pre-processing, it is competitive in this domain with more advanced methods including support vector machines. It also finds application in automatic medical diagnosis.\n",
    "\n",
    "https://en.wikipedia.org/wiki/Naive_Bayes_classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naïve Bayes is used mainly for text classification, such as spam filtration, sentimental analysis, classifying news articles and recommendation systems. \n",
    "\n",
    "The term \"naïve\" is used because this model makes the assumption that the occurance of a feature is independent of the occurrence of other features, that all the properties contribute to the probability of an event based on previous knowledge available of the events.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Install Packages and Import Libraries\n",
    "Typically packages and libraries are compiled at the start of the code so it's easier to read and understand what is used; however, it's acceptable to install or import at any point in your code.\n",
    "\n",
    "First, we would normally install the packages. Using mybinder.org, the packages are installed at execution time, so this code is not needed in these tutorials. If you download and run this notebook, you may need to install the packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is normally where you'd type the code to install the packages required.\n",
    "\n",
    "# !pip install sklearn\n",
    "# !pip install numpy\n",
    "# !pip install matplotlib\n",
    "# !pip install pandas\n",
    "# !pip install seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Package information for curious minds:\n",
    "https://numpy.org/devdocs/user/absolute_beginners.html  \n",
    "https://matplotlib.org/stable/tutorials/introductory/usage.html  \n",
    "https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html \n",
    "https://scikit-learn.org/stable/tutorial/index.html  \n",
    "https://seaborn.pydata.org/introduction.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will import the libraries we need. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### We shorten _pandas_ to _pd_ in order to save time and also to keep code standardized so that anyone working with your code can easily understand and run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### We provided an alias for _matplotlib.pyplot_ so that we can use _plt_ throughout the code instead of typing matplotlib.pyplot each time. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will import several different functions from the _sklearn_ module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "from sklearn import preprocessing\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To refer to items from a module within your program’s namespace, you can use the <font color=green>__from__</font> … <font color=green>__import__</font> statement.  \n",
    "When you import modules this way, you can refer to the functions by name rather than through dot notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "import seaborn as sns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, import numpy with the alias \"np\".  \n",
    "><font color=green>__import__</font> numpy <font color=green>__as__</font> np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to import numpy below:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating Models\n",
    "While numerical values may be the natural state of the data provided, such as a table with columns representing height, weight, age, and salary, it is quite common for data to be text values, such as colours (\"red\", \"blue\", \"yellow\", \"green\"), sizes (\"small\", \"medium\", \"large\") or geographic (\"Canada\", \"Netherlands\", \"Australia\").\n",
    "\n",
    "While some machine learning algorithms can support categorical data without manipulation, many models require numerical data. This requires transforming the text values into numbers.\n",
    "\n",
    "\n",
    "#### Label Encoder  \n",
    "LabelEncoder is a utility class to help normalize labels such that they contain only values between 0 and n_classes-1. \n",
    "> Why n-classes-1? If you recall that Python uses a zero-based index, the first value will start at 0, not 1.\n",
    "\n",
    "We will use Label Encoder to transform text values to numbers. We will name the variable `le_cities`. Each time we type `le_cities` it is the same as calling `preprocessing.LabelEncoder()`\n",
    "\n",
    ">`le_cities = preprocessing.LabelEncoder()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for le_cities below:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will call the fuction `fit` to fit the label encoder and pass through a list of city names.\n",
    ">`le_cities.fit([\"paris\", \"paris\", \"tokyo\", \"amsterdam\"])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to pass the list of city names into le\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results of fitting the label encoder were not returned because we didn't specify to do so. \n",
    "Let's return the classes in the city list.\n",
    ">`list(le_cities.classes_)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to return the classes\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that \"paris\" was returned once, even though it was originally listed twice. Because Label Encoder already assigned a value to \"paris\", any additional instances will have the same value. This means it will only display unique values.  \n",
    "\n",
    "Now let's transform a list of cities to numeric values.\n",
    ">`list(le_cities.transform([\"tokyo\", \"tokyo\", \"paris\"]))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to transform \"tokyo\", \"tokyo\", \"paris\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have the numeric values, we can use `inverse_transform` to convert the numbers back to text.  \n",
    ">`list(le_cities.inverse_transform([2, 2, 1]))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to inverse_transform 2, 2, 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now using the code you typed above perform the following steps:\n",
    "1. create a variable `le_colours`\n",
    "2. fit \"blue\", \"white\", \"red\" to the label encoder\n",
    "3. list the classes in le_colours\n",
    "4. transform \"blue\" to the encoded value\n",
    "5. transform the encoded value back to the text \"blue\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for step 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for step 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for step 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for step 4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code for step 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Our sample data\n",
    "For this example, we are using a small golf dataset to predict whether or not someone will play golf based on different conditions.\n",
    "\n",
    "Our data contains columns of data representing the outlook, temperature (one column in degrees Fahrenheit and one column categorized), humidity (column for relative humidity and one column categorized), windy conditions and whether or not golf was played. Each row represents one day of data.\n",
    "\n",
    "To start, import the dataset\n",
    ">`golf_data = pd.read_csv('datasets/golf_dataset.csv')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to import the dataset\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will explore the data before doing any transformation. \n",
    "To start, let's look at the first 5 rows of data.\n",
    ">`golf_data.head()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the first 5 rows of data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also view the last 5 rows of data using `.tail()`.\n",
    "\n",
    ">`golf_data.tail()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the last 5 rows of data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To explore the number of columns and rows in the data, we use `.shape`.\n",
    ">`golf_data.shape`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the shape of the data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also view the shape of the data by viewing the length of the index and columns.\n",
    ">`len(golf_data.index)`  \n",
    ">`len(golf_data.columns)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the length of the index column\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the number of columns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this is a small dataset, we could also display the entire table.\n",
    ">`golf_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the golf_data table\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most important basic blocks for machine learning is working with features. Considering data in a table format, a feature is a column with a header that contains different information in each row. Each unique value in a column is called a class.\n",
    "\n",
    "It's important to understand the features and classes in your data to know which columns contain important information when building your model. A dataset could contain hundreds of columns which have information that may not work in your model - the extremes are one value which makes up all or nearly all the instances, and unique values in each row. \n",
    "\n",
    "We can view the unique values in the outlook column to understand how many different values are present.\n",
    ">`print(golf_data[\"outlook\"].unique())`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the unique values in the outlook column\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __feature__ is \"outlook\". The __classes__ are \"overcast\", \"rainy\", \"sunny\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get a count of the number of instances of each value.\n",
    ">`print(golf_data.groupby(\"outlook\").size())`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the number of instances of each value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the Seaborn library to display some graphs of the data. \n",
    "\n",
    "First we will display the count of the outlook data. Outlook is a categorical feature. Recall that categorical or qualitative data is limited in how it can be displayed.\n",
    "\n",
    ">`sns.countplot(x=golf_data[\"outlook\"], label=\"count\")`  \n",
    ">`plt.show()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to create and display the countplot\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will display boxplots of the numerical data: __temp__ and __hum__\n",
    "\n",
    ">![image.png](attachment:image.png)\n",
    "\n",
    "_Be sure to keep the white space._   \n",
    "When you hit enter after the comma, it will automatically indent the next line of code to ensure that the proper tabbing is in place. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the boxplots\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we understand the data, we are going to use the label encoder to transform the categorical values to numeric values.\n",
    "\n",
    "We will use `le_outlook` to stand in for `preprocessing.LabelEncoder()` and we will pass through the unique values for the \"outlook\" feature (or column).\n",
    "\n",
    ">`le_outlook = preprocessing.LabelEncoder()`  \n",
    ">`le_outlook.fit(golf_data[\"outlook\"])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to fit the \"outlook\" column to label encoder\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Review the classes of data in \"outlook\".  \n",
    ">`list(le_outlook.classes_)`\n",
    "\n",
    "_Note: watch for the underscore following `classes`_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the classes for \"outlook\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine multiple steps in one cell. This code combines the label encoder and displaying the view the classes for \"temperature\".  \n",
    ">`le_temp = preprocessing.LabelEncoder()`  \n",
    ">`le_temp.fit(golf_data[\"temperature\"])`  \n",
    ">`list(le_temp.classes_)`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to label encode and display the classes for \"temperature\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeat the code to create the following variables:\n",
    " - le_hum for \"humidity\"\n",
    " - le_windy for \"windy\"\n",
    " - le_play for \"play\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to label encode and display the classes for \"humidity\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to label encode and display the classes for \"windy\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to label encode and display the classes for \"play\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to create a new dataframe for the Label Encoder values, using `le_golf_data`.  First, we declare `le_golf_data` as a dataframe. When we display `le_golf_data` it will appear empty because nothing has been added to it yet.\n",
    "\n",
    ">`le_golf_data = pd.DataFrame()`  \n",
    ">`le_golf_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to create le_golf_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Earlier, we created `le_outlook` with encoded lables.\n",
    "\n",
    ">`le_outlook.transform(golf_data['outlook'])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display le_outlook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will add a column for \"outlook\" to our new le_golf_data dataframe using this previously encoded `le_outlook` variable.  \n",
    ">`le_golf_data[\"outlook\"] = le_outlook.transform(golf_data[\"outlook\"])`  \n",
    ">`le_golf_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to add the new \"outlook\" column to \n",
    "# le_golf_data from the previously used variables.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeat for each of the features in the golf dataset.\n",
    "\n",
    ">`le_golf_data['temperature'] = le_temp.transform(golf_data['temperature'])`  \n",
    ">`le_golf_data['humidity'] = le_hum.transform(golf_data['humidity'])`  \n",
    ">`le_golf_data['windy'] = le_windy.transform(golf_data['windy'])`  \n",
    ">`le_golf_data['play'] = le_play.transform(golf_data['play'])`  \n",
    ">`le_golf_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to add new columns to le_golf_data from the\n",
    "#previously used variables.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will declare the features of our dataset. For the machine learning model, this means that this information will be the inputs. For future use, we expect to have the data for these features to make the target predictions.  \n",
    ">`features = [\"outlook\", \"temperature\", \"humidity\", \"windy\"]`  \n",
    ">`features`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to declare and display the feature columns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at golf_data features to review the values in each column.\n",
    ">`golf_data[features]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to view the golf_data features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at le_golf_data features to review the encoded values in each column.\n",
    ">`le_golf_data[features]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to view the le_golf_data features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will declare the target of our dataset. Our target will be the predicted value. Our machine learning model will look at the data in the features and predict whether or not golf will be played based on the values in the features. \n",
    "\n",
    "Our model is supervised learning, as we are providing information about the predicted value - we know the conditions in the features that occurred when golf was played, so our model can solve based on the previous information.\n",
    ">`target = \"play\"`  \n",
    ">`target`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to declare the target\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use Gaussian Naive Bayes to create our model.\n",
    "\n",
    "Gaussian Naive Bayes is an algorithm having a Probabilistic Approach. It involves prior and posterior probability calculation of the classes in the dataset and the test data given a class respectively. Prior probabilities of all the classes are calculated using the same formula.\n",
    "\n",
    "\n",
    ">`model = GaussianNB()`  \n",
    ">`model.fit(le_golf_data[features], le_golf_data[target])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to create the Gaussian model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will test our model using new data inputs for the features. For this test we will input the following:\n",
    " - test outlook=sunny\n",
    " - temperature=cool\n",
    " - humidity=high\n",
    " - windy=True\n",
    "We will need to use the transformed numeric values.\n",
    ">`a = list(le_outlook.transform(['sunny']))`  \n",
    ">`a.extend(list(le_temp.transform(['cool'])))`  \n",
    ">`a.extend(list(le_hum.transform(['high'])))`  \n",
    ">`a.extend(list(le_windy.transform([True])))`  \n",
    ">`a`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to test outlook=sunny, temperature=cool, humidity=high, windy=True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To view the prediction, we need to call the results.\n",
    "\n",
    ">`print(model.predict([a]))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the prediction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, the result is the encoded value - that's what we provided to the model. To translate back to text, you can wrap the call with the `inverse_tranform` function.\n",
    ">`print(le_play.inverse_transform(model.predict([a])))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to translate the numeric value back to text\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we want to look at the accuracy of the classification model. This compares the true values to the predicted values to determine the accuracy. The value returned is the fraction of correctly classified samples. Our example only has one predicted value.\n",
    "\n",
    ">`accuracy = accuracy_score([0], model.predict([a]))`  \n",
    ">`accuracy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the accuracy of the predicted values\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will test our model using different data inputs for the features. For this test we will input the following:\n",
    " - test outlook=sunny\n",
    " - temperature=hot\n",
    " - humidity=normal\n",
    " - windy=False\n",
    "\n",
    ">`a = list(le_outlook.transform(['sunny']))`  \n",
    ">`a.extend(list(le_temp.transform(['hot'])))`  \n",
    ">`a.extend(list(le_hum.transform(['normal'])))`  \n",
    ">`a.extend(list(le_windy.transform([False])))`  \n",
    ">`a`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to test outlook=sunny, temperature=hot, humidity=normal, windy=False\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the prediction and transform back to text.\n",
    "\n",
    ">`print(model.predict([a]))`  \n",
    ">`print(le_play.inverse_transform(model.predict([a])))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to translate the numeric value back to text\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the accuracy score for the new test.\n",
    "\n",
    ">`accuracy = accuracy_score([1], model.predict([a]))`  \n",
    ">`accuracy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type the code to display the accuracy of the predicted values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a comment explaining when you would use LabelEncoder\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download this completed notebook. \n",
    "#### File > Download as > Notebook (.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}