{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification\n",
    "\n",
    "Another general task in data analysis and machine learning is classification. \n",
    "\n",
    "Classification, in general, is the process of predicting the 'class' of datapoints, meaning to assign a label to the data point, or assign them to a grouping or cluster. \n",
    "\n",
    "Classification is a type of supervised learning, meaning we typically have some data for which we know the classes, and we want to learn a procedure that can use this information (the data with known labels), to learn a mapping from data to labels that we can apply to new data. \n",
    "\n",
    "Note that if we have data that we are trying to categorize, but don't already know any labels, we typically call this clustering. \n",
    "\n",
    "Classification can also be thought of as the categorical version of prediction. Prediction, as we've talked about it, is process of predicting a continuous output from a set of features. Classification is the same idea, except in case we are predicting a discrete category (or label). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Classification is process of categorizing data - of assigning data points to predefined groups (clusters) or labels. \n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "<a href=\"https://en.wikipedia.org/wiki/Statistical_classification\" class=\"alert-link\">Classification</a>\n",
    "article from wikipedia. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Support Vector Machines\n",
    "\n",
    "There are many algorithms for doing classification.\n",
    "\n",
    "For this example, we are going to use Support Vector Machines (SVMs) as an example algorithm. \n",
    "\n",
    "SVM is one of the most common algorithms for classification. SVMs are an algorithm that seeks to learn a boundary - or dividing line - between groups of data of interest. Once we learn this boundary, we can label datapoints based on where they sit relative to this boundary - basically which side of the line they are on. \n",
    "\n",
    "To separate the data, we want the dividing line, or 'decision boundary' that separates the data. There might be many different lines that do this. To try and find the best solution, SVMs try to learn the learn that has the greatest separation between the classes. To do so, SVMs use 'support vectors', which are datapoints nearby the boundary, that are used to calculate the line of greatest separation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Support Vector Machines are a supervised classification algorithm.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "This \n",
    "<a href=https://medium.com/machine-learning-101/chapter-2-svm-support-vector-machine-theory-f0812effc72 class=\"alert-link\">article</a>\n",
    "provides a nice overview of the SVM algorithm. This is also a code-based explainer from\n",
    "<a href=http://scikit-learn.org/stable/modules/svm.html class=\"alert-link\">scikit-learn</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Imports - from scikit-learn\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Generation\n",
    "\n",
    "In this example, we will generate some 2 dimensional data that comes from two different groups. \n",
    "\n",
    "This training data has labels, meaning for each data point we also know which group it comes from. \n",
    "\n",
    "We will then use a SVM classification model, to try and learn the decision boundary between the groups of data. If we are successful at learning a decision boundary, we can use this to predict the label of new datapoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting for generating some random data\n",
    "n_points = 50             # Total number of data points\n",
    "label_prop = 0.5          # Proportion of points in class 1\n",
    "\n",
    "# Initialize data matrix (as zeros)\n",
    "data = np.zeros(shape=[n_points, 2])\n",
    "\n",
    "# Set up the number of data points in each class\n",
    "n_data_1 = int(n_points * label_prop)\n",
    "n_data_2 = n_points - n_data_1\n",
    "\n",
    "# Generate the data\n",
    "data[0:n_data_1, 0] = np.abs(np.random.randn(n_data_1))\n",
    "data[0:n_data_1, 1] = np.abs(np.random.randn(n_data_1))\n",
    "data[n_data_2:, 0] = np.abs(np.random.randn(n_data_1)) + 2\n",
    "data[n_data_2:, 1] = np.abs(np.random.randn(n_data_1)) + 2\n",
    "\n",
    "# Create the labels vector\n",
    "labels = np.array([0] * n_data_1 + [1] * n_data_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Visualization\n",
    "\n",
    "Now that we have some data, let's start by plotting it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a1e0f2b90>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot out labelled data\n",
    "fig = plt.figure(figsize=[9, 7])\n",
    "plt.plot(data[0:n_data_1, 0], data[0:n_data_1, 1],\n",
    "         'b.', ms=12, label=\"Label=0\")\n",
    "plt.plot(data[n_data_2:, 0], data[n_data_2:, 1],\n",
    "         'g.', ms=12, label=\"Label=1\")\n",
    "plt.legend(fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see above, we have two fairly distinct groups of data. \n",
    "\n",
    "Now we want to learn a mathematical procedure that can learn the labels of these datapoints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-Learn Objects\n",
    "\n",
    "The SVM implementation we are using is from `sklearn`.\n",
    "\n",
    "Scikit-learn, as we have seen before, is object oriented. \n",
    "\n",
    "Here, we will again use the typical scikit-learn approach, which is to:\n",
    "\n",
    "- Initialize a sklearn object for the model we want to use, setting the desired parameters\n",
    "- Train the model on our labeled training data\n",
    "- Check performance of our model (in real applications, using a separate, labeled, test set)\n",
    "- Apply the model to make predictions about new datapoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize an SVM classifer object\n",
    "classifier = SVC(kernel='linear')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "    decision_function_shape='ovr', degree=3, gamma='auto_deprecated',\n",
       "    kernel='linear', max_iter=-1, probability=False, random_state=None,\n",
       "    shrinking=True, tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit our classification model to our training data\n",
    "classifier.fit(data, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate predictions of the model on the training data\n",
    "train_predictions = classifier.predict(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        25\n",
      "           1       1.00      1.00      1.00        25\n",
      "\n",
      "    accuracy                           1.00        50\n",
      "   macro avg       1.00      1.00      1.00        50\n",
      "weighted avg       1.00      1.00      1.00        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Print out the performance metrics on the \n",
    "print(classification_report(train_predictions, labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a trained classifier!\n",
    "\n",
    "We have trained our classifier on our data, and also checked it's performance. \n",
    "\n",
    "For this example, we have set up a simple example that is easy to predict, so our predictions are very accurate. \n",
    "\n",
    "Note that above all we doing is checking if our classifier can predict the labels of the training data - the data that is has already seen. This is _not_ a valid way to properly measure performance of machine learning algorithms. If you wish to continue to explore and use classification and other machine learning algorithms, you will need to look into how to properly test for accuracy, which is outside of the scope of these materials. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting New Data Points\n",
    "\n",
    "Now that we have a trained model, we can use it to predict labels for new data points, including for data points for which we do not know already know the correct label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a new data point, that we will predict a label for\n",
    "new_point = np.array([[3, 3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add our new point to figure, in red, and redraw the figure\n",
    "fig.gca().plot(new_point[0][0], new_point[0][1], '.r', ms=12);\n",
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted class of new data point is: 1\n"
     ]
    }
   ],
   "source": [
    "# Predict the class of the new data point\n",
    "prediction = classifier.predict(new_point)\n",
    "print('Predicted class of new data point is: {}'.format(prediction[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Support Vectors\n",
    "\n",
    "As we mentioned befor, SVMs use 'support vectors', which are the points closest to the decision boundary, to try and learn the decision boundary with the highest margin (or separation) between the classes. \n",
    "\n",
    "Now that we have a trained model, we can have a look at the support vectors, and the decision boundary learned from them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhEAAAGbCAYAAAB6XcIxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3df2xU15338c8Zw4InNXZdmy2C2sMfISU1ebKLtcmjANaGmDTtxoZIkYLcphJurY1NNmksrTYMKKTJJJV2C3RVO63XWI3KtNskG0wSJTSEbhxW2nTX3s2W8CQ4VmQ7P1DASjBeDLZhzvPHYIN/j69n5s7Mfb8ky9zD5c7XmdbnM+ece66x1goAAGCufG4XAAAA0hMhAgAAOEKIAAAAjhAiAACAI4QIAADgyIJEXLSgoMAGAoFEXBoAACRZR0dHn7W2cGJ7QkJEIBBQe3t7Ii4NAACSzBjTM1U70xkAAMARQgQAAHCEEAEAABwhRAAAAEcIEQAAwBFCBAAAcCQht3gCADLbuXPndPr0aY2MjLhdCuZh4cKFWrp0qZYsWeLo3xMiAABzcu7cOX322Wdavny5srOzZYxxuyQ4YK3VhQsX9Mknn0iSoyDBdAYAYE5Onz6t5cuXy+/3EyDSmDFGfr9fy5cv1+nTpx1dgxABAJiTkZERZWdnu10G4iQ7O9vxtBQhAgAwZ4xAZI75vJeECAAA4AghAgAAOEKIADBJ+HhYgX0B+R73KbAvoPDxsNslAXG3e/duFRQUzOsaxhj97Gc/m3ct3d3dMsbolVdemdd1hoaGVF9fr6VLl+q6667Tt7/9bXV3d8+7vukQIgCMEz4eVs3LNerp75GVVU9/j2periFIAGngb/7mb/TLX/5S//AP/6AXXnhBfX19Ki8v18WLFxPyeoQIAOMEjwY1ODI4rm1wZFDBo0GXKgIQi48//lj79+/X3r17df/99+uuu+7Siy++qJ6eHh04cCAhr0mIADBOb3/vnNqB+QiHpUBA8vmi38MpMuB1/vx5bd++XTfccIP8fr9Wrlypuro6nTt3btK5w8PDeuihh5Sfn6+8vDw9+OCDGh4eHndOb2+v7rvvPuXn58vv9+vOO+/UyZMn41rz66+/Lkm65557xtqWL1+udevW6bXXXovra40iRAAYpyi3aE7tgFPhsFRTI/X0SNZGv9fUpEaQGBwc1OXLlxUKhfTaa6/piSee0O9//3vde++9k879yU9+oo8//ljhcFg7d+5UU1OTgsGrI3eff/651q1bp5MnT+rnP/+5nnvuOZ0/f1533HGHLly4MG0NkUhEly5dmvHr8uXLY+e///77WrFihb70pS+Nu87q1av1/vvvx+G/ymRsew1gnNDGkGperhk3peFf6FdoY8jFqpCJgkFpcPzMmQYHo+1VVe7UNKqwsFDPPPPM2PGlS5e0cuVKrVu3Tr29vSoquhqqc3Jy9Pzzz8vn8+muu+7S0NCQQqGQHn30UeXn52vv3r06f/683nnnHeXn50uSbrvtNgUCAbW0tKiurm7KGrZt26Znn312xjrLysr05ptvSpK++OIL5eXlTTrny1/+sr744ou5/ieICSECwDhVa6K/vYNHg+rt71VRbpFCG0Nj7UC89E4zQzZde7L96le/0p49e/TBBx/o/PnzY+2dnZ3jQkRlZaV8vqsD+/fcc4927typd999Vxs2bNAbb7yh8vJyLVmyRJcuXZIUDR5r165Ve3v7tK+/e/dubd++fcYac3Jyxh1PtXGUtTZhm4MRIgBMUrWmitCAhCsqik5hTNXutoMHD+r+++/XAw88oKeeekr5+fk6deqUtmzZMulOh6VLl055fOrUKUlSX1+f3n77bf32t7+d9DobN26ctoaioiKtWLFixjqvDQdf/vKXdfbs2UnnnD17dsoRinggRAAAXBEKRddAXDul4fdH2932/PPP65ZbblFjY+NYW1tb25TnTnx41ejxsmXLJEn5+fmqqKjQrl27Jv3biSMJ15rrdMbXv/51ffTRRzp//ryuu+66sXPef/99ff3rX5/xOk4RIgCkhPDxMFMoHjO67iEYjE5hFBVFA4Tb6yEk6cKFC1q0aNG4tvA0Kz4PHTqkp59+emxK48UXX1R2drZKSkokRUcbnnvuOX3jG9+Y04PL5jqdsWnTJknRUZTvfOc7kqRPP/1Ux44dGxeG4okQAcB1oxtcjS7mHN3gShJBIsNVVbkbGoaHh/XCCy9Mar/55pu1e/duhUIh3XLLLXr11Vd19OjRKa8xMDCge++9Vz/4wQ904sQJ/ehHP9L27dvHFlE+8sgjOnDggG6//XY9+OCDWr58uT777DO1tbVp3bp12rp165TXDQQCCgQCMf8sK1asUHV1tR5++GFZa1VYWKjdu3eruLh4LFTEGyECgOtm2uCKEIFEGg0AE73xxhuqr6/XT3/6U128eFHl5eX69a9/rVtvvXXSufX19frwww+1detWRSIRff/739dTTz019vcFBQV6++23FQwG9cMf/lBnz57VsmXLtG7dOt10001x/Xn+8R//Udddd50eeeQRDQ4OqqysTL/5zW+0ePHiuL7OKGOtjftFS0tL7UwrTgHgWr7HfbKa/LvIyCjyWMSFijCT9957T6tXr3a7DMTRbO+pMabDWls6sZ3NpgC4jg2ugPREiADgutDGkPwL/ePa2OAKSH2ECACuq1pTpaa7m1ScWywjo+LcYjXd3cR6CCDFsbASQEpggysg/TASASBuwsfDCuwLyPe4T4F9AYWPp8CTlAAkDCMRAOKCvR4A72EkAkBczLTXA4DMRIgAEBe9/VM/enG6dgDpjxABIC7Y6wHwHkIEgLhgrwekm927d6ugoGBe1zDG6Gc/+9m8a+nu7pYxRq+88sq8rvPEE0/ojjvu0JIlS2SMUXd397xrmwkhAkBcsNcD4L5f/OIXunTpkv7yL/8yKa/H3RkA4oa9HgB39fb2yufz6ZVXXtFLL72U8NdjJAIA4JpU3Vvk/Pnz2r59u2644Qb5/X6tXLlSdXV1Onfu3KRzh4eH9dBDDyk/P195eXl68MEHNTw8PO6c3t5e3XfffcrPz5ff79edd96pkydPxr1uny+53TojEQAAV6Ty3iKDg4O6fPmyQqGQCgsL9dFHHykUCunee+/V7373u3Hn/uQnP9Gtt96qcDisEydOKBgMavHixfr7v/97SdLnn3+udevW6Stf+Yp+/vOfy+/368c//rHuuOMOdXZ2Kjs7e8oaIpGIIpGZn2JrjFFWVlZ8fmgHCBEAAFfMtLeI2yGisLBQzzzzzNjxpUuXtHLlSq1bt069vb0qKrp611FOTo6ef/55+Xw+3XXXXRoaGlIoFNKjjz6q/Px87d27V+fPn9c777yj/Px8SdJtt92mQCCglpYW1dXVTVnDtm3b9Oyzz85YZ1lZmd588835/8AOESIAAK5I9b1FfvWrX2nPnj364IMPdP78+bH2zs7OcSGisrJy3DTCPffco507d+rdd9/Vhg0b9MYbb6i8vFxLlizRpUuXJEWDx9q1a9Xe3j7t6+/evVvbt2+fscacnBynP15cECIAAK4oyi1ST3/PlO1uO3jwoO6//3498MADeuqpp5Sfn69Tp05py5Ytunjx4rhzly5dOuXxqVOnJEl9fX16++239dvf/nbS62zcuHHaGoqKirRixYoZ6zTGxPTzJAohAgDgitDG0Lg1EVLq7C3y/PPP65ZbblFjY+NYW1tb25Tnnj59esrjZcuWSZLy8/NVUVGhXbt2Tfq3M40kMJ0BAMA0Rtc9BI8G1dvfq6LcIoU2hlxfDyFJFy5c0KJFi8a1hcNT3zly6NAhPf3002NTGi+++KKys7NVUlIiKTra8Nxzz+kb3/jGtIsop8J0BgAAM3B7b5Hh4WG98MILk9pvvvlm7d69W6FQSLfccoteffVVHT16dMprDAwM6N5779UPfvADnThxQj/60Y+0ffv2sUWUjzzyiA4cOKDbb79dDz74oJYvX67PPvtMbW1tWrdunbZu3TrldQOBgAKBwJx+nra2Np05c0YdHR2SpNdee02FhYW68cYbdeONN87pWrEgRAAAPGs0AEz0xhtvqL6+Xj/96U918eJFlZeX69e//rVuvfXWSefW19frww8/1NatWxWJRPT9739fTz311NjfFxQU6O2331YwGNQPf/hDnT17VsuWLdO6det00003xfXneeyxx8ZNu9TW1o617969O66vJUnGWhv3i5aWltqZVpwCANLXe++9p9WrV7tdBuJotvfUGNNhrS2d2M6OlQAAwBFCBAAAcIQQAQAAHCFEAAAARwgRAIA5S8SifLhjPu9lzCHCGJNljPlvY8wrjl8NQEZJ1cc4I7EWLlyoCxcuuF0G4uTChQtauHCho387l5GIhyS95+hVAGSc0cc49/T3yMqOPcaZIJH5li5dqk8++USDg4OMSKQxa60GBwf1ySefTHr+R6xi2mzKGLNC0rclhSQ94uiVAGSUVH6MMxJryZIlkqRPP/1UIyMjLleD+Vi4cKH+9E//dOw9natYd6zcJ+lvJU27SbcxpkZSjaRxj0gFkJlS/THOSKwlS5Y47niQOWadzjDG/JWk09bajpnOs9Y2WWtLrbWlhYWFcSsQQGqa7nHNqfAYZwDJEcuaiNskVRhjuiX9s6TbjTEHEloVgJQX2hiSf6F/XFuqPMYZQHLMGiKstY9aa1dYawOS7pP0e2vtdxJeGYCUVrWmSk13N6k4t1hGRsW5xWq6u4n1EICH8BRPAI65/RhnAO6aU4iw1r4p6c2EVAIAANIKO1YCAABHCBEAAMARQgQAAHCEEAEAABwhRAAAAEcIEQAAwBFCBAAAcIQQAQAAHCFEAAAARwgRAADAEUIEAABwhBABAAAcIUQAAABHCBEAAMARQgQAAHCEEAEAABwhRAAAAEcIEQAAwBFCBAAAcIQQAQAAHCFEAAAARwgRAADAEUIEAABwhBABAAAcIUQAAABHCBEAAMARQgQAYFbh42EF9gXke9ynwL6AwsfDbpeEFECIAJBQdD7pL3w8rJqXa9TT3yMrq57+HtW8XMN7CUIEgMSh88kMwaNBDY4MjmsbHBlU8GjQpYqQKggRABKGzicz9Pb3zqkd3kGIAJAwdD6ZoSi3aE7t8A5CBICEofPJDKGNIfkX+se1+Rf6FdoYcqkipApCBICEofPJDFVrqtR0d5OKc4tlZFScW6ymu5tUtabK7dLgMmOtjftFS0tLbXt7e9yvCyD9hI+HFTwaVG9/r4pyixTaGKLzAdKMMabDWls6qZ0QAQAAZjJdiGA6AwAAOEKIAAAAjhAiAACAI4QIAADgCCECAAA4QogAAACOECIAAIAjhAgAAOAIIQIAADhCiAAAAI4QIgAAgCOECAAA4AghAgAAOEKIAAAAjhAiAACAI4QIAJOEj4cV2BeQ73GfAvsCCh8Pu10SgBS0wO0CAKSW8PGwal6u0eDIoCSpp79HNS/XSJKq1lS5WRqAFMNIBIBxgkeDYwFi1ODIoIJHgy5VBCBVESIAjNPb3zundgDeRYgAME5RbtGc2gF4FyECwDihjSH5F/rHtfkX+hXaGHKpIgCpihABYJyqNVVqurtJxbnFMjIqzi1W091NLKoEMImx1sb9oqWlpba9vT3u1wUAAMlnjOmw1pZObGckAgAAOEKIAAAAjhAiAACAI4QIAADgCCECAAA4QogAAACOECIAAIAjhAgAAOAIIQIAADhCiAAAAI7MGiKMMYuNMf9hjPkfY8wJY8zjySgMAFJKba20YIFkTPR7ba3bFQGuWxDDOUOSbrfW/q8xZqGkfzPGvGatfTvBtQFAaqitlZ555urx5ctXjxsb3akJSAGzjkTYqP+9crjwylf8n9oFAKmqqWlu7YBHxLQmwhiTZYx5R9JpSUestX+Y4pwaY0y7Mab9zJkz8a4TANxz+fLc2gGPiClEWGsvW2tvlrRC0l8YY0qmOKfJWltqrS0tLCyMd50A4J6srLm1Ax4xp7szrLVnJb0p6ZsJqQYAUlFNzdzaAY+I5e6MQmNM3pU/Z0u6Q9L7iS4MAFJGY6P0wANXRx6ysqLHLKqEx8Vyd8YySc8aY7IUDR3PWWtfSWxZAJBiGhsJDcAEs4YIa+0fJf1ZEmoBAABphB0rAQCAI4QIAADgCCECAAA4QogAAACOECIAKHw8rMC+gHyP+xTYF1D4eNjtkgCkAUIE4HHh42HVvFyjnv4eWVn19Peo5uUagkSSEeSQjggRgMcFjwY1ODI4rm1wZFDBo0GXKvIeghzSFSEC8Lje/t45tSP+nAY5Ri/gNkIE4HFFuUVzakf8OQlyjF4gFRAigDQSiUR0+PBhVVRUKC8vT1lZWcrLy1NFRYUOHz6sSCQy52uGNobkX+gf1+Zf6FdoYyheZWMWToIc01BIBYQIIE10dnaqpKREO3bsUGVlpbq6ujQ0NKSuri5VVlZqx44dKikpUWdn55yuW7WmSk13N6k4t1hGRsW5xWq6u0lVa6oS9JNklnhMKTgJckxDIRUYa23cL1paWmrb29vjfl3Aqzo7O1VWVqYnn3xS27ZtkzFm0jnWWrW0tGjnzp1qa2vTqlWrXKjUW0anFK4dEfAv9DsKYeHjYQWPBtXb36ui3CKFNoZmvEZgX0A9/T2T2otzi9X9cPecXhvpba7/23HCGNNhrS2d1E6IAFJbJBJRSUmJ6uvrVV1dPev5zc3N2rt3r44fPy6fj8HGRHKzI3cSYJLR2SC54hlkZzJdiOA3DJDiXn/9dWVnZ2vbtm1jbTMNoVdXV2vRokU6cuSIG+V6iptTCnOdhmIhZmZye20MIxFAiquoqFBlZeXYKEQsnzyam5v10ksv6aWXXnKlZq9IpymFdKoVsfM97pPV5H7cyCjy2NwXWk+HkQggTb311luqrKwcO47lk8fmzZt17NixpNXoVel0ZwsLMTOT27doEyKAFDcwMKC8vLyx41g6g9zcXA0MDCS8Nq+7dkpBkrJM1ligS7VpArc7GySG20GWEAGkuJycHJ09e3bsOJbOoL+/Xzk5OXN6HXY/dKZqTdXYL/LL9rIkpeR6A7c7GySG27doEyKAFLdhwwYdOnRo7DiWzqC1tVXr16+P+TVYdDc/bi9ui4XbnQ0Sp2pNlbof7lbksYi6H+5O6nvKwkogxR0+fFg7duxQR0fH2P4QM92qZ63Vn//5n+vHP/6x7rzzzpheg0V385OsxW2AW1hYCaSpTZs26eLFi2ppaRlrm+mTx/79+zU8PKzy8vKYX4NFd/PDegN4FSECSHE+n0+tra3auXOnmpubNd3oobVWzc3N2rVrlw4ePDinjaboBOeH9QbwKkIEkAZWrVqltrY27dmzR2vXrlVzc7P6+vo0MjKivr4+NTc3a+3atdq7d6+jLa/pBOeH9QbwKtZEAGkkEonoyJEjamho0LFjxzQwMKCcnBytX79edXV1Ki8vd7zVNVsiA5gOz84AAACOsLASAOaAfTOA2S1wuwAASDUTn08yum+GJKZ4gGswEgEAE6TD5lFAKiBEAMAE7JsBxIYQAQATsG8GEBtCBABMwL4ZQGwIEQAwAZtHAbFhnwgAADAj9okAAABxRYgAAACOECIAAIAjhAgAAOAIIQIAADhCiAAAAI4QIgAggXgaKDIZT/EEgAThaaDIdIxEAB7FJ+TE42mgyHSMRAAexCfk5OBpoMh0jEQAHsQn5OTgaaDIdIQIwIP4hJwcPA0UmY4QAXgQn5CTg6eBItOxJgLwoNDG0Lg1ERKfkBOlak0VoQEZi5EIwIP4hAwgHoy1Nu4XLS0tte3t7XG/LgAASD5jTIe1tnRiOyMRAADAEUIEALiEDb+Q7lhYCQAuYMMvZAJGIgDABW5u+MUICOKFkQgAcIFbG34xAoJ4YiQCAFzg1oZfbHmOeCJEAPCMVBrGd2tLbLY8RzwRIgB4wugwfk9/j6zs2DC+W0HCrQ2/2PIc8cRmUwA8IbAvoJ7+nkntxbnF6n64O/kFuWTimggpOgLCjqWYCZtNAfA0hvGj2PIc8cTdGQA8oSi3aMqRCC8O4/NQMMQLIxEAPGG6hYzfuv5bKbPYEkg3jEQA8ITRT97Bo0H19veqKLdI37r+W3r2f55lzwTAIUYigAwWiUR0+PBhVVRUKC8vT1lZWcrLy1NFRYUOHz6sSCTidolJVbWmSt0PdyvyWETdD3fr1Q9eZc8EYB4IEXCMDiq1dXZ2qqSkRDt27FBlZaW6uro0NDSkrq4uVVZWaseOHSopKVFnZ6fbpbqGxZbA/KRFiAiHpUBA8vmi38NMWbqODiq1dXZ2qqysTPX19ero6FB1dbUKCgq0YMECFRQUqLq6Wh0dHaqvr1dZWZln3yf2TADmyVob96+1a9faeDlwwFq/31rp6pffH22HO06ePGm/+tWv2ubmZhuJRKY8JxKJ2ObmZvvVr37Vnjx5MskVetvly5ft6tWrbXNzc0zn/9M//ZO98cYb7eXLlxNc2dQO/PGALd5bbM1uY4v3FtsDf0ze/7kP/PGA9Yf8Vrs19uUP+ZNaA5AOJLXbKfr7lB+JCAalwfFTlhocjLYj+SKRiDZv3qwnn3xS1dXVMsZMeZ4xRtXV1XriiSe0ZcsWpjaS6PXXX1d2dra2bds21jbTds/V1dVatGiRjhw5kvRa3d5Fkj0TgPmZNUQYY75mjPlXY8x7xpgTxpiHklHYqN5ppiana0diTdlBzTDd5GYH5VWNjY2qra0dC3izddTGGNXW1qqhoSHptabCw6AmLrYkQACxi2Uk4pKkemvtakm3SqozxtyY2LKuKppmanK6diTWpA4qLNXUSD090cmmnp7o8WiQcLOD8qq33npLlZWVY8exdNSbN2/WsWPHklbjKBY2Ault1hBhrT1lrf2vK38ekPSepOWJLmxUKCT5x+8PI78/2o7km9RBxTDd5FYH5VUDAwPKy8sbO46lo87NzdXAwEDCa5uIhY1AepvTmghjTEDSn0n6QyKKmUpVldTUJBUXS8ZEvzc1RduRfJM6qBimm9zqoLwqJydHZ8+eHTuOpaPu7+9XTk5OwmubyK3HYQOIj5hDhDHmS5L+RdLD1tpzU/x9jTGm3RjTfubMmXjWqKoqqbtbikSi3wkQ7pnUQcUw3eRWB+VVGzZs0KFDh8aOY+moW1tbtX79+qTVOIqFjUB6iylEGGMWKhogwtbaF6c6x1rbZK0ttdaWFhYWxrNGpJBJHVQM001udVBeNboGJXpX1uwdtbVWDQ0Nqqurc6VeFjYC6SuWuzOMpP2S3rPW7kl8SUhlkzqoWaab3O6gvGjTpk26ePGiWlpaxtpm6qj379+v4eFhlZeXu1EugDQWy0jEbZK+K+l2Y8w7V76+leC6kKKm7KBmmG6ig0o+n8+n1tZW7dy5U83NzWOBbyJrrZqbm7Vr1y4dPHhQPl/KbxsDIMXEcnfGv1lrjbX2JmvtzVe+Xk1GcV6RTtt600Glh1WrVqmtrU179uzR2rVr1dzcrL6+Po2MjKivr0/Nzc1au3at9u7dq7a2Nq1atcrtkgGkITNdJzAfpaWltr29Pe7XzUSj+yxce5uk35/6d6B0dnZq8+bNWrx4sWpra7V582bl5uaqv79fra2tamxs1NDQkA4ePEgH5aJIJKIjR46ooaFBx44d08DAgHJycrR+/XrV1dWpvLycgAdgVsaYDmtt6aR2QoS7AoHoBk0TFRdHpwZSGR0UAHgDISJF+XzRnR4nMia6xgAAALdNFyL4mOgytvUGAKQrQoTL2NYbAJCuCBEuY1tvAEC6WuB2AYgGBkIDACDdMBIBAAAcIUQAAABHCBEAAMARQgQAAHCEEAEAABwhRAAAAEcIEQAAwBFCBAAAcIQQAQAAHCFEICaRSESHDx9WRUWF8vLylJWVpby8PFVUVOjw4cOK8MhRAPAcQgRm1dnZqZKSEu3YsUOVlZXq6urS0NCQurq6VFlZqR07dqikpESdnZ1ulwoASCJCBGbU2dmpsrIy1dfXq6OjQ9XV1SooKNCCBQtUUFCg6upqdXR0qL6+XmVlZQQJAPAQHsCFaUUiEW3evFlPPvmkqqurpz3PGKPq6mpZa7VlyxYdP35cPh/5FAAyHb/pMa3XX39d2dnZ2rZt21hbOCwFApLPF/0eDl89v7q6WosWLdKRI0eSXisAIPkIEZhWY2OjamtrZYyRFA0MNTVST49kbfR7Tc3VIGGMUW1trRoaGlysGgCQLMZaG/eLlpaW2vb29rhfF8mVl5enrq4uFRQUSIqOPPT0TD6vuFjq7o7+ua+vT9dff72++OKLpNUJAEgsY0yHtbZ0YjsjER4x0zTEdAYGBpSXlzd23Ns79XnXtufm5mpgYGBetQIA0gMhwgNmm4aYTk5Ojs6ePTt2XFQ09XnXtvf39ysnJycOVQMAUh0hwgOCQWlwcHzb4GC0fSYbNmzQoUOHxo5DIcnvH3+O3x9tH9Xa2qr169fPs2IAQDogRHhALNMQUxldJDm6bqaqSmpqiq6BMCb6vakp2i5J1lo1NDSorq4ujtUDAFIVIcIDYpmGmMqmTZt08eJFtbS0jLVVVUUXUUYi0e+jAUKS9u/fr+HhYZWXl8+7ZgBA6mOzKQ8IhaJrIK6d0pg4DTEVn8+n1tZWlZWVyVqr6urqsds9r2Wt1f79+7Vr1y61tbWx0RQAeAS/7T1gtmmImaxatUptbW3as2eP1q5dq+bmZvX19WlkZER9fX1qbm7W2rVrtXfvXrW1tWnVqlWJ/4EAACmBfSIQk0gkoiNHjqihoUHHjh3TwMCAcnJytH79etXV1am8vJwRCADIUNPtE0GIAAAAM2KzKQAAEFeECAAA4AghAgAAOEKIAAAAjhAiAACAI4QIAADgCCECAAA4QogAAACOECImCIelQEDy+aLfw2G3KwIAIDXxAK5rhMPjH1TV0xM9lmJ7zgQAAF7CSMQ1gsHxT7qUosfBoDv1AACQyggR1+jtnVs7AABeRoi4RlHR3NoBAPAyQsQ1QiHJ7x/f5vdH2wEAwHiEiGtUVUlNTVJxsWRM9HtTE4sqAQCYCndnTFBVRWgAACAWjEQAAABHCBEAAMARQgQAAHCEEGZv9oIAAAsoSURBVAEAABwhRAAAAEcIEQAAwBFCBAAAcIQQAQAAHCFEAAAARwgRAADAEUIEAABwhBABAAAcIUQAAABHCBEAAMARQgQAAHCEEAEAABwhRAAAAEcIEQAAwBFCBAAAcIQQAQAAHJk1RBhjWowxp40x7yajIAAAkB5iGYn4paRvJrgOAACQZmYNEdbatyR9noRaAABAGonbmghjTI0xpt0Y037mzJl4XRYAAKSouIUIa22TtbbUWltaWFgYr8sCAIAUxd0ZmLdwWAoEJJ8v+j0cdrsiAEAyLHC7AKS3cFiqqZEGB6PHPT3RY0mqqnKvLgBA4sVyi+dvJP27pBuMMR8bY6oTXxbSRTB4NUCMGhyMtgMAMtusIxHW2q3JKATpqbd3bu0AgMzBmgjMS1HR3NoBAJmDEIF5CYUkv398m98fbQcAZDZCBOalqkpqapKKiyVjot+bmlhUCQBewN0ZmLeqKkIDAHiRJ0Yi2McAAID4y/iRCPYxAAAgMTJ+JIJ9DAAASIyMDxHsYwAAQGJkfIhgHwMAABIj40NEvPcxYJEmAABRGR8i4rmPwegizZ4eydqrizQJEgAALzLW2rhftLS01La3t8f9um4LBKLBYaLiYqm7O9nVAACQHMaYDmtt6cT2jB+JiCcWaQIAcBUhYg5YpAkAwFWEiDngYVMAAFxFiJgDHjYFAMBVGb/tdbzxsCkAAKIYiQAAAI6kfYhg8ycAANyR1tMZPKETAAD3pPVIBE/oBADAPWkdItj8CQAA96R1iGDzJwAA3JPWIYLNnwAAcE9ahwg2fwIAwD1pfXeGxOZPAAC4Ja1HImLFXhIAAMRf2o9EzIa9JAAASIyMH4lgL4n4Y2QHACB5IERMt2dETw+dnxOjIzs9PZK1V0d2+G8JAN6T8SFipj0j6PzmjpEdAMCojA8RU+0lMYrOb+7YJRQAMCrjQ8ToXhLTofObG3YJBQCMyvgQIUWDRHHx1H9H5zc37BIKABjliRAh0fnFC7uEAgBGZfw+EaNGO7lgMDqFUVQUDRB0fnPHLqEAAMlDIUKi8wMAIJ48M52B2LGZFAAgFp4aicDs2CYcABArRiIwDptJAQBiRYhIknSZImAzKQBArAgRMZhvAEin502wmRQAIFaEiFnEIwCk0xQB+2kAAGJFiJhFPAJAOk0RsJkUACBW3J0xi3gEgKKi6AjGVO2piP00AACxYCRiFvFYI8AUAQAgE3kuRMx1kWQ8AgBTBACATOSpEDHdIsna2umDRbwCQFWV1N0tRSLR7wQIAEC6M9bauF+0tLTUtre3x/268xUITL02wZhoqBjl9zNSAADAKGNMh7W2dGK7p0YiplsMOTFHpertlwAApBJPhYi5LIZMxdsvAQBIJZ4KEVMtkjRm6nNT9fZLAABShadCxFSLJP/6r7n9EgAAJzwVIqTJd0k0NnL7JQAATrBjpdihEQAAJzw3EoG5SZdHmAMAko8QkUaS3aGn0yPMAQDJR4hIE2506On0CHMAQPKlZYjw4hC7Gx16Oj3CHACQfGkXIrw6xO5Ghx6PJ5gCADJX2oUIrw6xu9Gh8whzAMBM0i5EeHWI3Y0O3SuPMPfi9BgAxEPa7RNRVDT1kzgzfYh9tOMOBqOBqagoGiAS3aFn+h4ao9Njo6Nbo9NjUmb/3AAQD2k3EuHlIfaJu23O1Mkl6tN1pn1qHz89FpF0WIODFfrud/OUlZWlvLw8VVRU6PDhw4pEIi5WCgCpJ+1ChFeG2OcjUYtPM3FR69VpsE5JJZJ2SKqUtV0aGhpSV1eXKisrtWPHDpWUlKizs9O1WgEg1RhrbdwvWlpaatvb2+N+XcQmEJh6yqe4ODqCkWrXdVP0Z+qUVCbpSUnbJJlJP5O1Vi0tLdq5c6fa2tq0atUqN8oFAFcYYzqstaUT29NuTQRml6jFp5m4qPWJJyL63vc2y9onJVVLmnp6zBij6upqWWu1ZcsWHT9+XD5f2g3kAUBc8VswAyXqdtBM3DeisPB1FRdnq6ho29j02Pe+F10rMdW6j+rqai1atEhHjhxxrWYASBUxhQhjzDeNMSeNMV3GmL9LdFGYn0QtPs3ERa2NjY3aubNWPT1GkUj0Z3n22enXfRhjVFtbq4aGBncLB4AUMOuaCGNMlqKrzsolfSzpPyVttdb+v+n+DWsi3BcOJ+Z20ERd1y15eXnq6upSQUGBpNjWffT19en666/XF198kbQ6AcBN062JiCVE/F9Ju621d145flSSrLVPT/dvCBFIF1lZWRoaGtKCBdHlQT5fdARiImOit9ZK0sjIiLKzs3Xp0qUkVgoA7pkuRMQynbFc0kfXHH98pW3iC9QYY9qNMe1nzpxxXimQRDk5OTp79uzYcSzrPvr7+5WTk5PgygAg9cUSIswUbZM+q1lrm6y1pdba0sLCwvlXBiTBhg0bdOjQobHjWNZ9tLa2av369UmqEABSVywh4mNJX7vmeIWkTxNTDpBco4skR6f1ZtvMzFqrhoYG1dXVuVg1AKSGWELEf0q63hiz0hjzJ5Luk/RSYssCkmPTpk26ePGiWlpaxtpm2l58//79Gh4eVnl5edJrBYBUM+tmU9baS8aY7ZJ+JylLUou19kTCKwOSwOfzqbW1VWVlZbLWqrq6WsZMnsGz1mr//v3atWuX2tra2GgKAMS214AkqbOzU5s3b9bixYtVW1urzZs3Kzc3V/39/WptbVVjY6OGhoZ08OBBtrwG4DmOb/F0ghCBdBSJRHTkyBE1NDTo2LFjGhgYUE5OjtavX6+6ujqVl5czAgHAkwgRAADAkfnsEwEAADAJIQIAADhCiAAAAI4QIgAAgCOECAAA4AghAgAAOEKIAAAAjhAiAACAIwnZbMoYc0ZSTxwvWSCpL47Xw9zxHriP9yA18D64j/cg+YqttYUTGxMSIuLNGNM+1U5ZSB7eA/fxHqQG3gf38R6kDqYzAACAI4QIAADgSLqEiCa3CwDvQQrgPUgNvA/u4z1IEWmxJgIAAKSedBmJAAAAKYYQAQAAHEn5EGGM+aYx5qQxpssY83du1+M1xpgWY8xpY8y7btfiVcaYrxlj/tUY854x5oQx5iG3a/IaY8xiY8x/GGP+58p78LjbNXmVMSbLGPPfxphX3K4FKR4ijDFZkhok3SXpRklbjTE3uluV5/xS0jfdLsLjLkmqt9aulnSrpDr+f5B0Q5Jut9b+H0k3S/qmMeZWl2vyqockved2EYhK6RAh6S8kdVlrP7TWDkv6Z0mVLtfkKdbatyR97nYdXmatPWWt/a8rfx5Q9Bfocner8hYb9b9XDhde+WJVepIZY1ZI+rakZrdrQVSqh4jlkj665vhj8csTHmaMCUj6M0l/cLcS77kyjP6OpNOSjlhreQ+Sb5+kv5UUcbsQRKV6iDBTtJH+4UnGmC9J+hdJD1trz7ldj9dYay9ba2+WtELSXxhjStyuyUuMMX8l6bS1tsPtWnBVqoeIjyV97ZrjFZI+dakWwDXGmIWKBoiwtfZFt+vxMmvtWUlvirVCyXabpApjTLeiU9u3G2MOuFsSUj1E/Kek640xK40xfyLpPkkvuVwTkFTGGCNpv6T3rLV73K7Hi4wxhcaYvCt/zpZ0h6T33a3KW6y1j1prV1hrA4r2Bb+31n7H5bI8L6VDhLX2kqTtkn6n6GKy56y1J9ytyluMMb+R9O+SbjDGfGyMqXa7Jg+6TdJ3Ff3k9c6Vr2+5XZTHLJP0r8aYPyr64eaItZZbDOF5bHsNAAAcSemRCAAAkLoIEQAAwBFCBAAAcIQQAQAAHCFEAAAARwgRAADAEUIEAABw5P8DxnAxAp+bTW4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the support vectors to plot, and redraw the figure\n",
    "#  Support vectors will be indicated by being highlighted with black circles\n",
    "for row in classifier.support_vectors_:\n",
    "    fig.gca().plot(row[0], row[1], 'ok', ms=14,  mfc='none')\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the support vectors, which are identified with some meta-data that is stored in the model object, are some datapoints at the end of the classes - those closest to the boundary. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing the decision boundary\n",
    "\n",
    "We can also draw the decision boundary - the boundary at which our model thinks the labels switch between groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "This following code to find and visualize the decision boundary and margins is adapted from this \n",
    "<a href=\"http://scikit-learn.org/stable/auto_examples/svm/plot_separating_hyperplane.html#sphx-glr-auto-examples-svm-plot-separating-hyperplane-py\" class=\"alert-link\">sklearn example</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab the current plot, and find axis sizes\n",
    "ax = fig.gca()\n",
    "xlim = ax.get_xlim()\n",
    "ylim = ax.get_ylim()\n",
    "\n",
    "# Create a grid of data to evaluate model\n",
    "xx = np.linspace(xlim[0], xlim[1], 30)\n",
    "yy = np.linspace(ylim[0], ylim[1], 30)\n",
    "YY, XX = np.meshgrid(yy, xx)\n",
    "xy = np.vstack([XX.ravel(), YY.ravel()]).T\n",
    "Z = classifier.decision_function(xy).reshape(XX.shape)\n",
    "\n",
    "# Plot the decision boundary and margins\n",
    "ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,\n",
    "           linestyles=['--', '-', '--']);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Redraw figure\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above plot, the solid line is the decision boundary that the model has learned. \n",
    "\n",
    "The dashed lines are the margins - the separation between the classes that the algorithm is trying to maximize. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVMs in more dimensions\n",
    "\n",
    "Note that, for simplicity, in this example we have used SVMs to learn a decision boundary in two dimensional data. \n",
    "\n",
    "In this case, with 2D data, the decision boundary is a line. \n",
    "\n",
    "SVMs also generalize to higher dimensions, and can be applied to data of any dimensionality. In higher dimensional data, the algorithm works the same, and the solution learned is a hyperplane that attempts the separate the data into categories in whatever dimensionality if lives. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusions\n",
    "\n",
    "The example above is a simplified example of an SVM application. With the code above, your are also encouraged to explore SVMs - investigate what happens as you change the data, change some settings, and predict different data points. \n",
    "\n",
    "This example is meant as a brief example for using classification models with scikit-learn. Much more information can be found in the `scikit-learn` documentation. \n",
    "\n",
    "Classification is a vast area of machine learning, with many tools, algorithms, and approaches that can be applied to data within the realm of data science. This example seeks merely to introduce the basic idea. If you are interested in classification algorithms, then you are recommended to look into resources and classes that focus on machine learning. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}