1_Introduction_to_Anomaly_Detection.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.6.1"
    },
    "colab": {
      "name": "1 Introduction to Anomaly Detection.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbJreuAjK8oN"
      },
      "source": [
        "## Introduction to Anamoly Detection\n",
        "\n",
        "\"Anomaly detection, also called outlier detection, is the identification of unexpected events, observations, or items that differ significantly from the norm.\"  OR\n",
        "\n",
        "Anomaly detection is any process that finds the outliers of a dataset; those items that don’t belong. These anomalies might point to unusual network traffic, uncover a sensor on the fritz, or simply identify data for cleaning, before analysis.\n",
        "\n",
        "\n",
        "Let's first create a dummy dataset for ourselves. The dataset will contain just two columns:\n",
        "\n",
        "* Name of the employees of an organization\n",
        "* Salaries of those employees (in USD) within a range of 1000 to 2500 (Monthly)\n",
        "\n",
        "For generating the names (and make them look like the real ones) we will use a Python library called Faker (read the documentation here). For generating salaries, we will use the good old numpy. After generating these, we will merge them in a pandas DataFrame. We are going to generate records for 100 employees. Let's begin."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C9WqRr2aK8od",
        "outputId": "5488846e-54ea-4fa1-8dcd-8e77493fa16a"
      },
      "source": [
        "!pip install Faker"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: Faker in /usr/local/lib/python3.6/dist-packages (5.0.1)\n",
            "Requirement already satisfied: text-unidecode==1.3 in /usr/local/lib/python3.6/dist-packages (from Faker) (1.3)\n",
            "Requirement already satisfied: python-dateutil>=2.4 in /usr/local/lib/python3.6/dist-packages (from Faker) (2.8.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.4->Faker) (1.15.0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "id": "q3foi6URK8og",
        "outputId": "c30760a7-7960-4606-cbcd-ef648df2e0a6"
      },
      "source": [
        "# Import the necessary package\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from faker import Faker\n",
        "\n",
        "%matplotlib inline\n",
        "plt.style.use('ggplot')\n",
        "\n",
        "faker = Faker()\n",
        "\n",
        "# to ensure the result are reproducible\n",
        "Faker.seed(123)\n",
        "\n",
        "names_list = []\n",
        "\n",
        "# Generate the name of 100 Employee\n",
        "\n",
        "for _ in range(100):\n",
        "    names_list.append(faker.name())\n",
        "    \n",
        "salaries = []\n",
        "# to ensure the result are reproducible\n",
        "np.random.seed(321)\n",
        "#Generate the salray of employee between 1000 to 2500 USD\n",
        "\n",
        "for _ in range(100):\n",
        "    salary = np.random.randint(1000, 2500)\n",
        "    salaries.append(salary)\n",
        "\n",
        "# Create Pandas DataFrame\n",
        "\n",
        "salary_df = pd.DataFrame({\n",
        "    'Person': names_list,\n",
        "    'Salary (in USD)': salaries\n",
        "})\n",
        "    \n",
        "# Print subsection of dataframe (first 10)\n",
        "\n",
        "salary_df.head(10)\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Person</th>\n",
              "      <th>Salary (in USD)</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Brandon Russell</td>\n",
              "      <td>2012</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Steven Johnson</td>\n",
              "      <td>1538</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Evelyn Christian</td>\n",
              "      <td>1124</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>George Cook</td>\n",
              "      <td>1799</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Aaron Graham</td>\n",
              "      <td>2425</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>Kyle Jones</td>\n",
              "      <td>1168</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>Jerome Whitehead</td>\n",
              "      <td>2434</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>Charles Tyler</td>\n",
              "      <td>1984</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>Thomas Berry</td>\n",
              "      <td>1357</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>Ryan Mack</td>\n",
              "      <td>1328</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "             Person  Salary (in USD)\n",
              "0   Brandon Russell             2012\n",
              "1    Steven Johnson             1538\n",
              "2  Evelyn Christian             1124\n",
              "3       George Cook             1799\n",
              "4      Aaron Graham             2425\n",
              "5        Kyle Jones             1168\n",
              "6  Jerome Whitehead             2434\n",
              "7     Charles Tyler             1984\n",
              "8      Thomas Berry             1357\n",
              "9         Ryan Mack             1328"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGM_8U_XK8oh"
      },
      "source": [
        "Let's now manually change the salary entries of two individuals. In reality, this can actually happen for a number of reasons such as the data recording, technical issue, or corrupted files etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y7A16gyMK8oi",
        "outputId": "a71193f5-d99c-4fe3-d40c-6833733c5a18"
      },
      "source": [
        "salary_df.at[16,'Salary (in USD)'] = 30\n",
        "salary_df.at[70,'Salary (in USD)'] = 23\n",
        "\n",
        "# Verify if the salries were changed\n",
        "\n",
        "print(salary_df.iloc[16])\n",
        "print(salary_df.iloc[70])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Person             Catherine Wilkins\n",
            "Salary (in USD)                   30\n",
            "Name: 16, dtype: object\n",
            "Person             James Rodriguez\n",
            "Salary (in USD)                 23\n",
            "Name: 70, dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OIRdMCw1K8oj"
      },
      "source": [
        "We now have a dataset to proceed with. We will start off our experiments just by looking at the dataset from a visual perspective and see if we can find the anomalies."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JRcuS1dXK8ok"
      },
      "source": [
        "## Seeing is believing: Detecting anomalies just by seeing\n",
        "\n",
        "Hint: Boxplots are great!\n",
        "\n",
        "Because we can find minimum, maximum, first quartile, 2nd,3rd quartile and median at one place"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "gHkVudoUK8ol",
        "outputId": "b3ea8ce5-de66-48b7-96ca-147dba54588d"
      },
      "source": [
        "# Generate a boxplot\n",
        "\n",
        "salary_df['Salary (in USD)'].plot(kind = 'box')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yQ30Bkt5K8om"
      },
      "source": [
        "Notice the tiny circle point in the bottom. You instantly get a feeling of something wrong in there as it deviates hugely from the rest of the data. Now, you decide to look at the data from another visual perspective i.e. in terms of histograms.\n",
        "\n",
        "How about histograms?\n",
        "\n",
        "Lets Generate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "XM0kLBzhK8on",
        "outputId": "f973d7b6-d4b4-49c3-ecb0-58b0a18d48e5"
      },
      "source": [
        "# Generate Histogram\n",
        "\n",
        "salary_df['Salary (in USD)'].plot(kind = 'hist')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHiJig7KK8on"
      },
      "source": [
        "In the above histogram plot also, we can see there's one particular bin that is just not right as it deviates hugely from the rest of the data \n",
        "\n",
        "\n",
        "So what might be an immediate way to confirm that the dataset contains anomalies? Let's take a look at the minimum and maximum values of the column Salary (in USD)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TymjCde4K8oo",
        "outputId": "b4ed48da-f723-4e1b-86d8-6913228d2cf4"
      },
      "source": [
        "# Minimum and Maximum salaries \n",
        "\n",
        "print('Minimum Salary: ', salary_df['Salary (in USD)'].min())\n",
        "print('Maximum Salary:', salary_df['Salary (in USD)'].max())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Minimum Salary:  23\n",
            "Maximum Salary: 2496\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkKWEqp5K8op"
      },
      "source": [
        "Look at the minimum value. From the accounts department of this hypothetical organization, you got to know that the minimum salary of an employee there is $1000. But you found out something different. Hence, its worth enough to conclude that this is indeed an anomaly. Let's now try to look at the data from a different perspective other than just simply plotting it.\n",
        "\n",
        "Note: Although our dataset contains only one feature (i.e. Salary (in USD)) that contains anomalies in reality, there can be a lot of features which will have anomalies in them. Even there also, these little visualizations will help you a lot.\n",
        "\n",
        "## Clustering based approach for anomaly detection\n",
        "\n",
        "We have seen how clustering and anomaly detection are closely related but they serve different purposes. But clustering can be used for anomaly detection. In this approach, we start by grouping the similar kind of objects. Mathematically, this similarity is measured by distance measurement functions like Euclidean distance, Manhattan distance and so on. Euclidean distance is a very popular choice when choosing in between several distance measurement functions. Let's take a look at what Euclidean distance is all about.\n",
        "\n",
        "An extremely short note on Euclidean distance\n",
        "\n",
        "If there are n points on a two-dimensional space and their coordinates are denoted by(x_i, y_i), then the Euclidean distance between any two points((x1, y1) and(x2, y2)) on this space is given by:\n",
        "\n",
        "square root[(x1-x2)^2 + (y1-y2)^2]\n",
        "\n",
        "\n",
        "## K-Means clustering\n",
        "\n",
        "We are going to use K-Means clustering which will help us cluster the data points (salary values in our case). The implementation that we are going to be using for KMeans uses Euclidean distance internally. Let's get started."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4cXiK8AHK8oq"
      },
      "source": [
        "# Convert the salary value to a numpy array\n",
        "\n",
        "salary_raw = salary_df['Salary (in USD)'].values\n",
        "\n",
        "# For compatibitlity with scipy implementation\n",
        "salary_raw = salary_raw.reshape(-1, 1)\n",
        "salary_raw = salary_raw.astype('float64')\n",
        "\n",
        "# import kmeans from scipy\n",
        "from scipy.cluster.vq import kmeans\n",
        "\n",
        "# Specify the data and the number of cluster to kmeans\n",
        "\n",
        "centroid, avg_distance = kmeans(salary_raw, 4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YEjlb1b9K8or"
      },
      "source": [
        "In the above chunk of code, we fed the salary data points the kmeans(). We also specified the number of clusters to which we want to group the data points. centroids are the centroids generated by kmeans() and avg_distance is the averaged Euclidean distance between the data points fed and the centroids generated by kmeans().Let's assign the groups of the data points by calling the vq() method. It takes -\n",
        "\n",
        "* The data points\n",
        "* The centroid as generated by the clustering algorithm (kmeans() in our case)\n",
        "It then returns the groups (clusters) of the data points and the distances between the data points and its nearest groups."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tfMiZO-qK8os"
      },
      "source": [
        "# Get the Group(Cluster) and distance\n",
        "from scipy import cluster\n",
        "from scipy.cluster.vq import vq\n",
        "\n",
        "groups, cdist = cluster.vq.vq(salary_raw, centroid)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-rxp-AaRK8ou"
      },
      "source": [
        "Let's now plot the groups we have got."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "R4ZMV9qNK8ou",
        "outputId": "4eb460f6-d330-416a-88cf-67d35b15c6d6"
      },
      "source": [
        "plt.scatter(salary_raw, np.arange(0,100), c=(groups))\n",
        "plt.xlabel('Salary (in USD)')\n",
        "plt.ylabel('Indices')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKgjCWwEK8ov"
      },
      "source": [
        "Can you point to the anomalies? I bet you can! So a few things to consider before you fit the data to a machine learning model:\n",
        "\n",
        "* Investigate the data thoroughly - take a look at each of the features that the dataset contains and pay close attention to their summary statistics like mean, median.\n",
        "* Sometimes, it is easy for the eyes to generate a number of useful plots of the different features of the dataset (as shown in the above). Because with the plots in front of you, you instantly get to know about the presence of the weird values which may need further investigation.\n",
        "* See how the features are correlated to one another. This will in turn help you to select the most significant features from the dataset and to discard the redundant ones. \n",
        "\n",
        "The above method for anomaly detection is purely unsupervised in nature. If we had the class-labels of the data points, we could have easily converted this to a supervised learning problem, specifically a classification problem. Shall we extend this? Well, why not?\n",
        "\n",
        "## Anomaly detection as a classification problem\n",
        "\n",
        "To be able to treat the task of anomaly detection as a classification task, we need a labeled dataset. Let's give our existing dataset some labels.\n",
        "\n",
        "We will first assign all the entries to the class of 0 and then we will manually edit the labels for those two anomalies. We will keep these class labels in a column named class. The label for the anomalies will be 1 (and for the normal entries the labels will be 0)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 393
        },
        "id": "Ozl4PS9HK8ow",
        "outputId": "e1878bdf-13d3-45c1-e1b7-6fbbfc7281a5"
      },
      "source": [
        "# First assign all the instance to 0\n",
        "\n",
        "salary_df['Class'] = 0\n",
        "\n",
        "# Now manually changed the class label for anamoly to 1\n",
        "salary_df.at[16, 'Class'] = 1\n",
        "salary_df.at[70, 'Class'] = 1\n",
        "\n",
        "# Lets verify\n",
        "print(salary_df.iloc[16]['Class'])\n",
        "print(salary_df.iloc[70]['Class'])\n",
        "\n",
        "# Lets see last 10 observation / row\n",
        "\n",
        "salary_df.tail(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Person</th>\n",
              "      <th>Salary (in USD)</th>\n",
              "      <th>Class</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>90</th>\n",
              "      <td>Andrea Ayers</td>\n",
              "      <td>1018</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>91</th>\n",
              "      <td>Rick Rodriguez</td>\n",
              "      <td>2155</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>92</th>\n",
              "      <td>Pamela Graham</td>\n",
              "      <td>1411</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>93</th>\n",
              "      <td>Johnny Lee</td>\n",
              "      <td>2246</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>94</th>\n",
              "      <td>David Johnson</td>\n",
              "      <td>2343</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>95</th>\n",
              "      <td>Angel Ho</td>\n",
              "      <td>2374</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>96</th>\n",
              "      <td>Matthew Payne</td>\n",
              "      <td>1994</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>97</th>\n",
              "      <td>Todd Cross</td>\n",
              "      <td>2372</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>98</th>\n",
              "      <td>Jessica Carter</td>\n",
              "      <td>1290</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>99</th>\n",
              "      <td>Brian Lambert</td>\n",
              "      <td>1341</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "            Person  Salary (in USD)  Class\n",
              "90    Andrea Ayers             1018      0\n",
              "91  Rick Rodriguez             2155      0\n",
              "92   Pamela Graham             1411      0\n",
              "93      Johnny Lee             2246      0\n",
              "94   David Johnson             2343      0\n",
              "95        Angel Ho             2374      0\n",
              "96   Matthew Payne             1994      0\n",
              "97      Todd Cross             2372      0\n",
              "98  Jessica Carter             1290      0\n",
              "99   Brian Lambert             1341      0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7dFpNRVtK8ox"
      },
      "source": [
        "We now have a Binary Classification Task.\n",
        "We are going to use KNN-Classification method for this class\n",
        "Also, we are going to use a Python library called PyOD which is specifically developed for anomaly detection purposes.\n",
        "\n",
        "\"PyOD is a comprehensive and scalable Python toolkit for detecting outlying objects in multivariate data. This exciting yet challenging field is commonly referred as Outlier Detection or Anomaly Detection.\"\n",
        "\n",
        "The column Person is not at all useful for the model as it is nothing but a kind of identifier. Let's prepare the training data accordingly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vpKYAUZ6LsEx",
        "outputId": "b54c817c-a173-4d13-d627-8c2bbb60ab0a"
      },
      "source": [
        "!pip install pyod"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pyod in /usr/local/lib/python3.6/dist-packages (0.8.4)\n",
            "Requirement already satisfied: numpy>=1.13 in /usr/local/lib/python3.6/dist-packages (from pyod) (1.18.5)\n",
            "Requirement already satisfied: scikit-learn>=0.19.1 in /usr/local/lib/python3.6/dist-packages (from pyod) (0.22.2.post1)\n",
            "Requirement already satisfied: pandas>=0.25 in /usr/local/lib/python3.6/dist-packages (from pyod) (1.1.5)\n",
            "Requirement already satisfied: combo in /usr/local/lib/python3.6/dist-packages (from pyod) (0.1.1)\n",
            "Requirement already satisfied: scipy>=0.19.1 in /usr/local/lib/python3.6/dist-packages (from pyod) (1.4.1)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from pyod) (1.15.0)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.6/dist-packages (from pyod) (0.17.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from pyod) (3.2.2)\n",
            "Requirement already satisfied: statsmodels in /usr/local/lib/python3.6/dist-packages (from pyod) (0.10.2)\n",
            "Requirement already satisfied: numba>=0.35 in /usr/local/lib/python3.6/dist-packages (from pyod) (0.48.0)\n",
            "Requirement already satisfied: suod in /usr/local/lib/python3.6/dist-packages (from pyod) (0.0.4)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.25->pyod) (2.8.1)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.25->pyod) (2018.9)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->pyod) (1.3.1)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->pyod) (2.4.7)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->pyod) (0.10.0)\n",
            "Requirement already satisfied: patsy>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from statsmodels->pyod) (0.5.1)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from numba>=0.35->pyod) (50.3.2)\n",
            "Requirement already satisfied: llvmlite<0.32.0,>=0.31.0dev0 in /usr/local/lib/python3.6/dist-packages (from numba>=0.35->pyod) (0.31.0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5wfD5wDMK8oy",
        "outputId": "7e21a347-6e06-4b35-ccb8-32cbe9e73ab9"
      },
      "source": [
        "# Import the knn from pyod model\n",
        "\n",
        "from pyod.models.knn import KNN\n",
        "\n",
        "# Segregate / seperate the salary and class values\n",
        "\n",
        "X = salary_df['Salary (in USD)'].values.reshape(-1,1)\n",
        "y = salary_df['Class'].values\n",
        "\n",
        "# Train KNN classifier\n",
        "\n",
        "clf = KNN(contamination = 0.02, n_neighbors = 5)\n",
        "clf.fit(X)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNN(algorithm='auto', contamination=0.02, leaf_size=30, method='largest',\n",
              "  metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
              "  radius=1.0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WztX-YfRK8oz"
      },
      "source": [
        "Let's discuss the two parameters we passed into KNN() -\n",
        "\n",
        "* contamination - the amount of anomalies in the data (in percentage) which for our case is 2/100 = 0.02\n",
        "* n_neighbors - number of neighbors to consider for measuring the proximity\n",
        "\n",
        "Let's now get the prediction labels on the training data and then get the outlier scores of the training data. The outlier scores of the training data. The higher the scores are, the more abnormal. This indicates the overall abnormality in the data. These handy features make PyOD a great utility for anomaly detection related tasks.\n",
        "\n",
        " Try to evaluate KNN() with respect to the training data. PyOD provides a handy function for this - evaluate_print()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ARbYMC4aK8o0",
        "outputId": "b10f0fd8-5ea4-4ba7-8a53-0ceab3587852"
      },
      "source": [
        "# Get the prediction label of training data\n",
        "\n",
        "y_train_pred = clf.labels_\n",
        "\n",
        "# Outlier Score\n",
        "y_train_score = clf.decision_scores_\n",
        "\n",
        "# Now Model Evaluation\n",
        "\n",
        "# for model evaluation we will import the utility function\n",
        "from pyod.utils import evaluate_print\n",
        "\n",
        "# Evaluate on the training data\n",
        "evaluate_print(KNN, y, y_train_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pyod.models.knn.KNN'> ROC:1.0, precision @ rank n:1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pADYLyobK8o0"
      },
      "source": [
        "We see that the KNN() model was able to perform exceptionally good on the training data. It provides three metrics and their scores -\n",
        "\n",
        "* ROC\n",
        "* Precision along with a confidence rank\n",
        "\n",
        "\n",
        "Note: While detecting anomalies, we almost always consider ROC and Precision as it gives a much better idea about the model's performance. We have also seen its significance in the earlier sections.\n",
        "\n",
        "We don't have any test data. But we can generate a sample salary value, right?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ksBZKrgEK8o1",
        "outputId": "b803e4f4-36fd-4d6e-ae42-47731d7b7323"
      },
      "source": [
        "# Lets check a salay of $37 and $1589\n",
        "\n",
        "x_test = np.array([[37.]])\n",
        "\n",
        "print('Class for $37: ',clf.predict(x_test))\n",
        "\n",
        "x_test = np.array([[1589.]])\n",
        "\n",
        "print('Class for $1589: ',clf.predict(x_test))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Class for $37:  [1]\n",
            "Class for $1589:  [0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAxDnF2GMwML"
      },
      "source": [
        "As the above result show correct prediction for unseen value.\r\n",
        "\r\n",
        "This was short introduction about Anomaly detection with a simple example. Hope this will help in complex problem."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ucb3B0h4K8o2"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}