ML_example5.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO0gHQbomQ+BZvLJVRfrEFq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jmbanda/CSC4850-Machine-Learning/blob/main/ML_example5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Multilayer Perceptron (MLP)\n",
        "\n",
        "Salient points of Multilayer Perceptron (MLP) in Scikit-learn\n",
        "\n",
        "There is no activation function in the output layer.\n",
        "\n",
        "For regression scenarios, the square error is the loss function, and cross-entropy is the loss function for the classification\n",
        "\n",
        "It can work with single as well as multiple target values regression.\n",
        "\n",
        "Unlike other popular packages, likes Keras the implementation of MLP in Scikit doesn’t support GPU.\n",
        "\n",
        "We cannot fine-tune the parameters like different activation functions, weight initializers etc. for each layer."
      ],
      "metadata": {
        "id": "HAs4SuJup5fZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Regression Example\n",
        "\n",
        "Step 1: In the Scikit-Learn package, MLPRegressor is implemented in neural_network module. We will import the other modules like “train_test_split” to split the dataset into training and train set to test the model, “fetch_california_housing” to get the data, and “StandardScaler” to scale the data as different features( independent variables) have wide value range scale. It is very important to scale the data used for training the model.\n",
        "\n",
        "You can learn more about different scalers in the article Feature Scaling — [Effect Of Different Scikit-Learn Scalers: Deep Dive](https://towardsdatascience.com/feature-scaling-effect-of-different-scikit-learn-scalers-deep-dive-8dec775d4946)"
      ],
      "metadata": {
        "id": "tz3TikXPpLbj"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_-IFX4C3pK6I"
      },
      "outputs": [],
      "source": [
        "from sklearn.neural_network import MLPRegressor\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.datasets import fetch_california_housing\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.metrics import r2_score\n",
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 2: We will split the dataset into train and test dataset. We have reserved 20% of the dataset for checking the accuracy of the trained model. Independent train and test dataset are further scaled to make sure that the input data is standard normally distributed are centred around zero and have variance in the same order."
      ],
      "metadata": {
        "id": "VkI-bwhYqNPQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cal_housing = fetch_california_housing()\n",
        "X = pd.DataFrame(cal_housing.data,columns=cal_housing.feature_names)\n",
        "y = cal_housing.target\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y,random_state=1, test_size=0.2)"
      ],
      "metadata": {
        "id": "PquCa255pO69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 3: We scale the data just like the above regression example and for the same reason."
      ],
      "metadata": {
        "id": "6VgRyOhPqPAe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sc_X = StandardScaler()\n",
        "X_trainscaled=sc_X.fit_transform(X_train)\n",
        "X_testscaled=sc_X.transform(X_test)\n"
      ],
      "metadata": {
        "id": "PJRQxF_epT_E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 4: In the below code, three hidden layers are modelled, with 64 neurons in each layer. Considering the input and output layer, we have a total of 5 layers in the model. In case any optimiser is not mentioned then “Adam” is the default optimiser and it can manage pretty large dataset."
      ],
      "metadata": {
        "id": "Hl0UEl7-qRbv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "reg = MLPRegressor(hidden_layer_sizes=(64,64,64),activation=\"relu\" ,random_state=1, max_iter=2000).fit(X_trainscaled, y_train)"
      ],
      "metadata": {
        "id": "HjW3yaIgqTPS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In addition to “RELU” activation, MLPRegressor supports the “sigmoid” and “hyperbolic tan” function.\n",
        "\n",
        "Step 5: In the below code, the trained model is used to predict the target values of the reserved test dataset, which model has not seen before."
      ],
      "metadata": {
        "id": "-a6KExggqayk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred=reg.predict(X_testscaled)\n",
        "print(\"The Score with \", (r2_score(y_pred, y_test)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJGm9G4RpaOb",
        "outputId": "8573561d-7bd7-4221-ca1a-8f848135faf2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Score with  0.7633133194206162\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Classification Example\n",
        "\n",
        "We have seen a regression example. Next, we will go through a classification example. In Scikit-learn “ MLPClassifier” is available for Multilayer Perceptron (MLP) classification scenarios.\n",
        "\n",
        "Step1: Like always first we will import the modules which we will use in the example. We will use the Iris database and MLPClassifierfrom for the classification example."
      ],
      "metadata": {
        "id": "TULwDMQ3pj40"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.datasets import load_iris\n",
        "from sklearn.neural_network import MLPClassifier \n",
        "from sklearn.model_selection import train_test_split \n",
        "from sklearn.preprocessing import StandardScaler\n",
        "import pandas as pd\n",
        "from sklearn.metrics import ConfusionMatrixDisplay\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "NjEpKtxdplCS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 2: In separate data frames “X” and “y”, the values of the independent and dependent features are stored.\n",
        "\n",
        "iris_data = load_iris()"
      ],
      "metadata": {
        "id": "TtyNWRerrmdl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "iris_data = load_iris()\n",
        "X = pd.DataFrame(iris_data.data, columns=iris_data.feature_names)\n",
        "y = iris_data.target"
      ],
      "metadata": {
        "id": "byAOruS_pnbK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 3: Similar to the regression example above we will split the dataset into train and test dataset. We have reserved 20% of the dataset for checking the accuracy of the trained model. Independent train and test dataset are further scaled to make sure that the input data is standard normally distributed are centred around zero and have variance in the same order."
      ],
      "metadata": {
        "id": "BUd5UPAcs-rq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=1, test_size=0.2)\n",
        "sc_X = StandardScaler()\n",
        "X_trainscaled=sc_X.fit_transform(X_train)\n",
        "X_testscaled=sc_X.transform(X_test)"
      ],
      "metadata": {
        "id": "g1dyaM2jpq9p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 4: In the below code, we have modelled four hidden layers with different neurons in each layer. Considering the input and output layer, we have a total of 6 layers in the model. In case any optimiser is not mentioned then “Adam” is the default optimiser."
      ],
      "metadata": {
        "id": "2G5MH_uUtBKw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "clf = MLPClassifier(hidden_layer_sizes=(256,128,64,32),activation=\"relu\",random_state=1).fit(X_trainscaled, y_train)\n",
        "y_pred=clf.predict(X_testscaled)\n",
        "print(clf.score(X_testscaled, y_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OCKGuGmKpsxZ",
        "outputId": "2799039f-3381-438f-e95e-f1d50a78d836"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9666666666666667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The classifier shows quite a high score for the test data. It is important to understand the areas in which the classification model is making an error to make a full sense of model accuracy.\n",
        "\n",
        "Step 5: We will draw a confusion matrix to understand the classifications which are made incorrect by the model."
      ],
      "metadata": {
        "id": "HjtQcKjetEi7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "disp = ConfusionMatrixDisplay.from_estimator(\n",
        "  clf,\n",
        "  X_testscaled,\n",
        "  y_test,\n",
        "  display_labels=[\"Setosa\",\"Versicolor\",\"Virginica\"]\n",
        ")\n",
        "title=\"Confusion Matrix for Iris Dataset\"\n",
        "disp.ax_.set_title(title)\n",
        "\n",
        "print(disp.confusion_matrix)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 364
        },
        "id": "gHdVimOKpv84",
        "outputId": "c7fb8b14-d521-4949-d7a0-e99354e2ea02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix for Iris Dataset\n",
            "[[11  0  0]\n",
            " [ 0 12  1]\n",
            " [ 0  0  6]]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAEWCAYAAADFF0QYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAorklEQVR4nO3debxVZdn/8c+XGVQgBBFHyIFCzYlUtAy11FLTylKz0obHNCvNyurR1Cz92ZxD5UNmmANOaWaZ4oRDieKsaA45gyagoIgiHK7fH/d9ZLM7wz6bfdbeZ/t9v17rxRrvda3FPte+973WupciAjMzK0avegdgZvZ24qRrZlYgJ10zswI56ZqZFchJ18ysQE66ZmYFctLt4SQNlHSlpAWSLlmJcg6UNLWWsdWDpL9LOqjKbX8kaa6kF2odVzv7+19JZxWxL2scTroFkfRpSXdKWijp+Zwc3leDovcFRgKrR8Qnqy0kIs6PiF1rEM8KJE2UFJIuL5u/eZ4/rcJyTpB0XmfrRcSHI+KcKuJcD/gmMC4i1uzq9u2UGZI2bG95RJwcEV+qotynJL0u6VVJ8yX9U9Khkir6e5Y0OsfWp6v77mKcheynp3HSLYCko4BfASeTEuR6wG+AvWtQ/PrAoxGxtAZldZc5wARJq5fMOwh4tFY7ULIyn+f1gHkR8WIV++5yUqlBItorIlYj/f+fAnwH+P1KlmlFiAgP3TgAQ4CFwCc7WKc/KSnPzsOvgP552UTgOVIt7EXgeeDzedkPgDeBJXkfXwROAM4rKXs0EECfPH0w8ATwKvAkcGDJ/FtLttsemAEsyP9uX7JsGvBD4B+5nKnA8HaOrTX+M4HD87zewCzgOGBaybqnAs8CrwB3Ae/P83cvO877SuI4KcfxOrBhnvelvPy3wJ9Kyv8xcD2gshg/mLdflsufnOd/FJgJzM/lvrtkm6dIie5+YHHr+S0rN4AN8/gJwKXAefn4vlT6fwUMyMvm5f3NAEa2c06fAj5YNm+bHP+meXoP4J68r2eBE0rWfSbHtjAPE4ANgBvy/ucC5wNDS7b5Tv4/exV4BNglz+8FfBf4d972YmBYe/up999jIwx1D6DZh5wwlrb1R1myzonAdGANYATwT+CHednEvP2JQF/gI8Ai4B15+Vt/uO1Mj84f/D7AKvmPcGxeNgrYJI8fTE66wDDgZeCzebsD8vTqefm0/Ee2MTAwT5/SzrFNJCXd7YHb87yPANfkxDOtZN3PAKvnfX4TeAEY0NZxlcTxDLBJ3qYvKybdQaTa9MHA+3MyWaejOEumNwZeAz6Uyz0aeBzol5c/BdwLrAsMbKfM8qS7BNiHlKgGsmLS/TJwZY65N7A1MLidcp+iLOnm+c8Ah5Ucz2Z5X+8B/gPsU/6ZKNl2w3ys/UmfwZuBX+VlY0mJe62S7TfI40eQPrvr5G3/D5jS3n48hJsXCrA6MDc6/vl/IHBiRLwYEXNINdjPlixfkpcviYirSLWGsVXGswzYVNLAiHg+Ima2sc4ewGMRcW5ELI2IKcC/gL1K1vlDRDwaEa+TajdbdLTTiPgnMEzSWOBzwB/bWOe8iJiX9/lz0h9xZ8c5OSJm5m2WlJW3iHQef0GqRX4tIp7rpLxW+wF/i4hrc7k/IyXK7UvWOS0ins3noBK3RcSfI2JZG9ssIX1WNoyIloi4KyJeqbDcVrNJX5hExLSIeCDv635gCvCB9jaMiMfzsS7On8FflKzfQvq/GCepb0Q8FRH/zssOBY6JiOciYjHpi2Rft+O2z0m3+80DhnfyIVwLeLpk+uk8760yypL2ImDVrgYSEa+RksmhwPOS/ibpXRXE0xrT2iXTpVf4K43nXOCrwE7A5eULJX1L0sP5Toz5pKaZ4Z2U+WxHCyPidlJzikhfDpVa4RxExLK8r9Jz0OG+29DR+ueSav8XSpot6SeS+nax/LWBlwAkbSvpRklzJC0g/Z+3ey4ljZR0oaRZkl4hfUkNh5SQgSNJCfXFvF7r53N94PJ8QW8+8DApSY/sYuxvG0663e82UpvfPh2sM5v04W21Xp5XjddIP1FbrXAlPiKuiYgPkZoW/gX8roJ4WmOaVWVMrc4FvgJclWuhb5H0ftJP+E+Rmk6GktqT1Rp6O2V22E2epMNJtbTZufxKrXAOJInUlFB6DrraRV+76+dfMT+IiHGk2vSepF8EFZH0XlLSvTXPugD4C7BuRAwhtal3dC5PzvM3i4jBpKae1vWJiAsi4n2kcxKk9nFIXyQfjoihJcOAiJjV0fG+nTnpdrOIWEC6YPRrSftIGiSpr6QPS/pJXm0KcKykEZKG5/U7vT2qHfcCO0paT9IQ4HutC3JtZm9Jq5C+CBaSmhvKXQVsnG9z6yNpP2Ac8NcqYwIgIp4k/WQ9po3Fq5HarucAfSQdBwwuWf4fYHRX7lCQtDHwI1IC+SxwtKQtKtz8YmAPSbvkGuc3Sefsn5Xuvysk7SRpM0m9Se3uS2j7/6Z8u8GS9gQuJLUPP5AXrQa8FBFvSNoG+HTJZnNy2e8smbca6fOwQNLawLdL9jFW0s6S+gNvsPyiI6RkfpKk9fO6IyS13pXT1n7e9px0C5DbJ48CjiV9EJ8l/cz+c17lR8CdpCvhDwB353nV7Ota4KJc1l2smCh75Thmk36GfgA4rI0y5pFqWt8kNY8cDewZEXOriams7Fsjoq1a/DXA1aQLX0+T/rhLf463PvgxT9Ldne0nN+ecB/w4Iu6LiMeA/wXOzcmjszgfISXr00kX4PYi3ab1ZmfbVmlN0t0Nr5B+ot9E+mXQnislvUo6R8eQ2mA/X7L8K8CJeZ3jKGlayb8yTgL+kZsFtiNdR9iK9Ovib8BlJWX1J92WNpfUrLQGy7/MTyXVqKfmfU0Htu1gP297ivAvADOzorima2ZWICddM7NOSDpb0ouSHiyZ91NJ/5J0v6TLJQ2tpCwnXTOzzk0mPehU6lrSE4DvIV2L+F75Rm1x0jUz60RE3Ey+B7pk3tSS++dbn8rrlJ8aqcLQYb1j1Do+de2Z9cAq9Q7BmsCrvDw3IkZUu/1uO60S815qqWjdu+5fPJN0x0yrSRExqQu7+wLprqFOOXNUYdQ6ffjDlaPqHUbD+v6Y99Y7BGsC18Wl5U9Fdsncl1q4/ZqKKp/0HfXvNyJifDX7kXQM6R7z8ytZ30nXzJpU0BKdPl+yUiQdTLqnfZeo8P5bJ10za0oBLOvGJ5El7U56cOgD5Y+1d8RJ18ya1rLOn6SuiKQppO4yh0t6DjiedLdCf+Da1DUH0yPi0M7KctI1s6YUBEtq1LwQEQe0MbuqN3U46ZpZUwqgpQE7OnPSNbOm1Z1tutVy0jWzphRASwN26OWka2ZNq3tvGKuOk66ZNaUg3KZrZlaUCFjSeDnXSdfMmpVoWf6at4bhpGtmTSmAZa7pmpkVxzVdM7OCpIcjnHTNzAoRwJJovPc0OOmaWVMKREsDvhzHSdfMmtaycPOCmVkh3KZrZlYo0eI2XTOzYqQ3RzjpmpkVIkK8Gb3rHcZ/cdI1s6a1zG26ZmbFSBfS3LxgZlYQX0gzMyuML6SZmRWsxQ9HmJkVIxBLovFSXONFZGZWA76QZmZWoEBuXjAzK1IjXkhrvIisQ5cfPZpTxm/B6btt8ta8B//2Dk7bdVOOe+d4Zt0/qI7RNZ7xE1/hrFv+xR/+8TCf+up/6h1OQ2rWcxQBLdGroqFIDZt0JR0jaaak+yXdK2nbDtY9WNJaRcZXL1t+Yi6fm/zoCvPWGPs6B/z2cdbf5tU6RdWYevUKDj95FsceOIb/mTiWnfaez3obvVHvsBpKM5+jdCGtd0VDZySdLelFSQ+WzBsm6VpJj+V/31FJXA2ZdCVNAPYEtoqI9wAfBJ7tYJODgbdF0h297UIGDl26wrw1NnyDERs0xx9KLY3dchGzn+rHC8/0Z+mSXky7YigTdltQ77AaSrOfoxZ6VTRUYDKwe9m87wLXR8RGwPV5ulMNmXSBUcDciFgMEBFzI2K2pK0l3STpLknXSBolaV9gPHB+rhEPlLSLpHskPZC/ofoDSDpF0kO59vyzPG8vSbfn9a+TNLJuR201tfqaS5gzu99b03Of78vwUUvqGFHjaeZzFIhlUdnQaVkRNwMvlc3eGzgnj58D7FNJXI2adKcC60p6VNJvJH1AUl/gdGDfiNgaOBs4KSIuBe4EDoyILUh3ikwG9ouIzUgXCw+TtDrwMWCTXHv+Ud7XrcB2EbElcCFwdGFHaWbdqoY13baMjIjn8/gLQEUVtoa8eyEiFkraGng/sBNwESlJbgpcKwmgN/B8G5uPBZ6MiNaGz3OAw4EzgDeA30v6K/DXvHwd4CJJo4B+wJNtxSTpEOAQgDXXbrzu4uy/zXuhLyPWevOt6eGjljD3+b51jKjxNPM5CmBZ5RfJhku6s2R6UkRMqnhfESEpKlm3UWu6RERLREyLiOOBrwKfAGZGxBZ52Cwidu1CeUuBbYBLSe3FV+dFpwNn5Frxl4EB7Ww/KSLGR8T4ocOcdHuCR+4dxNpj3mTkuovp03cZE/eez/SpQ+odVkNp7nMkWiocSM2Z40uGShLuf3Jljfzvi5VE1ZA1XUljgWUR8VietQXwMLCrpAkRcVtubtg4ImYCrwKr5XUfAUZL2jAiHgc+C9wkaVVgUERcJekfwBN5/SHArDx+ULcf3Eq6+Ovv5Mnpq7Ho5T78dMLm7HzkLAYOXcrfTlif117qw7lf2JhR4xZx0B8f7bywJresRfz6mLU5+YIn6NUbpl44jKcfbfM79W2rmc9RegV7t1aQ/kLKGafkf6+oZKOGTLrAqsDpkoYCS4HHST/tJwGnSRpCiv1XwExSG+6Zkl4HJgCfBy6R1AeYAZwJDAOukDQAEHBU3tcJed2XgRuAMd1/eNX71GlPtDl/3G7ziw2kh5hxw2Bm3DC43mE0tGY9RxHqSvNChyRNASaSmiGeA44nJduLJX0ReBr4VCVlNWTSjYi7gO3bWDQX2LGN9f8E/Klk1vXAlmWrPU9qXijf9goq/IYys56lVg8+RMQB7SzapatlNWTSNTNbWak/Xfe9YGZWEL85wsysMOmWMdd0zcwK0dr3QqNx0jWzptWIXTs66ZpZU0pdO7p5wcysMG7TNTMrSOplzM0LZmaFSI8BO+mamRXENV0zs0L5iTQzs4L47gUzs4K5ecHMrCCt70hrNE66ZtaUAljqmq6ZWXHcvGBmVpQKX69eNCddM2tK7sTczKxgrumamRXEnZibmRUoEEuX+UKamVlh3KZrZlaUcPOCmVlh3KZrZlYwJ10zs4IEosUX0szMiuMLaWZmBYkGvZDWeHVvM7MaiVBFQyUkfUPSTEkPSpoiaUA1MTnpmlmTSh3eVDJ0WpK0NvB1YHxEbAr0BvavJio3L5hZ06q0FluhPsBASUuAQcDsaguxLpr1wCp8f8x76x1Gw7pm9r31DqHh7bHtnvUOofE9s3KbR0DLsoqT7nBJd5ZMT4qIScvLilmSfpajeh2YGhFTq4nLSdfMmlYX7l6YGxHj21so6R3A3sAYYD5wiaTPRMR5XY3Jbbpm1pSCml5I+yDwZETMiYglwGXA9tXE5ZqumTWpmr454hlgO0mDSM0LuwB3drxJ25x0zaxpRdSqnLhd0qXA3cBS4B5gUsdbtc1J18yaVi3vXoiI44HjV7YcJ10za0rp7oXGu2zlpGtmTatWzQu15KRrZk2rxg9H1ISTrpk1paDyfhWK5KRrZk2rAVsXnHTNrEkFROWPARfGSdfMmpabF8zMCtSj7l6QdDodNIlExNe7JSIzsxpo7Xuh0XRU063quWIzs4YQQE9KuhFxTum0pEERsaj7QzIzq41GbF7o9Bk5SRMkPQT8K09vLuk33R6ZmdlKEbGssqFIlTyY/CtgN2AeQETcB+zYjTGZmdVGVDgUqKK7FyLiWWmFb4OW7gnHzKxGouddSGv1rKTtgZDUFzgCeLh7wzIzq4Ge2KYLHAocDqxNevvlFnnazKzBqcKhOJ3WdCNiLnBgAbGYmdXWsnoH8N8quXvhnZKulDRH0ouSrpD0ziKCMzOrWut9upUMBaqkeeEC4GJgFLAWcAkwpTuDMjOrhYjKhiJVknQHRcS5EbE0D+cBA7o7MDOzldaTbhmTNCyP/l3Sd4ELSeHtB1xVQGxmZiunh90ydhcpybZG/eWSZQF8r7uCMjOrBTXgLWMd9b0wpshAzMxqKgQ9tRNzSZsC4yhpy42IP3ZXUGZmNdGTarqtJB0PTCQl3auADwO3Ak66ZtbYGjDpVnL3wr7ALsALEfF5YHNgSLdGZWZWCz3p7oUSr0fEMklLJQ0GXgTW7ea4rELjJ77CoT+cTe9ewd+nDOPiM0bWO6S6+/k31uX26wYzdPhSJt34CAC/O3Etpl87mL79glHrL+abv3yWVYe436Yjjr2PbXZ4kfkv9+PwT3+g3uHUVoN2Yl5JTfdOSUOB35HuaLgbuK2jDSTdKGm3snlHSvpttYFK+mi+da2abRdWu99G1qtXcPjJszj2wDH8z8Sx7LT3fNbb6I16h1V3u+73Eied/8QK87ba8VUm3fgvzrz+EdZ+52IuPH2NOkXXWK776zocd+Q29Q6j2ygqGyoqSxoq6VJJ/5L0sKQJ1cTUadKNiK9ExPyIOBP4EHBQbmboyBRg/7J5+1PBk2ySercTx18i4pTOtl9ZknrMyzrHbrmI2U/144Vn+rN0SS+mXTGUCbstqHdYdbfZdq+x2jtWrMVuPfFVeuf/2XdvvYi5z/etQ2SNZ+a9q/PqK018LmrbvHAqcHVEvIvUzFpVb4vtJl1JW5UPwDCgTx7vyKXAHpL65bJGkx4hHijpNkl3S7pE0qp5+VOSfizpbuCTkr4u6SFJ90u6MK9zsKQz8vhISZdLui8P2+f5R0l6MA9HtnFMkvTTvPwBSfvl+RMl3SLpL8BDXTmB9bT6mkuYM7vfW9Nzn+/L8FFL6hhRz3DNlGG8d+dX6x2GFaBWNV1JQ0gvb/g9QES8GRHzq4mpo1rdzztYFsDO7S6MeEnSHaQ7Ha4g1XKnAscAH4yI1yR9BzgKODFvNi8itgKQNBsYExGLc9NGudOAmyLiY7lmvKqkrYHPA9uSHui4XdJNEXFPyXYfJ3VNuTkwHJgh6ea8bCtg04h4sq1jknQIcAjAAAa1f2asoV1w6kh69wl2/vjL9Q7FilB5m+5wSaUv450UEZNKpscAc4A/SNqc1NR6RES81tWQOno4YqeuFlamtYmhNeleDuwD/CO/haIfK7YNX1Qyfj9wvqQ/A39uo+ydgc/lOFuABZLeB1zeehIkXQa8HyhNuu8DpuRt/iPpJuC9wCvAHe0l3LyfScAkgMEa1hA3osx7oS8j1nrzrenho5b4Z3MHpl40jDuuG8wpFz2OGu/6itVa15oO5kbE+A6W9yFVzL4WEbdLOhX4LvD9roZVyYW0al0B7JKbIgaRLsBdGxFb5GFcRHyxZP3Sb4w9gF+TDnJGQe2sXf7GqrdH7h3E2mPeZOS6i+nTdxkT957P9Km+m68tM25cjUt+swYnTH6CAYMa4jvTilC7Nt3ngOci4vY8fSkpP3VZtyXdiFgI3AicTar1Tgd2kLQhgKRVJG1cvp2kXsC6EXEj8B3SPcGrlq12PXBYXr93bm+5BdhH0iBJqwAfy/NK3QLsl7cZQWqjuaMmB1wHy1rEr49Zm5MveILf3fQIN185lKcfdQdw/++w9fnGXhvx3L8HcODW47j6gmH8+ph1WLSwF9/bb0MO++BYTv3OOvUOsyEc/cN7+PlZ/2Sd9V/jnCuvZ9e9nql3SDWlZZUNnYmIF0ivLhubZ+1Cldd/ursGOYXUrLB/RMyRdDAwRVL/vPxY4NGybXoD5+VEKuC0iJhf9mLMI4BJkr5IeknmYRFxm6TJLE+iZ5W155JjmQDcR/p+OzoiXpD0rhoca13MuGEwM24YXO8wGsr3fvv0f83b/dMv1SGSxveT729Z7xC6V21/1HyN1OzZD3iCdA2pyyp5DFik1/W8MyJOlLQesGZEdFpDjIg/U/ICooi4gdSGWr7e6JLxJaS21/J1JgOT8/h/gL3bWOcXwC/amL9q/jeAb+ehdPk0YFpnx2NmPUdX7sGtRETcC3TU7luRSpoXfkOqHR6Qp18ltbeamTW2BnxdTyXNC9tGxFaS7gGIiJdb7781M2toDXjNtJKkuyTfCxsA+QJUA75j08xsRT2qE/MSp5EuQK0h6SRSr2PHdmtUZmYrKyq7M6FonSbdiDhf0l2kWyQE7BMRVT1zbGZWqJ5Y0813KywCriydFxHNdUOfmTWfnph0gb+x/AWVA0jPID8CbNKNcZmZrbQe2aYbEZuVTufHer/SbRGZmTWxLj+RFhF3S9q2O4IxM6upnljTlXRUyWQvUicPs7stIjOzWuipdy8Aq5WMLyW18f6pe8IxM6uhnlbTzQ9FrBYR3yooHjOzmhA97EKapD4RsVTSDkUGZGZWMz0p6ZK6SNwKuDe/O+wSSjr6jojLujk2M7Pq1biXsVqppE13ADCP9Iqc1vt1A3DSNbPG1sMupK2R71x4kOXJtlUDfn+Yma2op9V0e5Nek9NWZ5MNeChmZmUaMFN1lHSfj4gTO1huZta4uvY24MJ0lHT9kmoz69F6WvPCLoVFYWbWHXpS0o0Ivz7VzHq0nvoYsJlZz9MD23TNzHos0ZgXppx0zax5uaZrZlacnnb3gplZz+aka2ZWkAbtxLxXvQMwM+s2UeFQIUm9Jd0j6a/VhuSarpk1rW5o0z0CeBgYXG0BrumaWfOqYU1X0jrAHsBZKxOSa7pWc7uttUW9Q2h4j/9ynXqH0PiOXPkiulDTHS7pzpLpSRExqWydXwFHs+J7I7vMSdfMmlPQlU7M50bE+PYWStoTeDEi7pI0cWXCctI1s6ZU4xdT7gB8VNJHSG/TGSzpvIj4TFcLcpuumTWvGrXpRsT3ImKdiBgN7A/cUE3CBdd0zayJKRrv6QgnXTNrTt3Uy1hETAOmVbu9k66ZNS33vWBmVqBGfAzYSdfMmpdrumZmBQk3L5iZFctJ18ysGDV+OKJmnHTNrGlpWeNlXSddM2tOfhuwmVmxfMuYmVmRXNM1MyuOL6SZmRUlAHd4Y2ZWHLfpmpkVxPfpmpkVKcLNC2ZmRXJN18ysSE66ZmbFcU3XzKwoAbQ0XtZ10jWzpuWarplZkXz3gplZcVzTNTMrirt2NDMrjgD5QpqZWXHkNl0zs4K4ecG6w/iJr3DoD2fTu1fw9ynDuPiMkfUOqaH4/HSu1+tLWePCJ+j3wiIAXjxgA94YvVqdo6qFxux7oVeRO5N0o6TdyuYdKelJSd/tYllrSbq0gvWukjS0i6H2CL16BYefPItjDxzD/0wcy057z2e9jd6od1gNw+enMsMve4pF7x7KM9/bgme+/R7eHDmw3iHVjKKyodNypHVz/npI0kxJR1QbU6FJF5gC7F82b3/goIg4pXxlSe3WxCNidkTs29kOI+IjETG/q4H2BGO3XMTsp/rxwjP9WbqkF9OuGMqE3RbUO6yG4fPTuV6vL2XgE6/yyrYj0ow+vVg2sIl+ALf2NNbZ0LmlwDcjYhywHXC4pHHVhFR00r0U2ENSPwBJo4G1gA0knZHnTZZ0pqTbgZ9I2kDSdEkPSPqRpIWt20p6MI8fLOkySVdLekzST1p3KOkpScPz+Ock3S/pPknn5nl7Sbpd0j2SrpPUY35/rr7mEubM7vfW9Nzn+zJ81JI6RtRYfH461+elxbSs2oc1pvybdX92PyMu/Dda3FLvsGoj0t0LlQydFhXxfETcncdfBR4G1q4mrEKTbkS8BNwBfDjP2h+4mP9u7l4H2D4ijgJOBU6NiM2A5zoofgtgP2AzYD9J65YulLQJcCywc0RsDrT+PLgV2C4itgQuBI6u7ujMeh61BP2fe40FO4zk2W+9h+jXm3dcP7veYdVOVDh0Qa4sbgncXk1IRdd0YcUmhv3zdLlLIqL163YCcEkev6CDcq+PiAUR8QbwELB+2fKdc7lz4a0vAEgJ/hpJDwDfBjZpq3BJh0i6U9KdS1jcQRjFmfdCX0as9eZb08NHLWHu833rGFFj8fnp3NKh/Vg6pB+L108XzhZuPoz+z71W56hqRxEVDcDw1r/vPBzSZnnSqsCfgCMj4pVqYqpH0r0C2EXSVsCgiLirjXWq+V8vzYQtVH5nxunAGbkm/WVgQFsrRcSkiBgfEeP70r+K8GrvkXsHsfaYNxm57mL69F3GxL3nM33qkHqH1TB8fjrXMrgfS4f2p++LrwMw6LEFvLlm81xI60Kb7tzWv+88TCovSlJfUsI9PyIuqzakwlvMI2KhpBuBs2m7lltuOvAJ4CL++yJcV9wAXC7pFxExT9KwXNsdAszK6xy0EuUXblmL+PUxa3PyBU/QqzdMvXAYTz/a5nfG25LPT2XmfGI0I899HLUES1bvz4sHbFDvkGojgBq9mFKSgN8DD0fEL1amrHpdppwCXE5lSfRI4DxJxwBXA1Vdfo6ImZJOAm6S1ALcAxwMnABcIullUmIeU0359TLjhsHMuGFwvcNoWD4/nXtz7VV47pub1TuMmhNRyyfSdgA+Czwg6d48738j4qquFlSXpBsRfyY9Gt06PRmYnMcPLlt9FulCV0jaHxib13sK2LR8+zy9Z8n46JLxc4BzymK5gtTkYWbNZlltqroRcSslOWtl9IQb8rYGzsjV+/nAF+objpn1CDVsXqilhk+6EXELsHm94zCznscd3piZFclJ18ysKI3Z4Y2Trpk1J78N2MysWG7TNTMrkpOumVlBAljmpGtmVhBfSDMzK5aTrplZQQJoabxH0px0zaxJBYSTrplZcdy8YGZWEN+9YGZWMNd0zcwK5KRrZlaQCGhpvNfJO+maWfNyTdfMrEBOumZmRQnfvWBmVpiA8MMRZmYF8mPAZmYFiajZK9hryUnXzJqXL6SZmRUnXNM1MyuKOzE3MyuOO7wxMytOANGAjwH3qncAZmbdInIn5pUMFZC0u6RHJD0u6bvVhuWarpk1rahR84Kk3sCvgQ8BzwEzJP0lIh7qalmu6ZpZ86pdTXcb4PGIeCIi3gQuBPauJiRFA17da3SS5gBP1zuOEsOBufUOosH5HHWsEc/P+hExotqNJV1NOq5KDADeKJmeFBGTSsraF9g9Ir6Upz8LbBsRX+1qXG5eqMLKfBC6g6Q7I2J8veNoZD5HHWvG8xMRu9c7hra4ecHMrHOzgHVLptfJ87rMSdfMrHMzgI0kjZHUD9gf+Es1Bbl5oTlM6nyVtz2fo475/HQgIpZK+ipwDdAbODsiZlZTli+kmZkVyM0LZmYFctI1MyuQk26DkHSMpJmS7pd0r6RtO1j3YElrFRlfd5J0o6TdyuYdKem3K1HmR6t9VFPSwmr3W4QOzteTXT1mSWtJurSC9a6SNLSLoVob3KbbACRNAH4BTIyIxZKGA/0iYnY7608DvhURdxYYZreRdAgwISI+XzJvOnB0RNzcyba9I6KmvZpIWhgRq1a4bp+IWFrL/Vewzy6dr3rEaO1zTbcxjALmRsRigIiYGxGzJW0t6SZJd0m6RtKo/GTMeOD8XCMeKGkXSfdIekDS2ZL6A0g6RdJDufb8szxvL0m35/WvkzSybke93KXAHvlWHCSNBtYCBkq6TdLdki6RtGpe/pSkH0u6G/ikpK+XHOeFeZ2DJZ2Rx0dKulzSfXnYPs8/StKDeTiyPCglP83LH5C0X54/UdItkv4CdPnZ+xpo73xtUHLMkyWdKel24CeSNpA0PR/Hj1pr85JGS3owjx8s6TJJV0t6TNJPWneYz/nwPP65fK7vk3RunteIn6vGFBEe6jwAqwL3Ao8CvwE+APQF/gmMyOvsR7pNBWAaMD6PDwCeBTbO038EjgRWBx5h+a+Zofnfd5TM+xLw83off47lr8Deefy7wFnAzcAqed53gOPy+FOkWl3rtrOB/mXHeTBwRh6/CDgyj/cGhgBbAw8Aq+TzPxPYMq+zMP/7CeDavM1I4BnSF+RE4DVgTAOdr5+VHfPkvE7vkvUPyOOHlhzjaODBknP2RD4/A0iPuq9bcs6HA5vkz+nwPH9YI3+uGnFwTbcBRMRCUhI4BJhDShJfBjYFrpV0L3As6SmYcmOBJyPi0Tx9DrAjsID0LPnvJX0cWJSXrwNcI+kB4NukP6JGMIV0wzn532eBccA/8vEfBKxfsv5FJeP3k2r+nwHa+hm9M/BbgIhoiYgFwPuAyyPitXz+LwPeX7bd+4ApeZv/ADcB783L7oiIJ6s60tooP19T2ljnklje9DIBuCSPX9BBuddHxIKIeINUi1+/bPnOudy5ABHxUp7fqJ+rhuOk2yDyH/a0iDge+CqpljUzIrbIw2YRsWsXyltK6hnpUmBP4Oq86HRSbWgzUmIfUNMDqd4VwC6StgIGAXcD15Yc/7iI+GLJ+q+VjO9B6nZvK1KXe0U89PNa56t0qxXOV0Tc1cY61cS4uGS8hcofoGrUz1XDcdJtAJLGStqoZNYWwMPAiHyRDUl9JbXWHl4FVsvjjwCjJW2Ypz8L3JTbP4dExFXAN4DN8/IhLH9m/KDuOJ5q5NrmjcDZpFrbdGCH1uOStIqkjcu3k9SL9BP4RlITxBBSc0Gp64HD8vq9JQ0BbgH2kTRI0irAx/K8UrcA++VtRpB+QdxRkwNeSW2cr85MJ32Rw/IacjVuILWjrw4gaVie35Cfq0bkpNsYVgXOab0YRPpZfRywL/BjSfeR2ny3z+tPBs7MP7sFfB64JP+0WwacSUrKf83l3Qoclbc9Ia97F43Xld8U0pfDlIiYQ2pjnJKP4TbgXW1s0xs4Lx/7PcBpETG/bJ0jgJ3yOncB4yLibtJ5vAO4HTgrIu4p2+5yUtPFfaRkc3REvLCyB1lDb52vCtY9Ejgqn8sNSc1PXRbp0deTSF/s95HuuoHG/lw1FN8yZvY2IGkQ8HpEhKT9SRfVquqE21aOO7wxe3vYGjhDkoD5wBfqG87bl2u6ZmYFcpuumVmBnHTNzArkpGtmViAnXesWklqU+oZ4MPebMGglypqs1OcEks6SNK6DdSe29q3QxX281bdAJfPL1ulSr2SSTpD0ra7GaM3BSde6y+v5SbJNgTdJz/u/pdqnxiLiSxHRUSczE1l+P7NZw3HStSLcAmxY3jtXftLrp5Jm5F6rvgxv9e51hqRHJF0HrNFakKRpksbn8d2VeiC7T9L1ubetQ4Fv5Fr2+yWNkPSnvI8ZknbI264uaapSH8ZnkR4y6ZCkPyv1+DZTqXvF0mW/zPOvz0+vodSz19V5m1sktfVwh73N+D5d61a5Rvthlvf9sBWwaUQ8mRPXgoh4r1J3lP+QNBXYktSRzzhS714PkR53LS13BPA7YMdc1rCIeEnSmaQetFq7srwA+GVE3CppPdKLBd8NHA/cGhEnStoDKO3XoT1fyPsYSOrj4U8RMY/UU9mdEfENScflsr9KetnjoRHxmFKn9L8hdRhjb2NOutZdBubHlCHVdH9P+tlf2jvXrsB7WttrSc/vb0Tq42BK7iFrtqQb2ih/O+Dm1rJKersq90FgXHomAIDBuV+KHYGP523/JunlCo7p65I+lsfXzbHOIz163drr2XnAZXkf25MejW3dvn8F+7Am56Rr3eX1iNiidEZOPqU9Xwn4WkRcU7beR2oYRy9gu9xVYXksFZM0kZTAJ0TEIqW3d7TXk1bk/c4vPwdmbtO1eroGOExSXwBJG+cev25mee9eo4Cd2th2OrCjpDF529berkp7YAOYCnytdULSFnn0ZuDTed6HSZ1wd2QI8HJOuO8i1bRb9SJ1TkQu89aIeAV4UtIn8z4kaXPsbc9J1+rpLFJ77d1Kr4z5P9Kvr8uBx/KyP5J6GFtB7oXsENJP+ftY/vP+SuBjrRfSgK8D4/OFuodYfhfFD0hJeyapmeGZTmK9Gugj6WHgFFLSb/UasE0+hp2BE/P8A4Ev5vhmAu5gxtz3gplZkVzTNTMrkJOumVmBnHTNzArkpGtmViAnXTOzAjnpmpkVyEnXzKxA/x/PGZbH+7gKSwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It seems only one “Versicolor” species is incorrectly identified as “Virginica” and rest by the model.\n",
        "\n",
        "Conclusion: We can do simple deep learning regression and classification model in Scikit-learn. In my view, it is not up for any real-life large-scale modelling as there is no GPU support and very limited options to tweak the parameters."
      ],
      "metadata": {
        "id": "pzXkqq9ytKWw"
      }
    }
  ]
}