notebooks/Evaluation_Measure_Process.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ACM ML Team - Evaluation",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ljKwK9EBL8Cg"
      },
      "source": [
        "# Evaluation Measures # "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "epFFpbv4f3I0"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn import datasets\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score\n",
        "from sklearn.utils.multiclass import unique_labels"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W13rZcTufSpI"
      },
      "source": [
        "## Classification Measures ##\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FfMlEdmrgEpU"
      },
      "source": [
        "def plot_confusion_matrix(y_true, y_pred, classes,cmap=plt.cm.Blues):\n",
        "    \"\"\"\n",
        "    This function prints and plots the confusion matrix.\n",
        "    \"\"\"\n",
        "\n",
        "    # Compute confusion matrix\n",
        "    cm = confusion_matrix(y_true, y_pred)\n",
        "    # Only use the labels that appear in the data\n",
        "    classes = classes[unique_labels(y_true, y_pred)]\n",
        "\n",
        "    print(cm)\n",
        "\n",
        "    fig, ax = plt.subplots()\n",
        "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    ax.figure.colorbar(im, ax=ax)\n",
        "    # We want to show all ticks...\n",
        "    ax.set(xticks=np.arange(cm.shape[1]),\n",
        "           yticks=np.arange(cm.shape[0]),\n",
        "           # ... and label them with the respective list entries\n",
        "           xticklabels=classes, yticklabels=classes,\n",
        "           title=\"Confusion Matrix\",\n",
        "           ylabel='True label',\n",
        "           xlabel='Predicted label')\n",
        "\n",
        "    # Rotate the tick labels and set their alignment.\n",
        "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
        "             rotation_mode=\"anchor\")\n",
        "\n",
        "    # Loop over data dimensions and create text annotations.\n",
        "    fmt = 'd'\n",
        "    thresh = cm.max() / 2.\n",
        "    for i in range(cm.shape[0]):\n",
        "        for j in range(cm.shape[1]):\n",
        "            ax.text(j, i, format(cm[i, j], fmt),\n",
        "                    ha=\"center\", va=\"center\",\n",
        "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "    fig.tight_layout()\n",
        "    return ax"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jx7_PM1ajEN5",
        "outputId": "730b7ae7-8731-4a26-c316-a73edaeca2c8"
      },
      "source": [
        "# import some data to play with\r\n",
        "iris = datasets.load_iris()\r\n",
        "print(iris.DESCR)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            ".. _iris_dataset:\n",
            "\n",
            "Iris plants dataset\n",
            "--------------------\n",
            "\n",
            "**Data Set Characteristics:**\n",
            "\n",
            "    :Number of Instances: 150 (50 in each of three classes)\n",
            "    :Number of Attributes: 4 numeric, predictive attributes and the class\n",
            "    :Attribute Information:\n",
            "        - sepal length in cm\n",
            "        - sepal width in cm\n",
            "        - petal length in cm\n",
            "        - petal width in cm\n",
            "        - class:\n",
            "                - Iris-Setosa\n",
            "                - Iris-Versicolour\n",
            "                - Iris-Virginica\n",
            "                \n",
            "    :Summary Statistics:\n",
            "\n",
            "    ============== ==== ==== ======= ===== ====================\n",
            "                    Min  Max   Mean    SD   Class Correlation\n",
            "    ============== ==== ==== ======= ===== ====================\n",
            "    sepal length:   4.3  7.9   5.84   0.83    0.7826\n",
            "    sepal width:    2.0  4.4   3.05   0.43   -0.4194\n",
            "    petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)\n",
            "    petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)\n",
            "    ============== ==== ==== ======= ===== ====================\n",
            "\n",
            "    :Missing Attribute Values: None\n",
            "    :Class Distribution: 33.3% for each of 3 classes.\n",
            "    :Creator: R.A. Fisher\n",
            "    :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n",
            "    :Date: July, 1988\n",
            "\n",
            "The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\n",
            "from Fisher's paper. Note that it's the same as in R, but not as in the UCI\n",
            "Machine Learning Repository, which has two wrong data points.\n",
            "\n",
            "This is perhaps the best known database to be found in the\n",
            "pattern recognition literature.  Fisher's paper is a classic in the field and\n",
            "is referenced frequently to this day.  (See Duda & Hart, for example.)  The\n",
            "data set contains 3 classes of 50 instances each, where each class refers to a\n",
            "type of iris plant.  One class is linearly separable from the other 2; the\n",
            "latter are NOT linearly separable from each other.\n",
            "\n",
            ".. topic:: References\n",
            "\n",
            "   - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n",
            "     Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n",
            "     Mathematical Statistics\" (John Wiley, NY, 1950).\n",
            "   - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n",
            "     (Q327.D83) John Wiley & Sons.  ISBN 0-471-22361-1.  See page 218.\n",
            "   - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n",
            "     Structure and Classification Rule for Recognition in Partially Exposed\n",
            "     Environments\".  IEEE Transactions on Pattern Analysis and Machine\n",
            "     Intelligence, Vol. PAMI-2, No. 1, 67-71.\n",
            "   - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\".  IEEE Transactions\n",
            "     on Information Theory, May 1972, 431-433.\n",
            "   - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al\"s AUTOCLASS II\n",
            "     conceptual clustering system finds 3 classes in the data.\n",
            "   - Many, many more ...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o8Xte9znfZZ3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 353
        },
        "outputId": "978c4643-2e96-4803-df6d-481c43012dbb"
      },
      "source": [
        "\n",
        "X = iris.data\n",
        "y = iris.target\n",
        "class_names = iris.target_names\n",
        "\n",
        "# Split the data into a training set and a test set\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0,shuffle=True)\n",
        "\n",
        "classifier =  LogisticRegression(random_state=6,max_iter=1000)\n",
        "y_pred = classifier.fit(X_train, y_train).predict(X_test)\n",
        "\n",
        "# Plot confusion matrix\n",
        "plot_confusion_matrix(y_test, y_pred, classes=class_names)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[13  0  0]\n",
            " [ 0 15  1]\n",
            " [ 0  0  9]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EPQ_p3PwhnXY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "622dd1f0-7fab-4ffb-cc19-49d62bced1b9"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, log_loss\n",
        "# Accuracy\n",
        "print(\"Accuracy:\" + str(accuracy_score(y_test,y_pred)))\n",
        "# F1 Score\n",
        "print(\"F1-Score:\" + str(f1_score(y_test,y_pred,average='macro')))\n",
        "# Precision \n",
        "print(\"Precision:\" + str(precision_score(y_test,y_pred,average='macro')))\n",
        "# Recall \n",
        "print(\"Recall:\" + str(recall_score(y_test,y_pred,average='macro')))\n",
        "\n",
        "# Use average parameter on multi-class problems - the way it averages over classes.\n",
        "\n",
        "# Log loss - It only works with classifiers that support predict_proba\n",
        "print(\"Log Loss:\" + str(log_loss(y_test,classifier.predict_proba(X_test))))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy:0.9736842105263158\n",
            "F1-Score:0.9717034521788342\n",
            "Precision:0.9666666666666667\n",
            "Recall:0.9791666666666666\n",
            "Log Loss:0.17161639050637115\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a1m32hyEajLw"
      },
      "source": [
        "You can find all the metrics available in scikit-learn in the page [here](https://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "POfgDRLzfV4a"
      },
      "source": [
        "## Regression ##"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cBUVDuX8KfQ3"
      },
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.datasets import load_diabetes\n",
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JMmSbL9gpbdI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13e6c01d-17c8-456a-9bc6-8adb577f8edd"
      },
      "source": [
        "# import some data to play with\n",
        "diabetes = datasets.load_diabetes()\n",
        "print(diabetes.DESCR)\n",
        "X = diabetes.data\n",
        "y = diabetes.target\n",
        "\n",
        "\n",
        "# Split the data into a training set and a test set\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0,shuffle=True)\n",
        "\n",
        "classifier =  LinearRegression()\n",
        "y_pred = classifier.fit(X_train, y_train).predict(X_test)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            ".. _diabetes_dataset:\n",
            "\n",
            "Diabetes dataset\n",
            "----------------\n",
            "\n",
            "Ten baseline variables, age, sex, body mass index, average blood\n",
            "pressure, and six blood serum measurements were obtained for each of n =\n",
            "442 diabetes patients, as well as the response of interest, a\n",
            "quantitative measure of disease progression one year after baseline.\n",
            "\n",
            "**Data Set Characteristics:**\n",
            "\n",
            "  :Number of Instances: 442\n",
            "\n",
            "  :Number of Attributes: First 10 columns are numeric predictive values\n",
            "\n",
            "  :Target: Column 11 is a quantitative measure of disease progression one year after baseline\n",
            "\n",
            "  :Attribute Information:\n",
            "      - Age\n",
            "      - Sex\n",
            "      - Body mass index\n",
            "      - Average blood pressure\n",
            "      - S1\n",
            "      - S2\n",
            "      - S3\n",
            "      - S4\n",
            "      - S5\n",
            "      - S6\n",
            "\n",
            "Note: Each of these 10 feature variables have been mean centered and scaled by the standard deviation times `n_samples` (i.e. the sum of squares of each column totals 1).\n",
            "\n",
            "Source URL:\n",
            "https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html\n",
            "\n",
            "For more information see:\n",
            "Bradley Efron, Trevor Hastie, Iain Johnstone and Robert Tibshirani (2004) \"Least Angle Regression,\" Annals of Statistics (with discussion), 407-499.\n",
            "(https://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W-I0fR1pptnU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39e6bc30-df7a-4bc3-a5e3-17cecd1cf781"
      },
      "source": [
        "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error\n",
        "# MAE\n",
        "print(\"MAE:\" + str(mean_absolute_error(y_test,y_pred)))\n",
        "# Root Mean Sqaured Error\n",
        "print(\"Root Mean Squared Error:\" + str(mean_squared_error(y_test,y_pred) ** (1/2)))\n",
        "# R2 Score\n",
        "print(\"R2_Score:\" + str(r2_score(y_test,y_pred)))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "MAE:45.120987683251016\n",
            "Root Mean Squared Error:56.393251695949644\n",
            "R2_Score:0.35940090989715534\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IFeusEbOpbec"
      },
      "source": [
        "You can find all the available regression measures in the page [here](https://scikit-learn.org/stable/modules/model_evaluation.html#regression-metrics)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MMaHiR7iL36V"
      },
      "source": [
        "# Evaluation Process #"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kpus_aoHzwPs"
      },
      "source": [
        "#Imports\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.datasets import load_diabetes\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.utils  import resample\n",
        "from sklearn.tree import DecisionTreeRegressor\n",
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9q0BFkc_t13T"
      },
      "source": [
        "## Train, Validation and Test Set ## "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bkXFSzWmveS3"
      },
      "source": [
        "from sklearn.datasets import load_breast_cancer"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ENCvI0ZsvmTa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fcca3348-8628-41f6-ff5f-a239fb4d1b52"
      },
      "source": [
        "cancer_dataset = load_breast_cancer()\n",
        "print(cancer_dataset.DESCR[:1200])\n",
        "X = cancer_dataset.data\n",
        "y = cancer_dataset.target\n",
        "model = LogisticRegression(random_state = 6, max_iter=1000)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            ".. _breast_cancer_dataset:\n",
            "\n",
            "Breast cancer wisconsin (diagnostic) dataset\n",
            "--------------------------------------------\n",
            "\n",
            "**Data Set Characteristics:**\n",
            "\n",
            "    :Number of Instances: 569\n",
            "\n",
            "    :Number of Attributes: 30 numeric, predictive attributes and the class\n",
            "\n",
            "    :Attribute Information:\n",
            "        - radius (mean of distances from center to points on the perimeter)\n",
            "        - texture (standard deviation of gray-scale values)\n",
            "        - perimeter\n",
            "        - area\n",
            "        - smoothness (local variation in radius lengths)\n",
            "        - compactness (perimeter^2 / area - 1.0)\n",
            "        - concavity (severity of concave portions of the contour)\n",
            "        - concave points (number of concave portions of the contour)\n",
            "        - symmetry \n",
            "        - fractal dimension (\"coastline approximation\" - 1)\n",
            "\n",
            "        The mean, standard error, and \"worst\" or largest (mean of the three\n",
            "        largest values) of these features were computed for each image,\n",
            "        resulting in 30 features.  For instance, field 3 is Mean Radius, field\n",
            "        13 is Radius SE, field 23 is Worst Radius.\n",
            "\n",
            "        - class:\n",
            "                - WDBC-Malignant\n",
            "                - WDBC-Benign\n",
            "\n",
            "    :Summary Statistics:\n",
            "\n",
            "    ================================\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C6Ob3azow5tf"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)\n",
        "\n",
        "X_train, X_val, y_train, y_val  = train_test_split(X_train, y_train, test_size=0.2, random_state=1)\n",
        "\n",
        "# Alternatively we can split the initial dataset as 60% - 20% - 20%"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MHSsUXLExq-7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04c70b65-5b49-40b5-a93f-47c59c80b930"
      },
      "source": [
        "# Let's tune the regularization of the model using the f1_score score\n",
        "\n",
        "predictions = [ ]\n",
        "\n",
        "for reg in range(1,10):\n",
        "  reg = reg/10\n",
        "  model = LogisticRegression(C=reg, random_state = 6, max_iter = 10000)\n",
        "  model.fit(X_train,y_train)\n",
        "  pred = model.predict(X_val)\n",
        "  predictions.append([reg,f1_score(y_val,pred)])\n",
        "  \n",
        "print(predictions)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.1, 0.9743589743589743], [0.2, 0.9743589743589743], [0.3, 0.9743589743589743], [0.4, 0.9743589743589743], [0.5, 0.9743589743589743], [0.6, 0.9743589743589743], [0.7, 0.9743589743589743], [0.8, 0.9661016949152542], [0.9, 0.9661016949152542]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8qjLWwh0z58d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a9492323-21a6-4a1b-e015-c679693b74a5"
      },
      "source": [
        "  #Use the model of the validation test on the test set\n",
        "  \n",
        "  model = LogisticRegression(C=0.2, random_state = 6, max_iter=10000)\n",
        "  \n",
        "  pred = model.fit(X_train,y_train).predict(X_test)\n",
        "  print(\"Accuracy score on test set with just the training set:\" + str(accuracy_score(y_test,pred)))\n",
        "  \n",
        "  \n",
        "  \n",
        "  pred = model.fit(np.concatenate((X_train,X_val)),np.concatenate((y_train,y_val))).predict(X_test)\n",
        "  print(\"Accuracy score on test set with the training set and the validation set:\" + str(accuracy_score(y_test,pred)))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy score on test set with just the training set:0.8771929824561403\n",
            "Accuracy score on test set with the training set and the validation set:0.8771929824561403\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-NSLRZY4L44"
      },
      "source": [
        "## Cross Validation ## \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pD31_WFM4O0L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4977d83a-2cbd-4b51-b65e-eb0375abc333"
      },
      "source": [
        "# Repeated Holdout\n",
        "\n",
        "iterations =  10\n",
        "\n",
        "model = LogisticRegression(max_iter=10000, random_state = 6)\n",
        "\n",
        "accuracies = []\n",
        "for i in range(0,iterations):\n",
        "  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=i)\n",
        "  pred = model.fit(X_train,y_train).predict(X_test)\n",
        "  accuracies.append(accuracy_score(y_test,pred))\n",
        "  \n",
        "print(accuracies)\n",
        "sm = sum(accuracies[0:len(accuracies)])\n",
        "print(\"Average:\" + str(sm/iterations))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.9473684210526315, 0.9473684210526315, 0.9298245614035088, 0.9385964912280702, 0.9122807017543859, 0.9649122807017544, 0.9385964912280702, 0.9473684210526315, 0.9649122807017544, 0.9385964912280702]\n",
            "Average:0.9429824561403508\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4kqtybV5vsW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8c5ce2a-7ec5-47f1-9178-be325fda21b9"
      },
      "source": [
        "# K fold cross validation\n",
        "from sklearn.model_selection import KFold\n",
        "\n",
        "iterations =  20\n",
        "\n",
        "model = LogisticRegression(max_iter = 10000, random_state = 6)\n",
        "\n",
        "kf = KFold(n_splits=iterations)\n",
        "\n",
        "\n",
        "accuracies = []\n",
        "\n",
        "for train_index, test_index in kf.split(X):\n",
        "  X_train, X_test = X[train_index], X[test_index]\n",
        "  y_train, y_test = y[train_index], y[test_index]\n",
        "  pred = model.fit(X_train,y_train).predict(X_test)\n",
        "  accuracies.append(accuracy_score(y_test,pred))\n",
        "  \n",
        "print(accuracies)\n",
        "sm = sum(accuracies[0:len(accuracies)])\n",
        "print(\"Average:\" + str(sm/iterations))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.9310344827586207, 0.8275862068965517, 0.9310344827586207, 0.9655172413793104, 0.9655172413793104, 0.9310344827586207, 1.0, 0.9655172413793104, 0.9310344827586207, 0.9642857142857143, 0.9285714285714286, 1.0, 1.0, 0.9642857142857143, 0.9285714285714286, 0.9642857142857143, 0.9285714285714286, 0.9642857142857143, 0.9642857142857143, 0.9285714285714286]\n",
            "Average:0.9491995073891625\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "23Ax7dGoLu0f"
      },
      "source": [
        "## Stratified k-fold ## "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvDnpffkL_Ak",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d250b8dd-458c-45f6-a53d-263a9822ebec"
      },
      "source": [
        "from sklearn.model_selection import StratifiedKFold\n",
        "\n",
        "skf = StratifiedKFold(n_splits=10)\n",
        "model = LogisticRegression(max_iter=10000, random_state = 6)\n",
        "\n",
        "accuracies = []\n",
        "\n",
        "for train_index, test_index in skf.split(X,y): \n",
        "  X_train, X_test = X[train_index], X[test_index]\n",
        "  y_train, y_test = y[train_index], y[test_index]\n",
        "  print(\"train:\")\n",
        "  print(np.unique(y_train,return_counts=True))\n",
        "  print(\"test:\")\n",
        "  print(np.unique(y_test,return_counts=True))\n",
        "\n",
        "  pred = model.fit(X_train,y_train).predict(X_test)\n",
        "  accuracies.append(accuracy_score(y_test,pred))\n",
        "  \n",
        "print(accuracies)\n",
        "sm = sum(accuracies[0:len(accuracies)])\n",
        "print(\"Average:\" + str(sm/iterations))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "train:\n",
            "(array([0, 1]), array([190, 322]))\n",
            "test:\n",
            "(array([0, 1]), array([22, 35]))\n",
            "train:\n",
            "(array([0, 1]), array([190, 322]))\n",
            "test:\n",
            "(array([0, 1]), array([22, 35]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 321]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 36]))\n",
            "train:\n",
            "(array([0, 1]), array([191, 322]))\n",
            "test:\n",
            "(array([0, 1]), array([21, 35]))\n",
            "[0.9824561403508771, 0.9122807017543859, 0.9298245614035088, 0.9473684210526315, 0.9824561403508771, 0.9824561403508771, 0.9298245614035088, 0.9473684210526315, 0.9649122807017544, 0.9642857142857143]\n",
            "Average:0.47716165413533834\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BIWqYkgTNudE"
      },
      "source": [
        "## Limited Data ##\n",
        "\n",
        "Leave-one-out cross-validation [(LOO)](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeaveOneOut.html)\n",
        "\n",
        "For bagging you can use the resample function with replacement (default) and combine the score manually. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IIz2TV_SoZ68"
      },
      "source": [
        "## Learning Curves ##"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tBVxaezcpIff"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.datasets import load_digits,load_iris,load_wine,load_breast_cancer\n",
        "from sklearn.model_selection import learning_curve\n",
        "from sklearn.model_selection import ShuffleSplit"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wbX9aZLToZQa"
      },
      "source": [
        "def plot_learning_curve(estimator, title, X, y, axes=None, ylim=None, cv=None,\n",
        "                        n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\n",
        "  \n",
        "    if axes is None:\n",
        "        _, axes = plt.subplots(1, 3, figsize=(20, 5))\n",
        "\n",
        "    axes[0].set_title(title)\n",
        "    if ylim is not None:\n",
        "        axes[0].set_ylim(*ylim)\n",
        "    axes[0].set_xlabel(\"Training examples\")\n",
        "    axes[0].set_ylabel(\"Score\")\n",
        "\n",
        "    train_sizes, train_scores, test_scores, fit_times, _ = \\\n",
        "        learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs,\n",
        "                       train_sizes=train_sizes,\n",
        "                       return_times=True)\n",
        "    train_scores_mean = np.mean(train_scores, axis=1)\n",
        "    train_scores_std = np.std(train_scores, axis=1)\n",
        "    test_scores_mean = np.mean(test_scores, axis=1)\n",
        "    test_scores_std = np.std(test_scores, axis=1)\n",
        "    fit_times_mean = np.mean(fit_times, axis=1)\n",
        "    fit_times_std = np.std(fit_times, axis=1)\n",
        "\n",
        "    # Plot learning curve\n",
        "    axes[0].grid()\n",
        "    axes[0].fill_between(train_sizes, train_scores_mean - train_scores_std,\n",
        "                         train_scores_mean + train_scores_std, alpha=0.1,\n",
        "                         color=\"r\")\n",
        "    axes[0].fill_between(train_sizes, test_scores_mean - test_scores_std,\n",
        "                         test_scores_mean + test_scores_std, alpha=0.1,\n",
        "                         color=\"g\")\n",
        "    axes[0].plot(train_sizes, train_scores_mean, 'o-', color=\"r\",\n",
        "                 label=\"Training score\")\n",
        "    axes[0].plot(train_sizes, test_scores_mean, 'o-', color=\"g\",\n",
        "                 label=\"Cross-validation score\")\n",
        "    axes[0].legend(loc=\"best\")\n",
        "\n",
        "    # Plot n_samples vs fit_times\n",
        "    axes[1].grid()\n",
        "    axes[1].plot(train_sizes, fit_times_mean, 'o-')\n",
        "    axes[1].fill_between(train_sizes, fit_times_mean - fit_times_std,\n",
        "                         fit_times_mean + fit_times_std, alpha=0.1)\n",
        "    axes[1].set_xlabel(\"Training examples\")\n",
        "    axes[1].set_ylabel(\"fit_times\")\n",
        "    axes[1].set_title(\"Scalability of the model\")\n",
        "\n",
        "    # Plot fit_time vs score\n",
        "    axes[2].grid()\n",
        "    axes[2].plot(fit_times_mean, test_scores_mean, 'o-')\n",
        "    axes[2].fill_between(fit_times_mean, test_scores_mean - test_scores_std,\n",
        "                         test_scores_mean + test_scores_std, alpha=0.1)\n",
        "    axes[2].set_xlabel(\"fit_times\")\n",
        "    axes[2].set_ylabel(\"Score\")\n",
        "    axes[2].set_title(\"Performance of the model\")\n",
        "\n",
        "    return plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FUHp8F67pDqY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 894
        },
        "outputId": "1ae20c73-82bf-49f6-f320-9b8c25323298"
      },
      "source": [
        "\n",
        "fig, axes = plt.subplots(3, 2, figsize=(10, 15))\n",
        "\n",
        "X, y = load_digits(return_X_y=True)\n",
        "\n",
        "title = \"Learning Curves Decision Tree\"\n",
        "# Cross validation with 100 iterations to get smoother mean test and train\n",
        "# score curves, each time with 20% data randomly selected as a validation set.\n",
        "cv = ShuffleSplit(n_splits=10, test_size=0.2, random_state=0)\n",
        "estimator = LogisticRegression(random_state=42,max_iter=10000)\n",
        "plot_learning_curve(estimator, title, X, y, axes=axes[:, 0], ylim=(0.6, 1.01),\n",
        "                    cv=cv, n_jobs=-1)\n",
        "\n",
        "title = r\"Learning Curves Logistic Regression\"\n",
        "# SVC is more expensive so we do a lower number of CV iterations:\n",
        "cv = ShuffleSplit(n_splits=10, test_size=0.2, random_state=0)\n",
        "estimator = LogisticRegression(C=0.3,max_iter=10000,random_state=42)\n",
        "plot_learning_curve(estimator, title, X, y, axes=axes[:, 1], ylim=(0.6, 1.01),\n",
        "                    cv=cv, n_jobs=-1)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x1080 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}