Supervised Learning with scikit-learn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "democrat      267\n",
      "republican    168\n",
      "Name: Class Name, dtype: int64\n",
      "Prediction: ['democrat' 'democrat' 'republican' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'republican' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'republican' 'democrat' 'republican' 'republican' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'republican' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'republican' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'republican' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'republican' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'republican' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'republican' 'democrat' 'republican' 'democrat'\n",
      " 'republican' 'republican' 'democrat' 'republican' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'republican' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'republican' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'republican' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'republican' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'republican' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'republican' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'republican' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'republican' 'republican'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'republican'\n",
      " 'democrat' 'republican' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'republican' 'democrat' 'republican' 'republican'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'republican' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'republican' 'republican'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'republican' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'republican' 'democrat' 'democrat' 'democrat'\n",
      " 'republican' 'democrat' 'republican' 'democrat' 'democrat' 'republican'\n",
      " 'republican' 'republican' 'democrat' 'democrat' 'republican' 'democrat'\n",
      " 'democrat' 'republican' 'democrat' 'democrat' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat' 'republican' 'democrat' 'democrat'\n",
      " 'democrat' 'democrat' 'democrat']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Before thinking about what supervised learning models you can apply to this, however,\n",
    "you need to perform Exploratory data analysis (EDA) in order to understand the structure of the data.\n",
    "For a refresher on the importance of EDA, check out the first two chapters of Statistical Thinking in Python (Part 1).\n",
    "\n",
    "Get started with your EDA now by exploring this voting records dataset numerically. \n",
    "It has been pre-loaded for you into a DataFrame called df. Use pandas' .head(), .info(), \n",
    "and .describe() methods in the IPython Shell to explore the DataFrame, and select the statement\n",
    "below that is not true.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "It starts with a set of labeled data\n",
    ".fit() is the synonym of to train.\n",
    "We fit the data (.fit()) = we train the data.\n",
    "To predict labels of new data, we use predict().\n",
    "\n",
    "k-Nearest Neighbors: Fit\n",
    "Having explored the Congressional voting records dataset, it is time now to build your first classifier.\n",
    "In this exercise, you will fit a k-Nearest Neighbors classifier to the voting dataset, which has once again\n",
    "been pre-loaded for you into a DataFrame df.\n",
    "In the video, Hugo discussed the importance of ensuring your data adheres to the format required by the scikit-learn API.\n",
    "The features need to be in an array where each column is a feature and each row a different observation or data point\n",
    "- in this case, a Congressman's voting record. The target needs to be a single column with the same number of observations\n",
    "as the feature data. We have done this for you in this exercise. Notice we named the feature array X and response\n",
    "variable y: This is in accordance with the common scikit-learn practice.\n",
    "Your job is to create an instance of a k-NN classifier with 6 neighbors (by specifying the n_neighbors parameter)\n",
    "and then fit it to the data. The data has been pre-loaded into a DataFrame called df.\n",
    "\"\"\"\n",
    "\n",
    "# Import KNeighborsClassifier from sklearn.neighbors\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "import numpy as np\n",
    "import sys, os\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# with open(\"house-votes-84.names\") as f:\n",
    "#     #print(f.read())\n",
    "# with open(\"house-votes-84.data\") as f:\n",
    "#     #print(f.read())\n",
    "    \n",
    "df = pd.read_csv('house-votes-84.csv')\n",
    "print(df['Class Name'].value_counts())\n",
    "df = df.replace({'?':0})\n",
    "df = df.replace({'y':1, 'n':0})\n",
    "\n",
    "# Create arrays for the features and the response variable\n",
    "y = df['Class Name'].values\n",
    "X = df.drop('Class Name', axis=1).values\n",
    "\n",
    "# Create a k-NN classifier with 6 neighbors\n",
    "knn = KNeighborsClassifier(n_neighbors = 6)\n",
    "\n",
    "# Fit the classifier to the data\n",
    "knn.fit(X, y)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Now that your k-NN classifier with 6 neighbors has been fit to the data, it can be used to predict\n",
    "the labels of new data points.\n",
    "\n",
    "k-Nearest Neighbors: Predict\n",
    "Having fit a k-NN classifier, you can now use it to predict the label of a new data point. However, there is no unlabeled data available since all of it was used to fit the model! You can still use the .predict() method on the X that was used to fit the model, but it is not a good indicator of the model's ability to generalize to new, unseen data.\n",
    "\n",
    "In the next video, Hugo will discuss a solution to this problem. For now, a random unlabeled data point\n",
    "has been generated and is available to you as X_new. You will use your classifier to predict the label for\n",
    "this new data point, as well as on the training data X that the model has already seen. Using .predict()\n",
    "on X_new will generate 1 prediction, while using it on X will generate 435 predictions: 1 for each sample.\n",
    "\"\"\"\n",
    "\n",
    "# Import KNeighborsClassifier from sklearn.neighbors\n",
    "from sklearn.neighbors import KNeighborsClassifier \n",
    "\n",
    "# Create arrays for the features and the response variable\n",
    "y = df['Class Name'].values\n",
    "X = df.drop('Class Name', axis=1).values\n",
    "\n",
    "# Create a k-NN classifier with 6 neighbors: knn\n",
    "knn = KNeighborsClassifier(n_neighbors=6)\n",
    "\n",
    "# Fit the classifier to the data\n",
    "knn.fit(X, y)\n",
    "\n",
    "# Predict the labels for the training data X: y_pred\n",
    "y_pred = knn.predict(X)\n",
    "\n",
    "X_test = np.random.choice([0, 1], size=(435,16))\n",
    "\n",
    "# Predict and print the label for the new data point X_new\n",
    "new_prediction = knn.predict(X_test)\n",
    "print(\"Prediction: {}\".format(new_prediction)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0.0  0.0.1  0.0.2  0.0.3  0.0.4  0.0.5  0.0.6  0.0.7  0.0.8  0.0.9  ...  \\\n",
      "0  0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
      "1  0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
      "2  0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
      "3  0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
      "4  0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0    0.0  ...   \n",
      "\n",
      "   0.0.82  0.0.83  0.0.84  0.0.85  0.0.86  0.0.87  0.0.88  0.0.89  0.0.90  \\\n",
      "0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0   \n",
      "1     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0   \n",
      "2     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0   \n",
      "3     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0   \n",
      "4     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0   \n",
      "\n",
      "   0.0.91  \n",
      "0     0.0  \n",
      "1     0.0  \n",
      "2     0.0  \n",
      "3     0.0  \n",
      "4     0.0  \n",
      "\n",
      "[5 rows x 104 columns]\n",
      "dict_keys(['data', 'target', 'target_names', 'images', 'DESCR'])\n",
      ".. _digits_dataset:\n",
      "\n",
      "Optical recognition of handwritten digits dataset\n",
      "--------------------------------------------------\n",
      "\n",
      "**Data Set Characteristics:**\n",
      "\n",
      "    :Number of Instances: 5620\n",
      "    :Number of Attributes: 64\n",
      "    :Attribute Information: 8x8 image of integer pixels in the range 0..16.\n",
      "    :Missing Attribute Values: None\n",
      "    :Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)\n",
      "    :Date: July; 1998\n",
      "\n",
      "This is a copy of the test set of the UCI ML hand-written digits datasets\n",
      "http://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits\n",
      "\n",
      "The data set contains images of hand-written digits: 10 classes where\n",
      "each class refers to a digit.\n",
      "\n",
      "Preprocessing programs made available by NIST were used to extract\n",
      "normalized bitmaps of handwritten digits from a preprinted form. From a\n",
      "total of 43 people, 30 contributed to the training set and different 13\n",
      "to the test set. 32x32 bitmaps are divided into nonoverlapping blocks of\n",
      "4x4 and the number of on pixels are counted in each block. This generates\n",
      "an input matrix of 8x8 where each element is an integer in the range\n",
      "0..16. This reduces dimensionality and gives invariance to small\n",
      "distortions.\n",
      "\n",
      "For info on NIST preprocessing routines, see M. D. Garris, J. L. Blue, G.\n",
      "T. Candela, D. L. Dimmick, J. Geist, P. J. Grother, S. A. Janet, and C.\n",
      "L. Wilson, NIST Form-Based Handprint Recognition System, NISTIR 5469,\n",
      "1994.\n",
      "\n",
      ".. topic:: References\n",
      "\n",
      "  - C. Kaynak (1995) Methods of Combining Multiple Classifiers and Their\n",
      "    Applications to Handwritten Digit Recognition, MSc Thesis, Institute of\n",
      "    Graduate Studies in Science and Engineering, Bogazici University.\n",
      "  - E. Alpaydin, C. Kaynak (1998) Cascading Classifiers, Kybernetika.\n",
      "  - Ken Tang and Ponnuthurai N. Suganthan and Xi Yao and A. Kai Qin.\n",
      "    Linear dimensionalityreduction using relevance weighted LDA. School of\n",
      "    Electrical and Electronic Engineering Nanyang Technological University.\n",
      "    2005.\n",
      "  - Claudio Gentile. A New Approximate Maximal Margin Classification\n",
      "    Algorithm. NIPS. 2000.\n",
      "(1797, 8, 8)\n",
      "(1797, 64)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Measure model performance.\n",
    "Accuracy for a classifier : number of TruePositive divided by the number of datapoints (but which ? train/test data ?)\n",
    "So usually what we do, is split the data into a train and test set for model validation.\n",
    "We train on train set, then compute accuracy on test set.\n",
    "\n",
    "Note on model complexity here :\n",
    "the smaller the K the more complex the model, can lead to overfitting\n",
    "the larger the K, the smoother the model, less complexity\n",
    "\"\"\"\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "df = pd.read_csv('lcd-digits.csv')\n",
    "print(df.head())\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Exercise\n",
    "The digits recognition dataset\n",
    "Up until now, you have been performing binary classification, since the target variable had two possible outcomes.\n",
    "Hugo, however, got to perform multi-class classification in the videos, where the target variable could take on three\n",
    "possible outcomes. Why does he get to have all the fun?! In the following exercises, you'll be working with the MNIST\n",
    "digits recognition dataset, which has 10 classes, the digits 0 through 9! A reduced version of the MNIST dataset is\n",
    "one of scikit-learn's included datasets, and that is the one we will use in this exercise.\n",
    "\n",
    "Each sample in this scikit-learn dataset is an 8x8 image representing a handwritten digit. Each pixel is represented\n",
    "by an integer in the range 0 to 16, indicating varying levels of black. Recall that scikit-learn's built-in datasets\n",
    "are of type Bunch, which are dictionary-like objects. Helpfully for the MNIST dataset, scikit-learn provides an 'images'\n",
    "key in addition to the 'data' and 'target' keys that you have seen with the Iris data. Because it is a 2D array of the\n",
    "images corresponding to each sample, this 'images' key is useful for visualizing the images, as you'll see in this exercise\n",
    "(for more on plotting 2D arrays, see Chapter 2 of DataCamp's course on Data Visualization with Python). On the other hand,\n",
    "the 'data' key contains the feature array - that is, the images as a flattened array of 64 pixels.\n",
    "\n",
    "Notice that you can access the keys of these Bunch objects in two different ways: By using the . notation, as in\n",
    "digits.images, or the [] notation, as in digits['images'].\n",
    "\"\"\"\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn import datasets\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load the digits dataset: digits\n",
    "digits = datasets.load_digits()\n",
    "\n",
    "# Print the keys and DESCR of the dataset\n",
    "print(digits.keys())\n",
    "print(digits.DESCR)\n",
    "\n",
    "# Print the shape of the images and data keys\n",
    "print(digits.images.shape)\n",
    "print(digits.data.shape)\n",
    "\n",
    "# Display digit 1010\n",
    "plt.imshow(digits.images[1010], cmap=plt.cm.gray_r, interpolation='nearest')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'digits' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-b947050f484a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[1;31m# Create feature and target arrays\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 21\u001b[1;33m \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdigits\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     22\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdigits\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'digits' is not defined"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "It looks like the image in question corresponds to the digit '5'. Now, can you build a classifier\n",
    "that can make this prediction not only for this image, but for all the other ones in the dataset? You'll\n",
    "do so in the next exercise!\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Train/Test Split + Fit/Predict/Accuracy\n",
    "Now that you have learned about the importance of splitting your data into training and test sets,\n",
    "it's time to practice doing this on the digits dataset! After creating arrays for the features and target\n",
    "variable, you will split them into training and test sets, fit a k-NN classifier to the training data,\n",
    "and then compute its accuracy using the .score() method.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Create feature and target arrays\n",
    "X = digits.data\n",
    "y = digits.target\n",
    "\n",
    "# Split into training and test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42, stratify=y)\n",
    "\n",
    "# Create a k-NN classifier with 7 neighbors: knn\n",
    "knn = KNeighborsClassifier(n_neighbors = 7)\n",
    "\n",
    "# Fit the classifier to the training data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# Print the accuracy\n",
    "print(knn.score(X_test, y_test))\n",
    "\n",
    "\"\"\"\n",
    "Incredibly, this out of the box k-NN classifier with 7 neighbors has learned from the training data and\n",
    "predicted the labels of the images in the test set with 98% accuracy, and it did so in less than a second!\n",
    "This is one illustration of how incredibly useful machine learning techniques can be.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Overfitting and underfitting\n",
    "Remember the model complexity curve that Hugo showed in the video? You will now construct such a curve\n",
    "for the digits dataset! In this exercise, you will compute and plot the training and testing accuracy scores\n",
    "for a variety of different neighbor values. By observing how the accuracy scores differ for the training and\n",
    "testing sets with different values of k, you will develop your intuition for overfitting and underfitting.\n",
    "\n",
    "The training and testing sets are available to you in the workspace as X_train, X_test, y_train, y_test.\n",
    "In addition, KNeighborsClassifier has been imported from sklearn.neighbors.\n",
    "\"\"\"\n",
    "\n",
    "neighbors = np.arange(1, 9)\n",
    "train_accuracy = np.empty(len(neighbors))\n",
    "\n",
    "# Setup arrays to store train and test accuracies\n",
    "neighbors = np.arange(1, 9)\n",
    "train_accuracy = np.empty(len(neighbors))\n",
    "test_accuracy = np.empty(len(neighbors))\n",
    "\n",
    "# Loop over different values of k\n",
    "for i, k in enumerate(neighbors):\n",
    "    # Setup a k-NN Classifier with k neighbors: knn\n",
    "    knn = KNeighborsClassifier(n_neighbors = k)\n",
    "\n",
    "    # Fit the classifier to the training data\n",
    "    knn.fit(X_train, y_train)\n",
    "    \n",
    "    #Compute accuracy on the training set\n",
    "    train_accuracy[i] = knn.score(X_train, y_train)\n",
    "\n",
    "    #Compute accuracy on the testing set\n",
    "    test_accuracy[i] = knn.score(X_test, y_test)\n",
    "\n",
    "# Generate plot\n",
    "plt.title('k-NN: Varying Number of Neighbors')\n",
    "plt.plot(neighbors, test_accuracy, label = 'Testing Accuracy')\n",
    "plt.plot(neighbors, train_accuracy, label = 'Training Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('Number of Neighbors')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "It looks like the test accuracy is highest when using 3 and 5 neighbors. \n",
    "Using 8 neighbors or more seems to result in a simple model that underfits the data.\n",
    "Now that you've grasped the fundamentals of classification, you will learn about regression in the next chapter!\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions of y before reshaping: (79309,)\n",
      "Dimensions of X before reshaping: (79309,)\n",
      "Dimensions of y after reshaping: (79309, 1)\n",
      "Dimensions of X after reshaping: (79309, 1)\n",
      "0.3861771722430426\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "In regression matters, the target value is continuously varying variable (numeric).\n",
    "\"\"\"\n",
    "\n",
    "# Import numpy and pandas\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('gapminder.txt', delimiter = \",\")\n",
    "col_array = df.columns\n",
    "\n",
    "# Create arrays for features and target variable\n",
    "#target\n",
    "y = df['life_expectancy_years'].values\n",
    "y = np.nan_to_num(y, 0)\n",
    "#feature\n",
    "X = df['children_per_woman_total_fertility'].values\n",
    "X = np.nan_to_num(X, 0)\n",
    "\n",
    "# Print the dimensions of X and y before reshaping\n",
    "print(\"Dimensions of y before reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X before reshaping: {}\".format(X.shape))\n",
    "\n",
    "# Reshape X and y\n",
    "y = y.reshape(-1, 1)\n",
    "X = X.reshape(-1, 1)\n",
    "\n",
    "# Print the dimensions of X and y after reshaping\n",
    "print(\"Dimensions of y after reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X after reshaping: {}\".format(X.shape))\n",
    "\n",
    "\"\"\"\n",
    "Notice the differences in shape before and after applying the .reshape() method. Getting the feature and\n",
    "target variable arrays into the right format for scikit-learn is an important precursor to model building.\n",
    "\"\"\"\n",
    "\n",
    "# Import LinearRegression\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Create the regressor: reg\n",
    "reg = LinearRegression()\n",
    "\n",
    "# Create the prediction space\n",
    "prediction_space = np.linspace(min(X), max(X)).reshape(-1,1)\n",
    "\n",
    "# Fit the model to the data\n",
    "reg.fit(X, y)\n",
    "\n",
    "# Compute predictions over the prediction space: y_pred\n",
    "y_pred = reg.predict(prediction_space)\n",
    "\n",
    "# Print R^2 \n",
    "print(reg.score(X, y))\n",
    "\n",
    "# Plot regression line\n",
    "plt.plot(prediction_space, y_pred, color='black', linewidth=2)\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "Notice how the line captures the underlying trend in the data. \n",
    "And the performance is quite bad for this basic regression model with only one feature!\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R^2: 0.38512918452786693\n",
      "Root Mean Squared Error: 19.45998368278278\n",
      "[0.3155058  0.32624612 0.34073159 0.25431697 0.31391658]\n",
      "Average 5-Fold CV Score: 0.310143412454689\n",
      "0.3549745480392265\n",
      "0.31371544443491023\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Train/test split for regression\n",
    "As you learned in Chapter 1, train and test sets are vital to ensure that your supervised\n",
    "learning model is able to generalize well to new data. This was true for classification models,\n",
    "and is equally true for linear regression models.\n",
    "\"\"\"\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('gapminder.txt', delimiter = \",\")\n",
    "col_array = df.columns\n",
    "\n",
    "# Create arrays for features and target variable\n",
    "#target\n",
    "y = df['life_expectancy_years'].values\n",
    "y = np.nan_to_num(y, 0)\n",
    "#feature\n",
    "X = df['children_per_woman_total_fertility'].values\n",
    "X = np.nan_to_num(X, 0)\n",
    "# Reshape X and y\n",
    "y = y.reshape(-1, 1)\n",
    "X = X.reshape(-1, 1)\n",
    "\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42)\n",
    "\n",
    "# Create the regressor: reg_all\n",
    "reg_all = LinearRegression()\n",
    "\n",
    "# Fit the regressor to the training data\n",
    "reg_all.fit(X_train, y_train)\n",
    "\n",
    "# Predict on the test data: y_pred\n",
    "y_pred = reg_all.predict(X_test)\n",
    "\n",
    "# Compute and print R^2 and RMSE\n",
    "print(\"R^2: {}\".format(reg_all.score(X_test, y_test)))\n",
    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Using all features has improved the model score. This makes sense, as the model has more information to learn from.\n",
    "However, there is one potential pitfall to this process. Can you spot it? You'll learn about this as well how to \n",
    "better validate your models in the next video!\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Cross Validation\n",
    "\"\"\"\n",
    "\n",
    "# Import the necessary modules\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Create a linear regression object: reg\n",
    "reg = LinearRegression()\n",
    "\n",
    "# Compute 5-fold cross-validation scores: cv_scores\n",
    "cv_scores = cross_val_score(reg, X, y, cv=5)\n",
    "\n",
    "# Print the 5-fold cross-validation scores\n",
    "print(cv_scores)\n",
    "print(\"Average 5-Fold CV Score: {}\".format(np.mean(cv_scores)))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "K-Fold CV comparison\n",
    "Cross validation is essential but do not forget that the more folds you use, the more computationally expensive\n",
    "cross-validation becomes. In this exercise, you will explore this for yourself. Your job is to perform 3-fold\n",
    "cross-validation and then 10-fold cross-validation on the Gapminder dataset.\n",
    "\n",
    "In the IPython Shell, you can use %timeit to see how long each 3-fold CV takes compared to 10-fold CV by\n",
    "executing the following cv=3 and cv=10:\n",
    "\n",
    "%timeit cross_val_score(reg, X, y, cv = ____)\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Create a linear regression object: reg\n",
    "reg = LinearRegression()\n",
    "\n",
    "# Perform 3-fold CV\n",
    "cvscores_3 = cross_val_score(reg, X, y, cv=3)\n",
    "print(np.mean(cvscores_3))\n",
    "\n",
    "# Perform 10-fold CV\n",
    "cvscores_10 = cross_val_score(reg, X, y, cv=10)\n",
    "print(np.mean(cvscores_10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Unnamed: 0', 'country', 'year', 'population', 'continent', 'life_exp',\n",
      "       'gdp_cap'],\n",
      "      dtype='object')\n",
      "[[  974.5803384]\n",
      " [ 5937.029526 ]\n",
      " [ 6223.367465 ]\n",
      " [ 4797.231267 ]\n",
      " [12779.37964  ]\n",
      " [34435.36744  ]\n",
      " [36126.4927   ]\n",
      " [29796.04834  ]\n",
      " [ 1391.253792 ]\n",
      " [33692.60508  ]\n",
      " [ 1441.284873 ]\n",
      " [ 3822.137084 ]\n",
      " [ 7446.298803 ]\n",
      " [12569.85177  ]\n",
      " [ 9065.800825 ]\n",
      " [10680.79282  ]\n",
      " [ 1217.032994 ]\n",
      " [  430.0706916]\n",
      " [ 1713.778686 ]\n",
      " [ 2042.09524  ]\n",
      " [36319.23501  ]\n",
      " [  706.016537 ]\n",
      " [ 1704.063724 ]\n",
      " [13171.63885  ]\n",
      " [ 4959.114854 ]\n",
      " [ 7006.580419 ]\n",
      " [  986.1478792]\n",
      " [  277.5518587]\n",
      " [ 3632.557798 ]\n",
      " [ 9645.06142  ]\n",
      " [ 1544.750112 ]\n",
      " [14619.22272  ]\n",
      " [ 8948.102923 ]\n",
      " [22833.30851  ]\n",
      " [35278.41874  ]\n",
      " [ 2082.481567 ]\n",
      " [ 6025.374752 ]\n",
      " [ 6873.262326 ]\n",
      " [ 5581.180998 ]\n",
      " [ 5728.353514 ]\n",
      " [12154.08975  ]\n",
      " [  641.3695236]\n",
      " [  690.8055759]\n",
      " [33207.0844   ]\n",
      " [30470.0167   ]\n",
      " [13206.48452  ]\n",
      " [  752.7497265]\n",
      " [32170.37442  ]\n",
      " [ 1327.60891  ]\n",
      " [27538.41188  ]\n",
      " [ 5186.050003 ]\n",
      " [  942.6542111]\n",
      " [  579.231743 ]\n",
      " [ 1201.637154 ]\n",
      " [ 3548.330846 ]\n",
      " [39724.97867  ]\n",
      " [18008.94444  ]\n",
      " [36180.78919  ]\n",
      " [ 2452.210407 ]\n",
      " [ 3540.651564 ]\n",
      " [11605.71449  ]\n",
      " [ 4471.061906 ]\n",
      " [40675.99635  ]\n",
      " [25523.2771   ]\n",
      " [28569.7197   ]\n",
      " [ 7320.880262 ]\n",
      " [31656.06806  ]\n",
      " [ 4519.461171 ]\n",
      " [ 1463.249282 ]\n",
      " [ 1593.06548  ]\n",
      " [23348.13973  ]\n",
      " [47306.98978  ]\n",
      " [10461.05868  ]\n",
      " [ 1569.331442 ]\n",
      " [  414.5073415]\n",
      " [12057.49928  ]\n",
      " [ 1044.770126 ]\n",
      " [  759.3499101]\n",
      " [12451.6558   ]\n",
      " [ 1042.581557 ]\n",
      " [ 1803.151496 ]\n",
      " [10956.99112  ]\n",
      " [11977.57496  ]\n",
      " [ 3095.772271 ]\n",
      " [ 9253.896111 ]\n",
      " [ 3820.17523  ]\n",
      " [  823.6856205]\n",
      " [  944.       ]\n",
      " [ 4811.060429 ]\n",
      " [ 1091.359778 ]\n",
      " [36797.93332  ]\n",
      " [25185.00911  ]\n",
      " [ 2749.320965 ]\n",
      " [  619.6768924]\n",
      " [ 2013.977305 ]\n",
      " [49357.19017  ]\n",
      " [22316.19287  ]\n",
      " [ 2605.94758  ]\n",
      " [ 9809.185636 ]\n",
      " [ 4172.838464 ]\n",
      " [ 7408.905561 ]\n",
      " [ 3190.481016 ]\n",
      " [15389.92468  ]\n",
      " [20509.64777  ]\n",
      " [19328.70901  ]\n",
      " [ 7670.122558 ]\n",
      " [10808.47561  ]\n",
      " [  863.0884639]\n",
      " [ 1598.435089 ]\n",
      " [21654.83194  ]\n",
      " [ 1712.472136 ]\n",
      " [ 9786.534714 ]\n",
      " [  862.5407561]\n",
      " [47143.17964  ]\n",
      " [18678.31435  ]\n",
      " [25768.25759  ]\n",
      " [  926.1410683]\n",
      " [ 9269.657808 ]\n",
      " [28821.0637   ]\n",
      " [ 3970.095407 ]\n",
      " [ 2602.394995 ]\n",
      " [ 4513.480643 ]\n",
      " [33859.74835  ]\n",
      " [37506.41907  ]\n",
      " [ 4184.548089 ]\n",
      " [28718.27684  ]\n",
      " [ 1107.482182 ]\n",
      " [ 7458.396327 ]\n",
      " [  882.9699438]\n",
      " [18008.50924  ]\n",
      " [ 7092.923025 ]\n",
      " [ 8458.276384 ]\n",
      " [ 1056.380121 ]\n",
      " [33203.26128  ]\n",
      " [42951.65309  ]\n",
      " [10611.46299  ]\n",
      " [11415.80569  ]\n",
      " [ 2441.576404 ]\n",
      " [ 3025.349798 ]\n",
      " [ 2280.769906 ]\n",
      " [ 1271.211593 ]\n",
      " [  469.7092981]] [[43.828]\n",
      " [76.423]\n",
      " [72.301]\n",
      " [42.731]\n",
      " [75.32 ]\n",
      " [81.235]\n",
      " [79.829]\n",
      " [75.635]\n",
      " [64.062]\n",
      " [79.441]\n",
      " [56.728]\n",
      " [65.554]\n",
      " [74.852]\n",
      " [50.728]\n",
      " [72.39 ]\n",
      " [73.005]\n",
      " [52.295]\n",
      " [49.58 ]\n",
      " [59.723]\n",
      " [50.43 ]\n",
      " [80.653]\n",
      " [44.741]\n",
      " [50.651]\n",
      " [78.553]\n",
      " [72.961]\n",
      " [72.889]\n",
      " [65.152]\n",
      " [46.462]\n",
      " [55.322]\n",
      " [78.782]\n",
      " [48.328]\n",
      " [75.748]\n",
      " [78.273]\n",
      " [76.486]\n",
      " [78.332]\n",
      " [54.791]\n",
      " [72.235]\n",
      " [74.994]\n",
      " [71.338]\n",
      " [71.878]\n",
      " [51.579]\n",
      " [58.04 ]\n",
      " [52.947]\n",
      " [79.313]\n",
      " [80.657]\n",
      " [56.735]\n",
      " [59.448]\n",
      " [79.406]\n",
      " [60.022]\n",
      " [79.483]\n",
      " [70.259]\n",
      " [56.007]\n",
      " [46.388]\n",
      " [60.916]\n",
      " [70.198]\n",
      " [82.208]\n",
      " [73.338]\n",
      " [81.757]\n",
      " [64.698]\n",
      " [70.65 ]\n",
      " [70.964]\n",
      " [59.545]\n",
      " [78.885]\n",
      " [80.745]\n",
      " [80.546]\n",
      " [72.567]\n",
      " [82.603]\n",
      " [72.535]\n",
      " [54.11 ]\n",
      " [67.297]\n",
      " [78.623]\n",
      " [77.588]\n",
      " [71.993]\n",
      " [42.592]\n",
      " [45.678]\n",
      " [73.952]\n",
      " [59.443]\n",
      " [48.303]\n",
      " [74.241]\n",
      " [54.467]\n",
      " [64.164]\n",
      " [72.801]\n",
      " [76.195]\n",
      " [66.803]\n",
      " [74.543]\n",
      " [71.164]\n",
      " [42.082]\n",
      " [62.069]\n",
      " [52.906]\n",
      " [63.785]\n",
      " [79.762]\n",
      " [80.204]\n",
      " [72.899]\n",
      " [56.867]\n",
      " [46.859]\n",
      " [80.196]\n",
      " [75.64 ]\n",
      " [65.483]\n",
      " [75.537]\n",
      " [71.752]\n",
      " [71.421]\n",
      " [71.688]\n",
      " [75.563]\n",
      " [78.098]\n",
      " [78.746]\n",
      " [76.442]\n",
      " [72.476]\n",
      " [46.242]\n",
      " [65.528]\n",
      " [72.777]\n",
      " [63.062]\n",
      " [74.002]\n",
      " [42.568]\n",
      " [79.972]\n",
      " [74.663]\n",
      " [77.926]\n",
      " [48.159]\n",
      " [49.339]\n",
      " [80.941]\n",
      " [72.396]\n",
      " [58.556]\n",
      " [39.613]\n",
      " [80.884]\n",
      " [81.701]\n",
      " [74.143]\n",
      " [78.4  ]\n",
      " [52.517]\n",
      " [70.616]\n",
      " [58.42 ]\n",
      " [69.819]\n",
      " [73.923]\n",
      " [71.777]\n",
      " [51.542]\n",
      " [79.425]\n",
      " [78.242]\n",
      " [76.384]\n",
      " [73.747]\n",
      " [74.249]\n",
      " [73.422]\n",
      " [62.698]\n",
      " [42.384]\n",
      " [43.487]]\n",
      "[0.00026517]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "x and y must have same first dimension, but have shapes (7,) and (1,)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-126-3fb319e37cb6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     44\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     45\u001b[0m \u001b[1;31m# Plot the coefficients\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 46\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlasso_coef\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     47\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mxticks\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrotation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m60\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     48\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmargins\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.02\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2809\u001b[0m     return gca().plot(\n\u001b[0;32m   2810\u001b[0m         *args, scalex=scalex, scaley=scaley, **({\"data\": data} if data\n\u001b[1;32m-> 2811\u001b[1;33m         is not None else {}), **kwargs)\n\u001b[0m\u001b[0;32m   2812\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2813\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\__init__.py\u001b[0m in \u001b[0;36minner\u001b[1;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1808\u001b[0m                         \u001b[1;34m\"the Matplotlib list!)\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1809\u001b[0m                         RuntimeWarning, stacklevel=2)\n\u001b[1;32m-> 1810\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0max\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1811\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1812\u001b[0m         inner.__doc__ = _add_data_doc(inner.__doc__,\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_axes.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(self, scalex, scaley, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1609\u001b[0m         \u001b[0mkwargs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmlines\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLine2D\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_alias_map\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1610\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1611\u001b[1;33m         \u001b[1;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1612\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mline\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1613\u001b[0m             \u001b[0mlines\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mline\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m_grab_next_args\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    391\u001b[0m                 \u001b[0mthis\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    392\u001b[0m                 \u001b[0margs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 393\u001b[1;33m             \u001b[1;32myield\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_plot_args\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    394\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    395\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[1;34m(self, tup, kwargs)\u001b[0m\n\u001b[0;32m    368\u001b[0m             \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindex_of\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    369\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 370\u001b[1;33m         \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_xy_from_xy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    371\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    372\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcommand\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'plot'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Program Files\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m_xy_from_xy\u001b[1;34m(self, x, y)\u001b[0m\n\u001b[0;32m    229\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    230\u001b[0m             raise ValueError(\"x and y must have same first dimension, but \"\n\u001b[1;32m--> 231\u001b[1;33m                              \"have shapes {} and {}\".format(x.shape, y.shape))\n\u001b[0m\u001b[0;32m    232\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    233\u001b[0m             raise ValueError(\"x and y can be no greater than 2-D, but have \"\n",
      "\u001b[1;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (7,) and (1,)"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Regularization I: Lasso\n",
    "In the video, you saw how Lasso selected out the 'RM' feature as being the most important for predicting\n",
    "Boston house prices, while shrinking the coefficients of certain other features to 0. Its ability to perform\n",
    "feature selection in this way becomes even more useful when you are dealing with data involving thousands of features.\n",
    "\n",
    "In this exercise, you will fit a lasso regression to the Gapminder data you have been working with and plot\n",
    "the coefficients. Just as with the Boston data, you will find that the coefficients of some features are shrunk\n",
    "to 0, with only the most important ones remaining.\n",
    "\"\"\"\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('gapminder - gapminder.csv')\n",
    "col_array = df.columns\n",
    "print(col_array)\n",
    "\n",
    "# Create arrays for features and target variable\n",
    "#target\n",
    "y = df['life_exp'].values\n",
    "y = np.nan_to_num(y, 0)\n",
    "#feature\n",
    "X = df['gdp_cap'].values\n",
    "X = np.nan_to_num(X, 0)\n",
    "\n",
    "# Reshape X and y\n",
    "y = y.reshape(-1, 1)\n",
    "X = X.reshape(-1, 1)\n",
    "\n",
    "print(X, y)\n",
    "# Import Lasso\n",
    "from sklearn.linear_model import Lasso\n",
    "\n",
    "# Instantiate a lasso regressor: lasso\n",
    "lasso = Lasso(alpha=.4, normalize=True)\n",
    "\n",
    "# Fit the regressor to the data\n",
    "lasso.fit(X, y)\n",
    "\n",
    "# Compute and print the coefficients\n",
    "lasso_coef = lasso.fit(X, y).coef_\n",
    "print(lasso_coef)\n",
    "\n",
    "# Plot the coefficients\n",
    "plt.plot(range(len(df.columns)), lasso_coef)\n",
    "plt.xticks(range(len(df.columns)), df.columns.values, rotation=60)\n",
    "plt.margins(0.02)\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "According to the lasso algorithm, it seems like 'child_mortality' is the most important feature when\n",
    "predicting life expectancy.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Regularization II: Ridge\n",
    "Lasso is great for feature selection, but when building regression models, Ridge regression should be your first choice.\n",
    "\n",
    "Recall that lasso performs regularization by adding to the loss function a penalty term of the absolute value\n",
    "of each coefficient multiplied by some alpha. This is also known as  regularization because the regularization\n",
    "term is the  norm of the coefficients. This is not the only way to regularize, however.\n",
    "\n",
    "If instead you took the sum of the squared values of the coefficients multiplied by some alpha - like\n",
    "in Ridge regression - you would be computing the  norm. In this exercise, you will practice fitting ridge\n",
    "regression models over a range of different alphas, and plot cross-validated  scores for each, using this\n",
    "function that we have defined for you, which plots the  score as well as standard error for each alpha:\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Setup the array of alphas and lists to store scores\n",
    "alpha_space = np.logspace(-4, 0, 50)\n",
    "ridge_scores = []\n",
    "ridge_scores_std = []\n",
    "\n",
    "# Create a ridge regressor: ridge\n",
    "ridge = Ridge(normalize=True)\n",
    "\n",
    "# Compute scores over range of alphas\n",
    "for alpha in alpha_space:\n",
    "\n",
    "    # Specify the alpha value to use: ridge.alpha\n",
    "    ridge.alpha = alpha\n",
    "    \n",
    "    # Perform 10-fold CV: ridge_cv_scores\n",
    "    ridge_cv_scores = cross_val_score(ridge, X, y, cv=10)\n",
    "    \n",
    "    # Append the mean of ridge_cv_scores to ridge_scores\n",
    "    ridge_scores.append(np.mean(ridge_cv_scores))\n",
    "    \n",
    "    # Append the std of ridge_cv_scores to ridge_scores_std\n",
    "    ridge_scores_std.append(np.std(ridge_cv_scores))\n",
    "\n",
    "# Display the plot\n",
    "display_plot(ridge_scores, ridge_scores_std)\n",
    "\n",
    "\"\"\"\n",
    "Notice how the cross-validation scores change with different alphas. Which alpha should you pick? How can you\n",
    "fine-tune your model? You'll learn all about this in the next chapter!\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
      "0            6      148             72             35        0  33.6   \n",
      "1            1       85             66             29        0  26.6   \n",
      "2            8      183             64              0        0  23.3   \n",
      "3            1       89             66             23       94  28.1   \n",
      "4            0      137             40             35      168  43.1   \n",
      "\n",
      "   DiabetesPedigreeFunction  Age  Outcome  \n",
      "0                     0.627   50        1  \n",
      "1                     0.351   31        0  \n",
      "2                     0.672   32        1  \n",
      "3                     0.167   21        0  \n",
      "4                     2.288   33        1  \n",
      "Target (Response) variable, to predict :  (768,)\n",
      "Predictors (Explanatory Variables) :  (768, 8)\n",
      "[[176  30]\n",
      " [ 56  46]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.76      0.85      0.80       206\n",
      "           1       0.61      0.45      0.52       102\n",
      "\n",
      "   micro avg       0.72      0.72      0.72       308\n",
      "   macro avg       0.68      0.65      0.66       308\n",
      "weighted avg       0.71      0.72      0.71       308\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Metrics for classification\n",
    "In Chapter 1, you evaluated the performance of your k-NN classifier based on its accuracy. \n",
    "However, as Andy discussed, accuracy is not always an informative metric. In this exercise, you will \n",
    "dive more deeply into evaluating the performance of binary classifiers by computing a confusion matrix\n",
    "and generating a classification report.\n",
    "\n",
    "You may have noticed in the video that the classification report consisted of three rows, and an additional\n",
    "support column. The support gives the number of samples of the true response that lie in that class - so\n",
    "in the video example, the support was the number of Republicans or Democrats in the test set on which the\n",
    "classification report was computed. The precision, recall, and f1-score columns, then, gave the respective\n",
    "metrics for that particular class.\n",
    "\n",
    "Here, you'll work with the PIMA Indians dataset obtained from the UCI Machine Learning Repository. The goal is\n",
    "to predict whether or not a given female patient will contract diabetes based on features such as BMI, age, and\n",
    "number of pregnancies. Therefore, it is a binary classification problem. A target value of 0 indicates that the\n",
    "patient does not have diabetes, while a value of 1 indicates that the patient does have diabetes. As in Chapters\n",
    "1 and 2, the dataset has been preprocessed to deal with missing values.\n",
    "\"\"\"\n",
    "\n",
    "import sys, os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('diabetes.csv')\n",
    "print(df.head())\n",
    "\n",
    "y = df['Outcome']\n",
    "y = np.nan_to_num(y, 0)\n",
    "\n",
    "X = df.drop('Outcome', axis=1).values\n",
    "\n",
    "print(\"Target (Response) variable, to predict : \", y.shape)\n",
    "print(\"Predictors (Explanatory Variables) : \", X.shape)\n",
    "\n",
    "# Create training and test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)\n",
    "\n",
    "# Instantiate a k-NN classifier: knn\n",
    "knn = KNeighborsClassifier(n_neighbors = 6)\n",
    "\n",
    "# Fit the classifier to the training data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# Predict the labels of the test data: y_pred\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Generate the confusion matrix and classification report\n",
    "print(confusion_matrix(y_test, y_pred))\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[WinError 3] Le chemin d’accès spécifié est introuvable: 'C:/Users/T0230575/source/repos/DataCamp__/Python/Unsupervised Learning with Python/data/'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-21399778fba0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'C:/Users/T0230575/source/repos/DataCamp__/Python/Unsupervised Learning with Python/data/'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     17\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;31m# Read the CSV file into a DataFrame: df\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 3] Le chemin d’accès spécifié est introuvable: 'C:/Users/T0230575/source/repos/DataCamp__/Python/Unsupervised Learning with Python/data/'"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Building a logistic regression model\n",
    "Time to build your first logistic regression model! As Hugo showed in the video, scikit-learn makes it very\n",
    "easy to try different models, since the Train-Test-Split/Instantiate/Fit/Predict paradigm applies to all\n",
    "classifiers and regressors - which are known in scikit-learn as 'estimators'. You'll see this now for yourself\n",
    "as you train a logistic regression model on exactly the same data as in the previous exercise. \n",
    "Will it outperform k-NN? There's only one way to find out!\n",
    "\"\"\"\n",
    "\n",
    "# Import the necessary modules\n",
    "import sys, os\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('diabetes.csv')\n",
    "\n",
    "y = df['Outcome']\n",
    "y = np.nan_to_num(y, 0)\n",
    "X = df.drop('Outcome', axis=1).values\n",
    "\n",
    "# Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state=42)\n",
    "\n",
    "# Create the classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Fit the classifier to the training data\n",
    "logreg.fit(X_train, y_train)\n",
    "\n",
    "# Predict the labels of the test set: y_pred\n",
    "y_pred = logreg.predict(X_test)\n",
    "\n",
    "# Compute and print the confusion matrix and classification report\n",
    "print(confusion_matrix(y_test, y_pred))\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "\"\"\"\n",
    "You now know how to use logistic regression for binary classification - great work! Logistic regression\n",
    "is used in a variety of machine learning applications and will become a vital part of your data science toolbox.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Plotting an ROC curve\n",
    "Great job in the previous exercise - you now have a new addition to your toolbox of classifiers!\n",
    "\n",
    "Classification reports and confusion matrices are great methods to quantitatively evaluate model performance,\n",
    "while ROC curves provide a way to visually evaluate models. As Hugo demonstrated in the video, most classifiers\n",
    "in scikit-learn have a .predict_proba() method which returns the probability of a given sample being in a \n",
    "particular class. Having built a logistic regression model, you'll now evaluate its performance by plotting\n",
    "an ROC curve. In doing so, you'll make use of the .predict_proba() method and become familiar with its functionality.\n",
    "\n",
    "Here, you'll continue working with the PIMA Indians diabetes dataset. The classifier has already been fit\n",
    "to the training data and is available as logreg.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "# Compute predicted probabilities: y_pred_prob\n",
    "y_pred_prob = logreg.predict_proba(X_test)[:,1]\n",
    "\n",
    "# Generate ROC curve values: fpr, tpr, thresholds\n",
    "fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)\n",
    "\n",
    "# Plot ROC curve\n",
    "plt.plot([0, 1], [0, 1], 'k--')\n",
    "plt.plot(fpr, tpr)\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve')\n",
    "plt.show()\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "\"\"\"\n",
    "Precision-recall Curve\n",
    "When looking at your ROC curve, you may have noticed that the y-axis (True positive rate) is also known as recall. \n",
    "Indeed, in addition to the ROC curve, there are other ways to visually evaluate model performance. One such way is\n",
    "the precision-recall curve, which is generated by plotting the precision and recall for different thresholds. \n",
    "\n",
    "As a reminder, precision and recall are defined as:\n",
    "On the right, a precision-recall curve has been generated for the diabetes dataset. The classification report and\n",
    "confusion matrix are displayed in the IPython Shell.\n",
    "Study the precision-recall curve and then consider the statements given below. Choose the one statement that is not true.\n",
    "Note that here, the class is positive (1) if the individual has diabetes.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'X_test' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-974bd886e0b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[1;31m# Compute predicted probabilities: y_pred_prob\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 21\u001b[1;33m \u001b[0my_pred_prob\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlogreg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict_proba\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;31m# Compute and print AUC score\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'X_test' is not defined"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "AUC computation\n",
    "Say you have a binary classifier that in fact is just randomly making guesses. It would be correct approximately\n",
    "50% of the time, and the resulting ROC curve would be a diagonal line in which the True Positive Rate and False\n",
    "Positive Rate are always equal. The Area under this ROC curve would be 0.5. This is one way in which the AUC,\n",
    "which Hugo discussed in the video, is an informative metric to evaluate a model. If the AUC is greater than 0.5,\n",
    "the model is better than random guessing. Always a good sign!\n",
    "\n",
    "In this exercise, you'll calculate AUC scores using the roc_auc_score() function from sklearn.metrics as well\n",
    "as by performing cross-validation on the diabetes dataset.\n",
    "\n",
    "X and y, along with training and test sets X_train, X_test, y_train, y_test, have been pre-loaded for you,\n",
    "and a logistic regression classifier logreg has been fit to the training data.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Compute predicted probabilities: y_pred_prob\n",
    "y_pred_prob = logreg.predict_proba(X_test)[:,1]\n",
    "\n",
    "# Compute and print AUC score\n",
    "print(\"AUC: {}\".format(roc_auc_score(y_test, y_pred_prob)))\n",
    "\n",
    "# Compute cross-validated AUC scores: cv_auc\n",
    "cv_auc = cross_val_score(logreg, X, y, cv=5, scoring='roc_auc')\n",
    "\n",
    "# Print list of AUC scores\n",
    "print(\"AUC scores computed using 5-fold cross-validation: {}\".format(cv_auc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'X' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-648f7491a822>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     36\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     37\u001b[0m \u001b[1;31m# Fit it to the data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 38\u001b[1;33m \u001b[0mlogreg_cv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     39\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m \u001b[1;31m# Print the tuned parameter and score\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'X' is not defined"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Hyperparameter tuning with GridSearchCV\n",
    "Hugo demonstrated how to tune the n_neighbors parameter of the KNeighborsClassifier() using GridSearchCV\n",
    "on the voting dataset. You will now practice this yourself, but by using logistic regression on the diabetes\n",
    "dataset instead!\n",
    "\n",
    "Like the alpha parameter of lasso and ridge regularization that you saw earlier, logistic regression also has\n",
    "a regularization parameter: .  controls the inverse of the regularization strength, and this is what you will\n",
    "tune in this exercise. A large  can lead to an overfit model, while a small  can lead to an underfit model.\n",
    "\n",
    "The hyperparameter space for  has been setup for you. Your job is to use GridSearchCV and logistic regression\n",
    "to find the optimal  in this hyperparameter space. The feature array is available as X and target variable array\n",
    "is available as y.\n",
    "\n",
    "You may be wondering why you aren't asked to split the data into training and test sets. Good observation!\n",
    "Here, we want you to focus on the process of setting up the hyperparameter grid and performing grid-search\n",
    "cross-validation. In practice, you will indeed want to hold out a portion of your data for evaluation purposes,\n",
    "and you will learn all about this in the next video!\n",
    "\"\"\"\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Setup the hyperparameter grid\n",
    "c_space = np.logspace(-5, 8, 15)\n",
    "param_grid = {'C': c_space}\n",
    "\n",
    "# Instantiate a logistic regression classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Instantiate the GridSearchCV object: logreg_cv\n",
    "logreg_cv = GridSearchCV(logreg, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the data\n",
    "logreg_cv.fit(X, y)\n",
    "\n",
    "# Print the tuned parameter and score\n",
    "print(\"Tuned Logistic Regression Parameters: {}\".format(logreg_cv.best_params_))\n",
    "print(\"Best score is {}\".format(logreg_cv.best_score_))\n",
    "\n",
    "\"\"\"\n",
    "It looks like a 'C' of 268.3 results in the best performance.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Hyperparameter tuning with RandomizedSearchCV\n",
    "GridSearchCV can be computationally expensive, especially if you are searching over a large hyperparameter space\n",
    "and dealing with multiple hyperparameters. A solution to this is to use RandomizedSearchCV, in which not all\n",
    "hyperparameter values are tried out. Instead, a fixed number of hyperparameter settings is sampled from specified probability distributions. You'll practice using RandomizedSearchCV in this exercise and see how this works.\n",
    "\n",
    "Here, you'll also be introduced to a new model: the Decision Tree. Don't worry about the specifics of how this\n",
    "model works. Just like k-NN, linear regression, and logistic regression, decision trees in scikit-learn have .fit()\n",
    "and .predict() methods that you can use in exactly the same way as before. Decision trees have many parameters that\n",
    "can be tuned, such as max_features, max_depth, and min_samples_leaf: This makes it an ideal use case for \n",
    "RandomizedSearchCV.\n",
    "\n",
    "As before, the feature array X and target variable array y of the diabetes dataset have been pre-loaded. The\n",
    "hyperparameter settings have been specified for you. Your goal is to use RandomizedSearchCV to find the optimal\n",
    "hyperparameters. Go for it!\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned Logistic Regression Parameters: {'C': 268.2695795279727}\n",
      "Best score is 0.7708333333333334\n",
      "Tuned Decision Tree Parameters: {'criterion': 'entropy', 'max_depth': 3, 'max_features': 7, 'min_samples_leaf': 5}\n",
      "Best score is 0.7434895833333334\n",
      "Tuned Logistic Regression Parameter: {'C': 31.622776601683793, 'penalty': 'l2'}\n",
      "Tuned Logistic Regression Accuracy: 0.7673913043478261\n",
      "Tuned ElasticNet l1 ratio: {'l1_ratio': 0.0}\n",
      "Tuned ElasticNet R squared: 0.24765337510702745\n",
      "Tuned ElasticNet MSE: 0.16664179543611002\n"
     ]
    }
   ],
   "source": [
    "# Import necessary modules\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "import sys, os\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('diabetes.csv')\n",
    "\n",
    "y = df['Outcome']\n",
    "y = np.nan_to_num(y, 0)\n",
    "X = df.drop('Outcome', axis=1).values\n",
    "\n",
    "# Setup the hyperparameter grid\n",
    "c_space = np.logspace(-5, 8, 15)\n",
    "param_grid = {'C': c_space}\n",
    "\n",
    "# Instantiate a logistic regression classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Instantiate the GridSearchCV object: logreg_cv\n",
    "logreg_cv = GridSearchCV(logreg, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the data\n",
    "logreg_cv.fit(X, y)\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned Logistic Regression Parameters: {}\".format(logreg_cv.best_params_)) \n",
    "print(\"Best score is {}\".format(logreg_cv.best_score_))\n",
    "\n",
    "\"\"\"\n",
    "Hyperparameter tuning with RandomizedSearchCV\n",
    "GridSearchCV can be computationally expensive, especially if you are searching over a large hyperparameter\n",
    "space and dealing with multiple hyperparameters. A solution to this is to use RandomizedSearchCV, in which\n",
    "not all hyperparameter values are tried out. Instead, a fixed number of hyperparameter settings is sampled\n",
    "from specified probability distributions. You'll practice using RandomizedSearchCV in this exercise and see\n",
    "how this works.\n",
    "\n",
    "Here, you'll also be introduced to a new model: the Decision Tree. Don't worry about the specifics of how\n",
    "this model works. Just like k-NN, linear regression, and logistic regression, decision trees in scikit-learn \n",
    "have .fit() and .predict() methods that you can use in exactly the same way as before. Decision trees have\n",
    "many parameters that can be tuned, such as max_features, max_depth, and min_samples_leaf: This makes it an\n",
    "ideal use case for RandomizedSearchCV.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from scipy.stats import randint\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "\n",
    "# Setup the parameters and distributions to sample from: param_dist\n",
    "param_dist = {\"max_depth\": [3, None],\n",
    "              \"max_features\": randint(1, 9),\n",
    "              \"min_samples_leaf\": randint(1, 9),\n",
    "              \"criterion\": [\"gini\", \"entropy\"]}\n",
    "\n",
    "# Instantiate a Decision Tree classifier: tree\n",
    "tree = DecisionTreeClassifier()\n",
    "\n",
    "# Instantiate the RandomizedSearchCV object: tree_cv\n",
    "tree_cv = RandomizedSearchCV(tree, param_dist, cv=5)\n",
    "\n",
    "# Fit it to the data\n",
    "tree_cv.fit(X, y)\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned Decision Tree Parameters: {}\".format(tree_cv.best_params_))\n",
    "print(\"Best score is {}\".format(tree_cv.best_score_))\n",
    "\n",
    "\"\"\"\n",
    "You'll see a lot more of decision trees and RandomizedSearchCV as you continue your machine learning journey.\n",
    "Note that RandomizedSearchCV will never outperform GridSearchCV. Instead, it is valuable because it saves on\n",
    "computation time.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Hold-out set reasoning\n",
    "For which of the following reasons would you want to use a hold-out set for the very end?\n",
    ">> You want to be absolutely certain about your model's ability to generalize to unseen data\n",
    "\n",
    "The idea is to tune the model's hyperparameters on the training set, and then evaluate its performance on\n",
    "the hold-out set which it has never seen before.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Create the hyperparameter grid\n",
    "c_space = np.logspace(-5, 8, 15)\n",
    "param_grid = {'C': c_space, 'penalty': ['l1', 'l2']}\n",
    "\n",
    "# Instantiate the logistic regression classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)\n",
    "\n",
    "# Instantiate the GridSearchCV object: logreg_cv\n",
    "logreg_cv = GridSearchCV(logreg, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the training data\n",
    "logreg_cv.fit(X_train, y_train)\n",
    "\n",
    "# Print the optimal parameters and best score\n",
    "print(\"Tuned Logistic Regression Parameter: {}\".format(logreg_cv.best_params_))\n",
    "print(\"Tuned Logistic Regression Accuracy: {}\".format(logreg_cv.best_score_))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Hold-out set in practice II: Regression\n",
    "Remember lasso and ridge regression from the previous chapter? Lasso used the  penalty to regularize, \n",
    "while ridge used the  penalty. There is another type of regularized regression known as the elastic net.\n",
    "In elastic net regularization, the penalty term is a linear combination of the  and  penalties:\n",
    "\n",
    "In scikit-learn, this term is represented by the 'l1_ratio' parameter: An 'l1_ratio' of 1 corresponds to an\n",
    "penalty, and anything lower is a combination of  and .\n",
    "\n",
    "In this exercise, you will GridSearchCV to tune the 'l1_ratio' of an elastic net model trained on the Gapminder data.\n",
    "As in the previous exercise, use a hold-out set to evaluate your model's performance.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import ElasticNet\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state=42)\n",
    "\n",
    "# Create the hyperparameter grid\n",
    "l1_space = np.linspace(0, 1, 30)\n",
    "param_grid = {'l1_ratio': l1_space}\n",
    "\n",
    "# Instantiate the ElasticNet regressor: elastic_net\n",
    "elastic_net = ElasticNet()\n",
    "\n",
    "# Setup the GridSearchCV object: gm_cv\n",
    "gm_cv = GridSearchCV(elastic_net, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the training data\n",
    "gm_cv.fit(X_train, y_train)\n",
    "\n",
    "# Predict on the test set and compute metrics\n",
    "y_pred = gm_cv.predict(X_test)\n",
    "r2 = gm_cv.score(X_test, y_test)\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "print(\"Tuned ElasticNet l1 ratio: {}\".format(gm_cv.best_params_))\n",
    "print(\"Tuned ElasticNet R squared: {}\".format(r2))\n",
    "print(\"Tuned ElasticNet MSE: {}\".format(mse))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Now that you understand how to fine-tune your models, it's time to learn about preprocessing techniques\n",
    "and how to piece together all the different stages of the machine learning process into a pipeline!\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['year', 'population', 'life_exp', 'gdp_cap', 'country_Afghanistan',\n",
      "       'country_Albania', 'country_Algeria', 'country_Angola',\n",
      "       'country_Argentina', 'country_Australia',\n",
      "       ...\n",
      "       'country_Vietnam', 'country_West Bank and Gaza', 'country_Yemen, Rep.',\n",
      "       'country_Zambia', 'country_Zimbabwe', 'continent_Africa',\n",
      "       'continent_Americas', 'continent_Asia', 'continent_Europe',\n",
      "       'continent_Oceania'],\n",
      "      dtype='object', length=151)\n",
      "Index(['year', 'population', 'life_exp', 'gdp_cap', 'country_Albania',\n",
      "       'country_Algeria', 'country_Angola', 'country_Argentina',\n",
      "       'country_Australia', 'country_Austria',\n",
      "       ...\n",
      "       'country_Venezuela', 'country_Vietnam', 'country_West Bank and Gaza',\n",
      "       'country_Yemen, Rep.', 'country_Zambia', 'country_Zimbabwe',\n",
      "       'continent_Americas', 'continent_Asia', 'continent_Europe',\n",
      "       'continent_Oceania'],\n",
      "      dtype='object', length=149)\n",
      "[0.26648172 0.23084647 0.27355543 0.24898795 0.25673452]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exploring categorical features\n",
    "The Gapminder dataset that you worked with in previous chapters also contained a categorical 'Region' feature,\n",
    "which we dropped in previous exercises since you did not have the tools to deal with it. Now however, you do,\n",
    "so we have added it back in!\n",
    "\n",
    "Your job in this exercise is to explore this feature. Boxplots are particularly useful for visualizing categorical\n",
    "features such as this.\n",
    "\"\"\"\n",
    "\n",
    "# Import pandas\n",
    "import pandas as pd\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "df = pd.read_csv('gapminder_full.csv')\n",
    "\n",
    "# Create a boxplot of life expectancy per region\n",
    "df.boxplot('life_exp', 'continent', rot=60)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Creating dummy variables\n",
    "As Andy discussed in the video, scikit-learn does not accept non-numerical features. You saw in the previous exercise\n",
    "that the 'Region' feature contains very useful information that can predict life expectancy. For example, Sub-Saharan\n",
    "Africa has a lower life expectancy compared to Europe and Central Asia. Therefore, if you are trying to predict life\n",
    "expectancy, it would be preferable to retain the 'Region' feature. To do this, you need to binarize it by creating\n",
    "dummy variables, which is what you will do in this exercise.\n",
    "\"\"\"\n",
    "\n",
    "# Create dummy variables: df_region\n",
    "df_region = pd.get_dummies(df)\n",
    "\n",
    "# Print the columns of df_region\n",
    "print(df_region.columns)\n",
    "\n",
    "# Create dummy variables with drop_first=True: df_region\n",
    "df_region = pd.get_dummies(df, drop_first=True)\n",
    "\n",
    "# Print the new columns of df_region\n",
    "print(df_region.columns)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Now that you have created the dummy variables, you can use the 'Region' feature to predict life expectancy!\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Regression with categorical features\n",
    "Having created the dummy variables from the 'Region' feature, you can build regression models as you did before.\n",
    "Here, you'll use ridge regression to perform 5-fold cross-validation.\n",
    "\n",
    "The feature array X and target variable array y have been pre-loaded.\n",
    "\"\"\"\n",
    "# Import necessary modules\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Instantiate a ridge regressor: ridge\n",
    "ridge = Ridge(alpha=.5, normalize=True).fit(X, y)\n",
    "\n",
    "# Perform 5-fold cross-validation: ridge_cv\n",
    "ridge_cv = cross_val_score(ridge, X, y, cv=5)\n",
    "\n",
    "# Print the cross-validated scores\n",
    "print(ridge_cv)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "You now know how to build models using data that includes categorical features.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class Name                                   0\n",
      " handicapped-infants                        12\n",
      " water-project-cost-sharing                 48\n",
      " adoption-of-the-budget-resolution          11\n",
      " physician-fee-freeze                       11\n",
      " el-salvador-aid                            15\n",
      " religious-groups-in-schools                11\n",
      " anti-satellite-test-ban                    14\n",
      " aid-to-nicaraguan-contras                  15\n",
      " mx-missile                                 22\n",
      " immigration                                 7\n",
      " synfuels-corporation-cutback               21\n",
      " education-spending                         31\n",
      " superfund-right-to-sue                     25\n",
      " crime                                      17\n",
      " duty-free-exports                          28\n",
      " export-administration-act-south-africa    104\n",
      "dtype: int64\n",
      "Shape of Original DataFrame: (435, 17)\n",
      "Shape of DataFrame After Dropping All Rows with Missing Values: (232, 17)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.65      1.00      0.79       151\n",
      "           1       0.00      0.00      0.00        80\n",
      "\n",
      "   micro avg       0.65      0.65      0.65       231\n",
      "   macro avg       0.33      0.50      0.40       231\n",
      "weighted avg       0.43      0.65      0.52       231\n",
      "\n",
      "Mean of Unscaled Features: 44.98579117838542\n",
      "Standard Deviation of Unscaled Features: 58.37297131925462\n",
      "Mean of Scaled Features: 8.86154575644819e-17\n",
      "Standard Deviation of Scaled Features: 1.0\n",
      "Accuracy with Scaling: 0.7012987012987013\n",
      "Accuracy without Scaling: 0.6883116883116883\n",
      "Accuracy: 0.7532467532467533\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.75      0.90      0.82        94\n",
      "           1       0.78      0.52      0.62        60\n",
      "\n",
      "   micro avg       0.75      0.75      0.75       154\n",
      "   macro avg       0.76      0.71      0.72       154\n",
      "weighted avg       0.76      0.75      0.74       154\n",
      "\n",
      "Tuned Model Parameters: {'SVM__C': 1, 'SVM__gamma': 0.01}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Dropping missing data\n",
    "The voting dataset from Chapter 1 contained a bunch of missing values that we dealt with for you behind the scenes.\n",
    "Now, it's time for you to take care of these yourself!\n",
    "\n",
    "The unprocessed dataset has been loaded into a DataFrame df. Explore it in the IPython Shell with the .head() method.\n",
    "You will see that there are certain data points labeled with a '?'. These denote missing values. As you saw in the video,\n",
    "different datasets encode missing values in different ways. Sometimes it may be a '9999', other times a 0 - real-world\n",
    "data can be very messy! If you're lucky, the missing values will already be encoded as NaN. We use NaN because it is an\n",
    "efficient and simplified way of internally representing missing data, and it lets us take advantage of pandas methods\n",
    "such as .dropna() and .fillna(), as well as scikit-learn's Imputation transformer Imputer().\n",
    "\n",
    "In this exercise, your job is to convert the '?'s to NaNs, and then drop the rows that contain them from the DataFrame.\n",
    "\"\"\"\n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "import numpy as np\n",
    "import sys, os\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "os.chdir('C:/Users/T0230575/source/repos/DataCamp__/Python/Supervised Learning with scikit-learn/data/')\n",
    "df = pd.read_csv('house-votes-84.csv')\n",
    "\n",
    "# Convert '?' to NaN\n",
    "df[df == '?'] = np.nan\n",
    "\n",
    "# Print the number of NaNs\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Print shape of original DataFrame\n",
    "print(\"Shape of Original DataFrame: {}\".format(df.shape))\n",
    "\n",
    "# Drop missing values and print shape of new DataFrame\n",
    "df = df.dropna()\n",
    "\n",
    "# Print shape of new DataFrame\n",
    "print(\"Shape of DataFrame After Dropping All Rows with Missing Values: {}\".format(df.shape))\n",
    "\n",
    "\"\"\"\n",
    "When many values in your dataset are missing, if you drop them, you may end up throwing away valuable information\n",
    "along with the missing data. It's better instead to develop an imputation strategy. This is where domain knowledge\n",
    "is useful, but in the absence of it, you can impute missing values with the mean or the median of the row or column\n",
    "that the missing value is in.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Imputing missing data in a ML Pipeline I\n",
    "As you've come to appreciate, there are many steps to building a model, from creating training and test sets,\n",
    "to fitting a classifier or regressor, to tuning its parameters, to evaluating its performance on new data. \n",
    "Imputation can be seen as the first step of this machine learning process, the entirety of which can be viewed\n",
    "within the context of a pipeline. Scikit-learn provides a pipeline constructor that allows you to piece together\n",
    "these steps into one process and thereby simplify your workflow.\n",
    "\n",
    "You'll now practice setting up a pipeline with two steps: the imputation step, followed by the instantiation of a\n",
    "classifier. You've seen three classifiers in this course so far: k-NN, logistic regression, and the decision tree.\n",
    "You will now be introduced to a fourth one - the Support Vector Machine, or SVM. For now, do not worry about how it\n",
    "works under the hood. It works exactly as you would expect of the scikit-learn estimators that you have worked with\n",
    "previously, in that it has the same .fit() and .predict() methods as before.\n",
    "\"\"\"\n",
    "\n",
    "# Import the Imputer module\n",
    "from sklearn.preprocessing import Imputer\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# Setup the Imputation transformer: imp\n",
    "imp = Imputer(missing_values='NaN', strategy='most_frequent', axis=0)\n",
    "\n",
    "# Instantiate the SVC classifier: clf\n",
    "clf = SVC()\n",
    "\n",
    "# Setup the pipeline with the required steps: steps\n",
    "steps = [('imputation', imp),\n",
    "        ('SVM', clf)]\n",
    "\n",
    "\"\"\"\n",
    "Having set up the pipeline steps, you can now use it for classification.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Imputing missing data in a ML Pipeline II\n",
    "Having setup the steps of the pipeline in the previous exercise, you will now use it on the voting dataset to\n",
    "classify a Congressman's party affiliation. What makes pipelines so incredibly useful is the simple interface\n",
    "that they provide. You can use the .fit() and .predict() methods on pipelines just as you did with your classifiers\n",
    "and regressors!\n",
    "\n",
    "Practice this for yourself now and generate a classification report of your predictions. The steps of the pipeline\n",
    "have been set up for you, and the feature array X and target variable array y have been pre-loaded. Additionally,\n",
    "train_test_split and classification_report have been imported from sklearn.model_selection and sklearn.metrics\n",
    "respectively.\n",
    "\"\"\"\n",
    "\n",
    "# Import necessary modules\n",
    "from sklearn.preprocessing import Imputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [('imputation', Imputer(missing_values='NaN', strategy='most_frequent', axis=0)),\n",
    "        ('SVM', SVC())]\n",
    "\n",
    "# Create the pipeline: pipeline\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Fit the pipeline to the train set\n",
    "pipeline.fit(X_train, y_train)\n",
    "\n",
    "# Predict the labels of the test set\n",
    "y_pred = pipeline.predict(X_test)\n",
    "\n",
    "# Compute metrics\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Centering and scaling your data\n",
    "In the video, Hugo demonstrated how significantly the performance of a model can improve if the features are scaled.\n",
    "Note that this is not always the case: In the Congressional voting records dataset, for example, all of the features\n",
    "are binary. In such a situation, scaling will have minimal impact.\n",
    "\n",
    "You will now explore scaling for yourself on a new dataset - White Wine Quality! Hugo used the Red Wine Quality dataset\n",
    "in the video. We have used the 'quality' feature of the wine to create a binary target variable: If 'quality' is less\n",
    "than 5, the target variable is 1, and otherwise, it is 0.\n",
    "\n",
    "The DataFrame has been pre-loaded as df, along with the feature and target variable arrays X and y. Explore it in the\n",
    "IPython Shell. Notice how some features seem to have different units of measurement. 'density', for instance, takes\n",
    "values between 0.98 and 1.04, while 'total sulfur dioxide' ranges from 9 to 440. As a result, it may be worth scaling\n",
    "the features here. Your job in this exercise is to scale the features and compute the mean and standard deviation of\n",
    "the unscaled features compared to the scaled features.\n",
    "\"\"\"\n",
    "\n",
    "# Import scale\n",
    "from sklearn.preprocessing import scale\n",
    "\n",
    "# Scale the features: X_scaled\n",
    "X_scaled = scale(X)\n",
    "\n",
    "# Print the mean and standard deviation of the unscaled features\n",
    "print(\"Mean of Unscaled Features: {}\".format(np.mean(X))) \n",
    "print(\"Standard Deviation of Unscaled Features: {}\".format(np.std(X)))\n",
    "\n",
    "# Print the mean and standard deviation of the scaled features\n",
    "print(\"Mean of Scaled Features: {}\".format(np.mean(X_scaled))) \n",
    "print(\"Standard Deviation of Scaled Features: {}\".format(np.std(X_scaled)))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Notice the difference in the mean and standard deviation of the scaled features compared to the unscaled features.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Centering and scaling in a pipeline\n",
    "With regard to whether or not scaling is effective, the proof is in the pudding! \n",
    "See for yourself whether or not scaling the features of the White Wine Quality dataset has any impact on\n",
    "its performance. You will use a k-NN classifier as part of a pipeline that includes scaling, and for the\n",
    "purposes of comparison, a k-NN classifier trained on the unscaled data has been provided.\n",
    "\n",
    "The feature array and target variable array have been pre-loaded as X and y. Additionally, KNeighborsClassifier\n",
    "and train_test_split have been imported from sklearn.neighbors and sklearn.model_selection, respectively.\n",
    "\"\"\"\n",
    "\n",
    "# Import the necessary modules\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [('scaler', StandardScaler()),\n",
    "        ('knn', KNeighborsClassifier())]\n",
    "        \n",
    "# Create the pipeline: pipeline\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Fit the pipeline to the training set: knn_scaled\n",
    "knn_scaled = pipeline.fit(X_train, y_train)\n",
    "\n",
    "# Instantiate and fit a k-NN classifier to the unscaled data\n",
    "knn_unscaled = KNeighborsClassifier().fit(X_train, y_train)\n",
    "\n",
    "# Compute and print metrics\n",
    "print('Accuracy with Scaling: {}'.format(knn_scaled.score(X_test, y_test)))\n",
    "print('Accuracy without Scaling: {}'.format(knn_unscaled.score(X_test, y_test)))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Bringing it all together I: Pipeline for classification\n",
    "It is time now to piece together everything you have learned so far into a pipeline for classification!\n",
    "Your job in this exercise is to build a pipeline that includes scaling and hyperparameter tuning to classify\n",
    "wine quality.\n",
    "\n",
    "You'll return to using the SVM classifier you were briefly introduced to earlier in this chapter. The\n",
    "hyperparameters you will tune are  and .  controls the regularization strength. It is analogous to the\n",
    "you tuned for logistic regression in Chapter 3, while  controls the kernel coefficient: Do not worry about\n",
    "this now as it is beyond the scope of this course.\n",
    "\n",
    "The following modules and functions have been pre-loaded: Pipeline, SVC, train_test_split, GridSearchCV,\n",
    "classification_report, accuracy_score. The feature and target variable arrays X and y have also been pre-loaded.\n",
    "\"\"\"\n",
    "\n",
    "# Setup the pipeline\n",
    "steps = [('scaler', StandardScaler()),\n",
    "         ('SVM', SVC())]\n",
    "\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Specify the hyperparameter space\n",
    "parameters = {'SVM__C':[1, 10, 100],\n",
    "              'SVM__gamma':[0.1, 0.01]}\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=21)\n",
    "\n",
    "# Instantiate the GridSearchCV object: cv\n",
    "cv = GridSearchCV(pipeline, parameters)\n",
    "\n",
    "# Fit to the training set\n",
    "cv.fit(X_train, y_train)\n",
    "\n",
    "# Predict the labels of the test set: y_pred\n",
    "y_pred = cv.predict(X_test)\n",
    "\n",
    "# Compute and print metrics\n",
    "print(\"Accuracy: {}\".format(cv.score(X_test, y_test)))\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(\"Tuned Model Parameters: {}\".format(cv.best_params_))\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Bringing it all together II: Pipeline for regression\n",
    "For this final exercise, you will return to the Gapminder dataset. Guess what? Even this\n",
    "dataset has missing values that we dealt with for you in earlier chapters! Now, you have all\n",
    "the tools to take care of them yourself!\n",
    "\n",
    "Your job is to build a pipeline that imputes the missing data, scales the features, and fits an\n",
    "ElasticNet to the Gapminder data. You will then tune the l1_ratio of your ElasticNet using GridSearchCV.\n",
    "\"\"\"\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [('imputation', Imputer(missing_values='NaN', strategy='mean', axis=0)),\n",
    "         ('scaler', StandardScaler()),\n",
    "         ('elasticnet', ElasticNet())]\n",
    "         \n",
    "# Create the pipeline: pipeline\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Specify the hyperparameter space\n",
    "parameters = {'elasticnet__l1_ratio':np.linspace(0,1,30)}\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)\n",
    "\n",
    "# Create the GridSearchCV object: gm_cv\n",
    "gm_cv = GridSearchCV(pipeline, parameters)\n",
    "\n",
    "# Fit to the training set\n",
    "gm_cv.fit(X_train, y_train)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2 = gm_cv.score(X_test, y_test)\n",
    "print(\"Tuned ElasticNet Alpha: {}\".format(gm_cv.best_params_))\n",
    "print(\"Tuned ElasticNet R squared: {}\".format(r2))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}