02. Evaluation Metrics/Evaluation Metrics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Evaluation Metrics.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "13JmaEsH0SwL"
      },
      "source": [
        "**INITIALIZATION:**\n",
        "- I use these three lines of code on top of my each notebooks because it will help to prevent any problems while reloading the same project. And the third line of code helps to make visualization within the notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8G3fcytGy1Cp"
      },
      "source": [
        "#@ INITIALIZATION: \n",
        "%reload_ext autoreload\n",
        "%autoreload 2\n",
        "%matplotlib inline"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EW1J3VBj0g3N"
      },
      "source": [
        "**LIBRARIES AND DEPENDENCIES:**\n",
        "- I have downloaded all the libraries and dependencies required for the project in one particular cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QM4N-3MM0W4_"
      },
      "source": [
        "#@ GETTING LIBRARIES AND DEPENDENCIES: \n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from collections import Counter\n",
        "from sklearn import datasets\n",
        "from sklearn import manifold\n",
        "from sklearn import metrics\n",
        "from sklearn import model_selection\n",
        "%matplotlib inline\n",
        "\n",
        "#@ IGNORING WARNINGS: \n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cz5ctDQu1M4B"
      },
      "source": [
        "**ACCURACY:**\n",
        "- It is one of the most straightforward metrics used in machine learning. It defines how accurate the model is. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1inQc-cO0s0e",
        "outputId": "277fff0d-3f3e-4338-806f-a4510cf2fb9d"
      },
      "source": [
        "#@ INITIALIZING ACCURACY FUNCTION: \n",
        "def accuracy(y_true, y_pred):                   # Defining Accuracy Function. \n",
        "    correct_counter = 0                         # Initializing Counter. \n",
        "    for yt, yp in zip(y_true, y_pred):          # Iterating over Elements. \n",
        "        if yt == yp:\n",
        "            correct_counter += 1\n",
        "    return correct_counter / len(y_true)        # Getting Accuracy. \n",
        "\n",
        "#@ IMPLEMENTATION OF ACCURACY:\n",
        "l1 = [0, 1, 1, 1, 0, 0, 0, 1]                   # Initializing a List. \n",
        "l2 = [0, 1, 0, 1, 0, 1, 0, 0]                   # Initializing a List. \n",
        "metrics.accuracy_score(l1, l2)                  # Inspecting Accuracy. "
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.625"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AbLj6itt3m7v",
        "outputId": "3cdf368f-9395-497b-95cc-1430d3d5b80f"
      },
      "source": [
        "#@ INITIALIIZING TRUE POSIITVE: \n",
        "def true_positive(y_true, y_pred):                 # Defining TP Function. \n",
        "    tp = 0                                         # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):\n",
        "        if yt==1 and yp==1:\n",
        "            tp += 1\n",
        "    return tp                                      # Getting TP.\n",
        "\n",
        "#@ INITIALIZING TRUE NEGATIVE: \n",
        "def true_negative(y_true, y_pred):                 # Defining TN Function. \n",
        "    tn = 0                                         # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):\n",
        "        if yt==0 and yp==0:\n",
        "            tn += 1 \n",
        "    return tn                                      # Getting TN. \n",
        "\n",
        "#@ INITIALIZING FALSE POSITIVE: \n",
        "def false_positive(y_true, y_pred):                # Defining FP Function. \n",
        "    fp = 0                                         # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):\n",
        "        if yt==0 and yp==1:\n",
        "            fp += 1\n",
        "    return fp                                      # Getting FP.\n",
        "\n",
        "#@ INITIALIZING FALSE NEGATIVE: \n",
        "def false_negative(y_true, y_pred):                # Defining FN Function. \n",
        "    fn = 0                                         # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):\n",
        "        if yt==1 and yp==0:\n",
        "            fn += 1\n",
        "    return fn                                      # Getting FN. \n",
        "\n",
        "#@ IMPLEMENTATION OF FUNCTION: \n",
        "print(true_positive(l1,l2),true_negative(l1,l2))   # Calculating TP and TN. \n",
        "print(false_positive(l1,l2),false_negative(l1,l2)) # Calculating FP and FN. "
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2 3\n",
            "1 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0_6uJnM-TEU"
      },
      "source": [
        "**Note:**\n",
        "- **Accuracy Score** = **(TP + TN) / (TP + TN + FP + FN)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GJBu283N-E87",
        "outputId": "d04d7ebb-1ef4-4d2d-8622-5ab09e266b88"
      },
      "source": [
        "#@ INITIALIZING ACCURACY FUNCTION: \n",
        "def accuracy_v2(y_true, y_pred):                   # Defining Accuracy Function. \n",
        "    tp = true_positive(y_true, y_pred)             # Initializing TP. \n",
        "    fp = false_positive(y_true, y_pred)            # Initializing FP. \n",
        "    fn = false_negative(y_true, y_pred)            # Initializing FN. \n",
        "    tn = true_negative(y_true, y_pred)             # Initializing TN. \n",
        "    accuracy_score = (tp + tn) / (tp+tn+fp+fn)     # Initializing Accuracy Score. \n",
        "    return accuracy_score\n",
        "\n",
        "#@ COMPARING ACCURACY FUNCTION: \n",
        "print(accuracy(l1, l2))                            # Getting Accuracy. \n",
        "print(accuracy_v2(l1, l2))                         # Getting Accuracy. \n",
        "print(metrics.accuracy_score(l1, l2))              # Getting Accuracy. "
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.625\n",
            "0.625\n",
            "0.625\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xwmJXgHlcKpy"
      },
      "source": [
        "**PRECISION AND RECALL:**\n",
        "- **Precision = TP / (TP + FP)**\n",
        "- **Recall = TP / (TP + FN)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U_co7yb62CFx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba05b9ef-b650-4637-8ea3-3eef57e51bc5"
      },
      "source": [
        "#@ INITIALIZING PRECISION FUNCTION: \n",
        "def precision(y_true, y_pred):                     # Defining Precision Function. \n",
        "    tp = true_positive(y_true, y_pred)             # Initializing TP. \n",
        "    fp = false_positive(y_true, y_pred)            # Initializing FP. \n",
        "    precision = tp / (tp + fp)                     # Getting Precision. \n",
        "    return precision\n",
        "\n",
        "#@ IMPLEMENTATION OF PRECISION FUNCTION: \n",
        "precision(l1, l2)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6666666666666666"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8CJNm5urekna",
        "outputId": "7e790512-5f11-40d9-e3b4-943d54cfefb6"
      },
      "source": [
        "#@ INITIALIZING RECALL FUNCTION: \n",
        "def recall(y_true, y_pred):                        # Defining Precision Function. \n",
        "    tp = true_positive(y_true, y_pred)             # Initializing TP. \n",
        "    fn = false_negative(y_true, y_pred)            # Initializing FP. \n",
        "    recall = tp / (tp + fn)                        # Getting Precision. \n",
        "    return recall\n",
        "\n",
        "#@ IMPLEMENTATION OF PRECISION FUNCTION: \n",
        "recall(l1, l2)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.5"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W-nN2u6CfW90"
      },
      "source": [
        "#@ INITIALIZING LISTS: EXAMPLE: \n",
        "y_true = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, \n",
        "          1, 0, 0, 0, 0, 0, 0, 0, 1, 0]                   # Initializing Target Examples. \n",
        "y_pred = [0.02638412, 0.11114267, 0.31620708,\n",
        "          0.0490937, 0.0191491, 0.17554844,\n",
        "          0.15952202, 0.03819563, 0.11639273,\n",
        "          0.079377, 0.08584789, 0.39095342,\n",
        "          0.27259048, 0.03447096, 0.04644807,\n",
        "          0.03543574, 0.18521942, 0.05934905,\n",
        "          0.61977213, 0.33056815]                         # Initializing Prediction Examples. \n",
        "thresholds = [0.0490937 , 0.05934905, 0.079377,\n",
        "              0.08584789, 0.11114267, 0.11639273,\n",
        "              0.15952202, 0.17554844, 0.18521942,\n",
        "              0.27259048, 0.31620708, 0.33056815,\n",
        "              0.39095342, 0.61977213]                     # Initializing Threshold Examples. "
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "R5yPfVszh05b",
        "outputId": "72a8de96-8f67-40e8-855c-7dde85a71d75"
      },
      "source": [
        "#@ GETTING PRECISION AND RECALL VALUES: \n",
        "precisions = []                                    # Initializing a List. \n",
        "recalls = []                                       # Initializing a List. \n",
        "for i in thresholds:\n",
        "    temp_pred=[1 if x>=i else 0 for x in y_pred]   # Getting Predictions. \n",
        "    p = precision(y_true, temp_pred)               # Getting Precision. \n",
        "    r = recall(y_true, temp_pred)                  # Getting Recall. \n",
        "    precisions.append(p)\n",
        "    recalls.append(r)\n",
        "\n",
        "#@ PLOTTING PRECISION AND RECALL CURVE: \n",
        "plt.figure(figsize=(7, 7))\n",
        "plt.plot(recalls, precisions)\n",
        "plt.xlabel(\"Recall\", fontsize=15)\n",
        "plt.ylabel(\"Precision\", fontsize=15)\n",
        "plt.show();"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAGuCAYAAADvW2NyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5TdZ13v8fc390wyuV8mTSZNC7m0FLEllHYhUKlgW7FVetAWOYKi5XhAVDgILlgI1SUX0XN0US6Vw+LikQq61CqViloOR6SchlMu9pKSltIkza1NmkySyXW+54/9m8meaS6zm32Zmef9WmtW9v79fjP7+3Rn8unz/J79PJGZSJJUikmdLkCSpHYy+CRJRTH4JElFMfgkSUUx+CRJRZnS6QKaYdGiRblq1apOlyFJGkO+9a1vPZGZi0cenxDBt2rVKjZs2NDpMiRJY0hE/PBkxx3qlCQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFaWtwRcRn4qInRHxH6c4HxHxpxGxKSK+GxGXtLM+SdLE1+4e36eBq05z/mpgdfV1E/CxNtQkSSpIW4MvM78G7D7NJdcBn82au4F5EbGsHbVt2tnHjn2H2vFSkqQOGmv3+JYDm+ueb6mOtdyrP/4NbrlrUzteSpLUQWMt+EYtIm6KiA0RsWHXrl2dLkeSNE6MteDbCvTWPV9RHXuazLw1M9dn5vrFi5+2s7wkSSc11oLvduAXq9mdlwF7M3Nbp4uSJE0cU9r5YhHxeeAKYFFEbAF+F5gKkJkfB+4ArgE2AQeBX2pnfZKkia+twZeZN57hfAJvalM5kqQCjbWhTkmSWsrgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVpe3BFxFXRcTGiNgUEe88yfmVEXFXRNwbEd+NiGvaXaMkaeJqa/BFxGTgFuBq4ELgxoi4cMRl7wa+kJkXAzcAH21njZKkia3dPb5LgU2Z+UhmHgFuA64bcU0Cc6rHc4HH21ifJGmCa3fwLQc21z3fUh2r917gtRGxBbgD+PWT/aCIuCkiNkTEhl27drWiVknSBDQWJ7fcCHw6M1cA1wCfi4in1ZmZt2bm+sxcv3jx4rYXKUkan9odfFuB3rrnK6pj9d4AfAEgM78BzAAWtaU6SdKE1+7guwdYHRHnRcQ0apNXbh9xzWPAlQARcQG14HMsU5LUFG0Nvsw8BrwZuBN4gNrszfsi4uaIuLa67G3Ar0bEd4DPA6/PzGxnnZKkiWtKu18wM++gNmml/th76h7fD7yo3XVJksowFie3SJLUMgafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKAafJKkoBp8kqSgGnySpKFOe6TdGxGRg+sjjmXnwrCqSJKmFGurxRcSciPhIRDwOHAb6TvIlSdKY1WiP7xPAK4FPAvcDR5pekSRJLdRo8P0k8FuZ+clWFCNJUqs1OrnlALClFYVIktQOjQbfHwH/NSKcDSpJGpcaHepcDjwP2BgRdwFPjTifmfmOplQmSVILNBp8/wkYqL7v5Sc5n8Bpgy8irgL+BJgMfDIzP3CSa34OeG/1876Tma9psE5Jkk6qoeDLzPPO5sWqz/7dQi00twD3RMTtmXl/3TWrgd8BXpSZeyJiydm8piRJ9dp9r+5SYFNmPpKZR4DbgOtGXPOrwC2ZuQcgM3e2uUZJ0gTWcPBFxPkR8bGI+F5EbK3+/GhEnD+Kb18ObK57vqU6Vm8NsCYivh4Rd1dDoyer46aI2BARG3bt2tVoMyRJhWp05ZbnA98GrgfuAT5b/Xk9cG9EXNKEmqYAq4ErgBuBP4uIeSMvysxbM3N9Zq5fvHhxE15WklSCRie3fBi4F7i6fk3OiOgC7qjOv+w0378V6K17vqI6Vm8L8M3MPAr8ICIeohaE9zRYqyRJT9PoUOelwIdGLkRdPf8w8MIzfP89wOqIOC8ipgE3ALePuOZvqfX2iIhF1IY+H2mwTkmSTqrR4OsHFp7i3ALg0Om+OTOPAW8G7gQeAL6QmfdFxM0RcW112Z3AkxFxP3AX8PbMfLLBOiVJOqlGhzq/BHwgIh7JzH8bPBgRPwa8H/j7M/2AzLyD2rBo/bH31D1O4K3VlyRJTdVo8L0V+Dvgf0fETmAnsKT6+gbwtuaWJ0lSczX6AfYngR+rPmLwAmAZsI3aZJR/akF9kiQ11TPagT0zvwx8ucm1SJLUcmcMvojoGpzFWX1s4bRGzviUJGksGU2Pry8iLs/M/wvsp7Zw9OlMPvuyJElqjdEE3y8DD9c9PlPwSZI0Zp0x+DLzM3WPP93SaiRJarGGJrdExBRgcmYerjv2CuBC4GuZ+f+aXJ8kSU3V6KzOvwT2UhvyJCLeAvwP4DAwOSJelZn/0NwSJUlqnkaXLLuM4auuvB34o8ycCXwSeFezCpMkqRUaDb6FwHaAiHgucA7w8ercF6kNeUqSNGY1Gnw7gFXV46uAH2bm4IzPmcBAk+qSJKklGr3H90XggxHxPOCXgI/UnbsY+H6zCpMkqRUaDb53AvuordP5MeAP6s49n9rkF0mSxqxGF6k+Btx8inOvakpFkiS1UKP3+CRJGtdGs0j1TuAnM/PeiNjFGZYsy8wlzSpOkqRmG81Q5y3UZnMOPnatTknSuDWatTrfV/f4vS2tRpKkFmvoHl9E9EbEJac4d0lE9DanLEmSWqPRyS0fA157inOvAT56duVIktRaz2Stzn89xbm7qvOSJI1ZjQZfF6ef3DLrLGqRJKnlGg2+7wE3nuLcjcB9Z1eOJEmt1eiSZR8A/joipgOfBrYBy4DXAddXX5IkjVmNLln2NxHxOuD91EIugQC2Aq/NzL9tfomSJDVPoz0+MvNzEfHnwDpgAfAksDEz/WC7JGnMazj4ADIzI+JBasOcOw09SdJ40fAi1RFxTUR8EzgEPAb8SHX81og41Wf8JEkaExpdueUXgduBB4GbRnz/94E3NK80SZKar9Ee37uAP8zM1wF/PuLcfcCFTalKkqQWaTT4zgW+copzh4A5Z1eOJEmt1WjwbQYuPsW59cCmsytHkqTWajT4/ifwu9UklpnVsYiIK4HfBv6smcVJktRsjX6c4YNAL/AZ4Hh17N+BycAnMvNPm1ibJElN1+jKLQm8KSL+GLgSWATsBv41Mx9qQX2SJDXVqIMvImYAe4Gfr5Yme7hlVUmS1CKjvseXmYeAncCx1pUjSVJrNTq55RPAWyJiaiuKkSSp1Rqd3DIPuAh4NCL+BdjB8I1pMzPf0aziJElqtkaD73rgcPX4xSc5n4DBJ0kas0YVfBExE7gG+AiwHfjnzNzRysIkSWqFMwZfRJwP/DOwqu7w3oj4+cz8p1YVJklSK4xmcsuHgAFqQ5tdwHOAb1Ob6CJJ0rgymuC7HHh3Zn49Mw9l5gPAG4GVEbGsteVJktRcowm+ZcAjI449DATQ0/SKJElqodF+ji/PfIkkSWPfaD/OcGdEnGzFln8ZeTwzl5x9WZIktcZogu99La9CkqQ2OWPwZabBJ0maMBpdq1OSpHHN4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVpe3BFxFXRcTGiNgUEe88zXXXR0RGxPp21idJmtjaGnwRMRm4BbgauBC4MSIuPMl13cBvAN9sZ32SpImv3T2+S4FNmflIZh4BbgOuO8l1vwd8EDjUzuIkSRNfu4NvObC57vmW6tiQiLgE6M3ML53uB0XETRGxISI27Nq1q/mVSpImpDE1uSUiJgF/DLztTNdm5q2ZuT4z1y9evLj1xUmSJoR2B99WoLfu+Yrq2KBu4CLgqxHxKHAZcLsTXCRJzdLu4LsHWB0R50XENOAG4PbBk5m5NzMXZeaqzFwF3A1cm5kb2lynJGmCamvwZeYx4M3AncADwBcy876IuDkirm1nLZKkMk1p9wtm5h3AHSOOvecU117RjpokSeUYU5NbJElqNYNPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUFINPklQUg0+SVBSDT5JUlCmdLkCSJIBjxwfYtvcQA5mcu3BWy17H4JMktUVmsvvAER7bfZDNe/rZvPsgm3cfrJ4f5PGnDnF8IPmp5y7jll+4pGV1GHySpKbpP3KczXvqAm13P4/tPsiWPbXnB48cH3b9otnT6F3QxcW987n2eTNZuaCLdT1zWlqjwSdJGrXjA8m2vf1s3l312PYMBtxBHtvdzxP7Dw+7fubUyaxc0EXvgplc/qyF9M7vqp53sWL+TGZNb38Mtf0VI+Iq4E+AycAnM/MDI86/FfgV4BiwC/jlzPxhu+uUpBJlJk8dPFoXaMN7bI8/1c/R4zl0/aSAc+bNpHd+F1euW0Lvgpn0VsG2ckEXC2dNIyI62KKna2vwRcRk4Bbg5cAW4J6IuD0z76+77F5gfWYejIhfAz4E/Hw765SkiezQ0eNs2VPXY3tysOfWz5bdB+k7fGzY9QtmTaN3/kyeu3wu1zx3Wa3HVvXcls2bwdTJ4+sDAu3u8V0KbMrMRwAi4jbgOmAo+DLzrrrr7wZe29YKJWmcGxhIdvQdqgKt6rHVTSLZsW/4cOT0KZOGemiXrpo/rMfWu6CL2R0YjmyldrdmObC57vkW4IWnuf4NwD+e7ERE3ATcBLBy5cpm1SdJ48Le/qNPmxU52GPbsqefI8cHhq6NgGVzZtC7oIsXr148dM9tsOe2uHv6mBuObKUxG+MR8VpgPfDSk53PzFuBWwHWr1+fJ7tGksarw8eOs3VP/0l7bI89eZB9h4YPR86dObU2I3JZNy9/ztJhk0jOmTeD6VMmd6glY0+7g28r0Fv3fEV1bJiI+AngXcBLM/PwyPOSNN4NDCS79h9+2rT/wY8CbN93iKz7X/ppkyexYkFtEsnFvfOHemwr5tfCbe7MqZ1rzDjT7uC7B1gdEedRC7wbgNfUXxARFwOfAK7KzJ1trk+Smqbv0NGnzYocDLote/o5fGxg2PU9c2acdNr/ygVdLOmezqRJ5QxHtlJbgy8zj0XEm4E7qX2c4VOZeV9E3AxsyMzbgT8EZgNfrMacH8vMa9tZpySNxtHjAzz+VP9Je2ybdx9kz8Gjw67vnj6F3gVdrF7SzcvWLan12KpgWz5vJjOmOhzZDm2/x5eZdwB3jDj2nrrHP9HumiTpZDKTJ/YfOdFje/LgsM+3bdvbz0DdcOTUycHyebXPsV00Ytp/74KZzJ05tahJJGPVmJ3cIunMDh09zvd37OeB7fvYuL2Pw8eO875rL2KyQ2KjduDwsaqX1j80FLl5qOfWT//R4UtsLe6ezsoFXbxg1XxWLlg+1GPrXdBFz5wZ/rcfBww+aRwYGEg27znIA9v62Li9j4079vHgtj4effLAsB4HwBtf8ix6F3R1ptAxaHDF/5HT/gcD7skDR4ZdP2vaZHoXdHHuwlm8ePVieufPZOXCWs9txfwuZk5zOHK8M/ikMWb3gSM8WPXgNm7v44HtfXx/R9/Q4r4RcO6CLtb2dPPTzzuHdT3drO3p5p5Hd/OOv/5eh6tvv8EV/wen/df32GpLbNVW/B80edLgcORMXvGcpawYMYlkfpfDkROdwSd1yOFjx9m0cz8Pbutj444+HthWC7udfSc+wTO/ayrreubwc+t7uWBZN2t75rBm6Wy6pj39V/dbP9zTzvLbqv/I8RGzIvuHTSI5cJIV/1fMH77if2817X/Z3BlMGWdLbKm5DD6pxTKTLXv6eXB7Hxu37+PB7X08uL2PHzxxYKgnMm3KJFYvmc2PrV7EBT1zWNvTzbqe7mJW1Dg+kGzfd2ho8sjwFUn62dX39BX/Bz/Hdtn5C1m5oPMr/mv88G+H1ER7Dx6tDVPuqIXbg9v28dCO/eyvW/S3d8FM1i6dw9UX9QwF3KqFsyZ0LyQz2dt/9JTT/reeZsX/l60dvuJ/7/wuFs0eeyv+a/ww+KRn4MixAR7etZ+NVe9t8J7ctr2Hhq6ZO3Mqa3u6uf6S5aytenFre7on3IK/g4ZW/B/ZY6smkpxqxf+Lls/l6gmw4r/Gj4n5Gyg1SWby+N5DJ4Yoq1mVD+/az7FqmHLq5OBZi2fzwvMWsG5ZLeAu6JnD0jkTa5hycMX/k037f2z36Vf8f0EBK/5r/PBvnlTZd+goD43owT24vY++usWAl8+bydqebq68YEk1TDmH8xfPmjC9k/oV/+s/qL3ZFf81gRh8Ks7R4wP84IkDQ/fgBgNu61P9Q9d0T5/C2p5urvvRc1jbM4d1Pd2sWdo97hcCPnJsgK1PnbzHtnl3P3v7hy+x5Yr/mogMPk1YmcmOfYeH9d4e3N7Hwzv3D/VcpkwKzl88i+efO5/XvHAl63q6WbdsDufMnTFueyu79h9mx75D1fY1/UPBtmX3Qba54r9k8GliOHD4GBt31O6/Pbitdj9u444+nqpbJLhnzgzWLevmJWsW1QKuGqacKL2WSVVQv+qj/z7s+OCK/5e54r8EGHwaZ44dH+DRJw9WPbgq4Lb38djug0PXzJo2mbU93Vx90bKhVU3W9XQzr2taBytvvSvWLuY3rlxd+/C2K/5Lp2TwaUzKrG3SubGaSflgtT7lQzv2c6Taw2xSwHmLZvHcFXN59fNXsG5Z7V7c8nkzi+zFLJw9nd96+ZpOlyGNeQafOq7/yHEe2jG4LuWJ+3G76xYPXtw9nXU93bzu8nOHJps8e8lsezOSGmbwqW2ODySP7T7Ixu376nYZqO0wMDjhYubUyazp6eblFyytDVEuq92LWzBrYg9TSmofg08t8WQ1TPlAtT7lYMgdOlobpoyA8xbOYl31kYF1VS9u5YKuIocpJbWPwaezcuhobYeBwZ0FarsM9PHE/hOreCycNY11y7p5zaXnVj24blYv6XZfM0kdYfBpVAYGBncYODGT8oHt+3j0iRMboU6fMok1S7u5Yu3ioY8LrK12GJCkscLg09PsOXBkaAudwV0GHtreN2zPs3MXdrF2aTevfO6yofUpVy2cxWSHKSWNcQZfwQ4fO87DOw+MWNlk37DFhud1TWVdTzevXt879Jm4NUu73e9M0rjlv14FyEy2PtU/tNP34BqVj9RvhDp5Es9eMpsXPWsR66qdvtf1dLPEhYYlTTAG3wSzt/9obZJJ3U7fD23vG7YX2or5M1nX080rnrN0aDblqkUTZ4cBSTodg2+cOnJsgEeeqNsItZpV+XjdRqhzZkxhXc8cfubi5UOzKdcs7aZ7hgsPSyqXwTfGZSbb9x0aWrZr8H7cw7v2c/T48I1QX3DegqEe3NqebpaN4x0GJKlVDL4xpO/QUR6q7sGdWKNyH/vqNkI9Z+4M1vZ08+PrlgwF3PmLZjNtisOUkjQaBl8HHKvbCLV+l4Ete05shDq72gj1p593ThVwc1i7tJu5XQ5TStLZMPhaKDPZ2Xd46DNxg8OVm3ad2GFg8qTg/EWz+NHeedx46UrWLq314lbMn+kwpSS1gMHXJAcOHxvaYaD+Xtyeuo1Ql86ZztqeObx49SLWVsOUz14ye8JshCpJ44HB16DjA8mjTx542k7fj+0+OLTDQNe0yaxZ2s1VF/VUPbjahJP57jAgSR1n8J3Grr7DT9vp+6EdfRyu2wh11aJZXHTOXK6/ZAVre7q5oGcOK+aXuRGqJI0HBl+dB7bt4+a/v5+NO2rDlE/sP7ER6qLZtY1Q//Nl59YCbtkcN0KVpHHI4KvMnjGFex7dw/e27mXN0m5etm7J0BDl2p5uFs12hwFJmggMvsoX3ng5h44OsHJBlzsMSNIEZvBVls2d2ekSJElt4HIfkqSiGHySpKIYfJKkohh8kqSiGHySpKIYfJKkohh8kqSiGHySpKIYfJKkohh8kqSiGHySpKIYfJKkohh8kqSiGHySpKIYfJKkokRmdrqGsxYRfcDGTtfRZIuAJzpdRAtMxHbZpvFhIrYJJma7mtWmczNz8ciDE2Uj2o2Zub7TRTRTRGyYaG2Cidku2zQ+TMQ2wcRsV6vb5FCnJKkoBp8kqSgTJfhu7XQBLTAR2wQTs122aXyYiG2CidmulrZpQkxukSRptCZKj0+SpFEx+CRJRRlXwRcRV0XExojYFBHvPMn5/xIR34uIb0fEv0XEhZ2osxFnalPddddHREbEmJ+2PIr36fURsat6n74dEb/SiTobNZr3KiJ+LiLuj4j7IuIv2l1jo0bxXv33uvfpoYh4qhN1NmIUbVoZEXdFxL0R8d2IuKYTdTZiFG06NyL+pWrPVyNiRSfqbEREfCoidkbEf5zifETEn1Zt/m5EXNK0F8/McfEFTAYeBs4HpgHfAS4ccc2cusfXAl/udN1n26bqum7ga8DdwPpO192E9+n1wEc6XWsL2rUauBeYXz1f0um6z7ZNI67/deBTna67Ce/TrcCvVY8vBB7tdN1NaNMXgddVj18GfK7TdY+iXS8BLgH+4xTnrwH+EQjgMuCbzXrt8dTjuxTYlJmPZOYR4DbguvoLMnNf3dNZwFifuXPGNlV+D/ggcKidxT1Do23TeDOadv0qcEtm7gHIzJ1trrFRjb5XNwKfb0tlz9xo2pTAnOrxXODxNtb3TIymTRcC/1o9vusk58eczPwasPs0l1wHfDZr7gbmRcSyZrz2eAq+5cDmuudbqmPDRMSbIuJh4EPAW9pU2zN1xjZV3fvezPxSOws7C6N6n4Drq+GLv4qI3vaUdlZG0641wJqI+HpE3B0RV7WtumdmtO8VEXEucB4n/nEdq0bTpvcCr42ILcAd1HqyY9lo2vQd4FXV458FuiNiYRtqa6VR//1s1HgKvlHJzFsy81nAO4B3d7qesxERk4A/Bt7W6Vqa7O+BVZn5I8BXgM90uJ5mmUJtuPMKar2jP4uIeR2tqHluAP4qM493upAmuBH4dGauoDac9rnqd208+2/ASyPiXuClwFZgIrxXLTGe3uytQH3PYEV17FRuA36mpRWdvTO1qRu4CPhqRDxKbZz79jE+weWM71NmPpmZh6unnwSe36bazsZo/v5tAW7PzKOZ+QPgIWpBOFY18jt1A2N/mBNG16Y3AF8AyMxvADOoLYo8Vo3md+rxzHxVZl4MvKs6NuYnIp1Bo//mj9p4Cr57gNURcV5ETKP2i3h7/QURUf+PzE8B329jfc/EaduUmXszc1FmrsrMVdQmt1ybmRs6U+6ojOZ9qh+nvxZ4oI31PVNnbBfwt9R6e0TEImpDn4+0s8gGjaZNRMQ6YD7wjTbX90yMpk2PAVcCRMQF1IJvV1urbMxofqcW1fVafwf4VJtrbIXbgV+sZndeBuzNzG3N+MHjZneGzDwWEW8G7qQ2y+lTmXlfRNwMbMjM24E3R8RPAEeBPcDrOlfxmY2yTePKKNv0loi4FjhG7eb26ztW8CiNsl13Aq+IiPupDTO9PTOf7FzVp9fA378bgNuymmo3lo2yTW+jNgz9W9Qmurx+LLdtlG26Anh/RCS1GeBv6ljBoxQRn6dW96LqfuvvAlMBMvPj1O6/XgNsAg4Cv9S01x7D77ckSU03noY6JUk6awafJKkoBp8kqSgGnySpKAafJKkoBp/UIRHx3qjtuDH4tT0i/iEifqQDtayqanhl3bFHI+LD7a5FajWDT+qsvcDl1ddvUvvQ+1ciYkFHq5ImsHHzAXZpgjpWrTwPcHe1NN03gKuAMb+fnzQe2eOTxpbvVH8OrVEYEb9SbWx7OCJ+GBG/PfKbIuIl1eaq+yNib7UZ6cXVuWXVpp+PRER/1DaU/f1q+SupOPb4pLFlZfXnDwAi4u3AH1DbZuur1Bb0/r2IOJiZH6muuYLaLhd3UVum7wDwImpbuNxLbQHm3cBbqS3lt4ba1jyLgTe2vknS2GLwSR0WEYO/h+cCHwG+DfxdRMyhtn7h72fm+6prvhIRXZLq/AMAAAHESURBVMC7I+Jj1TZB76fWU/zJujUnvzz48zPze9S2rRl8va9TC8dPRcSvV5ubSsVwqFPqrIXUFlU/Sm0x3ouBV1XbNl0OzAK+GBFTBr+obQa7FFgREbOAFwKfOdVCy9Xq9r8ZEfdHRH/1Wv8LmM6JHqZUDINP6qy9wAuo7bX4RmAa8BfVFjODe8Tdx4lwPEptSBNq9wHnAwGcbruW3wQ+DPwNcB1wKSdW75/RrIZI44VDnVJnHavbX/GbVY/ss8Crqd2XA3glsOMk37sRGKi+lp3k/KBXU9s9/V2DByLiwrMtXBqvDD5pbPlz4B3V18uAfuCczPzSqb4hIr5JbcPOj5xiuHMmcHjEsV9oUr3SuGPwSWNIZmZE/AG1e3DPpzb78k8i4lxqG4xOojYr88cz82erb3sn8M/AP0bErdQmrlxObZPSf6A24/MtVUA+TC30nt2+Vklji/f4pLHnL4HvA7+dmR8CbgKuBv4O+Dy14Po/gxdn5teAlwNd1HqMfwm8FNhSXXJz9X2/X/15BHhLOxoijUXuwC5JKoo9PklSUQw+SVJRDD5JUlEMPklSUQw+SVJRDD5JUlEMPklSUQw+SVJR/j9atKu1ZQjgWgAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 504x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40EaAIDcoZGD"
      },
      "source": [
        "**F1 SCORE:**\n",
        "- **F1 Score** is a metric that combines both precision and recall. It is defined as a simple weighted average of precision and recall. \n",
        "- **F1 = 2PR / (P + R)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QzWycrTgj0mb",
        "outputId": "f653c954-5fd1-42c8-e3a6-a0be51dccfc4"
      },
      "source": [
        "#@ INITIALIZING F1 SCORE FUNCTION: \n",
        "def f1(y_true, y_pred):                         # Defining F1 Score Function. \n",
        "    p = precision(y_true, y_pred)               # Initializing Precision. \n",
        "    r = recall(y_true, y_pred)                  # Initializing Recall. \n",
        "    score = 2 * p * r / (p + r)                 # Getting F1 Score. \n",
        "    return score \n",
        "\n",
        "#@ IMPLEMENTATION OF F1 SCORE FUNCTION: \n",
        "print(f1(l1, l2))\n",
        "print(metrics.f1_score(l1, l2))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.5714285714285715\n",
            "0.5714285714285715\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vqlbhgT1q32D"
      },
      "source": [
        "**SENSITIVITY AND SPECIFICITY:**\n",
        "- **True Positive Rate** or **Recall** is known as **Sensitivity**. \n",
        "- **1 - False Positive Rate** is known as **Specificity**. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kSgq_AeMqAJN"
      },
      "source": [
        "#@ INITIALIZING TRUE POSITIVE RATE: \n",
        "def tpr(y_true, y_pred):                       # Defining TPR Function. \n",
        "    return recall(y_true, y_pred)              # Implementation of Recall. \n",
        "\n",
        "#@ INITIALIZING FALSE POSITIVE RATE: \n",
        "def fpr(y_true, y_pred):                       # Defining FPR Function. \n",
        "    fp = false_positive(y_true, y_pred)        # Getting False Positive. \n",
        "    tn = true_negative(y_true, y_pred)         # Getting True Negative. \n",
        "    return fp / (tn + fp)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451
        },
        "id": "7LmUmv4EGvzS",
        "outputId": "16abec9d-0b05-41ac-cbc3-d22e63897cc9"
      },
      "source": [
        "#@ INSPECTING TPR AND FPR: EXAMPLES: \n",
        "tpr_list, fpr_list = [], []                             # Initializing Lists.\n",
        "y_true = [0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1]  # Initializing Actual Targets. \n",
        "y_pred = [0.1, 0.3, 0.2, 0.6, 0.8, 0.05, 0.9, 0.5, 0.3, \n",
        "          0.66, 0.3, 0.2, 0.85, 0.15, 0.99]             # Initializing Predicted Probabilities. \n",
        "thresholds = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, \n",
        "              0.8, 0.85, 0.9, 0.99, 1.0]                # Initializing Thresholds. \n",
        "for thresh in thresholds:\n",
        "    temp_pred = [1 if x>=thresh else 0 for x in y_pred] # Getting Predictions for Thresholds. \n",
        "    temp_tpr = tpr(y_true, temp_pred)                   # Initializing TPR. \n",
        "    temp_fpr = fpr(y_true, temp_pred)                   # Initializing FPR. \n",
        "    tpr_list.append(temp_tpr)                           # Appending TPR Values. \n",
        "    fpr_list.append(temp_fpr)                           # Appending FPR Values. \n",
        "\n",
        "#@ PLOTTING TPR AND FPR VALUES: \n",
        "plt.figure(figsize=(7, 7))\n",
        "plt.fill_between(fpr_list, tpr_list, alpha=0.4)\n",
        "plt.plot(fpr_list, tpr_list, lw=3)\n",
        "plt.xlim(0, 1.0)\n",
        "plt.ylim(0, 1.0)\n",
        "plt.xlabel(\"FPR\", fontsize=15)\n",
        "plt.ylabel(\"TPR\", fontsize=15)\n",
        "plt.show();"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VIkEZmTNOAYv"
      },
      "source": [
        "**LOG LOSS FUNCTION:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mIEFRbjYKgq_",
        "outputId": "af82a68a-cb19-40ed-ddee-9c24b8a4c396"
      },
      "source": [
        "#@ FUNCTION TO CALCULATE LOG LOSS: \n",
        "def log_loss(y_true, y_proba):                      # Defining Log Loss Function. \n",
        "    epsilon = 1e-15                                 # Initialization. \n",
        "    loss = []                                       # Initialization. \n",
        "    for yt, yp in zip(y_true, y_proba):\n",
        "        yp = np.clip(yp, epsilon, 1 - epsilon)      # Initializing Prediction Probabilites. \n",
        "        temp_loss = -1.0 * (yt * np.log(yp) + \n",
        "                            (1-yt)*np.log(1-yp))\n",
        "        loss.append(temp_loss)                      # Appending Loss. \n",
        "    return np.mean(loss)\n",
        "\n",
        "#@ IMPLEMENTATION OF LOG LOSS: \n",
        "y_true = [0, 0, 0, 0, 1, 0, 1, \n",
        "          0, 0, 1, 0, 1, 0, 0, 1]                   # Initializing Actual Targets. \n",
        "y_proba = [0.1, 0.3, 0.2, 0.6, 0.8, 0.05, \n",
        "           0.9, 0.5, 0.3, 0.66, 0.3, 0.2,\n",
        "           0.85, 0.15, 0.99]                        # Initializing Predicted Probabilities. \n",
        "log_loss(y_true, y_proba)                           # Inspection. \n",
        "\n",
        "#@ IMPLEMENTATION OF LOG LOSS: \n",
        "metrics.log_loss(y_true, y_proba)                   # Inspection. "
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.49882711861432294"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XWba0ewBUCLX"
      },
      "source": [
        "#@ INITIALIZING MACRO AVERAGED PRECISION FUNCTION: \n",
        "def macro_precision(y_true, y_pred):                            # Defining Function. \n",
        "    num_classes = len(np.unique(y_true))                        # Initializing Number of Classes. \n",
        "    precision = 0                                               # Initialization. \n",
        "    for class_ in range(num_classes):\n",
        "        temp_true = [1 if p==class_ else 0 for p in y_true]     # Initializing One Hot Encoding. \n",
        "        temp_pred = [1 if p==class_ else 0 for p in y_pred]     # Initializing One Hot Encoding. \n",
        "        tp = true_positive(temp_true, temp_pred)                # Getting TP Value. \n",
        "        fp = false_positive(temp_true, temp_pred)               # Getting FP Value. \n",
        "        temp_precision = tp / (tp + fp)                         # Getting Precision Value. \n",
        "        precision += temp_precision\n",
        "    precision /= num_classes                                    # Getting Average Precision. \n",
        "    return precision"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lpjeUnqa7b71"
      },
      "source": [
        "#@ INITIALIZING MICRO AVERAGED PRECISION FUNCTION: \n",
        "def micro_precision(y_true, y_pred):                            # Defining Function. \n",
        "    num_classes = len(np.unique(y_true))                        # Initializing Number of Classes. \n",
        "    tp, fp = 0, 0                                               # Initialization. \n",
        "    for class_ in range(num_classes):\n",
        "        temp_true = [1 if p==class_ else 0 for p in y_true]     # Initializing One Hot Encoding. \n",
        "        temp_pred = [1 if p==class_ else 0 for p in y_pred]     # Initializing One Hot Encoding. \n",
        "        tp += true_positive(temp_true, temp_pred)               # Getting TP Values. \n",
        "        fp += false_positive(temp_true, temp_pred)              # Getting FP Values. \n",
        "    precision = tp / (tp + fp)                                  # Getting Precision Value. \n",
        "    return precision\n",
        "\n",
        "#@ INITIALIZING WEIGHTED PRECISION FUNCTION: \n",
        "def weighted_precision(y_true, y_pred):                         # Defining Function. \n",
        "    num_classes = len(np.unique(y_true))                        # Initializing Number of Classes. \n",
        "    class_counts = Counter(y_true)                              # Initializing Counter. \n",
        "    precision = 0                                               # Initializing Precision. \n",
        "    for class_ in range(num_classes):\n",
        "        temp_true = [1 if p==class_ else 0 for p in y_true]     # Initializing One Hot Encoding. \n",
        "        temp_pred = [1 if p==class_ else 0 for p in y_pred]     # Initializing One Hot Encoding. \n",
        "        tp = true_positive(temp_true, temp_pred)                # Getting True Positive. \n",
        "        fp = false_positive(temp_true, temp_pred)               # Getting FP Values. \n",
        "        temp_precision = tp / (tp + fp)                         # Getting Precision Value. \n",
        "        weighted_precision=class_counts[class_]*temp_precision  # Initializing Multiplication. \n",
        "        precision += weighted_precision                         # Initializing Overall Precision. \n",
        "    overall_precision = precision / len(y_true)\n",
        "    return overall_precision                                    "
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sVq_kc5cA4MJ",
        "outputId": "856808d1-555a-4f33-8c81-f843b300cffa"
      },
      "source": [
        "#@ IMPLEMENTATION OF FUNCTION: \n",
        "y_true = [0, 1, 2, 0, 1, 2, 0, 2, 2]                            # Initialization. \n",
        "y_pred = [0, 2, 1, 0, 2, 1, 0, 0, 2]                            # Initialization. \n",
        "print(macro_precision(y_true, y_pred))                          # Getting Macro Precision Value. \n",
        "print(metrics.precision_score(y_true, y_pred, average=\"macro\")) # Getting Macro Precision Value. \n",
        "print(micro_precision(y_true, y_pred))                          # Getting Micro Precision Value. \n",
        "print(metrics.precision_score(y_true, y_pred, average=\"micro\")) # Getting Micro Precision Value. \n",
        "print(weighted_precision(y_true, y_pred))                       # Getting Weighted Precision Value. \n",
        "metrics.precision_score(y_true, y_pred, average=\"weighted\")     # Getting Weighted Precision Value. "
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.3611111111111111\n",
            "0.3611111111111111\n",
            "0.4444444444444444\n",
            "0.4444444444444444\n",
            "0.39814814814814814\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.39814814814814814"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHApaa8ICKBY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "413927d1-bfeb-49e9-deee-f1b39462fe96"
      },
      "source": [
        "#@ INITIALIZING WEIGHTED F1 SCORE: \n",
        "def weighted_f1(y_true, y_pred):                              # Defining Function. \n",
        "    \"\"\"\n",
        "    Function to calculate weighted f1 score. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_proba: list of predicted values. \n",
        "    :return: weighted f1 score. \n",
        "    \"\"\"\n",
        "    num_classes = len(np.unique(y_true))                      # Initializing number of classes. \n",
        "    class_counts = Counter(y_true)                            # Initializing sample count dictionary.\n",
        "    f1 = 0                                                    # Initializing f1. \n",
        "    for class_ in range(num_classes):                         # Iterating over all classes. \n",
        "        temp_true = [1 if p==class_ else 0 for p in y_true]   # Initialization. \n",
        "        temp_pred = [1 if p==class_ else 0 for p in y_pred]   # Initialization. \n",
        "        p = precision(temp_true, temp_pred)                   # Calculating precision. \n",
        "        r = recall(temp_true, temp_pred)                      # Calculating recall. \n",
        "        if p + r != 0:\n",
        "            temp_f1 = 2 * p * r / (p + r)                     # Calculating f1 score. \n",
        "        else: \n",
        "            temp_f1 = 0\n",
        "        weighted_f1 = class_counts[class_] * temp_f1          # Multiplication. \n",
        "        f1 += weighted_f1                                     # Addition. \n",
        "    overall_f1 = f1 / len(y_true)                             # Initializing overall f1. \n",
        "    return overall_f1\n",
        "\n",
        "#@ IMPLEMENTATION OF WEIGHTED F1: \n",
        "print(weighted_f1(y_true, y_pred))                            # Getting f1 score. \n",
        "metrics.f1_score(y_true, y_pred, average=\"weighted\")          # Getting f1 score. "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.41269841269841273\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.41269841269841273"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 635
        },
        "id": "ZlFTAtBMFVtY",
        "outputId": "1a6caf00-3651-4704-b76a-a0c77e9215f6"
      },
      "source": [
        "#@ PLOTTING CONFUSION MATRIX: \n",
        "cm = metrics.confusion_matrix(y_true, y_pred)                 # Initializing confusion matrix. \n",
        "plt.figure(figsize=(10, 10))\n",
        "cmap = sns.cubehelix_palette(50, hue=0.05, rot=0, light=0.9, \n",
        "                             dark=0, as_cmap=True)\n",
        "sns.set(font_scale=2.5)\n",
        "sns.heatmap(cm, annot=True, cmap=cmap, cbar=False)\n",
        "plt.xlabel(\"Predicted Labels\", fontsize=20)\n",
        "plt.ylabel(\"Actual Labels\", fontsize=20)\n",
        "plt.show();"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zzgRZofJKwW_"
      },
      "source": [
        "#@ INITIALIZING PRECISION FOR MULTILABEL CLASSIFICATION: \n",
        "def pk(y_true, y_pred, k):                                      # Defining Function. \n",
        "    \"\"\"\n",
        "    Function to calculate precision at k. \n",
        "    :param y_true: list of actual classes values. \n",
        "    :param y_pred: list of predicted classes values. \n",
        "    :param k: the value for k. \n",
        "    :return: precision at a given value k. \n",
        "    \"\"\"\n",
        "    if k==0: return 0\n",
        "    y_pred = y_pred[:k]                                         # Initializing top k predictions. \n",
        "    pred_set = set(y_pred)                                      # Converting predictions to set. \n",
        "    true_set = set(y_true)                                      # Converting actual values to set. \n",
        "    common_values = pred_set.intersection(true_set)             # Initializing common values. \n",
        "    return len(common_values) / len(y_pred[:k])\n",
        "\n",
        "def apk(y_true, y_pred, k):                                     # Defining Function. \n",
        "    \"\"\"\n",
        "    Function to calculate average precision at k. \n",
        "    :param y_true: list of actual classes values. \n",
        "    :param y_pred: list of predicted classes values. \n",
        "    :param k: the value for k. \n",
        "    :return: average precision at a given value k. \n",
        "    \"\"\"\n",
        "    pk_values = []                                              # Initialization. \n",
        "    for i in range(1, k + 1):\n",
        "        pk_values.append(pk(y_true, y_pred, i))                 # Calculating precision at k. \n",
        "    if len(pk_values) == 0: return 0\n",
        "    return sum(pk_values) / len(pk_values)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UIRX5oojRCsn",
        "outputId": "dc2d2348-0924-48cc-abd4-75012444da72"
      },
      "source": [
        "#@ AVERAGE PRECISION AT K: \n",
        "y_true = [[1, 2, 3], [0, 2], [1], [2, 3], [1, 0], []]           # Initialization. \n",
        "y_pred = [[0, 1, 2], [1], [0, 2, 3], [2, 3, 4, 0], [0, 1, 2], \n",
        "          [0]]                                                  # Initialization. \n",
        "for i in range(len(y_true)):\n",
        "    for j in range(1, 4):\n",
        "        print(\n",
        "            f\"\"\"\n",
        "            y_true={y_true[i]},\n",
        "            y_pred={y_pred[i]},\n",
        "            AP@{j}={apk(y_true[i], y_pred[i], k=j)}\n",
        "            \"\"\"\n",
        "        )"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "            y_true=[1, 2, 3],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@1=0.0\n",
            "            \n",
            "\n",
            "            y_true=[1, 2, 3],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@2=0.25\n",
            "            \n",
            "\n",
            "            y_true=[1, 2, 3],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@3=0.38888888888888884\n",
            "            \n",
            "\n",
            "            y_true=[0, 2],\n",
            "            y_pred=[1],\n",
            "            AP@1=0.0\n",
            "            \n",
            "\n",
            "            y_true=[0, 2],\n",
            "            y_pred=[1],\n",
            "            AP@2=0.0\n",
            "            \n",
            "\n",
            "            y_true=[0, 2],\n",
            "            y_pred=[1],\n",
            "            AP@3=0.0\n",
            "            \n",
            "\n",
            "            y_true=[1],\n",
            "            y_pred=[0, 2, 3],\n",
            "            AP@1=0.0\n",
            "            \n",
            "\n",
            "            y_true=[1],\n",
            "            y_pred=[0, 2, 3],\n",
            "            AP@2=0.0\n",
            "            \n",
            "\n",
            "            y_true=[1],\n",
            "            y_pred=[0, 2, 3],\n",
            "            AP@3=0.0\n",
            "            \n",
            "\n",
            "            y_true=[2, 3],\n",
            "            y_pred=[2, 3, 4, 0],\n",
            "            AP@1=1.0\n",
            "            \n",
            "\n",
            "            y_true=[2, 3],\n",
            "            y_pred=[2, 3, 4, 0],\n",
            "            AP@2=1.0\n",
            "            \n",
            "\n",
            "            y_true=[2, 3],\n",
            "            y_pred=[2, 3, 4, 0],\n",
            "            AP@3=0.8888888888888888\n",
            "            \n",
            "\n",
            "            y_true=[1, 0],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@1=1.0\n",
            "            \n",
            "\n",
            "            y_true=[1, 0],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@2=1.0\n",
            "            \n",
            "\n",
            "            y_true=[1, 0],\n",
            "            y_pred=[0, 1, 2],\n",
            "            AP@3=0.8888888888888888\n",
            "            \n",
            "\n",
            "            y_true=[],\n",
            "            y_pred=[0],\n",
            "            AP@1=0.0\n",
            "            \n",
            "\n",
            "            y_true=[],\n",
            "            y_pred=[0],\n",
            "            AP@2=0.0\n",
            "            \n",
            "\n",
            "            y_true=[],\n",
            "            y_pred=[0],\n",
            "            AP@3=0.0\n",
            "            \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLne2wxOwSo9"
      },
      "source": [
        "**REGRESSION: EVALUATION METRICS:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XsMsZ6_kSgE4"
      },
      "source": [
        "#@ INITIALIZING MEAN ABSOLUTE ERROR: \n",
        "def mean_absolute_error(y_true, y_pred):                     # Defining MAE Function. \n",
        "    \"\"\"\n",
        "    Function to calculate mae. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mean absolute error. \n",
        "    \"\"\"\n",
        "    error = 0                                                # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        error += np.abs(yt - yp)                             # Calculating Absolute Error. \n",
        "    return error / len(y_true)                               # Getting Mean Error. \n",
        "\n",
        "#@ INITIALIZING MEAN SQUARED ERROR: \n",
        "def mean_squared_error(y_true, y_pred):                     # Defining MSE Function. \n",
        "    \"\"\"\n",
        "    Function to calculate mse. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mean squared error. \n",
        "    \"\"\"\n",
        "    error = 0                                                # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        error += (yt - yp)**2                                # Calculating Squared Error. \n",
        "    return error / len(y_true)                               # Getting Mean Error. \n",
        "\n",
        "#@ INITIALIZING MEAN SQUARED LOGARITHMETIC ERROR: \n",
        "def mean_squared_log_error(y_true, y_pred):                  # Defining MSLE Function. \n",
        "    \"\"\"\n",
        "    Function to calculate msle. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mean squared logarithmetic error. \n",
        "    \"\"\"\n",
        "    error = 0                                                # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        error += (np.log(1 + yt) - np.log(1 + yp))**2        # Calculating MSL Error. \n",
        "    return error / len(y_true)                               # Getting Mean Error. "
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O6WDqgBzqYBc"
      },
      "source": [
        "#@ INITIALIZING MEAN PERCENTAGE ERROR: \n",
        "def mean_percentage_error(y_true, y_pred):                   # Defining MPE Function. \n",
        "    \"\"\"\n",
        "    Function to calculate mpe. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mean percentage error. \n",
        "    \"\"\"\n",
        "    error = 0                                                # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        error += (yt - yp) / yt                              # Calculating Percentage Error. \n",
        "    return error / len(y_true)                               # Getting Mean Error. \n",
        "\n",
        "#@ INITIALIZING MEAN ABSOLUTE PERCENTAGE ERROR: \n",
        "def mean_abs_percentage_error(y_true, y_pred):               # Defining MAPE Function. \n",
        "    \"\"\"\n",
        "    Function to calculate mape. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mean absolute percentage error. \n",
        "    \"\"\"\n",
        "    error = 0                                                # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        error += np.abs(yt - yp) / yt                        # Calculating Percentage Error. \n",
        "    return error / len(y_true)                               # Getting Mean Error. \n",
        "\n",
        "#@ INITIALIZING R-SQUARED ERROR: \n",
        "def r2(y_true, y_pred):                                      # Defining R2 Function. \n",
        "    \"\"\"\n",
        "    Function to calculate r-squared score. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: r2 score. \n",
        "    \"\"\"\n",
        "    mean_true_value = np.mean(y_true)                        # Getting Mean Values. \n",
        "    numerator, denominator = 0, 0                            # Initialization. \n",
        "    for yt, yp in zip(y_true, y_pred):                       # Iterating over Lists.\n",
        "        numerator += (yt - yp)**2                            # Getting MSE. \n",
        "        denominator += (yt - mean_true_value)**2\n",
        "    ratio = numerator / denominator                            \n",
        "    return 1 - ratio"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xKUSWDkCuXyw",
        "outputId": "01db93b9-cd72-4d2a-9b7f-2b4555db4978"
      },
      "source": [
        "#@ INITIALIZING QUADRATIC WEIGHTED KAPPA SCORE: \n",
        "y_true =  [1, 2, 3, 1, 2, 3, 1, 2, 3]                         # Initialization. \n",
        "y_pred =  [2, 1, 3, 1, 2, 3, 3, 1, 2]                         # Initialization. \n",
        "metrics.cohen_kappa_score(y_true,y_pred,weights=\"quadratic\")  # Inspection. "
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.33333333333333337"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xpnmUWaUwFBB"
      },
      "source": [
        "#@ INITIALIZING MCC SCORE: BINARY CLASSIFICATION: \n",
        "def mcc(y_true, y_pred):                                      # Defining MCC Function. \n",
        "    \"\"\"\n",
        "    Function to calculate mcc score. \n",
        "    :param y_true: list of true values. \n",
        "    :param y_pred: list of predicted values. \n",
        "    :return: mcc score. \n",
        "    \"\"\"\n",
        "    tp = true_positive(y_true, y_pred)                        # Getting True Positive Value. \n",
        "    tn = true_negative(y_true, y_pred)                        # Getting True Negative Value.\n",
        "    fn = false_negative(y_true, y_pred)                       # Getting False Negative Value. \n",
        "    fp = false_positive(y_true, y_pred)                       # Getting False Positive Value. \n",
        "    numerator = (tp * tn) - (fp * fn)\n",
        "    denominator = (tp+fp) * (fn+tn) * (fp+tn) * (tp+fn)\n",
        "    denominator = denominator ** 0.5\n",
        "    return numerator / denominator "
      ],
      "execution_count": 24,
      "outputs": []
    }
  ]
}