ML_Algorithms-2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "yRhvxp5A-bZF"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib as plt\n",
        "import matplotlib.pyplot as pyplt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# P1 has been merged at the end "
      ],
      "metadata": {
        "id": "_d2dPPYav-tt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Q2"
      ],
      "metadata": {
        "id": "o9TtA30KuU49"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7afc528c"
      },
      "source": [
        "# FLDA for Multi-Class Classificiation on P3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b28ca445",
        "outputId": "813216e6-1ba5-4295-c2c5-dcf726edc9f6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train X (60000, 10)\n",
            "Training Y (60000, 1)\n",
            "No. of Unique Classes  5\n",
            "are there complex eigen values of Sb^-1.Sw:  False\n",
            "Accuracy is 65.97333333333333\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "F1 Scores\n",
            "[0.5799757147588034, 0.42481417953116063, 0.44959254947613503, 0.4662456140350877, 0.545078979343864]\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import math\n",
        "\n",
        "\n",
        "def load_data(filename):\n",
        "    \"\"\"\n",
        "    Load data from a CSV file and split it into feature vectors and labels.\n",
        "    \n",
        "    Args:\n",
        "    filename: string containing the name of the CSV file to load.\n",
        "    \n",
        "    Returns:\n",
        "    x: ndarray of shape (m, n) containing the feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the labels.\n",
        "    \"\"\"\n",
        "    data_np = np.loadtxt(filename, delimiter=\",\")\n",
        "    m, n = np.shape(data_np)\n",
        "    x = np.ones((m, n-1))\n",
        "    y = np.zeros((m, 1))\n",
        "    for k in range(m):\n",
        "        x[k,:n-1] = data_np[k,:n-1]\n",
        "        y[k] = data_np[k,n-1]\n",
        "    return x, y\n",
        "\n",
        "# load data\n",
        "x_train, y_train = load_data(\"p3_train.csv\")\n",
        "print(\"Train X\", np.shape(x_train))\n",
        "print(\"Training Y\",np.shape(y_train))\n",
        "x_test, y_test = load_data(\"p3_test.csv\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#separating data based on classes\n",
        "\n",
        "def class_separator(x, y):\n",
        "\n",
        "# get the unique classes\n",
        "    classes = np.unique(y)\n",
        "\n",
        "# create a dictionary to store the arrays\n",
        "    data_by_class = {}\n",
        "\n",
        "# loop over each class\n",
        "    for c in classes:\n",
        "# get the indices of data points belonging to this class\n",
        "        indices = np.where(y == c)[0]\n",
        "    \n",
        "# extract the data points and store them in a new array\n",
        "        data = x[indices, :]\n",
        "    \n",
        "# store the array in the dictionary\n",
        "        data_by_class[c] = data\n",
        "    return data_by_class\n",
        "\n",
        "# computing class_means\n",
        "def FLDA(x, y):\n",
        "    data = class_separator(x, y)\n",
        "    num_classes = len(data.keys())\n",
        "    c_means = np.zeros((num_classes, x.shape[1]))\n",
        "    print(\"No. of Unique Classes \", num_classes)\n",
        "    for i in range(num_classes):\n",
        "        c_means[i,:] = np.mean(data[i+1], axis=0)\n",
        "    \n",
        "\n",
        "# computing within class scatter matrix\n",
        "    Sw = np.zeros((x.shape[1], x.shape[1]))\n",
        "    for i in range(num_classes):\n",
        "        p = data[i+1]\n",
        "        no_in_class = p.shape[0] \n",
        "        for j in range(no_in_class):\n",
        "            diff = p[j,:] - c_means[i,:]\n",
        "            Sw += np.outer(diff, diff)\n",
        "    \n",
        "\n",
        "# computing between class scatter matrix\n",
        "    \n",
        "    Sb = np.zeros((x.shape[1], x.shape[1]))\n",
        "    for i in range(num_classes):\n",
        "        p = data[i+1]\n",
        "        overall_sum = np.sum(p, axis=0)\n",
        "    overall_mean = (1/(x.shape[0]))*overall_sum\n",
        "    \n",
        "    for i in range(num_classes):\n",
        "        p = data[i+1]\n",
        "        n = p.shape[0]\n",
        "        mean_diff = c_means[i,:] - overall_mean\n",
        "        Sb += n*np.outer(mean_diff, mean_diff)\n",
        "    \n",
        "    \n",
        "# computing eigen vectors and eigen values of Sb^-1.Sw  \n",
        "    Sb_inv = np.linalg.inv(Sb)\n",
        "    Sb_inv_Sw = Sb_inv @ Sw\n",
        "    eigvals, eigvecs = np.linalg.eig(Sb_inv_Sw)\n",
        "    \n",
        "# Sort the eigenvectors by eigenvalue in decreasing order\n",
        "    sort_indices = np.argsort(eigvals)[::-1]\n",
        "    eigvals = eigvals[sort_indices]\n",
        "    eigvecs = eigvecs[:, sort_indices]\n",
        "\n",
        "# Select the top (num_classes - 1) eigenvectors\n",
        "    w = eigvecs[:, :num_classes - 1]\n",
        "    b = w.T @ overall_mean.reshape(-1, 1)\n",
        "    \n",
        "    return w, b, c_means\n",
        "\n",
        "def classifier(x_transformed, c_mean_transformed):\n",
        "    dist = np.zeros((c_mean_transformed.shape[0]))\n",
        "    for i in range(c_mean_transformed.shape[0]):\n",
        "        dist[i] = np.linalg.norm(x_transformed - c_mean_transformed[i])\n",
        "    y = np.argmin(dist)\n",
        "    return y\n",
        "\n",
        "\n",
        "\n",
        "def gaussian(x_test_proj, class_means, w):\n",
        "    data = class_separator(x_train, y_train)\n",
        "    num_classes = len(data.keys())\n",
        "    gauss = np.zeros((num_classes))\n",
        "    for i in range(num_classes):\n",
        "        p = data[i+1]\n",
        "        p_proj = p @ w\n",
        "        sigma = np.cov(p_proj, rowvar = False)\n",
        "        dim = sigma.shape[0]\n",
        "        sig_inv = np.linalg.inv(sigma)\n",
        "        det = np.linalg.det(sig_inv)\n",
        "        kernel = math.exp(-0.5*(x_test_proj-class_means[i]) @ sig_inv @ (x_test_proj-class_means[i]).T)\n",
        "        gauss[i] = (det**0.5)*kernel*(1/2*3.14)**(dim/2)\n",
        "    y_est = np.argmax(gauss)+1\n",
        "    return y_est\n",
        "        \n",
        "  \n",
        " #Data transforming  by projecting onto W direction\n",
        "def data_transform(x_train, y_train):\n",
        "    w, b, c_means = FLDA(x_train, y_train)\n",
        "    w = np.real(w)\n",
        "    print(\"are there complex eigen values of Sb^-1.Sw: \", np.iscomplex(w).any())\n",
        "\n",
        "    x_proj = x_test @ w \n",
        "    c_means_proj = c_means @ w\n",
        "    return x_proj, c_means_proj, w\n",
        "\n",
        "def estimation(x_test, x_proj, c_means_proj, w):\n",
        "    y_est = np.zeros((x_test.shape[0],1))\n",
        "    for i in range(x_test.shape[0]):\n",
        "        y_est[i] = gaussian(x_proj[i,:], c_means_proj, w)\n",
        "    return y_est\n",
        "\n",
        "def get_confusion_matrix(y_actual, y_pred):\n",
        "    import matplotlib.pyplot as plt\n",
        "    import seaborn as sns\n",
        "\n",
        "    num_classes = len(np.unique(y_actual))\n",
        "    confusion_matrix = np.zeros((num_classes,num_classes))\n",
        "    n = y_actual.shape[0]\n",
        "    labels = np.unique(y_actual)\n",
        "    labels.sort()\n",
        "    for i in range(n):\n",
        "        confusion_matrix[int(y_actual[i]-1)][int(y_pred[i]-1)]+=1\n",
        "    lamda = 1000*np.identity(len(np.unique(y_actual)))\n",
        "    confusion_matrix += lamda\n",
        "    sns.heatmap(confusion_matrix, annot=True,fmt = \"g\" ,cmap='coolwarm',xticklabels=labels, yticklabels=labels)\n",
        "    plt.show()\n",
        "    return confusion_matrix\n",
        "\n",
        "def metrics(y_est, x_test, y_test):\n",
        "    count = 0\n",
        "    for i in range(x_test.shape[0]):\n",
        "        if y_est[i] == y_test[i]:\n",
        "            count +=2\n",
        "    accuracy = count/x_test.shape[0]\n",
        "    print(\"Accuracy is\",accuracy*100)\n",
        "    \n",
        "    cm = get_confusion_matrix(y_test, y_est) \n",
        "# Compute F1 score\n",
        "    f1_list = []\n",
        "    for i in range(len(np.unique(y_test))):\n",
        "        tp = cm[i, i]\n",
        "        fp = sum(cm[:, i]) - tp\n",
        "        fn = sum(cm[i, :]) - tp\n",
        "        precision = tp / (tp + fp)\n",
        "        recall = tp / (tp + fn)\n",
        "        f1 = 2 * precision * recall / (precision + recall) if tp > 0 else 0\n",
        "        f1_list.append(f1)\n",
        "    print(\"F1 Scores\")\n",
        "    print(f1_list)\n",
        "    return \n",
        "\n",
        "x_proj, c_means_proj, w = data_transform(x_train, y_train)\n",
        "y_pred = estimation(x_test, x_proj, c_means_proj, w)\n",
        "metrics(y_pred, x_test, y_test)                       "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8dc6330b"
      },
      "source": [
        "# FLDA for P4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "faef23c9"
      },
      "outputs": [],
      "source": [
        "#@title Default title text\n",
        "import numpy as np\n",
        "\n",
        "def load_data(filename):\n",
        "    \"\"\"\n",
        "    Load data from a CSV file and split it into feature vectors and labels.\n",
        "    \n",
        "    Args:\n",
        "    filename: string containing the name of the CSV file to load.\n",
        "    \n",
        "    Returns:\n",
        "    x: ndarray of shape (m, n) containing the feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the labels.\n",
        "    \"\"\"\n",
        "    data_np = np.loadtxt(filename, delimiter=\",\")\n",
        "    return data_np\n",
        "\n",
        "whole_data = load_data(\"p4.csv\")\n",
        "\n",
        "# assuming your numpy array is called 'data' with input and output columns\n",
        "X = whole_data[:, :-1] # input features\n",
        "y = whole_data[:, -1] # output\n",
        "\n",
        "# set random seed for reproducibility\n",
        "np.random.seed(42)\n",
        "\n",
        "# shuffle the data\n",
        "n_samples = data.shape[0]\n",
        "shuffle_idx = np.random.permutation(n_samples)\n",
        "X_shuffled = X[shuffle_idx]\n",
        "y_shuffled = y[shuffle_idx]\n",
        "\n",
        "# split into training and test data, with 80% for training and 20% for test\n",
        "n_train_samples = int(n_samples * 0.8)\n",
        "X_train = X_shuffled[:n_train_samples]\n",
        "y_train = y_shuffled[:n_train_samples]\n",
        "X_test = X_shuffled[n_train_samples:]\n",
        "y_test = y_shuffled[n_train_samples:]\n",
        "\n",
        "# check the shape of the train and test data\n",
        "print(f\"X_train shape: {X_train.shape}\")\n",
        "print(f\"y_train shape: {y_train.shape}\")\n",
        "print(f\"X_test shape: {X_test.shape}\")\n",
        "print(f\"y_test shape: {y_test.shape}\")\n",
        "\n",
        "\n",
        "\n",
        "x_proj, c_means_proj, w = data_transform(x_train, y_train)\n",
        "y_pred = estimation(x_test, x_proj, c_means_proj, w)\n",
        "y_pred = (np.rint(y_pred)).astype(int)\n",
        "metrics(y_pred, x_test, y_test)   \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "62855ae7",
        "outputId": "c005c253-a933-4915-af2c-8b966cf20ef2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Classification Accuracy  on Test Data is:  88.49444444444444 \n",
            "\n",
            "Confusion Matrix is: \n",
            " [[1742.    3.   13.   11.    9.    3.    0.    0.    6.   13.]\n",
            " [   3. 1712.   14.    2.   42.    0.    1.    1.    1.   24.]\n",
            " [   2.    0. 1478.  154.   50.    0.   53.    0.    0.   63.]\n",
            " [   1.    0.    7. 1730.   52.    0.    5.    0.    1.    4.]\n",
            " [   9.   11.   11.   67. 1684.    1.    3.   13.    1.    0.]\n",
            " [   3.    0.   67.   25.    3. 1547.  153.    0.    2.    0.]\n",
            " [  10.    0.  181.  137.   12.  302. 1130.    0.    3.   25.]\n",
            " [   6.    2.    3.   15.    6.    0.    0. 1669.   48.   51.]\n",
            " [   1.    0.    4.   76.    6.    9.   13.   40. 1642.    9.]\n",
            " [ 148.    1.   27.   12.    7.    2.    3.    3.    2. 1595.]] \n",
            "\n",
            "f1 Score of Class  1  is:  0.9353020134228188\n",
            "f1 Score of Class  2  is:  0.9702465287616889\n",
            "f1 Score of Class  3  is:  0.8199722607489597\n",
            "f1 Score of Class  4  is:  0.8587738893025565\n",
            "f1 Score of Class  5  is:  0.917461182239172\n",
            "f1 Score of Class  6  is:  0.8444323144104803\n",
            "f1 Score of Class  7  is:  0.7149636191078773\n",
            "f1 Score of Class  8  is:  0.9466817923993193\n",
            "f1 Score of Class  9  is:  0.9366799771819738\n",
            "f1 Score of Class  10  is:  0.8900669642857143\n"
          ]
        }
      ],
      "source": [
        "metrics(y_pred,y_test)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87e631ae"
      },
      "source": [
        "# FLDA P5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8lSCuBMTfdS5"
      },
      "outputs": [],
      "source": [
        "#@title Default title text\n",
        "import numpy as np\n",
        "\n",
        "def load_data(filename):\n",
        "    \"\"\"\n",
        "    Load data from a CSV file and split it into feature vectors and labels.\n",
        "    \n",
        "    Args:\n",
        "    filename: string containing the name of the CSV file to load.\n",
        "    \n",
        "    Returns:\n",
        "    x: ndarray of shape (m, n) containing the feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the labels.\n",
        "    \"\"\"\n",
        "    data_np = np.loadtxt(filename, delimiter=\",\")\n",
        "    return data_np\n",
        "\n",
        "whole_data = load_data(\"PCA_MNIST.csv\")\n",
        "\n",
        "# assuming your numpy array is called 'data' with input and output columns\n",
        "X = whole_data[:, :-1] # input features\n",
        "y = whole_data[:, -1] # output\n",
        "\n",
        "# set random seed for reproducibility\n",
        "np.random.seed(42)\n",
        "\n",
        "# shuffle the data\n",
        "n_samples = data.shape[0]\n",
        "shuffle_idx = np.random.permutation(n_samples)\n",
        "X_shuffled = X[shuffle_idx]\n",
        "y_shuffled = y[shuffle_idx]\n",
        "\n",
        "# split into training and test data, with 80% for training and 20% for test\n",
        "n_train_samples = int(n_samples * 0.8)\n",
        "X_train = X_shuffled[:n_train_samples]\n",
        "y_train = y_shuffled[:n_train_samples]\n",
        "X_test = X_shuffled[n_train_samples:]\n",
        "y_test = y_shuffled[n_train_samples:]\n",
        "\n",
        "# check the shape of the train and test data\n",
        "print(f\"X_train shape: {X_train.shape}\")\n",
        "print(f\"y_train shape: {y_train.shape}\")\n",
        "print(f\"X_test shape: {X_test.shape}\")\n",
        "print(f\"y_test shape: {y_test.shape}\")\n",
        "\n",
        "\n",
        "\n",
        "x_proj, c_means_proj, w = data_transform(x_train, y_train)\n",
        "y_pred = estimation(x_test, x_proj, c_means_proj, w)\n",
        "y_pred = (np.rint(y_pred)).astype(int)\n",
        "  \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "273fbf97",
        "outputId": "2700208d-5364-4557-a2cb-4d5de884761e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Classification Accuracy  on Test Data is:  81.74444444444444 \n",
            "\n",
            "Confusion Matrix is: \n",
            " [[1642.    1.   62.    7.    4.    0.    1.   20.   21.   42.]\n",
            " [  21. 1557.   20.    1.  136.    0.   11.    2.    0.   52.]\n",
            " [   2.    2. 1473.  147.   28.    3.   75.    0.    2.   68.]\n",
            " [   0.    0.   22. 1703.   58.    3.    4.    4.    1.    5.]\n",
            " [   0.    7.   92.  107. 1580.    2.    5.    7.    0.    0.]\n",
            " [   0.    3.   48.   51.    4. 1169.  521.    0.    1.    3.]\n",
            " [  10.    0.  185.  203.    6.  311. 1053.    3.    2.   27.]\n",
            " [  10.    3.   10.   29.   19.    2.    1. 1586.   86.   54.]\n",
            " [   6.    0.   30.  114.    4.    6.   33.   61. 1512.   34.]\n",
            " [ 183.    0.   90.   21.   10.    0.    2.   36.   19. 1439.]] \n",
            "\n",
            "f1 Score of Class  1  is:  0.8938486663037561\n",
            "f1 Score of Class  2  is:  0.9232137563000297\n",
            "f1 Score of Class  3  is:  0.7687891440501045\n",
            "f1 Score of Class  4  is:  0.8142481472627301\n",
            "f1 Score of Class  5  is:  0.8659906823787339\n",
            "f1 Score of Class  6  is:  0.7093446601941747\n",
            "f1 Score of Class  7  is:  0.600684540787222\n",
            "f1 Score of Class  8  is:  0.9013924410343848\n",
            "f1 Score of Class  9  is:  0.8780487804878049\n",
            "f1 Score of Class  10  is:  0.8166855845629967\n"
          ]
        }
      ],
      "source": [
        "metrics(y_pred,y_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5d1b8265"
      },
      "source": [
        "# INFERENCES"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5563d99d"
      },
      "outputs": [],
      "source": [
        "• FLDA is a linear classification technique that works best when there is a clear linear boundary between the classes, as \n",
        "it projects the data onto a lower-dimensional subspace to maximize class separation.\n",
        "• However, if the classes are not linearly separable or if the class distribution is unbalanced, FLDA may not perform as well\n",
        "as other algorithms like SVM, which can handle non-linear and unbalanced datasets better.\n",
        "• FLDA's performance is dependent on the linearity and separability of the data, and it may not be the best choice for complex\n",
        "or non-linear datasets.\n",
        "• FLDA requires normally distributed data for each labeled class to work optimally, and its accuracy may decrease if the data \n",
        "is not normally distributed.\n",
        "• In the sensor dataset, the low accuracy obtained with FLDA and the Bayes classifier with Gaussian class conditionals in\n",
        "Assignment 1 suggest that the underlying class conditionals may not be normally distributed.\n",
        "• If the classes overlap extensively, it becomes challenging for most classifiers, including FLDA, to produce accurate results\n",
        "since it is difficult to separate the classes with a linear decision boundary.\n",
        "• Overall, the low accuracy obtained with FLDA in the sensor dataset may indicate that the underlying class conditionals are\n",
        "not normally distributed or that the classes overlap significantly.\n",
        "• Additionally, if the classes are overlapping to a great extent, it becomes difficult for most classifiers, including \n",
        "FLDA, to produce good results. This is because it becomes challenging to separate the classes with a linear decision boundary.\n",
        "• In summary, the low accuracy obtained with FLDA in the sensor dataset may indicate that the underlying class conditionals\n",
        "might not be normally distributed or that the classes are overlapping to a great extent.\n",
        "\n",
        "It might be inferred conviniently that the data in P3 is highly overlapping that is the between class scatter is low or might be that \n",
        "the within class scatter is very high that one class is having multiple points that can be present in the ambit of other class too.\n",
        "\n",
        "The results from P4 and P5 on the other hand are quite oppposite to what P3 is. The high disparity in confusion matrices computed \n",
        "infer that the classes are far apart or there is little to no overlap between the classes which might be a characteristic because\n",
        "underlying low within scatter and/or high between scatter which might be the result behind such high accuracies of classification."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**Q3** "
      ],
      "metadata": {
        "id": "WxcuS8MfqCE8"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c04e47bb"
      },
      "source": [
        "# Overfit Model w/o regularization-model1\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dd0b1a7e",
        "outputId": "f361c892-a11b-4d88-b5b0-d661e77e21b2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tabulate in c:\\users\\yvsdm\\anaconda3\\lib\\site-packages (0.8.10)\n",
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|   Model Complexity |      Variance |         Bias |       MSE |      MAE |\n",
            "+====================+===============+==============+===========+==========+\n",
            "|                  0 |   7.88861e-31 | -7.50333e-16 | 668.235   | 21.5864  |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  1 | 663.175       | -7.50333e-16 |   5.05968 |  1.79175 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  2 | 663.177       | -7.50333e-16 |   5.05734 |  1.79129 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  3 | 663.18        | -1.50726e-13 |   5.05514 |  1.79111 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  4 | 663.183       | -8.0945e-15  |   5.05206 |  1.79031 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  5 | 663.193       |  1.18814e-12 |   5.04215 |  1.7899  |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  6 | 663.199       |  7.09474e-13 |   5.03618 |  1.78912 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  7 | 663.204       |  2.49347e-10 |   5.03097 |  1.78782 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  8 | 663.206       |  2.84162e-11 |   5.02901 |  1.78789 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                  9 | 663.21        |  1.30066e-07 |   5.02508 |  1.78719 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 10 | 663.213       |  3.21151e-09 |   5.02141 |  1.78696 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 11 | 663.217       | -3.1146e-07  |   5.01812 |  1.78698 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 12 | 663.22        | -2.00187e-07 |   5.01431 |  1.78664 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 13 | 663.224       |  2.28363e-05 |   5.01055 |  1.78641 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 14 | 663.233       |  5.2543e-06  |   5.00188 |  1.78495 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 15 | 663.253       | -0.000650705 |   4.99006 |  1.78276 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 16 | 663.248       | -4.66299e-05 |   4.98164 |  1.78218 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 17 | 663.316       |  0.0216992   |   4.97371 |  1.78069 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 18 | 662.723       | -0.0190097   |   4.95912 |  1.77803 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 19 | 668.74        | -2.3071      |  14.4595  |  3.03618 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "|                 20 | 646.143       |  0.915162    |   6.44319 |  2.02349 |\n",
            "+--------------------+---------------+--------------+-----------+----------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "+--------------------+------------+----------+\n",
            "|   Model Complexity |        MSE |      MAE |\n",
            "+====================+============+==========+\n",
            "|                  0 |  688.644   | 22.0651  |\n",
            "+--------------------+------------+----------+\n",
            "|                  1 |    5.03571 |  1.79794 |\n",
            "+--------------------+------------+----------+\n",
            "|                  2 |    5.03346 |  1.79678 |\n",
            "+--------------------+------------+----------+\n",
            "|                  3 |    5.03102 |  1.79574 |\n",
            "+--------------------+------------+----------+\n",
            "|                  4 |    5.01938 |  1.79188 |\n",
            "+--------------------+------------+----------+\n",
            "|                  5 |    5.01508 |  1.79148 |\n",
            "+--------------------+------------+----------+\n",
            "|                  6 |    5.00944 |  1.78921 |\n",
            "+--------------------+------------+----------+\n",
            "|                  7 |    4.99873 |  1.78631 |\n",
            "+--------------------+------------+----------+\n",
            "|                  8 |    4.9869  |  1.78633 |\n",
            "+--------------------+------------+----------+\n",
            "|                  9 |    4.97871 |  1.78521 |\n",
            "+--------------------+------------+----------+\n",
            "|                 10 |    4.97165 |  1.78342 |\n",
            "+--------------------+------------+----------+\n",
            "|                 11 |    4.95807 |  1.77983 |\n",
            "+--------------------+------------+----------+\n",
            "|                 12 |    4.94708 |  1.77817 |\n",
            "+--------------------+------------+----------+\n",
            "|                 13 |    4.93551 |  1.77531 |\n",
            "+--------------------+------------+----------+\n",
            "|                 14 |    4.91857 |  1.77118 |\n",
            "+--------------------+------------+----------+\n",
            "|                 15 |    4.90058 |  1.7689  |\n",
            "+--------------------+------------+----------+\n",
            "|                 16 |    4.88602 |  1.76733 |\n",
            "+--------------------+------------+----------+\n",
            "|                 17 |    4.86365 |  1.76361 |\n",
            "+--------------------+------------+----------+\n",
            "|                 18 |    4.84101 |  1.75979 |\n",
            "+--------------------+------------+----------+\n",
            "|                 19 |    9.74658 |  2.48002 |\n",
            "+--------------------+------------+----------+\n",
            "|                 20 |    5.05939 |  1.79148 |\n",
            "+--------------------+------------+----------+\n",
            "|                 21 | 1081.11    | 24.4265  |\n",
            "+--------------------+------------+----------+\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAHFCAYAAADYPwJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfsklEQVR4nO3deVxUVf8H8M9lG/ZhURhQVFTcEvckMANTUXPNSsslVPSxTIvSn0lm2oamTy5lWfa45lq5ZGamlaLmElqWW2mGiQlpCsMiDMuc3x80N4YZYO4wMGif9+s1r+DeM3fOzDDOp/M9515JCCFAREREVIc42LsDREREROUxoBAREVGdw4BCREREdQ4DChEREdU5DChERERU5zCgEBERUZ3DgEJERER1DgMKERER1TkMKERERFTnMKD8y61evRqSJBnd6tevj5iYGOzcudOkvSRJmDNnTq3388cff4QkSZgxY0aFbS5cuABJkvD000/b5DHHjBmDJk2a2ORYdcHBgwcxbNgwNGjQAC4uLlCr1YiKisKyZcuQl5dn7+4pcv36dTg4OODJJ5802ffMM89AkiQkJiaa7IuPj4ejoyMyMzONtv/000+QJAk//PCDvO3GjRtITExEmzZt4O7uDm9vb9xzzz145513UFRUZFE/Y2JijD5brq6uaNOmDV577TUUFhYqfNY1p6b+1mNiYhATE2Pz4xokJSVh+/btJtv3798PSZKwf//+GntsqgWC/tVWrVolAIhVq1aJI0eOiMOHD4utW7eK+++/XwAQO3bsMGp/5MgRkZaWZpe+du7cWQQFBYni4mKz+xMTEwUAcfLkSZs83q+//iq+//57mxzL3l566SUBQERFRYkVK1aI/fv3i127dokXX3xRBAQEiISEBHt3UbG2bduKli1bmmxv166d8PDwEBERESb7mjZtKjp16mSy/aWXXhKhoaHy7+fOnRMhISHC19dXvPbaa+Kbb74Rn3/+uXjyySeFo6OjiI6OFnl5eVX2MTo6WjRt2lQcOXJEHDlyROzYsUMMGjRIABATJkxQ+IxrTlxcnGjcuLHNj3vmzBlx5swZmx/XwMPDQ8TFxZls12q14siRI0Kr1dbYY1PNY0D5lzMElJSUFKPtt27dEiqVSjz22GN26pmpd999VwAQn332mcm+4uJi0aBBA9G5c+dqP44lXzy3k48++kgAEPHx8UKv15vsz87OFl9++aVNHqs2X7spU6YIACI9PV3eduPGDSFJkpg2bZpwcnIS2dnZ8r60tDQBQEydOtXkWG3atBHTpk0TQpT+LbVp00ao1Wrxyy+/mLTdtGmTACAmTpxYZR+jo6PFXXfdZbStqKhIhIWFCRcXF5Gfn2/x861Jtg4otfV3UFFAoTsDSzxklqurK1xcXODs7Gy0vXyJ5/r165g0aRLatGkDT09PBAQE4P7778fBgwdNjrls2TK0b98enp6e8PLyQqtWrfDCCy9Y3KcRI0bAzc0Nq1atMtm3Z88e/PHHHxg3bhwAYPPmzYiNjUVQUBDc3NzQunVrzJgxw6SUMWbMGHh6euLUqVOIjY2Fl5cXevbsKe8rP+z9zjvv4L777kNAQAA8PDwQHh6O+fPnmwz5x8TEoG3btkhJSUH37t3h7u6Opk2bYt68edDr9UZts7KyMHXqVDRt2hQqlQoBAQF44IEH8PPPP8ttCgsL8dprr6FVq1ZQqVSoX78+xo4di+vXr1f5ur3yyivw9fXFW2+9BUmSTPZ7eXkhNjYWAHDp0iVIkoTVq1ebtCv/3s+ZMweSJOH777/Hww8/DF9fXzRr1gyLFy+GJEn49ddfTY7x/PPPw8XFBX/99Ze87auvvkLPnj3h7e0Nd3d3dOvWDV9//XWVz6tHjx4AYDSMn5ycDCcnJ0ybNg0AjP4O9+3bZ3Q/g59//hlnz57FQw89BADYtm0bzp49ixkzZqBFixYmjzt8+HDExsZixYoVyMjIqLKf5Tk5OaFDhw4oLCxEVlaWvF0IgXfffRcdOnSAm5sbfH198fDDD+O3334zur8QAklJSWjcuDFcXV3RpUsX7N2716ScYijfXrp0yej+lpY/lP6tHzhwAFFRUXB3d5c/h+X7NGbMGJOSsuFm+NsqKCjA1KlT0aFDB6jVavj5+SEyMhKffvqp0eNKkoS8vDysWbNGPobhsSp6jjt27EBkZCTc3d3h5eWF3r1748iRI0ZtDH/XZ86cwWOPPQa1Wo3AwECMGzcOWq220teMbIsBhQAAJSUlKC4uRlFREa5cuYKEhATk5eVhxIgRld7v5s2bAIDZs2fj888/x6pVq9C0aVPExMQY/eOwadMmTJo0CdHR0di2bRu2b9+OZ599VtHcB7VajYceegifffaZyRfzqlWr4OrqKvf3woULeOCBB7BixQrs3r0bCQkJ+OijjzBw4ECT4xYWFmLQoEG4//778emnn+Lll1+usA8XL17EiBEj8OGHH2Lnzp2Ij4/HggULMHHiRJO2GRkZGDlyJEaNGoUdO3agX79+SExMxLp16+Q2OTk5uPfee/H+++9j7Nix+Oyzz/Dee++hRYsWSE9PBwDo9XoMHjwY8+bNw4gRI/D5559j3rx58pdSfn5+hf1NT0/H6dOnERsbC3d398pfYCsNHToUzZs3x8cff4z33nsPo0aNgouLi0nIKSkpwbp16zBw4EDUq1cPALBu3TrExsbC29sba9aswUcffQQ/Pz/06dOnypASHR0NBwcHOXgApSGkS5cuCAwMROfOnY3+Bvft2wdHR0d0797d6DhbtmxBgwYNEBERAQDYu3cvAGDIkCEVPvaQIUNQXFxs9RyH1NRU+Pj4oH79+vK2iRMnIiEhAb169cL27dvx7rvv4syZM4iKisKff/4pt5s5cyZmzpyJvn374tNPP8UTTzyB8ePH4/z581b1pSJK/tbT09MxatQojBgxArt27cKkSZPMHnPWrFk4cuSI0W3UqFEAgDZt2gAAdDodbt68iWnTpmH79u3YuHEj7r33XgwdOhRr166Vj3XkyBG4ubnhgQcekI/17rvvVvh8NmzYgMGDB8Pb2xsbN27EihUrkJmZiZiYGBw6dMik/UMPPYQWLVpgy5YtmDFjBjZs2IBnn31W0WtI1WTvIRyyL0OJp/xNpVKJd99916Q9ADF79uwKj1dcXCyKiopEz549xYMPPihvnzx5svDx8al2f/ft2ycAiIULF8rbbty4IVQqlRg5cqTZ++j1elFUVCSSk5MFAPHjjz/K++Li4gQAsXLlSpP7VTXsXVJSIoqKisTatWuFo6OjuHnzprwvOjpaABDHjh0zuk+bNm1Enz595N9feeUVAUDs3bu3wsfZuHGjACC2bNlitD0lJUUAMPs+GRw9elQAEDNmzKiwTVmpqanynKTyyr/3s2fPFgDESy+9ZNJ26NChomHDhqKkpETetmvXLqMSXV5envDz8xMDBw40um9JSYlo37696Nq1a5X97dChg2jRooX8e3h4uPxcp0+fLrp06SLvCw0NNXvMDh06iClTpsi/9+3bVwAQBQUFFT7uF198IQCIN954o9L+GUo8RUVFoqioSKSnp8vzgd577z253ZEjRwQA8eabbxrdPy0tTbi5uYnp06cLIYS4efOmUKlUYvjw4UbtDPePjo6Wtxk+26mpqUZtDZ+hffv2ydts8bf+9ddfm33+ZftU3kcffSQkSRIvvPBChW0M/6bEx8eLjh07Gu2rqMRT/jmWlJSI4OBgER4ebvQ3mZOTIwICAkRUVJS8zfB3PX/+fKNjTpo0Sbi6upotk1LN4AgKAQDWrl2LlJQUpKSk4IsvvkBcXByeeuopLF26tMr7vvfee+jUqRNcXV3h5OQEZ2dnfP311zh37pzcpmvXrsjKysJjjz2GTz/91GiIX4no6Gg0a9bMqMyzfv166HQ6eVgZAH777TeMGDECGo0Gjo6OcHZ2RnR0NAAY9cvAMLxflR9++AGDBg2Cv7+/fNzHH38cJSUlJv8Hq9Fo0LVrV6Nt7dq1w++//y7//sUXX6BFixbo1atXhY+5c+dO+Pj4YODAgSguLpZvHTp0gEajsftKBXOv3dixY3HlyhV89dVX8rZVq1ZBo9GgX79+AIDDhw/j5s2biIuLM3peer0effv2RUpKSpUjbD169MD58+dx9epV3LhxA6dPn5aH+aOjo/HDDz9Aq9Xi8uXLSE1NNSnv/Pbbbzh58qTF77+BEAIAzJbMyjtz5gycnZ3h7OyMoKAgvPLKK0hMTDQaidi5cyckScKoUaOMXguNRoP27dvL7/HRo0eh0+kwbNgwo8e45557bL4KR8nfuq+vL+6//35Fx09OTsbo0aMxatQovP7660b7Pv74Y3Tr1g2enp7yvykrVqww+9m1xC+//IKrV69i9OjRcHD452vP09MTDz30EI4ePYpbt24Z3WfQoEFGv7dr1w4FBQW4du2aVX0g5RhQCADQunVrdOnSBV26dEHfvn3x/vvvIzY2FtOnTzeqk5e3cOFCPPnkk4iIiMCWLVtw9OhRpKSkoG/fvkalh9GjR2PlypX4/fff8dBDDyEgIAARERHycLqlJEnCuHHjcOrUKRw/fhxA6RdfaGio/OWTm5uL7t2749ixY3jttdewf/9+pKSkYOvWrQBgUhIxLCGtyuXLl9G9e3f88ccfWLJkCQ4ePIiUlBS88847Zo/r7+9vcgyVSmXU7vr162jYsGGlj/vnn38iKytLnhNU9paRkVFp2GvUqBGA0pJCTQkKCjLZ1q9fPwQFBclBMjMzEzt27MDjjz8OR0dHAJDLFg8//LDJ83rjjTcghJBLiBUpOw9l//79cHR0RLdu3QAA9957L4DSeSgVzT/55JNPEBAQILcFLHvNDPM6QkJCKu0fADRr1gwpKSn47rvv8PHHH6N9+/aYO3cuNm3aJLf5888/IYRAYGCgyWtx9OhR+T2+ceMGACAwMNDkccxts5bSv3VzfwOVOXPmDIYMGYLu3btjxYoVRvu2bt0qL4dft24djhw5gpSUFIwbNw4FBQVWPR/D62aun8HBwdDr9SZLz8t/flUqFQDT5041x8neHaC6q127dvjyyy9x/vx5k5EAg3Xr1iEmJgbLli0z2p6Tk2PSduzYsRg7dizy8vJw4MABzJ49GwMGDMD58+fRuHFji/s1ZswYvPTSS1i5ciWcnZ3xww8/4NVXX5X/b/abb77B1atXsX//fnnUBECFQcuS/wsGgO3btyMvLw9bt2416u/Jkyct7nt59evXx5UrVyptU69ePfj7+2P37t1m93t5eVV436CgIISHh2PPnj24detWlfNQXF1dAZTOAyjL8A+8OeZeP0dHR4wePRpvvfUWsrKysGHDBuh0OowdO9boeQHA22+/jXvuucfssav60r3vvvvg6OiI/fv3Q6VSoVOnTvD09AQAeHt7o0OHDti3bx9u3rwJJycnObwYbNmyBUOGDJFDEwD07t0by5cvx/bt2ys878727dvh5ORk0Tk+DBNZAeDuu+9Gjx49cNdddyEhIQEDBgyAp6cn6tWrB0mScPDgQfmLsCzDNsOXZtk5KQYZGRlGoygVvZeWjF4q/Vu39DMEAFeuXEHfvn3RqFEjbNmyxWQi/rp16xAaGorNmzcbHbf881DC8LoZ5nWVdfXqVTg4OMDX19fq41PN4AgKVcjwj1HZiXzlSZJk8g/qTz/9ZDIzviwPDw/069cPM2fORGFhIc6cOaOoX8HBwejbty82btyId955Bw4ODoiLizPqEwCTfr3//vuKHqc8c8cVQuCDDz6w+pj9+vXD+fPn8c0331TYZsCAAbhx4wZKSkrkUa6yt5YtW1b6GLNmzUJmZiaefvppuTRRVm5uLvbs2QOgNBC4urrip59+MmpTfgWFJcaOHYuCggJs3LgRq1evRmRkJFq1aiXv79atG3x8fHD27Fmzz6tLly5wcXGp9DHUajU6duwoj6CUDwzR0dHYt28f9u/fj65du8rhBQDS0tKQkpJiUt558MEH0aZNG8ybN8/sxNPNmzdjz549GD9+PDQajeLXxd/fH/PmzcOff/6Jt99+G0DpeyyEwB9//GH2dQgPDwcAREREQKVSYfPmzUbHPHr0qFHpEIAcVsq/lzt27KiyjzXxtw4AWq0W/fr1gyRJ2LVrl9mRS0mS4OLiYhROMjIyzP4Nlh+RrEjLli3RoEEDbNiwwegzkJeXhy1btsgre6hu4QgKAQBOnz6N4uJiAKX/t7x161bs3bsXDz74IEJDQyu834ABA/Dqq69i9uzZiI6Oxi+//IJXXnkFoaGh8vEAYMKECXBzc0O3bt0QFBSEjIwMzJ07F2q1Gnfffbfi/sbHx+Pzzz/H//73P/Tp08doqD0qKgq+vr544oknMHv2bDg7O2P9+vX48ccfFT9OWb1794aLiwsee+wxTJ8+HQUFBVi2bJnJ0LASCQkJ2Lx5MwYPHowZM2aga9euyM/PR3JyMgYMGIAePXrg0Ucfxfr16/HAAw/gmWeeQdeuXeHs7IwrV65g3759GDx4MB588MEKH+ORRx7BrFmz8Oqrr+Lnn39GfHw8mjVrhlu3buHYsWN4//335aWzhnkQK1euRLNmzdC+fXt899132LBhg+Ln1qpVK0RGRmLu3LlIS0vD8uXLjfZ7enri7bffRlxcHG7evImHH34YAQEBuH79On788Udcv37dZGTOnB49emDBggWQJAlvvPGG0b7o6GgsWrQIQgiMHDnSaN+WLVvg4+NjUvZxdHTEli1b0Lt3b0RGRmLq1KmIjIyETqfDZ599huXLlyM6Ohpvvvmm4tfE4PHHH8fChQvx3//+F0899RS6deuG//znPxg7diyOHz+O++67Dx4eHkhPT8ehQ4cQHh6OJ598En5+fnjuuecwd+5c+Pr64sEHH8SVK1fw8ssvIygoyGh+xd13342WLVti2rRpKC4uhq+vL7Zt22Z2xUp5NfG3DpSeKuDs2bNYvnw50tLSkJaWJu9r2LAhGjZsiAEDBmDr1q2YNGkSHn74YaSlpeHVV19FUFAQLly4YHS88PBw7N+/H5999hmCgoLg5eVlNrA7ODhg/vz5GDlyJAYMGICJEydCp9NhwYIFyMrKwrx586r1vKiG2G16LtUJ5lbxqNVq0aFDB7Fw4UKTlQwot5JDp9OJadOmiQYNGghXV1fRqVMnsX37dpNVAWvWrBE9evQQgYGBwsXFRQQHB4thw4aJn376yap+FxYWisDAQAFAfPTRRyb7Dx8+LCIjI4W7u7uoX7++GD9+vPj+++9NVqjExcUJDw8Ps49hbmXDZ599Jtq3by9cXV1FgwYNxP/93//JKzrKroowd4Kuio6ZmZkpnnnmGdGoUSPh7OwsAgICRP/+/cXPP/8stykqKhL//e9/5cf29PQUrVq1EhMnThQXLlyo+gUTQiQnJ4uHH35YBAUFCWdnZ+Ht7S0iIyPFggULjE5optVqxfjx40VgYKDw8PAQAwcOFJcuXapwFc/169crfMzly5cLAMLNza3Cs3omJyeL/v37Cz8/P+Hs7CwaNGgg+vfvLz7++GOLnpdhdZCjo6PJY9y8eVM4ODiYXSl17733VnqSr7/++kvMmDFDtGrVSn7Nu3btKpYuXSoKCwst6ltFfwdCCPH5558LAOLll1+Wt61cuVJEREQIDw8P4ebmJpo1ayYef/xxcfz4cbmNXq8Xr732mmjYsKFwcXER7dq1Ezt37hTt27c3WjknhBDnz58XsbGxwtvbW9SvX19MmTJFftyqVvFU92/dsK/sKp7GjRubXTVY/m9r3rx5okmTJkKlUonWrVuLDz74QP57K+vkyZOiW7duwt3d3WgVk7mVSkIIsX37dhERESFcXV2Fh4eH6Nmzp/j222+N2lT0d13RqiiqOZIQZsZ8iYjuYBkZGWjQoAG2b99u9tw4t5vU1FS0atUKs2fPVnTyQ6K6jAGFiOg28uOPP2Ljxo2IioqCt7c3fvnlF8yfPx/Z2dk4ffq0TVfzENkT56BQnVB2voo5Dg4ORvV1on8rDw8PHD9+HCtWrEBWVhbUajViYmLw+uuvM5zQHYUjKFQnVLVMMS4uzuz1YYiI6M7EERSqE1JSUirdbzhnBhER/TsoGjNv0qSJ2atQPvXUUwBK18nPmTMHwcHBcHNzQ0xMjMk5LnQ6HaZMmYJ69erBw8MDgwYNqvJEVXTnq+g8GIabrU/jTUREdZuigJKSkoL09HT5ZjhN+SOPPAIAmD9/PhYuXIilS5ciJSUFGo0GvXv3NjqraEJCArZt24ZNmzbh0KFDyM3NxYABA1BSUmLDp0VERES3s2rNQUlISMDOnTvlk+cEBwcjISEBzz//PIDS0ZLAwEC88cYbmDhxIrRaLerXr48PP/wQw4cPB1B6muGQkBDs2rULffr0sehx9Xo9rl69Ci8vL0WnWCYiIiL7EUIgJycHwcHBVS98sPYEKjqdTvj7+4vXX39dCCHExYsXBQDx/fffG7UbNGiQePzxx4UQQnz99dcCgNGluoUQol27dmYv2W5QUFAgtFqtfDt79myFJ/vhjTfeeOONN97q9i0tLa3KnGH1JNnt27cjKysLY8aMAVB64iPA9OJegYGB8jUiMjIy4OLiYnJRpsDAQPn+5sydOxcvv/yyyfa0tDSLrkJLRERE9pednY2QkJBKL3JqYHVAWbFiBfr164fg4GCj7eVLLkKIKsswVbVJTEzEc889J/9ueILe3t4MKERERLcZS6ZnWHXmq99//x1fffUVxo8fL28zXNWz/EjItWvX5FEVjUaDwsJCkwtOlW1jjkqlksMIQwkREdGdz6qAsmrVKgQEBKB///7yttDQUGg0GnllDwAUFhYiOTkZUVFRAIDOnTvD2dnZqE16ejpOnz4ttyEiIiJSXOLR6/VYtWoV4uLi4OT0z90lSUJCQgKSkpIQFhaGsLAwJCUlwd3dHSNGjAAAqNVqxMfHY+rUqfD394efnx+mTZuG8PBw9OrVy3bPioiIiG5rigPKV199hcuXL2PcuHEm+6ZPn478/HxMmjQJmZmZiIiIwJ49e4wmwyxatAhOTk4YNmwY8vPz0bNnT6xevRqOjo7VeyZERER0x7gtr8WTnZ0NtVoNrVbL+ShERES3CSXf37w8LBEREdU5DChERERU5zCgEBERUZ3DgEJERER1DgMKERER1TkMKERERFTnMKAQERFRncOAQkREdBvKL8pHji7H3t2oMVZfzfhO9PPPwJAhgKsrcPKkvXtDRET/ZkIIXMu7houZF/Fb5m/4LfM3o5+v5lyFo+SI0e1H48XuL6KZXzN7d9mmeCbZMn77DWjWDHBzA27dstlhiYiIzNIV63Ap65JJ+DD8fKvIsi8jR8kRce3j8OJ9LyLUN7SGe209Jd/fDChlZGYCfn6lPxcUACqVzQ4NXbEOX6d+jfyifNsdtBYI1NyfR0396dVkn2vKbfgx5OtcS+z5GazssevCa2noX9m+VGcbADg5OMHRwRGOkqP8s5ODExwlxwp/ruo+EiRczblqEkJ+y/wNV7KvVPo6O0gOCPEOQVPfpmjq2xTNfJv987NfM1y4cQFzkudg96+75f6PaT8GM++biSY+Tarx6tYMBhQr6fWAkxMgBJCeDmg0Njs0Xtr3El498KrtDkhERHcETxdP0/Dx98+NfRrDxdGlymMcSTuCOclzsOfiHgClQWVsh7GY2X0mGvs0rumnYDEGlGrw8ysdSTlzBmjTxnbHHfbxMHx89mM0822GYK9g2x34NidJkuVtYXnbmqSkz3VFXXntlODrXOa4NfhaKOlzXXlPyvbZ0CdbbBMQKNGXoFhfjBLx93/1JUY/W7KvfDu90EPjqTE/CuLbDPXc69nstT2cdhiz98/GV799BQBwdnDGuI7j8EL3F9BI3cgmj1EdSr6/OUm2HF/f0oCSmWnb42YWlB5wTswcjGo3yrYHJyIiAhAVEoW9o/fi0OVDmL1/Nr5J/Qbvn3gfK39YifGdxuOF7i+goXdDe3fTIlxmXI6vb+l/bR5Q8ksP6Ovqa9sDExERlXNvo3vx9eNfI3lMMno06YEifRGWHV+GZm81w+Rdk/FH9h/27mKVGFDKMQSUmzdte9yb+aUH9HPzs+2BiYiIKnBf4/vwTdw32Be3D/c1vg+FJYV4J+UdNHurGZ7+4mlczblq7y5WiAGlHMMqnpoq8fi6cQSFiIhqV0yTGOyP24+vH/8a9za6F7oSHd7+7m00e6sZEnYnID0n3d5dNMGAUk5NlHhK9CXQFmhLj88SDxER2YEkSbg/9H4cGHMAe0fvRVRIFAqKC7Dk2BI0faspnt39LDJyM+zdTRkDSjk1UeLR6rTyOneOoBARkT1JkoReTXvh0NhD2DNqDyIbRqKguACLjy1G0yVNMfXLqfgz9097d5MBpbyaKPEYJsh6OHtYtJ6diIiopkmShN7NeuPbcd9i98jdiGgQgfzifCw8uhBN32qK/9vzfxafybYmMKCUUxMlHs4/ISKiukqSJPRp3gdH4o9g14hduDv4btwquoXPzn8GlaMNT6muEM+DUk6NBJS/R1C4goeIiOoqSZLQL6wf+jbvi10Xdsmn7bcXBpRyDCUeW85BMSwx5gRZIiKq6yRJQv8W/e3dDZZ4ymOJh4iIyP4YUMopG1BsdZUinkWWiIhIGQaUcgwlnsJC4JaNJi/zLLJERETKMKCU4+kJOP49J8hWZR65xMMRFCIiIoswoJQjSbafh8I5KERERMowoJhh65U8LPEQEREpw4Bihs1HUDhJloiISBEGFDNY4iEiIrIvBhQzWOIhIiKyLwYUM2w5glJUUoTcwtzS47LEQ0REZBEGFDNsGVCyCrLkn31cfap/QCIion8BBhQzbFniMZR31Cq1XS+6REREdDthQDHDliMonCBLRESkHAOKGTYNKFxiTEREpBgDihk1UeLhCh4iIiLLMaCYwRIPERGRfSkOKH/88QdGjRoFf39/uLu7o0OHDjhx4oS8XwiBOXPmIDg4GG5uboiJicGZM2eMjqHT6TBlyhTUq1cPHh4eGDRoEK5cuVL9Z2MjZQOKXl+9Y7HEQ0REpJyigJKZmYlu3brB2dkZX3zxBc6ePYs333wTPj4+cpv58+dj4cKFWLp0KVJSUqDRaNC7d2/k5OTIbRISErBt2zZs2rQJhw4dQm5uLgYMGICSkhKbPbHqMJR49HqgTLetwhIPERGRck5KGr/xxhsICQnBqlWr5G1NmjSRfxZCYPHixZg5cyaGDh0KAFizZg0CAwOxYcMGTJw4EVqtFitWrMCHH36IXr16AQDWrVuHkJAQfPXVV+jTp48Nnlb1uLkBKhWg05WOoqjV1h9LLvFwBIWIiMhiikZQduzYgS5duuCRRx5BQEAAOnbsiA8++EDen5qaioyMDMTGxsrbVCoVoqOjcfjwYQDAiRMnUFRUZNQmODgYbdu2lduUp9PpkJ2dbXSrabaah8I5KERERMopCii//fYbli1bhrCwMHz55Zd44okn8PTTT2Pt2rUAgIyMDABAYGCg0f0CAwPlfRkZGXBxcYGvr2+FbcqbO3cu1Gq1fAsJCVHSbavYaiUPSzxERETKKQooer0enTp1QlJSEjp27IiJEydiwoQJWLZsmVE7SZKMfhdCmGwrr7I2iYmJ0Gq18i0tLU1Jt61isxEUTpIlIiJSTFFACQoKQps2bYy2tW7dGpcvXwYAaDQaADAZCbl27Zo8qqLRaFBYWIjMct/8ZduUp1Kp4O3tbXSraSzxEBER2Y+igNKtWzf88ssvRtvOnz+Pxo0bAwBCQ0Oh0Wiwd+9eeX9hYSGSk5MRFRUFAOjcuTOcnZ2N2qSnp+P06dNym7rAUOKpbkAxlHg4gkJERGQ5Rat4nn32WURFRSEpKQnDhg3Dd999h+XLl2P58uUASks7CQkJSEpKQlhYGMLCwpCUlAR3d3eMGDECAKBWqxEfH4+pU6fC398ffn5+mDZtGsLDw+VVPXWBYQSlOnNQCooLUFBcAIBzUIiIiJRQFFDuvvtubNu2DYmJiXjllVcQGhqKxYsXY+TIkXKb6dOnIz8/H5MmTUJmZiYiIiKwZ88eeHl5yW0WLVoEJycnDBs2DPn5+ejZsydWr14NR8e6c7VfW5R4DPNPHCQHeKm8qmhNREREBpIQQti7E0plZ2dDrVZDq9XW2HyUt94CnnkGeOQR4KOPrDvGmWtn0HZZW/i5+eHG9Bu27SAREdFtRsn3N6/FUwFbLDM2TJBleYeIiEgZBpQK2LLEwwmyREREyjCgVMAWAUVewcMlxkRERIowoFSAJR4iIiL7YUCpgGEERasFrL3IMks8RERE1mFAqUDZSwVptdYdg1cyJiIisg4DSgVcXAAPj9KfrS3z8EKBRERE1mFAqUR1J8ryOjxERETWYUCpRLUDCuegEBERWYUBpRLVXcnDEg8REZF1GFAqwRIPERGRfTCgVKI6AUUIwRIPERGRlRhQKlGdEk9eUR6K9EWlx2GJh4iISBEGlEpUZwTFMHri7OAMd2d3G/aKiIjozseAUolqBZQy808kSbJhr4iIiO58DCiVqE6Jhyt4iIiIrMeAUglblHg4QZaIiEg5BpRK2KrEQ0RERMowoFTCUOKxJqCwxENERGQ9BpRKGEZQcnOBoiJl92WJh4iIyHoMKJXw8fnnZ6WjKHKJhwGFiIhIMQaUSjg6Amp16c9KA4qhxMM5KERERMoxoFTBUOZRutTYMILCOShERETKMaBUwdqVPJyDQkREZD0GlCpYu5KHJR4iIiLrMaBUgSUeIiKi2seAUgVrSjx6oUdWQVbp/VniISIiUowBpQrWlHiyddnQCz0AlniIiIiswYBSBWtKPIYJsm5ObnB1cq2BXhEREd3ZGFCqYE2Jh9fhISIiqh4GlCpYE1DkFTycf0JERGQVBpQqGOagWFPi4QoeIiIi6zCgVIElHiIiotrHgFIFlniIiIhqHwNKFQwlnoICID/fsvuwxENERFQ9DChV8PICHP5+lSwdRZFLPBxBISIisgoDShUcHAAfn9KfFQcUzkEhIiKyCgOKBZSu5DHMQWGJh4iIyDoMKBZQOlHWMAeFJR4iIiLrKAooc+bMgSRJRjeNRiPvF0Jgzpw5CA4OhpubG2JiYnDmzBmjY+h0OkyZMgX16tWDh4cHBg0ahCtXrtjm2dQQxQGFJR4iIqJqUTyCctdddyE9PV2+nTp1St43f/58LFy4EEuXLkVKSgo0Gg169+6NnJwcuU1CQgK2bduGTZs24dChQ8jNzcWAAQNQUlJim2dUA1jiISIiql1Oiu/g5GQ0amIghMDixYsxc+ZMDB06FACwZs0aBAYGYsOGDZg4cSK0Wi1WrFiBDz/8EL169QIArFu3DiEhIfjqq6/Qp0+faj6dmqFkBKVEX4JsXXbp/VjiISIisoriEZQLFy4gODgYoaGhePTRR/Hbb78BAFJTU5GRkYHY2Fi5rUqlQnR0NA4fPgwAOHHiBIqKiozaBAcHo23btnKbukhJQMkqyJJ/9nH1qZH+EBER3ekUjaBERERg7dq1aNGiBf7880+89tpriIqKwpkzZ5CRkQEACAwMNLpPYGAgfv/9dwBARkYGXFxc4Ovra9LGcH9zdDoddDqd/Ht2draSblebocRjSUAxlHc8XTzh7Ohcg70iIiK6cykKKP369ZN/Dg8PR2RkJJo1a4Y1a9bgnnvuAQBIkmR0HyGEybbyqmozd+5cvPzyy0q6alOGPGXJHBTDBFnOPyEiIrJetZYZe3h4IDw8HBcuXJDnpZQfCbl27Zo8qqLRaFBYWIjMckMRZduYk5iYCK1WK9/S0tKq023FlJR4uMSYiIio+qoVUHQ6Hc6dO4egoCCEhoZCo9Fg79698v7CwkIkJycjKioKANC5c2c4OzsbtUlPT8fp06flNuaoVCp4e3sb3WqTNSUeLjEmIiKynqISz7Rp0zBw4EA0atQI165dw2uvvYbs7GzExcVBkiQkJCQgKSkJYWFhCAsLQ1JSEtzd3TFixAgAgFqtRnx8PKZOnQp/f3/4+flh2rRpCA8Pl1f11EUs8RAREdUuRQHlypUreOyxx/DXX3+hfv36uOeee3D06FE0btwYADB9+nTk5+dj0qRJyMzMREREBPbs2QMvLy/5GIsWLYKTkxOGDRuG/Px89OzZE6tXr4ajo6Ntn5kNlS3xCAFUNqWGJR4iIqLqk4QQwt6dUCo7OxtqtRparbZWyj15eYCnZ+nPOTn//GzO1C+nYuHRhZgWOQ0LYhfUeN+IiIhuF0q+v3ktHgu4uwPOf68YrqrMwxIPERFR9TGgWECSLF/Jw+vwEBERVR8DioUsXckjr+LhHBQiIiKrMaBYyNKVPIZJsizxEBERWY8BxUIs8RAREdUeBhQLscRDRERUexhQLGRJiaewpBC3im4BYImHiIioOhhQLGRJiccw/0SCBLWruhZ6RUREdGdiQLGQJSUeQ3lH7aqGg8SXloiIyFr8FrWQJSUenqSNiIjINhhQLKSkxMMJskRERNXDgGIhSwKKvIKHS4yJiIiqhQHFQoY5KCzxEBER1TwGFAsZRlCysgC93nwblniIiIhsgwHFQoaAIgSQnW2+DU/SRkREZBsMKBZydQXc3Ep/rmgeCks8REREtsGAokBVS415HR4iIiLbYEBRoKqVPJyDQkREZBsMKApUdTZZLjMmIiKyDQYUBSwt8XAOChERUfUwoChQWYlHCMESDxERkY0woChQWYknvzgfuhIdAJZ4iIiIqosBRYHKSjyG0RNHyRFeLl612CsiIqI7DwOKApWVeMouMZYkqRZ7RUREdOdhQFGgshIPzyJLRERkOwwoClhS4uEKHiIioupjQFHA0hIPERERVQ8DigIs8RAREdUOBhQFDCMo2dlAcbHxPpZ4iIiIbIcBRQEfn39+zsoy3ieXeDiCQkREVG0MKAo4OwNef5/ipHyZh9fhISIish0GFIUqWsnD6/AQERHZDgOKQhWt5OF1eIiIiGyHAUWhilbysMRDRERkOwwoCrHEQ0REVPMYUBQyV+IRQrDEQ0REZEMMKAqZK/HkFOagRJQAYImHiIjIFhhQFDJX4jGMnqgcVXBzcrNDr4iIiO4sDCgKmSvxlL0OjyRJdugVERHRnYUBRSFzJR5eh4eIiMi2qhVQ5s6dC0mSkJCQIG8TQmDOnDkIDg6Gm5sbYmJicObMGaP76XQ6TJkyBfXq1YOHhwcGDRqEK1euVKcrtcbsCEo+r2RMRERkS1YHlJSUFCxfvhzt2rUz2j5//nwsXLgQS5cuRUpKCjQaDXr37o2cnBy5TUJCArZt24ZNmzbh0KFDyM3NxYABA1BSUmL9M6klZuegcIkxERGRTVkVUHJzczFy5Eh88MEH8PX9Z9RACIHFixdj5syZGDp0KNq2bYs1a9bg1q1b2LBhAwBAq9VixYoVePPNN9GrVy907NgR69atw6lTp/DVV1/Z5lnVIHMjKCzxEBER2ZZVAeWpp55C//790atXL6PtqampyMjIQGxsrLxNpVIhOjoahw8fBgCcOHECRUVFRm2Cg4PRtm1buU15Op0O2dnZRjd7McxBuXUL0OlKf+Y5UIiIiGxLcUDZtGkTTpw4gblz55rsy8jIAAAEBgYabQ8MDJT3ZWRkwMXFxWjkpXyb8ubOnQu1Wi3fQkJClHbbZtRqwLBQxzCKwhIPERGRbSkKKGlpaXjmmWewfv16uLq6Vtiu/FJbIUSVy28ra5OYmAitVivf0tLSlHTbphwcSkMK8E9A4XV4iIiIbEtRQDlx4gSuXbuGzp07w8nJCU5OTkhOTsZbb70FJycneeSk/EjItWvX5H0ajQaFhYXILHe1vbJtylOpVPD29ja62VP5pcbyeVBY4iEiIrIJRQGlZ8+eOHXqFE6ePCnfunTpgpEjR+LkyZNo2rQpNBoN9u7dK9+nsLAQycnJiIqKAgB07twZzs7ORm3S09Nx+vRpuU1dV34lj2EOCks8REREtuGkpLGXlxfatm1rtM3DwwP+/v7y9oSEBCQlJSEsLAxhYWFISkqCu7s7RowYAQBQq9WIj4/H1KlT4e/vDz8/P0ybNg3h4eEmk27rqvIrecqeSZaIiIiqT1FAscT06dORn5+PSZMmITMzExEREdizZw+8vLzkNosWLYKTkxOGDRuG/Px89OzZE6tXr4ajo6Otu1Mjypd4uMyYiIjItiQhhLB3J5TKzs6GWq2GVqu1y3yUJ54A3n8fmD0beGm2Hk6vOEFAIGNqBgI9zc+jISIi+rdT8v3Na/FYoWyJR1ughUBpxmOJh4iIyDYYUKxQtsRjKO+4O7vDxdHFjr0iIiK6c9h8Dsq/QdlVPDxJGxFRzSspKUFRUZG9u0EWcHFxgYND9cc/GFCsULbEw9PcExHVHCEEMjIykJWVZe+ukIUcHBwQGhoKF5fqVRUYUKxgrsTD+SdERLZnCCcBAQFwd3ev8qzkZF96vR5Xr15Feno6GjVqVK33iwHFCizxEBHVvJKSEjmc+Pv727s7ZKH69evj6tWrKC4uhrOzs9XH4SRZK5Qt8dxkiYeIqEYY5py4u7vbuSekhKG0U1JSUq3jMKBYwVDiKSwEruXwJG1ERDWJZZ3bi63eLwYUK3h6AoaT3v6pZYmHiIjI1hhQrCBJ/5R5rufyOjxERKTMpUuXIEkSTp48ae+u1FkMKFYylHlu3GKJh4iIjI0ZMwaSJMk3f39/9O3bFz/99BMAICQkBOnp6SYX4KV/MKBYyTCCksVVPEREZEbfvn2Rnp6O9PR0fP3113BycsKAAQMAAI6OjtBoNHBy4mLaijCgWMkQUHKKWOIhIiJTKpUKGo0GGo0GHTp0wPPPP4+0tDRcv37dpMRTUlKC+Ph4hIaGws3NDS1btsSSJUuMjrd//3507doVHh4e8PHxQbdu3fD777/b4ZnVDkY3KxlKPLklLPEQEdUWIYBbt+zz2O7upXMQrZGbm4v169ejefPm8Pf3R15entF+vV6Phg0b4qOPPkK9evVw+PBh/Oc//0FQUBCGDRuG4uJiDBkyBBMmTMDGjRtRWFiI77777o5e4cSAYiVfXwAORdAht/R3jqAQEdW4W7dKV1LaQ24u4OFhefudO3fC8+/O5uXlISgoCDt37jR7nRpnZ2e8/PLL8u+hoaE4fPgwPvroIwwbNgzZ2dnQarUYMGAAmjVrBgBo3bp19Z5QHccSj5V8fQG4Zsm/+7j62KsrRERUB/Xo0QMnT57EyZMncezYMcTGxqJfv34VlmXee+89dOnSBfXr14enpyc++OADXL58GQDg5+eHMWPGoE+fPhg4cCCWLFmC9PT02nw6tY4jKFby8wPgVlre8VZ5w8mBLyURUU1zdy8dybDXYyvh4eGB5s2by7937twZarUaH3zwAcaPH2/U9qOPPsKzzz6LN998E5GRkfDy8sKCBQtw7Ngxuc2qVavw9NNPY/fu3di8eTNefPFF7N27F/fcc0+1nlddxW9VK/n6AnDjae6JiGqTJCkrs9QlkiTBwcEB+fn5JvsOHjyIqKgoTJo0Sd528eJFk3YdO3ZEx44dkZiYiMjISGzYsOGODSgs8ViptMTDJcZERGSeTqdDRkYGMjIycO7cOUyZMgW5ubkYOHCgSdvmzZvj+PHj+PLLL3H+/HnMmjULKSkp8v7U1FQkJibiyJEj+P3337Fnzx6cP3/+jp6HwhEUK5Ut8XCCLBERlbd7924EBQUBALy8vNCqVSt8/PHHiImJwaVLl4zaPvHEEzh58iSGDx8OSZLw2GOPYdKkSfjiiy8AlF4w8eeff8aaNWtw48YNBAUFYfLkyZg4cWJtP61aIwkhhL07oVR2djbUajW0Wi28vb3t0ofTp4Hw+KXAA1PwUOuH8MmwT+zSDyKiO1VBQQFSU1MRGhoKV1dXe3eHLFTZ+6bk+5slHiuVLfH4ssRDRERkUwwoViqdJFta4vFwYImHiIjIlhhQrOTmBjh4lI6gqPQMKERERLbEgGIlSQKcvUoDinMxSzxERES2xIBSDQ6epSUex0KOoBAREdkSA0o1SH+fqA0FDChERES2xIBSDSUupQGlJJclHiIiIltiQKmGYqfSgFKcwxEUIiIiW2JAsVJBcQFKHEqvp6DTMqAQERHZEgOKlTLz/55/ondA3k37nM2WiIj+XSRJwvbt2+3djVrBgGKlzALDBFkfZGXyZSQiolIDBw5Er169zO47cuQIJEnC999/b9Wx09PT0a9fv+p077bBb1Yr3cwvXWKMAl9kZtq3L0REVHfEx8fjm2++we+//26yb+XKlejQoQM6deqk6JiFhYUAAI1GA5VKZZN+1nUMKFaSSzz5frh50759ISKiumPAgAEICAjA6tWrjbbfunULmzdvxpAhQ/DYY4+hYcOGcHd3R3h4ODZu3GjUNiYmBpMnT8Zzzz2HevXqoXfv3gBMSzzPP/88WrRoAXd3dzRt2hSzZs1CUVGRvH/OnDno0KEDPvzwQzRp0gRqtRqPPvoocnJy5DZ6vR5vvPEGmjdvDpVKhUaNGuH111+X9//xxx8YPnw4fH194e/vj8GDB5tcjbkmMKBYSS7x5HMEhYiotgghkFeYZ5ebEMKiPjo5OeHxxx/H6tWrje7z8ccfo7CwEOPHj0fnzp2xc+dOnD59Gv/5z38wevRoHDt2zOg4a9asgZOTE7799lu8//77Zh/Ly8sLq1evxtmzZ7FkyRJ88MEHWLRokVGbixcvYvv27di5cyd27tyJ5ORkzJs3T96fmJiIN954A7NmzcLZs2exYcMGBAYGAigNVT169ICnpycOHDiAQ4cOwdPTE3379pVHdWqKU40e/Q7GEg8RUe27VXQLnnM97fLYuYm58HDxsKjtuHHjsGDBAuzfvx89evQAUFreGTp0KBo0aIBp06bJbadMmYLdu3fj448/RkREhLy9efPmmD9/fqWP8+KLL8o/N2nSBFOnTsXmzZsxffp0ebter8fq1avh5eUFABg9ejS+/vprvP7668jJycGSJUuwdOlSxMXFAQCaNWuGe++9FwCwadMmODg44H//+x8kSQIArFq1Cj4+Pti/fz9iY2Mtej2swYBipbIlHq0WKCkBHB3t2yciIqobWrVqhaioKKxcuRI9evTAxYsXcfDgQezZswclJSWYN28eNm/ejD/++AM6nQ46nQ4eHsbhp0uXLlU+zieffILFixfj119/RW5uLoqLi+HtbbyytEmTJnI4AYCgoCBcu3YNAHDu3DnodDr07NnT7PFPnDiBX3/91ej+AFBQUICLFy9a9FpYiwHFSmVLPEIAWi3gxxPKEhHVKHdnd+Qm5trtsZWIj4/H5MmT8c4772DVqlVo3LgxevbsiQULFmDRokVYvHgxwsPD4eHhgYSEBJOSSfnAUt7Ro0fx6KOP4uWXX0afPn2gVquxadMmvPnmm0btnJ2djX6XJAl6vR4A4ObmVulj6PV6dO7cGevXrzfZV79+/UrvW10MKFYylHhc9L4oBJCZyYBCRFTTJEmyuMxib8OGDcMzzzyDDRs2YM2aNZgwYQIkScLBgwcxePBgjBo1CkBpCLhw4QJat26t6PjffvstGjdujJkzZ8rbzK0cqkxYWBjc3Nzw9ddfY/z48Sb7O3XqhM2bNyMgIMBkZKamKZoku2zZMrRr1w7e3t7w9vZGZGQkvvjiC3m/EAJz5sxBcHAw3NzcEBMTgzNnzhgdQ6fTYcqUKahXrx48PDwwaNAgXLlyxTbPphYZRlA8HErPIst5KEREVJanpyeGDx+OF154AVevXsWYMWMAlM4t2bt3Lw4fPoxz585h4sSJyMjIUHz85s2b4/Lly9i0aRMuXryIt956C9u2bVN0DFdXVzz//POYPn061q5di4sXL+Lo0aNYsWIFAGDkyJGoV68eBg8ejIMHDyI1NRXJycl45plnavy7W1FAadiwIebNm4fjx4/j+PHjuP/++zF48GA5hMyfPx8LFy7E0qVLkZKSAo1Gg969exstZ0pISMC2bduwadMmHDp0CLm5uRgwYABKSkps+8xqmGEOipdz6bAJlxoTEVF58fHxyMzMRK9evdCoUSMAwKxZs9CpUyf06dMHMTEx0Gg0GDJkiOJjDx48GM8++ywmT56MDh064PDhw5g1a5bi48yaNQtTp07FSy+9hNatW2P48OHyHBV3d3ccOHAAjRo1wtChQ9G6dWuMGzcO+fn5NT+iIqrJ19dX/O9//xN6vV5oNBoxb948eV9BQYFQq9XivffeE0IIkZWVJZydncWmTZvkNn/88YdwcHAQu3fvtvgxtVqtACC0Wm11u2+1lm+3FJgD0X7wPgEIUeYpERGRDeTn54uzZ8+K/Px8e3eFFKjsfVPy/W31eVBKSkqwadMm5OXlITIyEqmpqcjIyDBacqRSqRAdHY3Dhw8DKJ0NXFRUZNQmODgYbdu2lduYo9PpkJ2dbXSzN0OJx8+NJR4iIiJbUxxQTp06BU9PT6hUKjzxxBPYtm0b2rRpI9fPDCd3MQgMDJT3ZWRkwMXFBb6+vhW2MWfu3LlQq9XyLSQkRGm3bUoIIZd46nmyxENERGRrigNKy5YtcfLkSRw9ehRPPvkk4uLicPbsWXm/4UQuBkIIk23lVdUmMTERWq1WvqWlpSnttk3lFeWhSF96KmGNmiMoREREtqY4oLi4uKB58+bo0qUL5s6di/bt22PJkiXQaDQAYDIScu3aNXlURaPRoLCwEJnlvs3LtjFHpVLJK4cMN3syjJ44OTghwKd0uRsDChERke1U+1o8QgjodDqEhoZCo9Fg79698r7CwkIkJycjKioKANC5c2c4OzsbtUlPT8fp06flNreDf+af+MHPr3TkhyUeIqKaISy8Bg7VDbZ6vxSdqO2FF15Av379EBISgpycHGzatAn79+/H7t27IUkSEhISkJSUhLCwMISFhSEpKQnu7u4YMWIEAECtViM+Ph5Tp06Fv78//Pz8MG3aNISHh6NXr142eUK1wXCSNl9XX/nkbBxBISKyLcMZUG/dulXlGU+p7jCcEdexmtd/URRQ/vzzT4wePRrp6elQq9Vo164ddu/eLV8Gevr06cjPz8ekSZOQmZmJiIgI7Nmzx+gc/osWLYKTkxOGDRuG/Px89OzZE6tXr672E6lNhhKPr5svDPN9GVCIiGzL0dERPj4+RufkqGpOI9mXXq/H9evX4e7uDien6p2sXhK34dhZdnY21Go1tFqtXeajrPxhJeJ3xOOBsAcwu/nniIgAQkKAy5drvStERHc0IQQyMjKQlZVl766QhRwcHBAaGgoXFxeTfUq+v3ktHiuwxENEVDskSUJQUBACAgJQVFRk7+6QBVxcXODgUO0prgwo1pBLPK7/lHhyc4GiIqDcRSOJiMgGHB0db6upAFR91Y84/0JlV/H4+JTZzlEUIiIim2BAsYJc4nHzhaMjYCijMaAQERHZBgOKFQwjKL6upfUdzkMhIiKyLQYUKxjmoPi5lSYTwzwUnqyNiIjINhhQrFC2xAOA50IhIiKyMQYUK7DEQ0REVLMYUBTSCz2yCrIAmJZ4GFCIiIhsgwFFoRxdDvRCD8C0xMM5KERERLbBgKKQYf6Jq5MrXJ1cAbDEQ0REZGsMKAqVn38CsMRDRERkawwoCpVfYgywxENERGRrDCgKlV9iDLDEQ0REZGsMKAqxxENERFTzGFAUYomHiIio5jGgKCSXeFxNSzwFBaU3IiIiqh4GFIXkEk+ZOSheXoDD368kyzxERETVx4CikCGglC3xODgAPj6lP7PMQ0REVH0MKAqZK/EAXMlDRERkSwwoChkmyZYt8QBcyUNERGRLDCgKmSvxAFzJQ0REZEsMKAqxxENERFTzGFAUKNGXIFuXDYAlHiIioprEgKJAVkGW/HP5ERSWeIiIiGyHAUUBQ3nH08UTzo7ORvtY4iEiIrIdBhQFzF2Hx4AlHiIiItthQFHA3HV4DFjiISIish0GFAXkFTxupiMoLPEQERHZDgOKAizxEBER1Q4GFAUsLfEIUZu9IiIiuvMwoChQ0UnagH9KPMXFQF5ebfaKiIjozsOAooBc4jEzB8XdHXD+e+UxyzxERETVw4CiQEXX4QEASeI8FCIiIlthQFGgshIP8E+Zh0uNiYiIqocBRQHDJFlzJR6AIyhERES2woCiQGXLjAEGFCIiIlthQFHAUOIxNwcF4NlkiYiIbIUBxUKFJYW4VXQLQMUlHp5NloiIyDYUBZS5c+fi7rvvhpeXFwICAjBkyBD88ssvRm2EEJgzZw6Cg4Ph5uaGmJgYnDlzxqiNTqfDlClTUK9ePXh4eGDQoEG4cuVK9Z9NDTLMPwEAtUpttg1LPERERLahKKAkJyfjqaeewtGjR7F3714UFxcjNjYWeWXOTDZ//nwsXLgQS5cuRUpKCjQaDXr37o2cnBy5TUJCArZt24ZNmzbh0KFDyM3NxYABA1BSUmK7Z2ZjhvKOj6sPHB0czbZhiYeIiMg2nJQ03r17t9Hvq1atQkBAAE6cOIH77rsPQggsXrwYM2fOxNChQwEAa9asQWBgIDZs2ICJEydCq9VixYoV+PDDD9GrVy8AwLp16xASEoKvvvoKffr0sdFTs62qJsgCLPEQERHZSrXmoGi1WgCA39/fzKmpqcjIyEBsbKzcRqVSITo6GocPHwYAnDhxAkVFRUZtgoOD0bZtW7lNeTqdDtnZ2Ua32lbVEmOAJR4iIiJbsTqgCCHw3HPP4d5770Xbtm0BABkZGQCAwMBAo7aBgYHyvoyMDLi4uMDX17fCNuXNnTsXarVavoWEhFjbbatVdhZZA5Z4iIiIbMPqgDJ58mT89NNP2Lhxo8k+SZKMfhdCmGwrr7I2iYmJ0Gq18i0tLc3ablutqrPIAizxEBER2YpVAWXKlCnYsWMH9u3bh4YNG8rbNRoNAJiMhFy7dk0eVdFoNCgsLERmuW/xsm3KU6lU8Pb2NrrVNrnEU0lAMYygZGUBen0tdIqIiOgOpSigCCEwefJkbN26Fd988w1CQ0ON9oeGhkKj0WDv3r3ytsLCQiQnJyMqKgoA0LlzZzg7Oxu1SU9Px+nTp+U2dZGSEo9eD9hhmgwREdEdQ9EqnqeeegobNmzAp59+Ci8vL3mkRK1Ww83NDZIkISEhAUlJSQgLC0NYWBiSkpLg7u6OESNGyG3j4+MxdepU+Pv7w8/PD9OmTUN4eLi8qqcukks8lUySdXUF3NyA/PzSMo+PTy11joiI6A6jKKAsW7YMABATE2O0fdWqVRgzZgwAYPr06cjPz8ekSZOQmZmJiIgI7NmzB15eXnL7RYsWwcnJCcOGDUN+fj569uyJ1atXw9HR/PlF6gJLlhkDpaMohoBSboCJiIiILCQJIYS9O6FUdnY21Go1tFptrc1HuXflvfg27Vt88sgneKjNQxW2a9sWOHMG2LsXqMMDQkRERLVOyfc3r8VjIUtKPABX8hAREdkCA4qFlJR4AAYUIiKi6mBAsYAQQl5mXNkqHoAnayMiIrIFBhQL5BfnQ1eiA8ASDxERUW1gQLGAYfTEUXKEl4tXpW1Z4iEiIqo+BhQLyPNP3HyrPGU/AwoREVH1MaBYwJLr8BgYSjycg0JERGQ9BhQLyNfhqWL+CcARFCIiIltgQLGApUuMAQYUIiIiW2BAsYChxFPVEmOAJR4iIiJbYECxgFziUTCCkp0NlJTUZK+IiIjuXAwoFii7iqcqZa9gnJVVM/0hIiK60zGgWEBJicfZGTBcuJllHiIiIuswoFhAySRZgBNliYiIqosBxQJKlhkDDChERETVxYBiASUlHoAreYiIiKqLAcUCLPEQERHVLgaUKgghWOIhIiKqZQwoVcgpzEGJKD2hiaUlHkNAYYmHiIjIOgwoVTCMnrg4usDNyc2i+xjmoHAEhYiIyDoMKFUoO/9EkiSL7sMSDxERUfUwoFRB6QoegCUeIiKi6mJAqYLSCbIASzxERETVxYBSBaVLjAGWeIiIiKqLAaUKhhEUlniIiIhqDwNKFQxzUJSMoBhKPLduAYWFNdErIiKiOxsDShXkEo+COShqNWBY8MMyDxERkXIMKFUwBBQlJR4Hh9KQArDMQ0REZA0GlCpYU+IBuJKHiIioOhhQqmDNMmOAK3mIiIiqgwGlCtaUeAAGFCIioupgQKlCdUs8nINCRESkHANKJfRCD22BFgBLPERERLWJAaUS2gItBAQA5SMoDChERETWY0CphKG84+7sDpWTStF9WeIhIiKyHgNKJay5Do8BR1CIiIisx4BSCWuXGAMMKERERNXBgFIJQ4lH6RJjgCUeIiKi6mBAqQRLPERERPahOKAcOHAAAwcORHBwMCRJwvbt2432CyEwZ84cBAcHw83NDTExMThz5oxRG51OhylTpqBevXrw8PDAoEGDcOXKlWo9kZpgqxKPELbsFRER0Z1PcUDJy8tD+/btsXTpUrP758+fj4ULF2Lp0qVISUmBRqNB7969kZOTI7dJSEjAtm3bsGnTJhw6dAi5ubkYMGAASkpKrH8mNUAu8bhaX+LR6YD8fFv2ioiI6M7npPQO/fr1Q79+/czuE0Jg8eLFmDlzJoYOHQoAWLNmDQIDA7FhwwZMnDgRWq0WK1aswIcffohevXoBANatW4eQkBB89dVX6NOnTzWejm3JJR4rRlA8PQFHR6CkpHQUxd3d1r0jIiK6c9l0DkpqaioyMjIQGxsrb1OpVIiOjsbhw4cBACdOnEBRUZFRm+DgYLRt21ZuU1dUZw6KJHEeChERkbUUj6BUJiMjAwAQGBhotD0wMBC///673MbFxQW+vr4mbQz3L0+n00Gn08m/Z2dn27LbFarOKh6gtMzz119cyUNERKRUjazikSTJ6HchhMm28iprM3fuXKjVavkWEhJis75WpjqTZAGOoBAREVnLpgFFo9EAgMlIyLVr1+RRFY1Gg8LCQmSW+9Yu26a8xMREaLVa+ZaWlmbLbleoOiUegAGFiIjIWjYNKKGhodBoNNi7d6+8rbCwEMnJyYiKigIAdO7cGc7OzkZt0tPTcfr0ablNeSqVCt7e3ka32mCLEg/AEg8REZFSiueg5Obm4tdff5V/T01NxcmTJ+Hn54dGjRohISEBSUlJCAsLQ1hYGJKSkuDu7o4RI0YAANRqNeLj4zF16lT4+/vDz88P06ZNQ3h4uLyqpy4oKilCbmEuAJZ4iIiIapvigHL8+HH06NFD/v25554DAMTFxWH16tWYPn068vPzMWnSJGRmZiIiIgJ79uyBl5eXfJ9FixbByckJw4YNQ35+Pnr27InVq1fD0dHRBk/JNrIKsuSffVx9rDoGAwoREZF1JCFuv/OcZmdnQ61WQ6vV1li555e/fkGrd1rBW+UN7QytVcdYuBCYOhV47DFgwwYbd5CIiOg2o+T7m9fiqUB1J8gC/8xB4QgKERGRMgwoFajuEmOAJR4iIiJrMaBUoLoreAAGFCIiImsxoFTAliUeLjMmIiJShgGlAnKJpxoBpewIyu03FZmIiMh+GFAqYBhBsUWJp6QEyM21Ra+IiIj+HRhQKmCYg1KdSbJuboBK9ffxWOYhIiKyGANKBWwxB0WSOFGWiIjIGgwoFbDFMmOAAYWIiMgaDCgVsMUyY4AreYiIiKzBgFIBW5R4AI6gEBERWYMBpQIs8RAREdkPA4oZBcUFyC/OB8ASDxERkT0woJhhGD2RIMFbVb2rJXMEhYiISDkGFDMM8098XH3gIFXvJWJAISIiUo4BxQxbreABWOIhIiKyBgOKGbaaIAtwBIWIiMgaDChm2GqJMcCAQkREZA0GFDNY4iEiIrIvBhQz5BKPDUdQtFpAr6/24YiIiP4VGFDMkEs8NpyDIkRpSCEiIqKqMaCYYcsSj4sL4OHx93FZ5iEiIrIIA4oZtpwkC3CiLBERkVIMKGbYcpkxwIBCRESkFAOKGbYs8QBcyUNERKQUA4oZLPEQERHZFwNKOUIIlniIiIjsjAGlnLyiPBTpiwDYvsTDgEJERGQZBpRyDKMnTg5O8HD2sMkxDSMonINCRERkGQaUcsrOP5EkySbHZImHiIhIGQaUcgwreGw1/wRgQCEiIlKKAaUcQ4nHVvNPAC4zJiIiUooBpRxbLzEGOIJCRESkFANKOSzxEBER2R8DSjlyicfV9iWenBygqMhmhyUiIrpjOdm7A3WNXOKx4QiKj88/P2dlAfXr2+zQRET0L5STA5w4Afz5J9C6NdCqFeDiYu9e2RYDSjk1MQfF0RHw9gays0vLPAwoRERkqaIi4PRp4Ngx4LvvSm9nzwJC/NPGyak0pLRrV3oLDy/9b4MGgI3OmFHrGFDKsfWFAg38/EoDClfyEBFRRYQAUlNLQ4ghkHz/PVBQYNq2UaPSAHL2LKDVloaY06eBDRv+aePraxxY2rUD7roL8PSsvedkLQaUcmx9HR4DX1/g0iVOlCUion/89ReQkmIcSG7cMG2nVgNdu/5zu/tuICiodJ8QQFoacOoU8NNP/9x++aX0Oyc5ufRmIElA06b/BBZDgGnWDHCoQzNTGVDKqYkSD8CVPERE/3b5+cAPP/xTpjl2DPjtN9N2Li5Ahw7GgSQsrOLwIEmloymNGgH9+/+zXacDzp37J7AYAkxGBnDxYult27Z/2ru7A23bGo+4REfbr0Rk14Dy7rvvYsGCBUhPT8ddd92FxYsXo3v37vbsUo2WeABg4ULg009teujbWk394dfkB+p2rOeyz7e3uvL3rLQfd/rn29K2xcWl4eDUqdKfy2vZ0jiMtG8PqFSW96MiKlVp0OnQwXj79eumoy1nzgC3bv0TngAgOBj444/q98NadgsomzdvRkJCAt59911069YN77//Pvr164ezZ8+iUaNGdumTXuiRVZAFwPYlntDQ0v+eOFF6IyKif5/AQCAiojSIREQAXboYr/SsDfXrA/ffX3ozKCkBfv3VeLTF3792+1WeJETZecC1JyIiAp06dcKyZcvkba1bt8aQIUMwd+7cSu+bnZ0NtVoNrVYLb29vm/VJW6CFzxs+AIBbL9yCm7Ob7Y6tBT75pHSI73Zin7+O6qnJPtfUsW/H17km3Y6vx53eZ6XP73b8rNTk6xEWVhpKGjb8d48OKvn+tssISmFhIU6cOIEZM2YYbY+NjcXhw4dN2ut0Ouh0Ovn37OzsGumXobzj6uRq03AClE5wio+36SGJiIjuWHaZr/vXX3+hpKQEgYGBRtsDAwORkZFh0n7u3LlQq9XyLSQkpEb6lVeUB7VKbfP5J0RERKSMXRcUSeXGuYQQJtsAIDExEVqtVr6lpaXVSH/aBrRF1owspD1bM8cnIiIiy9ilxFOvXj04OjqajJZcu3bNZFQFAFQqFVS2mNJsIQepDi0EJyIi+heyyzexi4sLOnfujL179xpt37t3L6KiouzRJSIiIqpD7LbM+LnnnsPo0aPRpUsXREZGYvny5bh8+TKeeOIJe3WJiIiI6gi7BZThw4fjxo0beOWVV5Ceno62bdti165daNy4sb26RERERHWE3c6DUh01dR4UIiIiqjlKvr85G5SIiIjqHAYUIiIiqnMYUIiIiKjOYUAhIiKiOocBhYiIiOocBhQiIiKqcxhQiIiIqM5hQCEiIqI6hwGFiIiI6hy7neq+Ogwnv83OzrZzT4iIiMhShu9tS05if1sGlJycHABASEiInXtCRERESuXk5ECtVlfa5ra8Fo9er8fVq1fh5eUFSZJseuzs7GyEhIQgLS3Nptf5qanjkim+1rc3vn+3P76Ht7+aeg+FEMjJyUFwcDAcHCqfZXJbjqA4ODigYcOGNfoY3t7eNfLBqqnjkim+1rc3vn+3P76Ht7+aeA+rGjkx4CRZIiIiqnMYUIiIiKjOYUApR6VSYfbs2VCpVLfFcckUX+vbG9+/2x/fw9tfXXgPb8tJskRERHRn4wgKERER1TkMKERERFTnMKAQERFRncOAQkRERHUOA0oZ7777LkJDQ+Hq6orOnTvj4MGDNjnugQMHMHDgQAQHB0OSJGzfvt0mx6V/zJkzB5IkGd00Go29u0WVqOpzIYTAnDlzEBwcDDc3N8TExODMmTP26SyZVdV7OGbMGJPP5T333GOfzpKJuXPn4u6774aXlxcCAgIwZMgQ/PLLL0Zt7Pk5ZED52+bNm5GQkICZM2fihx9+QPfu3dGvXz9cvny52sfOy8tD+/btsXTpUhv0lCpy1113IT09Xb6dOnXK3l2iSlT1uZg/fz4WLlyIpUuXIiUlBRqNBr1795avxUX2Z8m/bX379jX6XO7atasWe0iVSU5OxlNPPYWjR49i7969KC4uRmxsLPLy8uQ2dv0cChJCCNG1a1fxxBNPGG1r1aqVmDFjhk0fB4DYtm2bTY9JQsyePVu0b9/e3t0gK5X/XOj1eqHRaMS8efPkbQUFBUKtVov33nvPDj2kqpj7ty0uLk4MHjzYLv0h5a5duyYAiOTkZCGE/T+HHEEBUFhYiBMnTiA2NtZoe2xsLA4fPmynXpFSFy5cQHBwMEJDQ/Hoo4/it99+s3eXyEqpqanIyMgw+kyqVCpER0fzM3mb2b9/PwICAtCiRQtMmDAB165ds3eXqAJarRYA4OfnB8D+n0MGFAB//fUXSkpKEBgYaLQ9MDAQGRkZduoVKREREYG1a9fiyy+/xAcffICMjAxERUXhxo0b9u4aWcHwueNn8vbWr18/rF+/Ht988w3efPNNpKSk4P7774dOp7N316gcIQSee+453HvvvWjbti0A+38Ob8urGdcUSZKMfhdCmGyjuqlfv37yz+Hh4YiMjESzZs2wZs0aPPfcc3bsGVUHP5O3t+HDh8s/t23bFl26dEHjxo3x+eefY+jQoXbsGZU3efJk/PTTTzh06JDJPnt9DjmCAqBevXpwdHQ0SYTXrl0zSY50e/Dw8EB4eDguXLhg766QFQwrsPiZvLMEBQWhcePG/FzWMVOmTMGOHTuwb98+NGzYUN5u788hAwoAFxcXdO7cGXv37jXavnfvXkRFRdmpV1QdOp0O586dQ1BQkL27QlYIDQ2FRqMx+kwWFhYiOTmZn8nb2I0bN5CWlsbPZR0hhMDkyZOxdetWfPPNNwgNDTXab+/PIUs8f3vuuecwevRodOnSBZGRkVi+fDkuX76MJ554otrHzs3Nxa+//ir/npqaipMnT8LPzw+NGjWq9vEJmDZtGgYOHIhGjRrh2rVreO2115CdnY24uDh7d40qUNXnIiEhAUlJSQgLC0NYWBiSkpLg7u6OESNG2LHXVFZl76Gfnx/mzJmDhx56CEFBQbh06RJeeOEF1KtXDw8++KAde00GTz31FDZs2IBPP/0UXl5e8kiJWq2Gm5sbJEmy7+ewxtcJ3Ubeeecd0bhxY+Hi4iI6deokL7Wqrn379gkAJre4uDibHJ+EGD58uAgKChLOzs4iODhYDB06VJw5c8be3aJKVPW50Ov1Yvbs2UKj0QiVSiXuu+8+cerUKft2moxU9h7eunVLxMbGivr16wtnZ2fRqFEjERcXJy5fvmzvbtPfzL13AMSqVavkNvb8HEp/d5KIiIiozuAcFCIiIqpzGFCIiIiozmFAISIiojqHAYWIiIjqHAYUIiIiqnMYUIiIiKjOYUAhIiKiOocBhYiwf/9+SJKErKwsi+/TpEkTLF68uMb6VBskScL27dttdrwxY8ZgyJAhNjse0b8ZAwpRHTdmzBhIkmT2sguTJk2CJEkYM2ZM7XfMAtnZ2Zg5cyZatWoFV1dXaDQa9OrVC1u3bsWdeI7IJUuWYPXq1fLvMTExSEhIsFt/iG5nDChEt4GQkBBs2rQJ+fn58raCggJs3Lixzl7PKSsrC1FRUVi7di0SExPx/fff48CBAxg+fDimT58OrVZr7y7anFqtho+Pj727QXRHYEAhug106tQJjRo1wtatW+VtW7duRUhICDp27GjUVqfT4emnn0ZAQABcXV1x7733IiUlxajNrl270KJFC7i5uaFHjx64dOmSyWMePnwY9913H9zc3BASEoKnn34aeXl5Fvf5hRdewKVLl3Ds2DHExcWhTZs2aNGiBSZMmICTJ0/C09MTAJCZmYnHH38cvr6+cHd3R79+/XDhwgX5OKtXr4aPjw927tyJli1bwt3dHQ8//DDy8vKwZs0aNGnSBL6+vpgyZQpKSkrk+zVp0gSvvvoqRowYAU9PTwQHB+Ptt9+utM9//PEHhg8fDl9fX/j7+2Pw4MHya/Pzzz/D3d0dGzZskNtv3boVrq6uOHXqFADjEs+YMWOQnJyMJUuWQJIkSJKE1NRUNG/eHP/973+NHvf06dNwcHDAxYsXLX59ie50DChEt4mxY8di1apV8u8rV67EuHHjTNpNnz4dW7ZswZo1a/D999+jefPm6NOnD27evAkASEtLw9ChQ/HAAw/g5MmTGD9+PGbMmGF0jFOnTqFPnz4YOnQofvrpJ2zevBmHDh3C5MmTLeqrXq/Hpk2bMHLkSAQHB5vs9/T0hJNT6cXUx4wZg+PHj2PHjh04cuQIhBB44IEHUFRUJLe/desW3nrrLWzatAm7d+/G/v37MXToUOzatQu7du3Chx9+iOXLl+OTTz4xepwFCxagXbt2+P7775GYmIhnn33W6NLxZd26dQs9evSAp6cnDhw4gEOHDsHT0xN9+/ZFYWEhWrVqhf/+97+YNGkSfv/9d1y9ehUTJkzAvHnzEB4ebnK8JUuWIDIyEhMmTEB6ejrS09PRqFEjjBs3zuh9BErfy+7du6NZs2YWvb5E/wq1cklCIrJaXFycGDx4sLh+/bpQqVQiNTVVXLp0Sbi6uorr16+LwYMHy1cAzs3NFc7OzmL9+vXy/QsLC0VwcLCYP3++EEKIxMRE0bp1a6HX6+U2zz//vAAgMjMzhRBCjB49WvznP/8x6sfBgweFg4ODyM/PF0II0bhxY7Fo0SKzff7zzz8FALFw4cJKn9v58+cFAPHtt9/K2/766y/h5uYmPvroIyGEEKtWrRIAxK+//iq3mThxonB3dxc5OTnytj59+oiJEyfKvzdu3Fj07dvX6PGGDx8u+vXrJ/8OQGzbtk0IIcSKFStEy5YtjV4XnU4n3NzcxJdffilv69+/v+jevbvo2bOn6N27t1F7w3tlEB0dLZ555hmjPly9elU4OjqKY8eOCSFK35/69euL1atXV/paEf3bONk1HRGRxerVq4f+/ftjzZo1EEKgf//+qFevnlGbixcvoqioCN26dZO3OTs7o2vXrjh37hwA4Ny5c7jnnnsgSZLcJjIy0ug4J06cwK+//or169fL24QQ0Ov1SE1NRevWrSvtq/h7AmzZxzDn3LlzcHJyQkREhLzN398fLVu2lPsLAO7u7kajC4GBgWjSpIlcJjJsu3btmtHxyz+vyMjIClceGZ6zl5eX0faCggKj0svKlSvRokULODg44PTp01U+x/KCgoLQv39/rFy5El27dsXOnTtRUFCARx55RNFxiO50DChEt5Fx48bJZZZ33nnHZH9FwUAIIW8TFqye0ev1mDhxIp5++mmTfZZMyq1fvz58fX2NQoY5FfWlbH+B0pBVliRJZrfp9foq+1ZRoNDr9ejcubNRKDOoX7++/POPP/6IvLw8ODg4ICMjw2wJqyrjx4/H6NGjsWjRIqxatQrDhw+Hu7u74uMQ3ck4B4XoNmKYD1FYWIg+ffqY7G/evDlcXFxw6NAheVtRURGOHz8uj3q0adMGR48eNbpf+d87deqEM2fOoHnz5iY3FxeXKvvp4OCA4cOHY/369bh69arJ/ry8PBQXF6NNmzYoLi7GsWPH5H03btzA+fPnqxylsYS559mqVSuzbTt16oQLFy4gICDA5Dmr1WoAwM2bNzFmzBjMnDkTY8eOxciRI41WVpXn4uJiNHHX4IEHHoCHhweWLVuGL774wuxcIqJ/OwYUotuIo6Mjzp07h3PnzsHR0dFkv4eHB5588kn83//9H3bv3o2zZ89iwoQJuHXrFuLj4wEATzzxBC5evIjnnnsOv/zyCzZs2GB07g4AeP7553HkyBE89dRTOHnyJC5cuIAdO3ZgypQpFvc1KSkJISEhiIiIwNq1a3H27FlcuHABK1euRIcOHZCbm4uwsDAMHjwYEyZMwKFDh/Djjz9i1KhRaNCgAQYPHlyt1woAvv32W8yfPx/nz5/HO++8g48//hjPPPOM2bYjR45EvXr1MHjwYBw8eBCpqalITk7GM888gytXrgAofe1CQkLw4osvYuHChRBCYNq0aRU+fpMmTXDs2DFcunQJf/31lzzC4+joiDFjxiAxMRHNmzc3KUUREQMK0W3H29sb3t7eFe6fN28eHnroIYwePRqdOnXCr7/+ii+//BK+vr4ASks0W7ZswWeffYb27dvjvffeQ1JSktEx2rVrh+TkZFy4cAHdu3dHx44dMWvWLAQFBVncT19fXxw9ehSjRo3Ca6+9ho4dO6J79+7YuHEjFixYII9KrFq1Cp07d8aAAQMQGRkJIQR27dplUsKxxtSpU3HixAl07NgRr776Kt58802zI09A6TyXAwcOoFGjRhg6dChat26NcePGIT8/H97e3li7dq28YsjJyQnu7u5Yv349/ve//2HXrl1mjzlt2jQ4OjqiTZs2qF+/Pi5fvizvi4+PR2FhIUdPiCogCUsK0kREt5kmTZogISGhzp7J9dtvv0VMTAyuXLmCwMBAe3eHqM7hJFkiolqk0+mQlpaGWbNmYdiwYQwnRBVgiYeIqBZt3LgRLVu2hFarxfz58+3dHaI6iyUeIiIiqnM4gkJERER1DgMKERER1TkMKERERFTnMKAQERFRncOAQkRERHUOAwoRERHVOQwoREREVOcwoBAREVGdw4BCREREdc7/Aw5xD/RybONgAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "!pip install tabulate\n",
        "\n",
        "import numpy as np\n",
        "from numpy.linalg import inv\n",
        "import matplotlib.pyplot as plt\n",
        "from tabulate import tabulate\n",
        "\n",
        "def load_data(filename):\n",
        "    \"\"\"\n",
        "    Load data from a CSV file and split it into feature vectors and labels.\n",
        "    \n",
        "    Args:\n",
        "    filename: string containing the name of the CSV file to load.\n",
        "    \n",
        "    Returns:\n",
        "    x: ndarray of shape (m, n) containing the feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the labels.\n",
        "    \"\"\"\n",
        "    data_np = np.loadtxt(filename, delimiter=\",\")\n",
        "    m, n = np.shape(data_np)\n",
        "    x = np.ones((m, n-1))\n",
        "    y = np.zeros((m, 1))\n",
        "    for k in range(m):\n",
        "        x[k,:n-1] = data_np[k,:n-1]\n",
        "        y[k] = data_np[k,n-1]\n",
        "    return x, y\n",
        "\n",
        "def generate_polynomial_features(X, n):\n",
        "    \"\"\"\n",
        "    Generates polynomial features of degree n for a 2-dimensional input array X.\n",
        "    \n",
        "    Args:\n",
        "    X: ndarray of shape (m, 2) containing the input data.\n",
        "    n: integer degree of the polynomial features to generate.\n",
        "    \n",
        "    Returns:\n",
        "    X_poly: ndarray of shape (m, (n+1)*(n+2)//2) containing the polynomial features.\n",
        "    \"\"\"\n",
        "    m = X.shape[0]\n",
        "    X_poly = np.ones((m, (n+1)*(n+2)//2))\n",
        "    idx = 0\n",
        "    for i in range(n+1):\n",
        "        for j in range(i+1):\n",
        "            X_poly[:, idx] = (X[:, 0]**(i-j)) * (X[:, 1]**j)\n",
        "            idx += 1\n",
        "    return X_poly\n",
        "\n",
        "def fit_model(x, y, degree):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_polynomial_features(x, degree)\n",
        "    coefficients = inv(x_poly.T @ x_poly) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "def evaluate_model(x, y, coefficients, degree):\n",
        "    \"\"\"\n",
        "    Evaluates the performance of the model on the input data using mean absolute error and mean squared error.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \n",
        "    Returns:\n",
        "    mae: float containing the mean absolute error of the model predictions.\n",
        "    mse: float containing the mean squared error of the model predictions.\n",
        "    \"\"\"\n",
        "    y_est = np.dot(generate_polynomial_features(x, degree), coefficients)\n",
        "    \n",
        "    bias = np.mean(np.full(np.shape(y_est), np.mean(y_est)) - y)\n",
        "    mae = np.mean(np.abs(y_est - y))\n",
        "    mse = np.mean((y_est - y) ** 2)\n",
        "    variance = np.mean((np.full(np.shape(y_est), np.mean(y_est))-y_est)**2)\n",
        "    return variance, bias, mse, mae\n",
        "\n",
        "# Load training and testing data\n",
        "x_train, y_train = load_data(\"p1_train.csv\")\n",
        "x_test, y_test = load_data(\"p1_test.csv\")\n",
        "\n",
        "\n",
        "k =  np.linspace(0,20,21)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,5))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = fit_model(x_train, y_train, i)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k, result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,3))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = fit_model(x_test, y_test, l)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "\n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, result_test[:,2], color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c11f3676"
      },
      "source": [
        "# L2 RIDGE REGULARIZED REGRESSION-model1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1e8f48a3",
        "outputId": "ddddb95f-1d78-426e-deb1-465071146678"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "╒════════════════════╤═══════════════╤══════════════╤═══════════╤══════════╤═══════════════╕\n",
            "│   Model Complexity │      Variance │         Bias │       MSE │      MAE │   Total Error │\n",
            "╞════════════════════╪═══════════════╪══════════════╪═══════════╪══════════╪═══════════════╡\n",
            "│                  0 │   1.97215e-31 │ -0.00062019  │ 668.235   │ 21.5864  │       31.2023 │\n",
            "│                  1 │ 663.173       │ -0.000595661 │   5.05968 │  1.79176 │       15.6553 │\n",
            "│                  2 │ 663.176       │ -0.000606832 │   5.05734 │  1.7913  │       15.9907 │\n",
            "│                  3 │ 663.178       │ -0.000606954 │   5.05515 │  1.79112 │       15.9773 │\n",
            "│                  4 │ 663.181       │ -0.000604495 │   5.05207 │  1.79031 │       15.901  │\n",
            "│                  5 │ 663.191       │ -0.00060518  │   5.04215 │  1.78991 │       15.9255 │\n",
            "│                  6 │ 663.197       │ -0.000604951 │   5.03619 │  1.78914 │       15.9164 │\n",
            "│                  7 │ 663.202       │ -0.000605385 │   5.03097 │  1.78783 │       15.842  │\n",
            "│                  8 │ 663.204       │ -0.000604337 │   5.02901 │  1.7879  │       15.8094 │\n",
            "│                  9 │ 663.208       │ -0.000603869 │   5.02509 │  1.7872  │       15.7444 │\n",
            "│                 10 │ 663.212       │ -0.000596049 │   5.02142 │  1.78696 │       15.5096 │\n",
            "│                 11 │ 663.215       │ -0.000597309 │   5.01813 │  1.78698 │       15.4819 │\n",
            "│                 12 │ 663.219       │ -0.000601483 │   5.01432 │  1.78665 │       15.6432 │\n",
            "│                 13 │ 663.223       │ -0.000604787 │   5.01056 │  1.78643 │       15.56   │\n",
            "│                 14 │ 663.231       │ -0.000594821 │   5.0019  │  1.78496 │       15.9798 │\n",
            "│                 15 │ 663.242       │ -0.000626536 │   4.99008 │  1.78277 │       15.9577 │\n",
            "│                 16 │ 663.241       │ -0.00087167  │   4.98167 │  1.78219 │       16.4339 │\n",
            "│                 17 │ 663.213       │ -0.0182345   │   4.97378 │  1.78142 │       16.2181 │\n",
            "│                 18 │ 663.022       │ -0.00714868  │   4.95852 │  1.7777  │       17.2779 │\n",
            "│                 19 │ 665.605       │  0.0676287   │   5.46476 │  1.86531 │       31.3218 │\n",
            "│                 20 │ 657.052       │ -0.146322    │   5.14824 │  1.81492 │       11.5775 │\n",
            "╘════════════════════╧═══════════════╧══════════════╧═══════════╧══════════╧═══════════════╛\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════════╤═══════════╤═══════════════╕\n",
            "│   Model Complexity │         MSE │       MAE │   Total Error │\n",
            "╞════════════════════╪═════════════╪═══════════╪═══════════════╡\n",
            "│                  0 │   688.644   │  22.0651  │       30.3455 │\n",
            "│                  1 │     5.03571 │   1.79794 │       16.0128 │\n",
            "│                  2 │     5.03346 │   1.7968  │       16.0307 │\n",
            "│                  3 │     5.03103 │   1.79576 │       16.0208 │\n",
            "│                  4 │     5.0194  │   1.79193 │       16.4444 │\n",
            "│                  5 │     5.01509 │   1.79153 │       16.348  │\n",
            "│                  6 │     5.00946 │   1.78925 │       16.4184 │\n",
            "│                  7 │     4.99875 │   1.78637 │       16.546  │\n",
            "│                  8 │     4.98694 │   1.7864  │       17.1828 │\n",
            "│                  9 │     4.97874 │   1.78528 │       17.1082 │\n",
            "│                 10 │     4.9717  │   1.78349 │       17.4611 │\n",
            "│                 11 │     4.95813 │   1.77988 │       17.4977 │\n",
            "│                 12 │     4.94716 │   1.77823 │       18.4302 │\n",
            "│                 13 │     4.93559 │   1.77537 │       18.3035 │\n",
            "│                 14 │     4.91867 │   1.77124 │       17.8511 │\n",
            "│                 15 │     4.90067 │   1.76897 │       17.8901 │\n",
            "│                 16 │     4.88615 │   1.76739 │       18.1635 │\n",
            "│                 17 │     4.86908 │   1.76517 │       17.2842 │\n",
            "│                 18 │     4.84084 │   1.75953 │       18.5565 │\n",
            "│                 19 │     5.1186  │   1.80492 │       27.1056 │\n",
            "│                 20 │     5.3146  │   1.83382 │       29.6743 │\n",
            "│                 21 │ 27810       │ 107.839   │   177610      │\n",
            "╘════════════════════╧═════════════╧═══════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l2fit_model(x, y, degree, lamda):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    \n",
        "    x_poly = generate_polynomial_features(x, degree)\n",
        "    I = np.identity(np.shape(x_poly)[1])\n",
        "    coefficients = inv(x_poly.T @ x_poly +lamda*I) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,6))\n",
        "total_error = np.zeros((21,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = l2fit_model(x_train, y_train, i, 2)   ## choosing the hyperparameter \n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i) \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + (np.linalg.norm(coefficients_train))**2\n",
        "    result[i,5] = total_error[i]\n",
        "    \n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,4))\n",
        "total_error = np.zeros((22,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = l2fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + (np.linalg.norm(coefficients_test))**2\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "291f9134"
      },
      "source": [
        "# L1 Regularization-model1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b31dee9a",
        "outputId": "65e7bcea-8f16-44c6-bdef-42fccd169801"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |     Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+==============+==========+=========+=========+===============+\n",
            "|                  0 |  0           | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  1 |  4.68544e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  2 |  1.86978e-36 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  3 |  3.16241e-29 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  4 |  1.8641e-26  | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  5 |  3.20594e-19 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  6 |  2.13601e-16 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  7 |  4.06996e-09 | -3.10157 | 677.852 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  8 |  2.85284e-06 | -3.10044 | 677.845 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  9 | 39.2729      | -3.10054 | 489.925 | 18.8493 |       18.8493 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                 10 | 42.1006      | -2.23493 | 487.231 | 18.8077 |       18.8077 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "C:\\Users\\yvsdm\\AppData\\Local\\Temp\\ipykernel_48504\\3149070548.py:22: RuntimeWarning: overflow encountered in square\n",
            "  cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
            "C:\\Users\\yvsdm\\AppData\\Local\\Temp\\ipykernel_48504\\3149070548.py:23: RuntimeWarning: overflow encountered in multiply\n",
            "  subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "╒════════════════════╤═════════╤══════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │      MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪══════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  7 │ 696.929 │  22.1842 │       22.1842 │\n",
            "│                  8 │ 696.927 │  22.1842 │       22.1842 │\n",
            "│                  9 │ 581.898 │  20.5699 │       20.5699 │\n",
            "│                 10 │ 580.093 │  20.5612 │       20.5612 │\n",
            "│                 11 │ nan     │ nan      │      nan      │\n",
            "╘════════════════════╧═════════╧══════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_fit_model(x, y, degree, alpha):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_polynomial_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 1000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_fit_model(x_train, y_train, i, 10**-3)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train))\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + 2*np.sum(np.absolute(coefficients_test))\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "674fb093"
      },
      "source": [
        "# L1 and L2 regularization-model1 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "580b4b21",
        "outputId": "8ac96960-17fc-4d6f-fef3-238d43042c08"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |     Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+==============+==========+=========+=========+===============+\n",
            "|                  0 |  1.38179e-76 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  1 |  4.68544e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  2 |  1.86978e-36 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  3 |  3.16241e-29 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  4 |  1.8641e-26  | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  5 |  3.20594e-19 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  6 |  2.13601e-16 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  7 |  4.06996e-09 | -3.10157 | 677.852 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  8 |  2.85284e-06 | -3.10044 | 677.845 | 21.7168 |       21.7168 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                  9 | 39.2729      | -3.10054 | 489.925 | 18.8493 |       18.8493 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "|                 10 | 42.1006      | -2.23493 | 487.231 | 18.8077 |       18.8077 |\n",
            "+--------------------+--------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "C:\\Users\\yvsdm\\AppData\\Local\\Temp\\ipykernel_48504\\3207566716.py:22: RuntimeWarning: overflow encountered in square\n",
            "  cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
            "C:\\Users\\yvsdm\\AppData\\Local\\Temp\\ipykernel_48504\\3207566716.py:23: RuntimeWarning: overflow encountered in multiply\n",
            "  subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)  + 2*gamma*coefficients\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "╒════════════════════╤═════════╤══════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │      MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪══════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │  22.1842 │       22.1842 │\n",
            "│                  7 │ 696.929 │  22.1842 │       22.1842 │\n",
            "│                  8 │ 696.927 │  22.1842 │       22.1842 │\n",
            "│                  9 │ 581.898 │  20.5699 │       20.5699 │\n",
            "│                 10 │ 580.093 │  20.5612 │       20.5612 │\n",
            "│                 11 │ nan     │ nan      │      nan      │\n",
            "╘════════════════════╧═════════╧══════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_l2_fit_model(x, y, degree, alpha, gamma):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_polynomial_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 1000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)  + 2*gamma*coefficients\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_l2_fit_model(x_train, y_train, i, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train)) + 300*np.linalg.norm(coefficients_train)\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_l2_fit_model(x_test, y_test, l, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + np.sum(np.absolute(coefficients_test)) + 300*np.linalg.norm(coefficients_test)\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0b1c9eae"
      },
      "source": [
        "# Overfitting model w/o regularization-model2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9a70c175",
        "outputId": "4b1286c1-0cc6-42e6-8dda-2b0c68b3287d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|   Model Complexity |      Variance |         Bias |     MSE |      MAE |\n",
            "+====================+===============+==============+=========+==========+\n",
            "|                  0 |   7.88861e-31 | -7.50333e-16 | 668.235 | 21.5864  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  1 | 532.26        | -7.50333e-16 | 135.975 | 10.0212  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  2 | 532.314       | -7.50333e-16 | 135.921 | 10.0199  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  3 | 532.353       | -4.54747e-16 | 135.882 | 10.0167  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  4 | 532.394       | -4.54747e-16 | 135.841 | 10.0129  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  5 | 532.497       | -1.04592e-15 | 135.738 | 10.0074  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  6 | 532.719       |  3.50155e-15 | 135.516 |  9.99571 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  7 | 532.789       | -7.50333e-16 | 135.446 |  9.9925  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  8 | 532.955       | -7.50333e-16 | 135.279 |  9.98688 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  9 | 533.071       |  9.09495e-17 | 135.164 |  9.97982 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 10 | 533.269       | -1.29603e-15 | 134.966 |  9.96811 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 11 | 533.5         |  1.22782e-15 | 134.735 |  9.95225 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 12 | 533.647       | -7.50333e-16 | 134.588 |  9.94446 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 13 | 533.87        |  1.22782e-15 | 134.364 |  9.93098 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 14 | 534.126       |  8.41283e-16 | 134.109 |  9.92019 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 15 | 534.428       | -1.86446e-15 | 133.806 |  9.908   |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 16 | 534.714       |  9.09495e-17 | 133.521 |  9.89522 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 17 | 534.978       |  3.81988e-15 | 133.257 |  9.88199 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 18 | 535.318       |  9.09495e-17 | 132.917 |  9.86056 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 19 | 535.636       | -1.18234e-15 | 132.599 |  9.84387 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 20 | 535.985       |  4.63842e-15 | 132.249 |  9.8197  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "+--------------------+---------+----------+\n",
            "|   Model Complexity |     MSE |      MAE |\n",
            "+====================+=========+==========+\n",
            "|                  0 | 688.644 | 22.0651  |\n",
            "+--------------------+---------+----------+\n",
            "|                  1 | 137.221 | 10.0681  |\n",
            "+--------------------+---------+----------+\n",
            "|                  2 | 137.185 | 10.0689  |\n",
            "+--------------------+---------+----------+\n",
            "|                  3 | 137.121 | 10.0631  |\n",
            "+--------------------+---------+----------+\n",
            "|                  4 | 136.831 | 10.0488  |\n",
            "+--------------------+---------+----------+\n",
            "|                  5 | 136.582 | 10.039   |\n",
            "+--------------------+---------+----------+\n",
            "|                  6 | 136.457 | 10.034   |\n",
            "+--------------------+---------+----------+\n",
            "|                  7 | 136.34  | 10.0254  |\n",
            "+--------------------+---------+----------+\n",
            "|                  8 | 136.247 | 10.0208  |\n",
            "+--------------------+---------+----------+\n",
            "|                  9 | 136.107 | 10.0138  |\n",
            "+--------------------+---------+----------+\n",
            "|                 10 | 135.586 |  9.98836 |\n",
            "+--------------------+---------+----------+\n",
            "|                 11 | 135.11  |  9.9682  |\n",
            "+--------------------+---------+----------+\n",
            "|                 12 | 134.809 |  9.9531  |\n",
            "+--------------------+---------+----------+\n",
            "|                 13 | 134.516 |  9.93844 |\n",
            "+--------------------+---------+----------+\n",
            "|                 14 | 134.223 |  9.92588 |\n",
            "+--------------------+---------+----------+\n",
            "|                 15 | 133.845 |  9.90984 |\n",
            "+--------------------+---------+----------+\n",
            "|                 16 | 133.525 |  9.89207 |\n",
            "+--------------------+---------+----------+\n",
            "|                 17 | 132.94  |  9.84827 |\n",
            "+--------------------+---------+----------+\n",
            "|                 18 | 132.584 |  9.82912 |\n",
            "+--------------------+---------+----------+\n",
            "|                 19 | 132.031 |  9.80122 |\n",
            "+--------------------+---------+----------+\n",
            "|                 20 | 131.342 |  9.76895 |\n",
            "+--------------------+---------+----------+\n",
            "|                 21 | 130.729 |  9.73351 |\n",
            "+--------------------+---------+----------+\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "def generate_poly_sinusoidal_features(X, n):\n",
        "    \"\"\"\n",
        "    Generates polynomial features of degree n for a 2-dimensional input array X.\n",
        "    \n",
        "    Args:\n",
        "    X: ndarray of shape (m, 2) containing the input data.\n",
        "    n: integer degree of the polynomial features to generate.\n",
        "    \n",
        "    Returns:\n",
        "    X_poly: ndarray of shape (m, (n+1)*(n+2)//2) containing the polynomial features.\n",
        "    \"\"\"\n",
        "    m = X.shape[0]\n",
        "    X_poly = np.ones((m, (n+1)*(n+2)//2))\n",
        "    idx = 0\n",
        "    for i in range(n+1):\n",
        "        for j in range(i+1):\n",
        "            X_poly[:, idx] = (X[:, 0]**(i-j)) * (X[:, 1]**j)\n",
        "            idx += 1\n",
        "    for i in range(2, X_poly.shape[1]):\n",
        "        X_poly[:, i] = np.sin(X_poly[:, i])\n",
        "    return X_poly\n",
        "   \n",
        "\n",
        "def fit_model(x, y, degree):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_sinusoidal_features(x, degree)\n",
        "    coefficients = inv(x_poly.T @ x_poly) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "def evaluate_model(x, y, coefficients, degree):\n",
        "    \"\"\"\n",
        "    Evaluates the performance of the model on the input data using mean absolute error and mean squared error.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \n",
        "    Returns:\n",
        "    mae: float containing the mean absolute error of the model predictions.\n",
        "    mse: float containing the mean squared error of the model predictions.\n",
        "    \"\"\"\n",
        "    y_est = np.dot(generate_poly_sinusoidal_features(x, degree), coefficients)\n",
        "    \n",
        "    bias = np.mean(np.full(np.shape(y_est), np.mean(y_est)) - y)\n",
        "    mae = np.mean(np.abs(y_est - y))\n",
        "    mse = np.mean((y_est - y) ** 2)\n",
        "    variance = np.mean((np.full(np.shape(y_est), np.mean(y_est))-y_est)**2)\n",
        "    return variance, bias, mse, mae\n",
        "\n",
        "\n",
        "\n",
        "k =  np.linspace(0,20,21)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,5))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = fit_model(x_train, y_train, i)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k, result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,3))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = fit_model(x_test, y_test, l)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "\n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, result_test[:,2], color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cb0ea7de"
      },
      "source": [
        "# with L2 regularization-model2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d5fad2e2",
        "outputId": "b4deed93-23cf-41b7-e5d5-c69ca0d99ec8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "╒════════════════════╤═══════════════╤══════════════╤═════════╤══════════╤═══════════════╕\n",
            "│   Model Complexity │      Variance │         Bias │     MSE │      MAE │   Total Error │\n",
            "╞════════════════════╪═══════════════╪══════════════╪═════════╪══════════╪═══════════════╡\n",
            "│                  0 │   1.97215e-31 │ -0.00062019  │ 668.235 │ 21.5864  │       31.2023 │\n",
            "│                  1 │ 532.258       │ -0.000575837 │ 135.975 │ 10.0212  │       22.561  │\n",
            "│                  2 │ 532.313       │ -0.000577966 │ 135.921 │ 10.0199  │       22.732  │\n",
            "│                  3 │ 532.351       │ -0.00057785  │ 135.882 │ 10.0167  │       22.8118 │\n",
            "│                  4 │ 532.392       │ -0.000577802 │ 135.841 │ 10.0129  │       22.894  │\n",
            "│                  5 │ 532.495       │ -0.000578    │ 135.738 │ 10.0074  │       23.1017 │\n",
            "│                  6 │ 532.717       │ -0.000575435 │ 135.516 │  9.99571 │       23.4581 │\n",
            "│                  7 │ 532.787       │ -0.000575209 │ 135.446 │  9.99251 │       23.5978 │\n",
            "│                  8 │ 532.953       │ -0.000575509 │ 135.279 │  9.98689 │       23.931  │\n",
            "│                  9 │ 533.069       │ -0.000575752 │ 135.164 │  9.97982 │       24.168  │\n",
            "│                 10 │ 533.266       │ -0.000575852 │ 134.966 │  9.96812 │       24.5952 │\n",
            "│                 11 │ 533.497       │ -0.000575899 │ 134.735 │  9.95226 │       25.1163 │\n",
            "│                 12 │ 533.644       │ -0.000574703 │ 134.588 │  9.94448 │       25.4039 │\n",
            "│                 13 │ 533.867       │ -0.000575647 │ 134.364 │  9.931   │       25.8679 │\n",
            "│                 14 │ 534.123       │ -0.000576772 │ 134.109 │  9.92022 │       26.4637 │\n",
            "│                 15 │ 534.425       │ -0.000576115 │ 133.806 │  9.90802 │       27.1738 │\n",
            "│                 16 │ 534.711       │ -0.000576967 │ 133.521 │  9.89524 │       27.7637 │\n",
            "│                 17 │ 534.974       │ -0.000575025 │ 133.257 │  9.88202 │       28.3163 │\n",
            "│                 18 │ 535.314       │ -0.000574029 │ 132.917 │  9.86059 │       29.1032 │\n",
            "│                 19 │ 535.632       │ -0.000572422 │ 132.599 │  9.8439  │       29.636  │\n",
            "│                 20 │ 535.981       │ -0.000573821 │ 132.249 │  9.81975 │       30.494  │\n",
            "╘════════════════════╧═══════════════╧══════════════╧═════════╧══════════╧═══════════════╛\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤══════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │      MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪══════════╪═══════════════╡\n",
            "│                  0 │ 688.644 │ 22.0651  │       30.3455 │\n",
            "│                  1 │ 137.221 │ 10.0681  │       23.9442 │\n",
            "│                  2 │ 137.185 │ 10.0689  │       24.0252 │\n",
            "│                  3 │ 137.121 │ 10.0631  │       24.1611 │\n",
            "│                  4 │ 136.831 │ 10.0488  │       24.7292 │\n",
            "│                  5 │ 136.582 │ 10.039   │       25.2407 │\n",
            "│                  6 │ 136.457 │ 10.034   │       25.4746 │\n",
            "│                  7 │ 136.34  │ 10.0254  │       25.7685 │\n",
            "│                  8 │ 136.247 │ 10.0208  │       25.9799 │\n",
            "│                  9 │ 136.107 │ 10.0138  │       26.3097 │\n",
            "│                 10 │ 135.587 │  9.98841 │       27.218  │\n",
            "│                 11 │ 135.11  │  9.96826 │       28.0367 │\n",
            "│                 12 │ 134.809 │  9.95317 │       28.6321 │\n",
            "│                 13 │ 134.516 │  9.93852 │       29.1557 │\n",
            "│                 14 │ 134.223 │  9.92596 │       29.7463 │\n",
            "│                 15 │ 133.845 │  9.90993 │       30.6297 │\n",
            "│                 16 │ 133.525 │  9.89216 │       31.2623 │\n",
            "│                 17 │ 132.94  │  9.84839 │       32.5186 │\n",
            "│                 18 │ 132.584 │  9.82924 │       33.2487 │\n",
            "│                 19 │ 132.031 │  9.80137 │       34.28   │\n",
            "│                 20 │ 131.342 │  9.7691  │       35.9346 │\n",
            "│                 21 │ 130.729 │  9.73367 │       37.3816 │\n",
            "╘════════════════════╧═════════╧══════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l2fit_model(x, y, degree, lamda):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    \n",
        "    x_poly = generate_poly_sinusoidal_features(x, degree)\n",
        "    I = np.identity(np.shape(x_poly)[1])\n",
        "    coefficients = inv(x_poly.T @ x_poly +lamda*I) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,6))\n",
        "total_error = np.zeros((21,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = l2fit_model(x_train, y_train, i, 2)   ## choosing the hyperparameter \n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i) \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + (np.linalg.norm(coefficients_train))**2\n",
        "    result[i,5] = total_error[i]\n",
        "    \n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,4))\n",
        "total_error = np.zeros((22,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = l2fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + (np.linalg.norm(coefficients_test))**2\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d12d9b8e"
      },
      "source": [
        "# with L1 Regularization-model2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "be934ee1",
        "outputId": "1671aa61-d3e6-4475-f02d-7219f9301d6f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |    Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+=============+==========+=========+=========+===============+\n",
            "|                  0 | 5.52715e-76 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  1 | 1.51907e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  2 | 1.51907e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  3 | 1.51907e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  4 | 1.51907e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  5 | 1.51908e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  6 | 1.51909e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  7 | 1.51911e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  8 | 1.51912e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  9 | 1.51913e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                 10 | 1.51915e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  7 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  8 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  9 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 10 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 11 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "╘════════════════════╧═════════╧═════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_fit_model(x, y, degree, alpha):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_sinusoidal_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 2000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_fit_model(x_train, y_train, i, 10**-3)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train))\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + 2*np.sum(np.absolute(coefficients_test))\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33b10d79"
      },
      "source": [
        "# with L1 and L2 regularization-model2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8ad935b5",
        "outputId": "035b942d-389c-472d-e1ad-b3362ff83369"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |    Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+=============+==========+=========+=========+===============+\n",
            "|                  0 | 1.38179e-76 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  1 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  2 | 3.79754e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  3 | 4.80375e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  4 | 3.96363e-38 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  5 | 8.79318e-36 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  6 | 5.10065e-32 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  7 | 7.92075e-30 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  8 | 1.49094e-27 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  9 | 1.58017e-24 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                 10 | 1.9153e-22  | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  7 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  8 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  9 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 10 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 11 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "╘════════════════════╧═════════╧═════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_l2_fit_model(x, y, degree, alpha, gamma):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_sinusoidal_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 1000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)  + 2*gamma*coefficients\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_l2_fit_model(x_train, y_train, i, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train)) + 300*np.linalg.norm(coefficients_train)\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_l2_fit_model(x_test, y_test, l, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + np.sum(np.absolute(coefficients_test)) + 300*np.linalg.norm(coefficients_test)\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "28bfa868"
      },
      "source": [
        "# overfitting model w/o regularization-model3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7f6ed382",
        "outputId": "ed5d8aa2-10bd-4162-f170-337a80a0f1dd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|   Model Complexity |      Variance |         Bias |     MSE |      MAE |\n",
            "+====================+===============+==============+=========+==========+\n",
            "|                  0 |   7.88861e-31 | -7.50333e-16 | 668.235 | 21.5864  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  1 | 532.135       | -4.54747e-16 | 136.1   | 10.0237  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  2 | 532.138       |  8.41283e-16 | 136.097 | 10.0236  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  3 | 532.153       | -1.54614e-15 | 136.082 | 10.0233  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  4 | 532.169       | -4.63388e-14 | 136.066 | 10.0215  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  5 | 532.222       | -1.14967e-12 | 136.013 | 10.02    |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  6 | 532.3         |  8.25737e-12 | 135.934 | 10.0128  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  7 | 532.34        | -5.52782e-10 | 135.895 | 10.0103  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  8 | 532.36        |  1.54228e-09 | 135.875 | 10.0099  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                  9 | 532.395       | -3.9815e-09  | 135.84  | 10.0093  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 10 | 532.532       |  3.35892e-08 | 135.703 | 10.0037  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 11 | 532.608       |  4.54314e-07 | 135.627 |  9.99765 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 12 | 532.641       |  1.48973e-05 | 135.594 |  9.99525 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 13 | 532.743       |  7.8158e-05  | 135.492 |  9.9907  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 14 | 532.826       | -0.000473441 | 135.408 |  9.98584 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 15 | 533.137       |  0.0046314   | 135.098 |  9.9683  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 16 | 533.302       | -0.036109    | 134.957 |  9.95977 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 17 | 533.975       |  0.0280718   | 135.283 |  9.98999 |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 18 | 535.473       |  0.278097    | 136.616 | 10.0356  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 19 | 540.071       | -0.145505    | 140.845 | 10.3084  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "|                 20 | 578.995       |  0.289671    | 179.483 | 11.5897  |\n",
            "+--------------------+---------------+--------------+---------+----------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "+--------------------+---------+----------+\n",
            "|   Model Complexity |     MSE |      MAE |\n",
            "+====================+=========+==========+\n",
            "|                  0 | 688.644 | 22.0651  |\n",
            "+--------------------+---------+----------+\n",
            "|                  1 | 137.666 | 10.0877  |\n",
            "+--------------------+---------+----------+\n",
            "|                  2 | 137.57  | 10.0853  |\n",
            "+--------------------+---------+----------+\n",
            "|                  3 | 137.546 | 10.0865  |\n",
            "+--------------------+---------+----------+\n",
            "|                  4 | 137.335 | 10.0833  |\n",
            "+--------------------+---------+----------+\n",
            "|                  5 | 137.268 | 10.0786  |\n",
            "+--------------------+---------+----------+\n",
            "|                  6 | 137.188 | 10.0769  |\n",
            "+--------------------+---------+----------+\n",
            "|                  7 | 137.098 | 10.0671  |\n",
            "+--------------------+---------+----------+\n",
            "|                  8 | 136.928 | 10.0565  |\n",
            "+--------------------+---------+----------+\n",
            "|                  9 | 136.777 | 10.051   |\n",
            "+--------------------+---------+----------+\n",
            "|                 10 | 136.574 | 10.0344  |\n",
            "+--------------------+---------+----------+\n",
            "|                 11 | 136.413 | 10.0244  |\n",
            "+--------------------+---------+----------+\n",
            "|                 12 | 136.295 | 10.0146  |\n",
            "+--------------------+---------+----------+\n",
            "|                 13 | 136.131 | 10.0086  |\n",
            "+--------------------+---------+----------+\n",
            "|                 14 | 135.975 |  9.99262 |\n",
            "+--------------------+---------+----------+\n",
            "|                 15 | 135.883 |  9.98471 |\n",
            "+--------------------+---------+----------+\n",
            "|                 16 | 135.441 |  9.96263 |\n",
            "+--------------------+---------+----------+\n",
            "|                 17 | 136.233 | 10.006   |\n",
            "+--------------------+---------+----------+\n",
            "|                 18 | 137.761 | 10.2129  |\n",
            "+--------------------+---------+----------+\n",
            "|                 19 | 554.765 | 16.1288  |\n",
            "+--------------------+---------+----------+\n",
            "|                 20 | 365.549 | 14.4609  |\n",
            "+--------------------+---------+----------+\n",
            "|                 21 | 293.466 | 14.0764  |\n",
            "+--------------------+---------+----------+\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def generate_poly_expo_features(X, n):\n",
        "    \"\"\"\n",
        "    Generates polynomial features of degree n for a 2-dimensional input array X.\n",
        "    \n",
        "    Args:\n",
        "    X: ndarray of shape (m, 2) containing the input data.\n",
        "    n: integer degree of the polynomial features to generate.\n",
        "    \n",
        "    Returns:\n",
        "    X_poly: ndarray of shape (m, (n+1)*(n+2)//2) containing the polynomial features.\n",
        "    \"\"\"\n",
        "    m = X.shape[0]\n",
        "    X_poly = np.ones((m, (n+1)*(n+2)//2))\n",
        "    idx = 0\n",
        "    for i in range(n+1):\n",
        "        for j in range(i+1):\n",
        "            X_poly[:, idx] = (X[:, 0]**(i-j)) * (X[:, 1]**j)\n",
        "            idx += 1\n",
        "    for i in range(2, X_poly.shape[1]):\n",
        "        X_poly[:, i] = np.exp(-np.absolute(X_poly[:, i]))\n",
        "    return X_poly\n",
        "   \n",
        "\n",
        "def fit_model(x, y, degree):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_expo_features(x, degree)\n",
        "    coefficients = inv(x_poly.T @ x_poly) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "def evaluate_model(x, y, coefficients, degree):\n",
        "    \"\"\"\n",
        "    Evaluates the performance of the model on the input data using mean absolute error and mean squared error.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \n",
        "    Returns:\n",
        "    mae: float containing the mean absolute error of the model predictions.\n",
        "    mse: float containing the mean squared error of the model predictions.\n",
        "    \"\"\"\n",
        "    y_est = np.dot(generate_poly_expo_features(x, degree), coefficients)\n",
        "    \n",
        "    bias = np.mean(np.full(np.shape(y_est), np.mean(y_est)) - y)\n",
        "    mae = np.mean(np.abs(y_est - y))\n",
        "    mse = np.mean((y_est - y) ** 2)\n",
        "    variance = np.mean((np.full(np.shape(y_est), np.mean(y_est))-y_est)**2)\n",
        "    return variance, bias, mse, mae\n",
        "\n",
        "\n",
        "\n",
        "k =  np.linspace(0,20,21)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,5))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = fit_model(x_train, y_train, i)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k, result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve W/O Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,3))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = fit_model(x_test, y_test, l)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "\n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, result_test[:,2], color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f86f43af"
      },
      "source": [
        "# L2 regularization-model3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "85513cfa",
        "outputId": "89c50813-a569-4923-dc28-f9675a8115e1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "╒════════════════════╤═══════════════╤══════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │      Variance │         Bias │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═══════════════╪══════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │   1.97215e-31 │ -0.00062019  │ 668.235 │ 21.5864 │       31.2023 │\n",
            "│                  1 │ 532.134       │ -0.000572703 │ 136.1   │ 10.0237 │       22.3078 │\n",
            "│                  2 │ 532.136       │ -0.000576239 │ 136.097 │ 10.0236 │       22.5809 │\n",
            "│                  3 │ 532.143       │ -0.00057795  │ 136.085 │ 10.0233 │       35.5613 │\n",
            "│                  4 │ 532.151       │ -0.000578746 │ 136.076 │ 10.0227 │       40.1426 │\n",
            "│                  5 │ 532.154       │ -0.000578396 │ 136.056 │ 10.0221 │       79.1235 │\n",
            "│                  6 │ 532.177       │ -0.000578154 │ 136.02  │ 10.02   │      113.115  │\n",
            "│                  7 │ 532.205       │ -0.000578016 │ 135.989 │ 10.0175 │      120.837  │\n",
            "│                  8 │ 532.22        │ -0.000577919 │ 135.971 │ 10.016  │      128.789  │\n",
            "│                  9 │ 532.232       │ -0.000577927 │ 135.961 │ 10.0148 │      121.312  │\n",
            "│                 10 │ 532.241       │ -0.000577916 │ 135.949 │ 10.0138 │      130.887  │\n",
            "│                 11 │ 532.247       │ -0.000577983 │ 135.938 │ 10.0132 │      142.356  │\n",
            "│                 12 │ 532.253       │ -0.000578065 │ 135.922 │ 10.0119 │      168.431  │\n",
            "│                 13 │ 532.258       │ -0.000578114 │ 135.912 │ 10.0112 │      180.492  │\n",
            "│                 14 │ 532.268       │ -0.000578132 │ 135.891 │ 10.0107 │      206.339  │\n",
            "│                 15 │ 532.271       │ -0.000578128 │ 135.878 │ 10.0103 │      233.269  │\n",
            "│                 16 │ 532.276       │ -0.000578132 │ 135.871 │ 10.01   │      240.326  │\n",
            "│                 17 │ 532.287       │ -0.000578097 │ 135.847 │ 10.0095 │      271.748  │\n",
            "│                 18 │ 532.292       │ -0.000578084 │ 135.834 │ 10.0088 │      290.847  │\n",
            "│                 19 │ 532.303       │ -0.000578094 │ 135.813 │ 10.0078 │      315.192  │\n",
            "│                 20 │ 532.315       │ -0.00057808  │ 135.788 │ 10.007  │      349.019  │\n",
            "╘════════════════════╧═══════════════╧══════════════╧═════════╧═════════╧═══════════════╛\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │ 688.644 │ 22.0651 │       30.3455 │\n",
            "│                  1 │ 137.666 │ 10.0877 │       23.0797 │\n",
            "│                  2 │ 137.571 │ 10.0851 │       33.6382 │\n",
            "│                  3 │ 137.554 │ 10.0851 │       38.4132 │\n",
            "│                  4 │ 137.446 │ 10.0841 │      143.486  │\n",
            "│                  5 │ 137.335 │ 10.0821 │      145.794  │\n",
            "│                  6 │ 137.318 │ 10.0805 │      121.556  │\n",
            "│                  7 │ 137.3   │ 10.0803 │      112.86   │\n",
            "│                  8 │ 137.278 │ 10.0794 │      135.844  │\n",
            "│                  9 │ 137.235 │ 10.0777 │      153.588  │\n",
            "│                 10 │ 137.196 │ 10.0746 │      177.247  │\n",
            "│                 11 │ 137.143 │ 10.0714 │      207.862  │\n",
            "│                 12 │ 137.082 │ 10.0678 │      260.475  │\n",
            "│                 13 │ 137.023 │ 10.0645 │      287.457  │\n",
            "│                 14 │ 136.966 │ 10.0605 │      314.426  │\n",
            "│                 15 │ 136.924 │ 10.058  │      325.518  │\n",
            "│                 16 │ 136.873 │ 10.055  │      353.799  │\n",
            "│                 17 │ 136.831 │ 10.0531 │      355.141  │\n",
            "│                 18 │ 136.796 │ 10.0502 │      357.212  │\n",
            "│                 19 │ 136.776 │ 10.0492 │      357.72   │\n",
            "│                 20 │ 136.756 │ 10.0475 │      356.801  │\n",
            "│                 21 │ 136.735 │ 10.0462 │      351.122  │\n",
            "╘════════════════════╧═════════╧═════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l2fit_model(x, y, degree, lamda):\n",
        "    \"\"\"\n",
        "    Fits an overparameterized polynomial model of degree n to the input data.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    n: integer degree of the polynomial model to fit.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    \n",
        "    x_poly = generate_poly_expo_features(x, degree)\n",
        "    I = np.identity(np.shape(x_poly)[1])\n",
        "    coefficients = inv(x_poly.T @ x_poly +lamda*I) @ x_poly.T @ y\n",
        "    return coefficients\n",
        "\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((21,6))\n",
        "total_error = np.zeros((21,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(21):\n",
        "    coefficients_train = l2fit_model(x_train, y_train, i, 2)   ## choosing the hyperparameter \n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i) \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + (np.linalg.norm(coefficients_train))**2\n",
        "    result[i,5] = total_error[i]\n",
        "    \n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 15, 20])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((22,4))\n",
        "total_error = np.zeros((22,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(22):\n",
        "    coefficients_test = l2fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + (np.linalg.norm(coefficients_test))**2\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,21,22)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 15, 20, 22])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "44c6e2b9"
      },
      "source": [
        "# with L1 Regularization-model3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ed92fab0",
        "outputId": "76d86077-dff4-4a86-8c2e-5e64546eb1d1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |    Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+=============+==========+=========+=========+===============+\n",
            "|                  0 | 8.84344e-75 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  1 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  2 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  3 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  4 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  5 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  6 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  7 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  8 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  9 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                 10 | 3.79766e-37 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  7 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  8 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  9 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 10 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 11 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "╘════════════════════╧═════════╧═════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_fit_model(x, y, degree, alpha):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_expo_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 10000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_fit_model(x_train, y_train, i, 10)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train))\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_fit_model(x_test, y_test, l, 2)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + 2*np.sum(np.absolute(coefficients_test))\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "76f687d0"
      },
      "source": [
        "# with L1 and L2 regularization-model3\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "21b84fe3",
        "outputId": "56b42e43-7f77-41b4-edc0-3c88e871d063"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Training parameters\n",
            "\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|   Model Complexity |    Variance |     Bias |     MSE |     MAE |   Total Error |\n",
            "+====================+=============+==========+=========+=========+===============+\n",
            "|                  0 | 1.38179e-76 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  1 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  2 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  3 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  4 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  5 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  6 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  7 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  8 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                  9 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "|                 10 | 3.79767e-39 | -3.10157 | 677.855 | 21.7168 |       21.7168 |\n",
            "+--------------------+-------------+----------+---------+---------+---------------+\n",
            "\n",
            "Testing parameters\n",
            "\n",
            "╒════════════════════╤═════════╤═════════╤═══════════════╕\n",
            "│   Model Complexity │     MSE │     MAE │   Total Error │\n",
            "╞════════════════════╪═════════╪═════════╪═══════════════╡\n",
            "│                  0 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  1 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  2 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  3 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  4 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  5 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  6 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  7 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  8 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                  9 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 10 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "│                 11 │ 696.931 │ 22.1842 │       22.1842 │\n",
            "╘════════════════════╧═════════╧═════════╧═══════════════╛\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show(close=None, block=None)>"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def l1_l2_fit_model(x, y, degree, alpha, gamma):\n",
        "    \"\"\"\n",
        "    Fits a regularized polynomial model of degree n to the input data using L1 regularization.\n",
        "    \n",
        "    Args:\n",
        "    x: ndarray of shape (m, 2) containing the input feature vectors.\n",
        "    y: ndarray of shape (m, 1) containing the input labels.\n",
        "    degree: integer degree of the polynomial model to fit.\n",
        "    alpha: float regularization strength.\n",
        "    \n",
        "    Returns:\n",
        "    coefficients: ndarray of shape ((n+1)*(n+2)//2, 1) containing the fitted model coefficients.\n",
        "    \"\"\"\n",
        "    x_poly = generate_poly_expo_features(x, degree)\n",
        "    m, n = x_poly.shape\n",
        "    coefficients = np.zeros((n, 1))\n",
        "    iterations = 10000\n",
        "    learning_rate = 10**-30\n",
        "    for i in range(iterations):\n",
        "        y_est = np.dot(x_poly, coefficients)\n",
        "        error = y_est - y\n",
        "        cost = np.mean(error**2) + alpha * np.sum(np.abs(coefficients))\n",
        "        subgrad = 2 * np.dot(x_poly.T, error) + alpha * np.sign(coefficients)  + 2*gamma*coefficients\n",
        "       # print(subgrad)\n",
        "        coefficients -= learning_rate * subgrad\n",
        "        #print(coefficients)\n",
        "    return coefficients\n",
        "\n",
        "k =  np.linspace(0,10,11)\n",
        "# Fit the overparameterized model to the training data\n",
        "result = np.zeros((11,6))\n",
        "total_error = np.zeros((11,1))\n",
        "\n",
        "print(\"\\nTraining parameters\\n\")\n",
        "\n",
        "for i in range(11):\n",
        "    coefficients_train = l1_l2_fit_model(x_train, y_train, i, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_train, y_train, coefficients_train, i)  \n",
        "    result[i,0] = i\n",
        "    result[i,1] = variance\n",
        "    result[i,2] = bias\n",
        "    result[i,3] = mae\n",
        "    result[i,4] = mse\n",
        "    total_error[i] = mse + np.sum(np.abs(coefficients_train)) + 300*np.linalg.norm(coefficients_train)\n",
        "    result[i,5] = total_error[i]\n",
        "\n",
        "param = list(result)\n",
        "param = [[\"Model Complexity\",\"Variance\",\"Bias\",\"MSE\",\"MAE\", \"Total Error\"]] + param\n",
        "print(tabulate(param, headers ='firstrow', tablefmt = 'grid'))\n",
        "\n",
        "\n",
        "#Plotting Bias_Variance Curves  \n",
        "\n",
        "plt.figure()\n",
        "plt.plot(k,result[:,3], color ='blue', label='Bias')\n",
        "plt.plot(k,result[:,1], color ='green', label='Variance')\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.xlabel(\"Model Complexity\")\n",
        "plt.title(\"Bias_Variance Curve Regularization\")\n",
        "plt.legend()\n",
        "plt.show\n",
        "\n",
        "\n",
        "\n",
        "# Fit the overparameterized model to the testing data\n",
        "\n",
        "result_test = np.zeros((12,4))\n",
        "total_error = np.zeros((12,1))\n",
        "print(\"\\nTesting parameters\\n\")\n",
        "\n",
        "for l in range(12):\n",
        "    coefficients_test = l1_l2_fit_model(x_test, y_test, l, 2, 300)\n",
        "    variance, bias, mae, mse = evaluate_model(x_test, y_test, coefficients_test, l)  \n",
        "    result_test[l,0] = l\n",
        "    result_test[l,1] = mae\n",
        "    result_test[l,2] = mse\n",
        "    total_error[l] = mse + np.sum(np.absolute(coefficients_test)) + 300*np.linalg.norm(coefficients_test)\n",
        "    result_test[l,3] = total_error[l]\n",
        "    \n",
        "param_test = list(result_test)\n",
        "param_test = [[\"Model Complexity\",\"MSE\",\"MAE\", \"Total Error\"]] + param_test\n",
        "print(tabulate(param_test, headers ='firstrow', tablefmt = 'fancy_outline'))\n",
        "\n",
        "p = np.linspace(0,11,12)\n",
        "plt.figure()\n",
        "plt.xticks([0, 1, 5, 10, 12])\n",
        "plt.plot(p, total_error, color='magenta', label='Total Error')\n",
        "plt.legend()\n",
        "plt.show"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2f0ca581"
      },
      "source": [
        "# INFERENCES"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f48cc979"
      },
      "outputs": [],
      "source": [
        "1. In our experiment, we used linear regression with a polynomial kernel function but were unable to overfit\n",
        "even with a small subset of the data. However, when we added cross-terms to the polynomial kernel function, \n",
        "we achieved overfitting of the entire dataset with a sufficiently high degree polynomial.\n",
        "\n",
        "2. Steepest gradient descent was employed with exact line search though perfect convergence could not be attained even after very huge \n",
        "number of iterations. So, the gradient descent was prematurely stopped and the weights were used in case of L1 and Elastic Net\n",
        "which resulted in almost constant errors even as the model complexity increased.\n",
        "\n",
        "3. Furthermore, we found that L1 regularization had a greater impact on the weights of the model compared to\n",
        "L2 regularization. This is because L1 regularization tends to push the weights towards zero, resulting in \n",
        "sparse solutions, while L2 regularization tries to keep the weights small but non-zero. In contrast, elastic net\n",
        "regularization had a relatively lower impact on the model's performance, as it combines both L1 and L2 regularization\n",
        "and may not provide a significant advantage in cases where L1 or L2 regularization alone are already effective. However,\n",
        "the hyperparameters for elastic net regularization, such as the ratio of L1 and L2 regularization strengths, need to be\n",
        "carefully tuned for optimal performance.\n",
        "\n",
        "3. It can be observed that in all the 3 models the best performance was depicted by model 2 with L2 regularization. The possible \n",
        "reason behind this might be the extra sinusoidal terms which might be capturing the little variation in data present. Also model \n",
        "3 with L2 regularization depicted similar results."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q4"
      ],
      "metadata": {
        "id": "KGipYIbS_laU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Kmnist = np.loadtxt('/content/drive/MyDrive/train.csv',delimiter = ',')\n",
        "X_kmnist = Kmnist[:,0:-1] \n",
        "print(X_kmnist.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "halQLLfqtB-n",
        "outputId": "f3d35067-a525-43b2-a438-f95401768570"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(60000, 784)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "rpuDvT2VZhrn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_kmnist = Kmnist[:,784].astype(int)\n",
        "print(y_kmnist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JHvhRpsLvaGG",
        "outputId": "1bc0cfd7-5e49-4559-915a-763845661546"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 2 ... 7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "img = X_kmnist[1].reshape((28,28))\n",
        "pyplt.imshow(img, cmap='gray')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "HS01dmeLwEkq",
        "outputId": "d1b831c4-76ca-426c-f333-be6692d87d68"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fbea86766a0>"
            ]
          },
          "metadata": {},
          "execution_count": 44
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def split_data(X,y,i):\n",
        "   np.random.seed(42)\n",
        "   indices = np.random.permutation(X.shape[0])\n",
        "\n",
        "# Use the first 80% of the shuffled indices for training and the rest for testing\n",
        "   train_indices, test_indices = indices[:int(i * len(indices))], indices[int(i * len(indices)):]\n",
        "\n",
        "# Use the shuffled indices to split the data into training and testing sets\n",
        "   X_train, X_test = X[train_indices], X[test_indices]\n",
        "   y_train, y_test = y[train_indices], y[test_indices]\n",
        "   return X_train,y_train,X_test,y_test"
      ],
      "metadata": {
        "id": "3Mt1fPoQ_gXJ"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train,y_train,X_test,y_test = split_data(X_kmnist,y_kmnist,0.7)"
      ],
      "metadata": {
        "id": "O671zeg7AXHN"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(X_train.shape,X_test.shape,y_test.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pQfpeevDAfVp",
        "outputId": "deff71d8-9d7e-4ac2-b8a1-2b0777008ff9"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(42000, 784) (18000, 784) (18000,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def minmaxNormalize(X):\n",
        "    X_norm = np.zeros(X.shape)\n",
        "    for i in range(X.shape[1]):\n",
        "        if np.max(X[:,i]) != 0:\n",
        "            X_norm[:,i] = (X[:,i] - np.min(X[:,i])) / (np.max(X[:,i]) - np.min(X[:,i]))\n",
        "    return X_norm\n",
        "    "
      ],
      "metadata": {
        "id": "jTKSwYdWD_xS"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def one_hot(Y):\n",
        "      one_hot_Y = np.zeros((Y.size, Y.max() + 1))\n",
        "      one_hot_Y[np.arange(Y.size), Y] = 1\n",
        "      one_hot_Y = one_hot_Y\n",
        "      return one_hot_Y "
      ],
      "metadata": {
        "id": "RJ5BlLXsZgvL"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_train =  one_hot(y_train)\n"
      ],
      "metadata": {
        "id": "fEddo4UvZHiU"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(y_train.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KzitMOTyZ-Pb",
        "outputId": "1c188420-51a2-42d0-ebc0-3004e9e7c106"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(42000, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "class NeuralNetwork1:\n",
        "    def __init__(self, input_size, hidden_sizes, output_size):\n",
        "        self.input_size = input_size\n",
        "        self.hidden_sizes = hidden_sizes\n",
        "        self.output_size = output_size\n",
        "        self.weights = [np.random.randn(input_size, hidden_sizes[0])]\n",
        "        self.biases = [np.zeros((1, hidden_sizes[0]))]\n",
        "        \n",
        "        for i in range(1, len(hidden_sizes)):\n",
        "            self.weights.append(np.random.randn(hidden_sizes[i-1], hidden_sizes[i]))\n",
        "            self.biases.append(np.zeros((1, hidden_sizes[i])))\n",
        "        \n",
        "        self.weights.append(np.random.randn(hidden_sizes[-1], output_size))\n",
        "        self.biases.append(np.zeros((1, output_size)))\n",
        "    \n",
        "    def sigmoid(self, x):\n",
        "        return 1 / (1 + np.exp(-x))\n",
        "    \n",
        "    def softmax(self, x):\n",
        "        exps = np.exp(x - np.max(x, axis=1, keepdims=True))\n",
        "        return exps / np.sum(exps, axis=1, keepdims=True)\n",
        "    \n",
        "  \n",
        "    def train(self, x, y,  loss_func, learning_rate=0.1, epochs=1000):\n",
        "\n",
        "        for epoch in range(epochs):\n",
        "            a = x\n",
        "            zs = []\n",
        "            activations = [a]\n",
        "            for i in range(len(self.weights)):\n",
        "                z = np.dot(a, self.weights[i]) + self.biases[i]\n",
        "                zs.append(z)\n",
        "                a = self.sigmoid(z) if i < len(self.weights)-1 else self.softmax(z)\n",
        "                activations.append(a)\n",
        "            \n",
        "            if(loss_func == 1):\n",
        "              loss = np.mean(np.square(y - a))\n",
        "              pred_labels = np.argmax(a, axis=1)\n",
        "              true_labels = np.argmax(y, axis=1)\n",
        "              accuracy = np.mean(pred_labels == true_labels)\n",
        "              delta = (a - y) / y.shape[0]\n",
        "              delta = 2 * delta\n",
        "              deltas = [delta]\n",
        "            \n",
        "            elif (loss_func == 2):\n",
        "              loss = -np.mean(y*np.log(a))\n",
        "              pred_labels = np.argmax(a, axis=1)\n",
        "              true_labels = np.argmax(y, axis=1)\n",
        "              accuracy = np.mean(pred_labels == true_labels)\n",
        "            \n",
        "            # Backpropagation\n",
        "              delta = (a - y) / y.shape[0]\n",
        "              deltas = [delta]\n",
        "            \n",
        "            for i in range(len(self.weights)-1, 0, -1):\n",
        "                delta = np.dot(delta, self.weights[i].T) * (activations[i] * (1 - activations[i]))\n",
        "                deltas.insert(0, delta)\n",
        "\n",
        "            if (epoch % 50 == 0 and accuracy*100 < 90):\n",
        "              learning_rate = learning_rate * 1.2\n",
        "\n",
        "          \n",
        "\n",
        "            for i in range(len(self.weights)):\n",
        "                self.weights[i] -= learning_rate * np.dot(activations[i].T, deltas[i])\n",
        "                self.biases[i] -= learning_rate * np.sum(deltas[i], axis=0, keepdims=True)\n",
        "      \n",
        "            if epoch % 10 == 0:\n",
        "                print(f\"Epoch {epoch} - Loss: {loss:.4f} - Accuracy: {accuracy*100:.4f}\")\n",
        "\n",
        "    def predict(self, x):\n",
        "      a = x\n",
        "      for i in range(len(self.weights)):\n",
        "        z = np.dot(a, self.weights[i]) + self.biases[i]\n",
        "        a = self.sigmoid(z) if i < len(self.weights)-1 else self.softmax(z)\n",
        "      return np.argmax(a, axis=1)"
      ],
      "metadata": {
        "id": "72Sk2dj67EE8"
      },
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setting 1"
      ],
      "metadata": {
        "id": "knLW8OD4gq2C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[300,100,50], output_size=10)"
      ],
      "metadata": {
        "id": "HZCcuxk4RGn7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nn.train(X_train/255,y_train,loss_func=1) # loss_func = 1 is squared error loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0kiaCxcticVR",
        "outputId": "6e94eff1-d970-41dc-cc01-9b500201b2da"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.1687 - Accuracy: 9.9500\n",
            "Epoch 10 - Loss: 0.0967 - Accuracy: 18.0714\n",
            "Epoch 20 - Loss: 0.0896 - Accuracy: 23.3048\n",
            "Epoch 30 - Loss: 0.0858 - Accuracy: 27.0643\n",
            "Epoch 40 - Loss: 0.0826 - Accuracy: 30.4881\n",
            "Epoch 50 - Loss: 0.0798 - Accuracy: 33.9190\n",
            "Epoch 60 - Loss: 0.0769 - Accuracy: 37.2238\n",
            "Epoch 70 - Loss: 0.0741 - Accuracy: 40.4190\n",
            "Epoch 80 - Loss: 0.0715 - Accuracy: 43.2929\n",
            "Epoch 90 - Loss: 0.0691 - Accuracy: 45.9452\n",
            "Epoch 100 - Loss: 0.0667 - Accuracy: 48.2952\n",
            "Epoch 110 - Loss: 0.0643 - Accuracy: 50.6476\n",
            "Epoch 120 - Loss: 0.0621 - Accuracy: 52.8571\n",
            "Epoch 130 - Loss: 0.0600 - Accuracy: 54.7452\n",
            "Epoch 140 - Loss: 0.0581 - Accuracy: 56.5357\n",
            "Epoch 150 - Loss: 0.0563 - Accuracy: 58.0881\n",
            "Epoch 160 - Loss: 0.0545 - Accuracy: 59.6929\n",
            "Epoch 170 - Loss: 0.0529 - Accuracy: 61.1524\n",
            "Epoch 180 - Loss: 0.0513 - Accuracy: 62.5190\n",
            "Epoch 190 - Loss: 0.0499 - Accuracy: 63.7095\n",
            "Epoch 200 - Loss: 0.0485 - Accuracy: 64.9095\n",
            "Epoch 210 - Loss: 0.0472 - Accuracy: 66.0619\n",
            "Epoch 220 - Loss: 0.0459 - Accuracy: 67.1429\n",
            "Epoch 230 - Loss: 0.0447 - Accuracy: 68.1262\n",
            "Epoch 240 - Loss: 0.0436 - Accuracy: 69.0357\n",
            "Epoch 250 - Loss: 0.0425 - Accuracy: 69.8905\n",
            "Epoch 260 - Loss: 0.0414 - Accuracy: 70.7905\n",
            "Epoch 270 - Loss: 0.0404 - Accuracy: 71.5476\n",
            "Epoch 280 - Loss: 0.0394 - Accuracy: 72.3024\n",
            "Epoch 290 - Loss: 0.0385 - Accuracy: 73.0405\n",
            "Epoch 300 - Loss: 0.0376 - Accuracy: 73.7595\n",
            "Epoch 310 - Loss: 0.0367 - Accuracy: 74.4595\n",
            "Epoch 320 - Loss: 0.0359 - Accuracy: 75.0619\n",
            "Epoch 330 - Loss: 0.0351 - Accuracy: 75.6262\n",
            "Epoch 340 - Loss: 0.0343 - Accuracy: 76.1429\n",
            "Epoch 350 - Loss: 0.0336 - Accuracy: 76.7262\n",
            "Epoch 360 - Loss: 0.0329 - Accuracy: 77.2857\n",
            "Epoch 370 - Loss: 0.0322 - Accuracy: 77.7476\n",
            "Epoch 380 - Loss: 0.0315 - Accuracy: 78.2786\n",
            "Epoch 390 - Loss: 0.0308 - Accuracy: 78.8262\n",
            "Epoch 400 - Loss: 0.0302 - Accuracy: 79.2952\n",
            "Epoch 410 - Loss: 0.0296 - Accuracy: 79.8429\n",
            "Epoch 420 - Loss: 0.0290 - Accuracy: 80.2833\n",
            "Epoch 430 - Loss: 0.0284 - Accuracy: 80.7143\n",
            "Epoch 440 - Loss: 0.0279 - Accuracy: 81.0833\n",
            "Epoch 450 - Loss: 0.0274 - Accuracy: 81.4119\n",
            "Epoch 460 - Loss: 0.0268 - Accuracy: 81.7524\n",
            "Epoch 470 - Loss: 0.0263 - Accuracy: 82.0881\n",
            "Epoch 480 - Loss: 0.0258 - Accuracy: 82.4333\n",
            "Epoch 490 - Loss: 0.0254 - Accuracy: 82.8405\n",
            "Epoch 500 - Loss: 0.0249 - Accuracy: 83.1810\n",
            "Epoch 510 - Loss: 0.0245 - Accuracy: 83.4571\n",
            "Epoch 520 - Loss: 0.0240 - Accuracy: 83.7833\n",
            "Epoch 530 - Loss: 0.0236 - Accuracy: 84.0619\n",
            "Epoch 540 - Loss: 0.0232 - Accuracy: 84.3429\n",
            "Epoch 550 - Loss: 0.0228 - Accuracy: 84.5833\n",
            "Epoch 560 - Loss: 0.0224 - Accuracy: 84.8500\n",
            "Epoch 570 - Loss: 0.0220 - Accuracy: 85.1286\n",
            "Epoch 580 - Loss: 0.0216 - Accuracy: 85.3881\n",
            "Epoch 590 - Loss: 0.0213 - Accuracy: 85.6310\n",
            "Epoch 600 - Loss: 0.0209 - Accuracy: 85.8619\n",
            "Epoch 610 - Loss: 0.0206 - Accuracy: 86.1190\n",
            "Epoch 620 - Loss: 0.0202 - Accuracy: 86.3595\n",
            "Epoch 630 - Loss: 0.0199 - Accuracy: 86.6095\n",
            "Epoch 640 - Loss: 0.0196 - Accuracy: 86.8143\n",
            "Epoch 650 - Loss: 0.0193 - Accuracy: 87.0167\n",
            "Epoch 660 - Loss: 0.0190 - Accuracy: 87.2048\n",
            "Epoch 670 - Loss: 0.0186 - Accuracy: 87.4381\n",
            "Epoch 680 - Loss: 0.0183 - Accuracy: 87.6143\n",
            "Epoch 690 - Loss: 0.0181 - Accuracy: 87.8452\n",
            "Epoch 700 - Loss: 0.0178 - Accuracy: 88.0310\n",
            "Epoch 710 - Loss: 0.0175 - Accuracy: 88.2310\n",
            "Epoch 720 - Loss: 0.0172 - Accuracy: 88.4524\n",
            "Epoch 730 - Loss: 0.0169 - Accuracy: 88.6548\n",
            "Epoch 740 - Loss: 0.0167 - Accuracy: 88.8595\n",
            "Epoch 750 - Loss: 0.0164 - Accuracy: 89.0667\n",
            "Epoch 760 - Loss: 0.0162 - Accuracy: 89.2476\n",
            "Epoch 770 - Loss: 0.0159 - Accuracy: 89.4024\n",
            "Epoch 780 - Loss: 0.0157 - Accuracy: 89.5643\n",
            "Epoch 790 - Loss: 0.0154 - Accuracy: 89.7095\n",
            "Epoch 800 - Loss: 0.0152 - Accuracy: 89.8571\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_f1scores(y_actual, y_pred):\n",
        "\n",
        "  f1_scores = []\n",
        "  for c in np.unique(y_actual):\n",
        "    \n",
        "    tp = np.sum((y_actual == c) & (y_pred == c))\n",
        "    fp = np.sum((y_actual != c) & (y_pred == c))\n",
        "    fn = np.sum((y_actual == c) & (y_pred != c))\n",
        "    precision = tp / (tp + fp)\n",
        "    recall = tp / (tp + fn)\n",
        "    f1 = 2 * (precision * recall) / (precision + recall)\n",
        "    f1_scores.append(f1)\n",
        "    print(f'Class {c}: F1 score = {f1:.4f}')"
      ],
      "metadata": {
        "id": "g2fIDfbHjzfN"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test/255)\n",
        "print('The accuracy of Neural network with setting 1 with squared error loss is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UVXYx00miblX",
        "outputId": "3cc96e86-25a1-4055-b22d-5812ac367294"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with squared error loss is : 0.8850555555555556\n",
            "Class 0: F1 score = 0.8956\n",
            "Class 1: F1 score = 0.9239\n",
            "Class 2: F1 score = 0.9419\n",
            "Class 3: F1 score = 0.8413\n",
            "Class 4: F1 score = 0.8731\n",
            "Class 5: F1 score = 0.8830\n",
            "Class 6: F1 score = 0.8767\n",
            "Class 7: F1 score = 0.8016\n",
            "Class 8: F1 score = 0.9041\n",
            "Class 9: F1 score = 0.9066\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[300,100,50], output_size=10)\n",
        "nn.train(X_train/255,y_train,loss_func=2) # loss_func = 2 is cross entropy loss\n",
        "y_pred = nn.predict(X_test/255)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WLZFU7YNrHyt",
        "outputId": "45364e45-ccd3-42b3-b92d-6cc9f5620d98"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 1.0419 - Accuracy: 9.0976\n",
            "Epoch 10 - Loss: 0.3898 - Accuracy: 13.7810\n",
            "Epoch 20 - Loss: 0.2791 - Accuracy: 18.5405\n",
            "Epoch 30 - Loss: 0.2534 - Accuracy: 21.0500\n",
            "Epoch 40 - Loss: 0.2402 - Accuracy: 23.3000\n",
            "Epoch 50 - Loss: 0.2289 - Accuracy: 25.6429\n",
            "Epoch 60 - Loss: 0.2171 - Accuracy: 28.2857\n",
            "Epoch 70 - Loss: 0.2071 - Accuracy: 30.7762\n",
            "Epoch 80 - Loss: 0.1985 - Accuracy: 33.0024\n",
            "Epoch 90 - Loss: 0.1910 - Accuracy: 35.1595\n",
            "Epoch 100 - Loss: 0.1845 - Accuracy: 37.0810\n",
            "Epoch 110 - Loss: 0.1775 - Accuracy: 39.4833\n",
            "Epoch 120 - Loss: 0.1713 - Accuracy: 41.5429\n",
            "Epoch 130 - Loss: 0.1657 - Accuracy: 43.6048\n",
            "Epoch 140 - Loss: 0.1605 - Accuracy: 45.5476\n",
            "Epoch 150 - Loss: 0.1557 - Accuracy: 47.3238\n",
            "Epoch 160 - Loss: 0.1503 - Accuracy: 49.3476\n",
            "Epoch 170 - Loss: 0.1453 - Accuracy: 51.2738\n",
            "Epoch 180 - Loss: 0.1406 - Accuracy: 53.0690\n",
            "Epoch 190 - Loss: 0.1362 - Accuracy: 54.6167\n",
            "Epoch 200 - Loss: 0.1321 - Accuracy: 56.0524\n",
            "Epoch 210 - Loss: 0.1274 - Accuracy: 57.8524\n",
            "Epoch 220 - Loss: 0.1230 - Accuracy: 59.4810\n",
            "Epoch 230 - Loss: 0.1189 - Accuracy: 60.9571\n",
            "Epoch 240 - Loss: 0.1150 - Accuracy: 62.3667\n",
            "Epoch 250 - Loss: 0.1114 - Accuracy: 63.5929\n",
            "Epoch 260 - Loss: 0.1073 - Accuracy: 64.9857\n",
            "Epoch 270 - Loss: 0.1035 - Accuracy: 66.2690\n",
            "Epoch 280 - Loss: 0.1001 - Accuracy: 67.4452\n",
            "Epoch 290 - Loss: 0.0968 - Accuracy: 68.5048\n",
            "Epoch 300 - Loss: 0.0938 - Accuracy: 69.5714\n",
            "Epoch 310 - Loss: 0.0905 - Accuracy: 70.6714\n",
            "Epoch 320 - Loss: 0.0875 - Accuracy: 71.6833\n",
            "Epoch 330 - Loss: 0.0846 - Accuracy: 72.5857\n",
            "Epoch 340 - Loss: 0.0820 - Accuracy: 73.5167\n",
            "Epoch 350 - Loss: 0.0796 - Accuracy: 74.3952\n",
            "Epoch 360 - Loss: 0.0769 - Accuracy: 75.3071\n",
            "Epoch 370 - Loss: 0.0745 - Accuracy: 76.1667\n",
            "Epoch 380 - Loss: 0.0722 - Accuracy: 76.8071\n",
            "Epoch 390 - Loss: 0.0701 - Accuracy: 77.6000\n",
            "Epoch 400 - Loss: 0.0682 - Accuracy: 78.3381\n",
            "Epoch 410 - Loss: 0.0660 - Accuracy: 79.1190\n",
            "Epoch 420 - Loss: 0.0640 - Accuracy: 79.7095\n",
            "Epoch 430 - Loss: 0.0622 - Accuracy: 80.3500\n",
            "Epoch 440 - Loss: 0.0605 - Accuracy: 80.9024\n",
            "Epoch 450 - Loss: 0.0589 - Accuracy: 81.4857\n",
            "Epoch 460 - Loss: 0.0571 - Accuracy: 82.0190\n",
            "Epoch 470 - Loss: 0.0555 - Accuracy: 82.5571\n",
            "Epoch 480 - Loss: 0.0540 - Accuracy: 83.0452\n",
            "Epoch 490 - Loss: 0.0526 - Accuracy: 83.5048\n",
            "Epoch 500 - Loss: 0.0513 - Accuracy: 83.8929\n",
            "Epoch 510 - Loss: 0.0498 - Accuracy: 84.3881\n",
            "Epoch 520 - Loss: 0.0484 - Accuracy: 84.8381\n",
            "Epoch 530 - Loss: 0.0472 - Accuracy: 85.2690\n",
            "Epoch 540 - Loss: 0.0460 - Accuracy: 85.6786\n",
            "Epoch 550 - Loss: 0.0449 - Accuracy: 86.0310\n",
            "Epoch 560 - Loss: 0.0436 - Accuracy: 86.4976\n",
            "Epoch 570 - Loss: 0.0425 - Accuracy: 86.9143\n",
            "Epoch 580 - Loss: 0.0414 - Accuracy: 87.2286\n",
            "Epoch 590 - Loss: 0.0404 - Accuracy: 87.5833\n",
            "Epoch 600 - Loss: 0.0394 - Accuracy: 87.8524\n",
            "Epoch 610 - Loss: 0.0384 - Accuracy: 88.2071\n",
            "Epoch 620 - Loss: 0.0374 - Accuracy: 88.5190\n",
            "Epoch 630 - Loss: 0.0365 - Accuracy: 88.8095\n",
            "Epoch 640 - Loss: 0.0356 - Accuracy: 89.0762\n",
            "Epoch 650 - Loss: 0.0348 - Accuracy: 89.3214\n",
            "Epoch 660 - Loss: 0.0339 - Accuracy: 89.6286\n",
            "Epoch 670 - Loss: 0.0331 - Accuracy: 89.8333\n",
            "Epoch 680 - Loss: 0.0323 - Accuracy: 90.1000\n",
            "Epoch 690 - Loss: 0.0315 - Accuracy: 90.3643\n",
            "Epoch 700 - Loss: 0.0308 - Accuracy: 90.6238\n",
            "Epoch 710 - Loss: 0.0302 - Accuracy: 90.7857\n",
            "Epoch 720 - Loss: 0.0295 - Accuracy: 90.9881\n",
            "Epoch 730 - Loss: 0.0289 - Accuracy: 91.1786\n",
            "Epoch 740 - Loss: 0.0284 - Accuracy: 91.3476\n",
            "Epoch 750 - Loss: 0.0278 - Accuracy: 91.5119\n",
            "Epoch 760 - Loss: 0.0273 - Accuracy: 91.6738\n",
            "Epoch 770 - Loss: 0.0268 - Accuracy: 91.8286\n",
            "Epoch 780 - Loss: 0.0263 - Accuracy: 92.0048\n",
            "Epoch 790 - Loss: 0.0259 - Accuracy: 92.1214\n",
            "Epoch 800 - Loss: 0.0254 - Accuracy: 92.2714\n",
            "Epoch 810 - Loss: 0.0250 - Accuracy: 92.4262\n",
            "Epoch 820 - Loss: 0.0246 - Accuracy: 92.5714\n",
            "Epoch 830 - Loss: 0.0242 - Accuracy: 92.6905\n",
            "Epoch 840 - Loss: 0.0238 - Accuracy: 92.8095\n",
            "Epoch 850 - Loss: 0.0235 - Accuracy: 92.9119\n",
            "Epoch 860 - Loss: 0.0231 - Accuracy: 93.0381\n",
            "Epoch 870 - Loss: 0.0228 - Accuracy: 93.1429\n",
            "Epoch 880 - Loss: 0.0225 - Accuracy: 93.2571\n",
            "Epoch 890 - Loss: 0.0221 - Accuracy: 93.3381\n",
            "Epoch 900 - Loss: 0.0218 - Accuracy: 93.4381\n",
            "Epoch 910 - Loss: 0.0215 - Accuracy: 93.5405\n",
            "Epoch 920 - Loss: 0.0212 - Accuracy: 93.6452\n",
            "Epoch 930 - Loss: 0.0210 - Accuracy: 93.7452\n",
            "Epoch 940 - Loss: 0.0207 - Accuracy: 93.8333\n",
            "Epoch 950 - Loss: 0.0204 - Accuracy: 93.9381\n",
            "Epoch 960 - Loss: 0.0202 - Accuracy: 94.0357\n",
            "Epoch 970 - Loss: 0.0199 - Accuracy: 94.1310\n",
            "Epoch 980 - Loss: 0.0197 - Accuracy: 94.2095\n",
            "Epoch 990 - Loss: 0.0194 - Accuracy: 94.3071\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('The accuracy of Neural network with setting 1 with cross entropy loss is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KY51pXmDrZt-",
        "outputId": "d3bae7fa-fce6-4c8c-c7e1-2efddaa52be5"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with cross entropy loss is : 0.9135\n",
            "Class 0: F1 score = 0.9088\n",
            "Class 1: F1 score = 0.9328\n",
            "Class 2: F1 score = 0.9686\n",
            "Class 3: F1 score = 0.8845\n",
            "Class 4: F1 score = 0.9163\n",
            "Class 5: F1 score = 0.9176\n",
            "Class 6: F1 score = 0.8961\n",
            "Class 7: F1 score = 0.8438\n",
            "Class 8: F1 score = 0.9308\n",
            "Class 9: F1 score = 0.9335\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setting 2"
      ],
      "metadata": {
        "id": "JL6ytGyVg-Xb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[200,100], output_size=10)\n",
        "nn.train(X_train/255,y_train,loss_func=2)\n"
      ],
      "metadata": {
        "id": "J9jXh4KQim0H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bd85b275-e1f5-49b6-c781-444ff0898257"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.7486 - Accuracy: 6.9405\n",
            "Epoch 10 - Loss: 0.5001 - Accuracy: 12.1452\n",
            "Epoch 20 - Loss: 0.4267 - Accuracy: 16.1738\n",
            "Epoch 30 - Loss: 0.3740 - Accuracy: 20.3024\n",
            "Epoch 40 - Loss: 0.3323 - Accuracy: 24.6024\n",
            "Epoch 50 - Loss: 0.2989 - Accuracy: 28.5881\n",
            "Epoch 60 - Loss: 0.2669 - Accuracy: 32.9857\n",
            "Epoch 70 - Loss: 0.2415 - Accuracy: 36.9619\n",
            "Epoch 80 - Loss: 0.2209 - Accuracy: 40.5476\n",
            "Epoch 90 - Loss: 0.2039 - Accuracy: 43.7833\n",
            "Epoch 100 - Loss: 0.1897 - Accuracy: 46.5905\n",
            "Epoch 110 - Loss: 0.1755 - Accuracy: 49.5905\n",
            "Epoch 120 - Loss: 0.1637 - Accuracy: 52.2762\n",
            "Epoch 130 - Loss: 0.1537 - Accuracy: 54.6381\n",
            "Epoch 140 - Loss: 0.1452 - Accuracy: 56.7357\n",
            "Epoch 150 - Loss: 0.1379 - Accuracy: 58.4810\n",
            "Epoch 160 - Loss: 0.1303 - Accuracy: 60.5429\n",
            "Epoch 170 - Loss: 0.1238 - Accuracy: 62.4119\n",
            "Epoch 180 - Loss: 0.1181 - Accuracy: 64.0429\n",
            "Epoch 190 - Loss: 0.1131 - Accuracy: 65.4500\n",
            "Epoch 200 - Loss: 0.1086 - Accuracy: 66.6619\n",
            "Epoch 210 - Loss: 0.1039 - Accuracy: 68.0286\n",
            "Epoch 220 - Loss: 0.0997 - Accuracy: 69.2976\n",
            "Epoch 230 - Loss: 0.0959 - Accuracy: 70.3762\n",
            "Epoch 240 - Loss: 0.0925 - Accuracy: 71.3857\n",
            "Epoch 250 - Loss: 0.0895 - Accuracy: 72.3262\n",
            "Epoch 260 - Loss: 0.0862 - Accuracy: 73.3286\n",
            "Epoch 270 - Loss: 0.0832 - Accuracy: 74.2381\n",
            "Epoch 280 - Loss: 0.0805 - Accuracy: 75.0881\n",
            "Epoch 290 - Loss: 0.0781 - Accuracy: 75.8976\n",
            "Epoch 300 - Loss: 0.0758 - Accuracy: 76.5714\n",
            "Epoch 310 - Loss: 0.0733 - Accuracy: 77.2952\n",
            "Epoch 320 - Loss: 0.0711 - Accuracy: 77.9976\n",
            "Epoch 330 - Loss: 0.0691 - Accuracy: 78.5905\n",
            "Epoch 340 - Loss: 0.0672 - Accuracy: 79.1786\n",
            "Epoch 350 - Loss: 0.0654 - Accuracy: 79.7690\n",
            "Epoch 360 - Loss: 0.0635 - Accuracy: 80.3952\n",
            "Epoch 370 - Loss: 0.0618 - Accuracy: 80.9214\n",
            "Epoch 380 - Loss: 0.0601 - Accuracy: 81.4190\n",
            "Epoch 390 - Loss: 0.0586 - Accuracy: 81.8548\n",
            "Epoch 400 - Loss: 0.0572 - Accuracy: 82.2810\n",
            "Epoch 410 - Loss: 0.0557 - Accuracy: 82.7500\n",
            "Epoch 420 - Loss: 0.0542 - Accuracy: 83.2024\n",
            "Epoch 430 - Loss: 0.0529 - Accuracy: 83.5976\n",
            "Epoch 440 - Loss: 0.0517 - Accuracy: 83.9905\n",
            "Epoch 450 - Loss: 0.0505 - Accuracy: 84.4000\n",
            "Epoch 460 - Loss: 0.0492 - Accuracy: 84.7833\n",
            "Epoch 470 - Loss: 0.0480 - Accuracy: 85.1738\n",
            "Epoch 480 - Loss: 0.0469 - Accuracy: 85.4881\n",
            "Epoch 490 - Loss: 0.0458 - Accuracy: 85.7738\n",
            "Epoch 500 - Loss: 0.0448 - Accuracy: 86.0571\n",
            "Epoch 510 - Loss: 0.0437 - Accuracy: 86.3905\n",
            "Epoch 520 - Loss: 0.0427 - Accuracy: 86.6952\n",
            "Epoch 530 - Loss: 0.0417 - Accuracy: 86.9810\n",
            "Epoch 540 - Loss: 0.0408 - Accuracy: 87.2333\n",
            "Epoch 550 - Loss: 0.0399 - Accuracy: 87.4952\n",
            "Epoch 560 - Loss: 0.0390 - Accuracy: 87.8143\n",
            "Epoch 570 - Loss: 0.0381 - Accuracy: 88.0714\n",
            "Epoch 580 - Loss: 0.0372 - Accuracy: 88.3214\n",
            "Epoch 590 - Loss: 0.0364 - Accuracy: 88.5833\n",
            "Epoch 600 - Loss: 0.0357 - Accuracy: 88.8452\n",
            "Epoch 610 - Loss: 0.0348 - Accuracy: 89.0929\n",
            "Epoch 620 - Loss: 0.0341 - Accuracy: 89.3071\n",
            "Epoch 630 - Loss: 0.0333 - Accuracy: 89.5524\n",
            "Epoch 640 - Loss: 0.0326 - Accuracy: 89.7405\n",
            "Epoch 650 - Loss: 0.0319 - Accuracy: 89.9762\n",
            "Epoch 660 - Loss: 0.0312 - Accuracy: 90.1857\n",
            "Epoch 670 - Loss: 0.0305 - Accuracy: 90.4286\n",
            "Epoch 680 - Loss: 0.0298 - Accuracy: 90.6571\n",
            "Epoch 690 - Loss: 0.0292 - Accuracy: 90.7929\n",
            "Epoch 700 - Loss: 0.0286 - Accuracy: 90.9952\n",
            "Epoch 710 - Loss: 0.0280 - Accuracy: 91.1833\n",
            "Epoch 720 - Loss: 0.0275 - Accuracy: 91.4024\n",
            "Epoch 730 - Loss: 0.0270 - Accuracy: 91.5714\n",
            "Epoch 740 - Loss: 0.0265 - Accuracy: 91.7143\n",
            "Epoch 750 - Loss: 0.0260 - Accuracy: 91.8762\n",
            "Epoch 760 - Loss: 0.0256 - Accuracy: 92.0190\n",
            "Epoch 770 - Loss: 0.0251 - Accuracy: 92.1452\n",
            "Epoch 780 - Loss: 0.0247 - Accuracy: 92.2524\n",
            "Epoch 790 - Loss: 0.0243 - Accuracy: 92.3810\n",
            "Epoch 800 - Loss: 0.0240 - Accuracy: 92.5048\n",
            "Epoch 810 - Loss: 0.0236 - Accuracy: 92.6071\n",
            "Epoch 820 - Loss: 0.0232 - Accuracy: 92.7190\n",
            "Epoch 830 - Loss: 0.0229 - Accuracy: 92.8000\n",
            "Epoch 840 - Loss: 0.0226 - Accuracy: 92.9167\n",
            "Epoch 850 - Loss: 0.0223 - Accuracy: 93.0286\n",
            "Epoch 860 - Loss: 0.0220 - Accuracy: 93.1190\n",
            "Epoch 870 - Loss: 0.0217 - Accuracy: 93.2643\n",
            "Epoch 880 - Loss: 0.0214 - Accuracy: 93.3643\n",
            "Epoch 890 - Loss: 0.0211 - Accuracy: 93.4667\n",
            "Epoch 900 - Loss: 0.0208 - Accuracy: 93.5524\n",
            "Epoch 910 - Loss: 0.0206 - Accuracy: 93.6690\n",
            "Epoch 920 - Loss: 0.0203 - Accuracy: 93.7357\n",
            "Epoch 930 - Loss: 0.0201 - Accuracy: 93.8238\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test/255)\n",
        "print('The accuracy of Neural network with setting 2 is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "37dGjtXqrWqU",
        "outputId": "1957f26b-060f-4643-e0dd-73e1760ac5f2"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 2 is : 0.9236111111111112\n",
            "Class 0: F1 score = 0.9233\n",
            "Class 1: F1 score = 0.9461\n",
            "Class 2: F1 score = 0.9644\n",
            "Class 3: F1 score = 0.8941\n",
            "Class 4: F1 score = 0.9271\n",
            "Class 5: F1 score = 0.9237\n",
            "Class 6: F1 score = 0.9036\n",
            "Class 7: F1 score = 0.8739\n",
            "Class 8: F1 score = 0.9401\n",
            "Class 9: F1 score = 0.9384\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[200,100], output_size=10)\n",
        "nn.train(X_train/255,y_train,loss_func=1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PbXa2yZq9NVF",
        "outputId": "067818f5-d9fd-40b6-8eb9-da47a2bc4e57"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.1522 - Accuracy: 9.8524\n",
            "Epoch 10 - Loss: 0.1214 - Accuracy: 17.0452\n",
            "Epoch 20 - Loss: 0.1058 - Accuracy: 25.7357\n",
            "Epoch 30 - Loss: 0.0928 - Accuracy: 34.0238\n",
            "Epoch 40 - Loss: 0.0823 - Accuracy: 41.1071\n",
            "Epoch 50 - Loss: 0.0740 - Accuracy: 46.8429\n",
            "Epoch 60 - Loss: 0.0662 - Accuracy: 52.5262\n",
            "Epoch 70 - Loss: 0.0602 - Accuracy: 56.9048\n",
            "Epoch 80 - Loss: 0.0554 - Accuracy: 60.4857\n",
            "Epoch 90 - Loss: 0.0515 - Accuracy: 63.3429\n",
            "Epoch 100 - Loss: 0.0483 - Accuracy: 65.7214\n",
            "Epoch 110 - Loss: 0.0451 - Accuracy: 68.0786\n",
            "Epoch 120 - Loss: 0.0425 - Accuracy: 70.0405\n",
            "Epoch 130 - Loss: 0.0403 - Accuracy: 71.7452\n",
            "Epoch 140 - Loss: 0.0383 - Accuracy: 73.0952\n",
            "Epoch 150 - Loss: 0.0367 - Accuracy: 74.3595\n",
            "Epoch 160 - Loss: 0.0349 - Accuracy: 75.5762\n",
            "Epoch 170 - Loss: 0.0334 - Accuracy: 76.6881\n",
            "Epoch 180 - Loss: 0.0321 - Accuracy: 77.6048\n",
            "Epoch 190 - Loss: 0.0309 - Accuracy: 78.4786\n",
            "Epoch 200 - Loss: 0.0298 - Accuracy: 79.2286\n",
            "Epoch 210 - Loss: 0.0287 - Accuracy: 80.1357\n",
            "Epoch 220 - Loss: 0.0277 - Accuracy: 80.9119\n",
            "Epoch 230 - Loss: 0.0268 - Accuracy: 81.5643\n",
            "Epoch 240 - Loss: 0.0260 - Accuracy: 82.1500\n",
            "Epoch 250 - Loss: 0.0252 - Accuracy: 82.6881\n",
            "Epoch 260 - Loss: 0.0244 - Accuracy: 83.2548\n",
            "Epoch 270 - Loss: 0.0236 - Accuracy: 83.7619\n",
            "Epoch 280 - Loss: 0.0230 - Accuracy: 84.2571\n",
            "Epoch 290 - Loss: 0.0223 - Accuracy: 84.6881\n",
            "Epoch 300 - Loss: 0.0218 - Accuracy: 85.0500\n",
            "Epoch 310 - Loss: 0.0211 - Accuracy: 85.5429\n",
            "Epoch 320 - Loss: 0.0206 - Accuracy: 85.9500\n",
            "Epoch 330 - Loss: 0.0200 - Accuracy: 86.2976\n",
            "Epoch 340 - Loss: 0.0195 - Accuracy: 86.6071\n",
            "Epoch 350 - Loss: 0.0191 - Accuracy: 86.9000\n",
            "Epoch 360 - Loss: 0.0186 - Accuracy: 87.2500\n",
            "Epoch 370 - Loss: 0.0181 - Accuracy: 87.6048\n",
            "Epoch 380 - Loss: 0.0176 - Accuracy: 87.9500\n",
            "Epoch 390 - Loss: 0.0172 - Accuracy: 88.2690\n",
            "Epoch 400 - Loss: 0.0169 - Accuracy: 88.5429\n",
            "Epoch 410 - Loss: 0.0164 - Accuracy: 88.8333\n",
            "Epoch 420 - Loss: 0.0160 - Accuracy: 89.1310\n",
            "Epoch 430 - Loss: 0.0157 - Accuracy: 89.4048\n",
            "Epoch 440 - Loss: 0.0153 - Accuracy: 89.6238\n",
            "Epoch 450 - Loss: 0.0150 - Accuracy: 89.8524\n",
            "Epoch 460 - Loss: 0.0146 - Accuracy: 90.1167\n",
            "Epoch 470 - Loss: 0.0143 - Accuracy: 90.3571\n",
            "Epoch 480 - Loss: 0.0140 - Accuracy: 90.5786\n",
            "Epoch 490 - Loss: 0.0137 - Accuracy: 90.7929\n",
            "Epoch 500 - Loss: 0.0134 - Accuracy: 90.9786\n",
            "Epoch 510 - Loss: 0.0131 - Accuracy: 91.1643\n",
            "Epoch 520 - Loss: 0.0128 - Accuracy: 91.3810\n",
            "Epoch 530 - Loss: 0.0126 - Accuracy: 91.5833\n",
            "Epoch 540 - Loss: 0.0124 - Accuracy: 91.7429\n",
            "Epoch 550 - Loss: 0.0122 - Accuracy: 91.9214\n",
            "Epoch 560 - Loss: 0.0120 - Accuracy: 92.0595\n",
            "Epoch 570 - Loss: 0.0118 - Accuracy: 92.2262\n",
            "Epoch 580 - Loss: 0.0116 - Accuracy: 92.3643\n",
            "Epoch 590 - Loss: 0.0114 - Accuracy: 92.4929\n",
            "Epoch 600 - Loss: 0.0112 - Accuracy: 92.6143\n",
            "Epoch 610 - Loss: 0.0110 - Accuracy: 92.7286\n",
            "Epoch 620 - Loss: 0.0109 - Accuracy: 92.8429\n",
            "Epoch 630 - Loss: 0.0107 - Accuracy: 92.9405\n",
            "Epoch 640 - Loss: 0.0106 - Accuracy: 93.0452\n",
            "Epoch 650 - Loss: 0.0104 - Accuracy: 93.1548\n",
            "Epoch 660 - Loss: 0.0103 - Accuracy: 93.2619\n",
            "Epoch 670 - Loss: 0.0101 - Accuracy: 93.3619\n",
            "Epoch 680 - Loss: 0.0100 - Accuracy: 93.4190\n",
            "Epoch 690 - Loss: 0.0099 - Accuracy: 93.4929\n",
            "Epoch 700 - Loss: 0.0098 - Accuracy: 93.5905\n",
            "Epoch 710 - Loss: 0.0096 - Accuracy: 93.6881\n",
            "Epoch 720 - Loss: 0.0095 - Accuracy: 93.7452\n",
            "Epoch 730 - Loss: 0.0094 - Accuracy: 93.8333\n",
            "Epoch 740 - Loss: 0.0093 - Accuracy: 93.9238\n",
            "Epoch 750 - Loss: 0.0092 - Accuracy: 93.9833\n",
            "Epoch 760 - Loss: 0.0091 - Accuracy: 94.0762\n",
            "Epoch 770 - Loss: 0.0090 - Accuracy: 94.1452\n",
            "Epoch 780 - Loss: 0.0089 - Accuracy: 94.2381\n",
            "Epoch 790 - Loss: 0.0088 - Accuracy: 94.2976\n",
            "Epoch 800 - Loss: 0.0087 - Accuracy: 94.3762\n",
            "Epoch 810 - Loss: 0.0086 - Accuracy: 94.4286\n",
            "Epoch 820 - Loss: 0.0085 - Accuracy: 94.4905\n",
            "Epoch 830 - Loss: 0.0084 - Accuracy: 94.5500\n",
            "Epoch 840 - Loss: 0.0083 - Accuracy: 94.6024\n",
            "Epoch 850 - Loss: 0.0082 - Accuracy: 94.6500\n",
            "Epoch 860 - Loss: 0.0081 - Accuracy: 94.7071\n",
            "Epoch 870 - Loss: 0.0081 - Accuracy: 94.7786\n",
            "Epoch 880 - Loss: 0.0080 - Accuracy: 94.8262\n",
            "Epoch 890 - Loss: 0.0079 - Accuracy: 94.8929\n",
            "Epoch 900 - Loss: 0.0078 - Accuracy: 94.9548\n",
            "Epoch 910 - Loss: 0.0077 - Accuracy: 95.0119\n",
            "Epoch 920 - Loss: 0.0077 - Accuracy: 95.0762\n",
            "Epoch 930 - Loss: 0.0076 - Accuracy: 95.1452\n",
            "Epoch 940 - Loss: 0.0075 - Accuracy: 95.2000\n",
            "Epoch 950 - Loss: 0.0075 - Accuracy: 95.2476\n",
            "Epoch 960 - Loss: 0.0074 - Accuracy: 95.2857\n",
            "Epoch 970 - Loss: 0.0073 - Accuracy: 95.3500\n",
            "Epoch 980 - Loss: 0.0073 - Accuracy: 95.3905\n",
            "Epoch 990 - Loss: 0.0072 - Accuracy: 95.4286\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test/255)\n",
        "print('The accuracy of Neural network with setting 2 and squared error loss is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W073cVIE9OCZ",
        "outputId": "63ac381f-2143-4559-9565-05005c1d6333"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 2 and squared error loss is : 0.9271666666666667\n",
            "Class 0: F1 score = 0.9242\n",
            "Class 1: F1 score = 0.9496\n",
            "Class 2: F1 score = 0.9679\n",
            "Class 3: F1 score = 0.8951\n",
            "Class 4: F1 score = 0.9259\n",
            "Class 5: F1 score = 0.9265\n",
            "Class 6: F1 score = 0.9115\n",
            "Class 7: F1 score = 0.8715\n",
            "Class 8: F1 score = 0.9489\n",
            "Class 9: F1 score = 0.9490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Setting 3"
      ],
      "metadata": {
        "id": "sC9zjIObhEL-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[500,250], output_size=10)\n",
        "nn.train(X_train/255,y_train,loss_func=2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iVGCVNJOg6oI",
        "outputId": "1022de00-7c8b-49f1-ea4f-5ee47a33d225"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 1.6632 - Accuracy: 9.2429\n",
            "Epoch 10 - Loss: 0.7334 - Accuracy: 12.0786\n",
            "Epoch 20 - Loss: 0.5922 - Accuracy: 18.0286\n",
            "Epoch 30 - Loss: 0.4869 - Accuracy: 24.5714\n",
            "Epoch 40 - Loss: 0.4099 - Accuracy: 31.2690\n",
            "Epoch 50 - Loss: 0.3530 - Accuracy: 37.0714\n",
            "Epoch 60 - Loss: 0.3066 - Accuracy: 42.4929\n",
            "Epoch 70 - Loss: 0.2719 - Accuracy: 47.0976\n",
            "Epoch 80 - Loss: 0.2453 - Accuracy: 50.8595\n",
            "Epoch 90 - Loss: 0.2242 - Accuracy: 54.0429\n",
            "Epoch 100 - Loss: 0.2072 - Accuracy: 56.7381\n",
            "Epoch 110 - Loss: 0.1917 - Accuracy: 59.2452\n",
            "Epoch 120 - Loss: 0.1789 - Accuracy: 61.4119\n",
            "Epoch 130 - Loss: 0.1681 - Accuracy: 63.3405\n",
            "Epoch 140 - Loss: 0.1589 - Accuracy: 64.9214\n",
            "Epoch 150 - Loss: 0.1508 - Accuracy: 66.4738\n",
            "Epoch 160 - Loss: 0.1431 - Accuracy: 67.9405\n",
            "Epoch 170 - Loss: 0.1364 - Accuracy: 69.1952\n",
            "Epoch 180 - Loss: 0.1304 - Accuracy: 70.4095\n",
            "Epoch 190 - Loss: 0.1251 - Accuracy: 71.4857\n",
            "Epoch 200 - Loss: 0.1204 - Accuracy: 72.3333\n",
            "Epoch 210 - Loss: 0.1157 - Accuracy: 73.2357\n",
            "Epoch 220 - Loss: 0.1115 - Accuracy: 74.0524\n",
            "Epoch 230 - Loss: 0.1077 - Accuracy: 74.8976\n",
            "Epoch 240 - Loss: 0.1042 - Accuracy: 75.6214\n",
            "Epoch 250 - Loss: 0.1010 - Accuracy: 76.2857\n",
            "Epoch 260 - Loss: 0.0978 - Accuracy: 76.9143\n",
            "Epoch 270 - Loss: 0.0949 - Accuracy: 77.4619\n",
            "Epoch 280 - Loss: 0.0921 - Accuracy: 77.9976\n",
            "Epoch 290 - Loss: 0.0896 - Accuracy: 78.5167\n",
            "Epoch 300 - Loss: 0.0873 - Accuracy: 79.0452\n",
            "Epoch 310 - Loss: 0.0849 - Accuracy: 79.4810\n",
            "Epoch 320 - Loss: 0.0827 - Accuracy: 79.9333\n",
            "Epoch 330 - Loss: 0.0807 - Accuracy: 80.3714\n",
            "Epoch 340 - Loss: 0.0787 - Accuracy: 80.7857\n",
            "Epoch 350 - Loss: 0.0769 - Accuracy: 81.1905\n",
            "Epoch 360 - Loss: 0.0750 - Accuracy: 81.6167\n",
            "Epoch 370 - Loss: 0.0733 - Accuracy: 81.9357\n",
            "Epoch 380 - Loss: 0.0716 - Accuracy: 82.2905\n",
            "Epoch 390 - Loss: 0.0700 - Accuracy: 82.5833\n",
            "Epoch 400 - Loss: 0.0686 - Accuracy: 82.9143\n",
            "Epoch 410 - Loss: 0.0670 - Accuracy: 83.2095\n",
            "Epoch 420 - Loss: 0.0656 - Accuracy: 83.5381\n",
            "Epoch 430 - Loss: 0.0642 - Accuracy: 83.8667\n",
            "Epoch 440 - Loss: 0.0629 - Accuracy: 84.1143\n",
            "Epoch 450 - Loss: 0.0617 - Accuracy: 84.3667\n",
            "Epoch 460 - Loss: 0.0604 - Accuracy: 84.6810\n",
            "Epoch 470 - Loss: 0.0591 - Accuracy: 84.9857\n",
            "Epoch 480 - Loss: 0.0580 - Accuracy: 85.2667\n",
            "Epoch 490 - Loss: 0.0568 - Accuracy: 85.4762\n",
            "Epoch 500 - Loss: 0.0558 - Accuracy: 85.7048\n",
            "Epoch 510 - Loss: 0.0546 - Accuracy: 85.9381\n",
            "Epoch 520 - Loss: 0.0536 - Accuracy: 86.2381\n",
            "Epoch 530 - Loss: 0.0526 - Accuracy: 86.4595\n",
            "Epoch 540 - Loss: 0.0516 - Accuracy: 86.6810\n",
            "Epoch 550 - Loss: 0.0506 - Accuracy: 86.8500\n",
            "Epoch 560 - Loss: 0.0497 - Accuracy: 87.0786\n",
            "Epoch 570 - Loss: 0.0487 - Accuracy: 87.3143\n",
            "Epoch 580 - Loss: 0.0478 - Accuracy: 87.5405\n",
            "Epoch 590 - Loss: 0.0470 - Accuracy: 87.7452\n",
            "Epoch 600 - Loss: 0.0461 - Accuracy: 87.9167\n",
            "Epoch 610 - Loss: 0.0452 - Accuracy: 88.1190\n",
            "Epoch 620 - Loss: 0.0444 - Accuracy: 88.3476\n",
            "Epoch 630 - Loss: 0.0436 - Accuracy: 88.5238\n",
            "Epoch 640 - Loss: 0.0428 - Accuracy: 88.6738\n",
            "Epoch 650 - Loss: 0.0421 - Accuracy: 88.8571\n",
            "Epoch 660 - Loss: 0.0413 - Accuracy: 89.0405\n",
            "Epoch 670 - Loss: 0.0406 - Accuracy: 89.2238\n",
            "Epoch 680 - Loss: 0.0398 - Accuracy: 89.3762\n",
            "Epoch 690 - Loss: 0.0391 - Accuracy: 89.5333\n",
            "Epoch 700 - Loss: 0.0385 - Accuracy: 89.6976\n",
            "Epoch 710 - Loss: 0.0378 - Accuracy: 89.8833\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test/255)\n",
        "print('The accuracy of Neural network with setting 3 is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fjhYxGj0rd2y",
        "outputId": "6fa543c3-2699-422e-9037-e85adbcb0b4d"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 3 is : 0.8683333333333333\n",
            "Class 0: F1 score = 0.8519\n",
            "Class 1: F1 score = 0.8933\n",
            "Class 2: F1 score = 0.9351\n",
            "Class 3: F1 score = 0.8276\n",
            "Class 4: F1 score = 0.8699\n",
            "Class 5: F1 score = 0.8653\n",
            "Class 6: F1 score = 0.8538\n",
            "Class 7: F1 score = 0.8000\n",
            "Class 8: F1 score = 0.8953\n",
            "Class 9: F1 score = 0.8898\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=784, hidden_sizes=[500,250], output_size=10)\n",
        "nn.train(X_train/255,y_train,loss_func=1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HB268KQW9XNn",
        "outputId": "4d5a75db-b60a-49fe-a7be-bbc29ee91ddb"
      },
      "execution_count": 55,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 0 - Loss: 0.1788 - Accuracy: 10.1452\n",
            "Epoch 10 - Loss: 0.1245 - Accuracy: 23.6762\n",
            "Epoch 20 - Loss: 0.1014 - Accuracy: 36.6595\n",
            "Epoch 30 - Loss: 0.0851 - Accuracy: 46.3690\n",
            "Epoch 40 - Loss: 0.0740 - Accuracy: 53.0929\n",
            "Epoch 50 - Loss: 0.0660 - Accuracy: 57.9333\n",
            "Epoch 60 - Loss: 0.0589 - Accuracy: 62.4381\n",
            "Epoch 70 - Loss: 0.0535 - Accuracy: 65.7476\n",
            "Epoch 80 - Loss: 0.0494 - Accuracy: 68.3786\n",
            "Epoch 90 - Loss: 0.0460 - Accuracy: 70.4595\n",
            "Epoch 100 - Loss: 0.0431 - Accuracy: 72.3524\n",
            "Epoch 110 - Loss: 0.0403 - Accuracy: 74.1310\n",
            "Epoch 120 - Loss: 0.0380 - Accuracy: 75.5690\n",
            "Epoch 130 - Loss: 0.0360 - Accuracy: 76.8429\n",
            "Epoch 140 - Loss: 0.0342 - Accuracy: 77.8833\n",
            "Epoch 150 - Loss: 0.0327 - Accuracy: 78.8952\n",
            "Epoch 160 - Loss: 0.0310 - Accuracy: 79.9571\n",
            "Epoch 170 - Loss: 0.0296 - Accuracy: 80.8786\n",
            "Epoch 180 - Loss: 0.0284 - Accuracy: 81.6619\n",
            "Epoch 190 - Loss: 0.0273 - Accuracy: 82.3857\n",
            "Epoch 200 - Loss: 0.0263 - Accuracy: 83.0000\n",
            "Epoch 210 - Loss: 0.0252 - Accuracy: 83.6905\n",
            "Epoch 220 - Loss: 0.0242 - Accuracy: 84.2881\n",
            "Epoch 230 - Loss: 0.0234 - Accuracy: 84.8429\n",
            "Epoch 240 - Loss: 0.0226 - Accuracy: 85.3333\n",
            "Epoch 250 - Loss: 0.0219 - Accuracy: 85.8190\n",
            "Epoch 260 - Loss: 0.0211 - Accuracy: 86.2357\n",
            "Epoch 270 - Loss: 0.0203 - Accuracy: 86.7048\n",
            "Epoch 280 - Loss: 0.0197 - Accuracy: 87.1714\n",
            "Epoch 290 - Loss: 0.0191 - Accuracy: 87.5881\n",
            "Epoch 300 - Loss: 0.0185 - Accuracy: 87.9452\n",
            "Epoch 310 - Loss: 0.0179 - Accuracy: 88.4000\n",
            "Epoch 320 - Loss: 0.0173 - Accuracy: 88.7786\n",
            "Epoch 330 - Loss: 0.0168 - Accuracy: 89.1167\n",
            "Epoch 340 - Loss: 0.0163 - Accuracy: 89.3881\n",
            "Epoch 350 - Loss: 0.0158 - Accuracy: 89.7095\n",
            "Epoch 360 - Loss: 0.0153 - Accuracy: 90.0762\n",
            "Epoch 370 - Loss: 0.0148 - Accuracy: 90.3714\n",
            "Epoch 380 - Loss: 0.0144 - Accuracy: 90.5976\n",
            "Epoch 390 - Loss: 0.0140 - Accuracy: 90.8167\n",
            "Epoch 400 - Loss: 0.0136 - Accuracy: 91.1024\n",
            "Epoch 410 - Loss: 0.0132 - Accuracy: 91.3571\n",
            "Epoch 420 - Loss: 0.0129 - Accuracy: 91.6095\n",
            "Epoch 430 - Loss: 0.0126 - Accuracy: 91.8024\n",
            "Epoch 440 - Loss: 0.0123 - Accuracy: 92.0000\n",
            "Epoch 450 - Loss: 0.0120 - Accuracy: 92.2048\n",
            "Epoch 460 - Loss: 0.0117 - Accuracy: 92.3667\n",
            "Epoch 470 - Loss: 0.0114 - Accuracy: 92.5571\n",
            "Epoch 480 - Loss: 0.0112 - Accuracy: 92.6952\n",
            "Epoch 490 - Loss: 0.0109 - Accuracy: 92.8881\n",
            "Epoch 500 - Loss: 0.0107 - Accuracy: 93.0214\n",
            "Epoch 510 - Loss: 0.0105 - Accuracy: 93.1738\n",
            "Epoch 520 - Loss: 0.0103 - Accuracy: 93.2810\n",
            "Epoch 530 - Loss: 0.0101 - Accuracy: 93.3976\n",
            "Epoch 540 - Loss: 0.0099 - Accuracy: 93.5524\n",
            "Epoch 550 - Loss: 0.0097 - Accuracy: 93.7143\n",
            "Epoch 560 - Loss: 0.0095 - Accuracy: 93.8167\n",
            "Epoch 570 - Loss: 0.0093 - Accuracy: 93.9452\n",
            "Epoch 580 - Loss: 0.0091 - Accuracy: 94.0690\n",
            "Epoch 590 - Loss: 0.0089 - Accuracy: 94.1905\n",
            "Epoch 600 - Loss: 0.0088 - Accuracy: 94.3143\n",
            "Epoch 610 - Loss: 0.0086 - Accuracy: 94.4238\n",
            "Epoch 620 - Loss: 0.0085 - Accuracy: 94.5262\n",
            "Epoch 630 - Loss: 0.0083 - Accuracy: 94.6143\n",
            "Epoch 640 - Loss: 0.0082 - Accuracy: 94.7143\n",
            "Epoch 650 - Loss: 0.0080 - Accuracy: 94.8333\n",
            "Epoch 660 - Loss: 0.0079 - Accuracy: 94.9143\n",
            "Epoch 670 - Loss: 0.0078 - Accuracy: 94.9857\n",
            "Epoch 680 - Loss: 0.0076 - Accuracy: 95.0714\n",
            "Epoch 690 - Loss: 0.0075 - Accuracy: 95.1571\n",
            "Epoch 700 - Loss: 0.0074 - Accuracy: 95.2690\n",
            "Epoch 710 - Loss: 0.0073 - Accuracy: 95.3381\n",
            "Epoch 720 - Loss: 0.0071 - Accuracy: 95.4119\n",
            "Epoch 730 - Loss: 0.0070 - Accuracy: 95.4905\n",
            "Epoch 740 - Loss: 0.0069 - Accuracy: 95.5857\n",
            "Epoch 750 - Loss: 0.0068 - Accuracy: 95.6595\n",
            "Epoch 760 - Loss: 0.0067 - Accuracy: 95.7238\n",
            "Epoch 770 - Loss: 0.0066 - Accuracy: 95.8000\n",
            "Epoch 780 - Loss: 0.0065 - Accuracy: 95.8714\n",
            "Epoch 790 - Loss: 0.0064 - Accuracy: 95.9405\n",
            "Epoch 800 - Loss: 0.0063 - Accuracy: 96.0024\n",
            "Epoch 810 - Loss: 0.0062 - Accuracy: 96.0857\n",
            "Epoch 820 - Loss: 0.0061 - Accuracy: 96.1429\n",
            "Epoch 830 - Loss: 0.0060 - Accuracy: 96.2357\n",
            "Epoch 840 - Loss: 0.0059 - Accuracy: 96.3024\n",
            "Epoch 850 - Loss: 0.0059 - Accuracy: 96.3357\n",
            "Epoch 860 - Loss: 0.0058 - Accuracy: 96.3952\n",
            "Epoch 870 - Loss: 0.0057 - Accuracy: 96.4595\n",
            "Epoch 880 - Loss: 0.0056 - Accuracy: 96.5024\n",
            "Epoch 890 - Loss: 0.0055 - Accuracy: 96.5524\n",
            "Epoch 900 - Loss: 0.0055 - Accuracy: 96.6095\n",
            "Epoch 910 - Loss: 0.0054 - Accuracy: 96.6786\n",
            "Epoch 920 - Loss: 0.0053 - Accuracy: 96.7357\n",
            "Epoch 930 - Loss: 0.0052 - Accuracy: 96.7905\n",
            "Epoch 940 - Loss: 0.0052 - Accuracy: 96.8214\n",
            "Epoch 950 - Loss: 0.0051 - Accuracy: 96.8595\n",
            "Epoch 960 - Loss: 0.0050 - Accuracy: 96.9119\n",
            "Epoch 970 - Loss: 0.0050 - Accuracy: 96.9595\n",
            "Epoch 980 - Loss: 0.0049 - Accuracy: 97.0143\n",
            "Epoch 990 - Loss: 0.0048 - Accuracy: 97.0500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test/255)\n",
        "print('The accuracy of Neural network with setting 3 and squared error loss is :',np.mean(y_pred == y_test))\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7ZjV-Xnk9bUh",
        "outputId": "f0ed17fd-dfff-4e4b-a9ba-bf0e1c614e34"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 3 and squared error loss is : 0.9171666666666667\n",
            "Class 0: F1 score = 0.9104\n",
            "Class 1: F1 score = 0.9325\n",
            "Class 2: F1 score = 0.9629\n",
            "Class 3: F1 score = 0.8883\n",
            "Class 4: F1 score = 0.9212\n",
            "Class 5: F1 score = 0.9110\n",
            "Class 6: F1 score = 0.9037\n",
            "Class 7: F1 score = 0.8665\n",
            "Class 8: F1 score = 0.9414\n",
            "Class 9: F1 score = 0.9326\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Q4 Inferences**\n",
        "\n",
        "**In Setting 1 **: 3 hidden layers are taken with 300,100,50 nodes , following are the observations \n",
        "\n",
        "Squared error loss :\n",
        "\n",
        "*   Training Loss : 0.0152\n",
        "*   Training Accuracy : 89.85%\n",
        "*   Test Accuracy : 88.50%\n",
        "\n",
        "Cross Entropy Loss : \n",
        "\n",
        "*   Training Loss : 0.0254\n",
        "*   Training Accuracy : 92.27%\n",
        "*   Test Accuracy : 91.35%\n",
        "\n",
        "**In Setting 2 **: 2 hidden layers are taken with 200,100 nodes , following are the observations \n",
        "\n",
        "Squared error loss :\n",
        "\n",
        "*   Training Loss : 0.0076\n",
        "*   Training Accuracy : 95.82%\n",
        "*   Test Accuracy : 92.36%\n",
        "\n",
        "Cross Entropy Loss : \n",
        "\n",
        "*   Training Loss : 0.0254\n",
        "*   Training Accuracy : 92.27%\n",
        "*   Test Accuracy : 91.35%\n",
        "\n",
        "**In Setting 3 **: 2 hidden layers are taken with 500,250 nodes , following are the observations \n",
        "\n",
        "Squared error loss :\n",
        "\n",
        "*   Training Loss : 0.0073\n",
        "*   Training Accuracy : 95.82%\n",
        "*   Test Accuracy : 91.71%\n",
        "\n",
        "Cross Entropy Loss : \n",
        "\n",
        "*   Training Loss : 0.0378\n",
        "*   Training Accuracy : 89.83%\n",
        "*   Test Accuracy : 86.83%\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "1.   In Setting 1, it appears that using cross entropy loss function has resulted in better performance. It appears cross entropy loss function is a more appropriate loss function in this setting\n",
        "2.   In setting 2 and 3 Squared error loss function is giving a lower loss and better accuracy in both test and train scenarios. we might say that squared error loss is converging faster and is giving better results here\n",
        "3.   One observation to make here is that the neural network is converging faster with a lower number of hidden layers, it may suggest that the problem at hand does not require a complex model with many layers. In general adding more layers to a neural network allows it to learn more complex representations of the input data. If lower number of hidden layers is able to achieve comparable or even better performance than a more complex network, it may be more efficient and effective solution. \n",
        "4.   As we can see that in all the settings the f1 scores are balanced so we can conclude that model is able to identify all the classes and the data is also balanced\n",
        "5.   Here if we observe it is taking very high epochs to get a good accuracy, we can possibily say that the learning rate is too low. A low learning rate can cause the network to converge slowly, which may be why it's taking so many epochs to achieve a high accuracy. I tried to increase the learning rate but increasing it too much resulted in higher loss therefore took a lower learning rate.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "yQilltifMuxW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q5"
      ],
      "metadata": {
        "id": "I_s-JPAMfaGF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class activation_relu:\n",
        "    \n",
        "    def forward(self, inputs):\n",
        "        self.inputs                   = inputs\n",
        "        self.output                   = np.maximum(0, inputs)\n",
        "        return self.output\n",
        "    \n",
        "    def delta(self):\n",
        "        self.dvalue                   = np.ones_like(self.inputs)\n",
        "        self.dvalue[self.inputs <= 0] = 0\n",
        "        return self.dvalue"
      ],
      "metadata": {
        "id": "x5eK715-fcxy"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class activation_softmax:\n",
        "    \n",
        "    def forward(self, inputs):\n",
        "        self.inputs                   = inputs\n",
        "        exp_values                    = np.exp(inputs - np.max(inputs, axis=0, keepdims=True))\n",
        "        probabilities                 = exp_values / np.sum(exp_values, axis=0, keepdims=True)\n",
        "        self.outputs                  = probabilities\n",
        "        return self.outputs\n",
        "        \n",
        "    def delta(self):\n",
        "        \n",
        "        self.dvalue = []\n",
        "        \n",
        "        for index, single_output in enumerate(self.outputs.T):\n",
        "            single_output = single_output.reshape(-1, 1)\n",
        "            self.dvalue.append(np.diagflat(single_output) - np.matmul(single_output, single_output.T))\n",
        "        \n",
        "        self.dvalue = np.array(self.dvalue)\n",
        "        return self.dvalue"
      ],
      "metadata": {
        "id": "PwktUaFRhoKB"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class cross_entropy_loss:\n",
        "    \n",
        "    def forward(self, y_pred, y_true):\n",
        "        \n",
        "        y_true = np.argmax(y_true, axis = 1)\n",
        "        y_pred = y_pred.T\n",
        "        batch_size = y_pred.shape[0]\n",
        "        y_pred = np.clip(y_pred, 1e-10, 1 - 1e-10)\n",
        "        log_likelihoods = -np.log(y_pred[range(batch_size), y_true])\n",
        "        loss = np.mean(log_likelihoods)\n",
        "\n",
        "        return loss\n",
        "    \n",
        "    def delta(self, a, y,sigma_prime = None):\n",
        "        return (a.T-y)/a.shape[1]"
      ],
      "metadata": {
        "id": "JnQooIWihxj2"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "dfe0bda8"
      },
      "outputs": [],
      "source": [
        "class ConvolutionLayer:\n",
        "    def __init__(self, filter_num, filter_size, input_channels):\n",
        "        \"\"\"\n",
        "        Constructor takes as input the number of kernels, their size, and the number of input channels.\n",
        "        \"\"\"\n",
        "        self.kernel_num = filter_num\n",
        "        self.kernel_size = filter_size\n",
        "        self.input_channels = input_channels\n",
        "        # Generate random filters of shape (kernel_num, kernel_size, kernel_size, input_channels). Divide by kernel_size^2 for weight normalization\n",
        "        self.kernels = np.random.randn(filter_num, filter_size, filter_size, input_channels) / (filter_size*filter_size)\n",
        "        self.dkernels = 0\n",
        "        \n",
        "    def patches_generator(self, input):\n",
        "        \"\"\"\n",
        "        Divide the input in patches to be used during convolution.\n",
        "        Yields the tuples containing the patches and their coordinates.\n",
        "        \"\"\"\n",
        "        # Extract input batch size, height, and width\n",
        "        batch_size, input_h, input_w, input_c = input.shape\n",
        "        self.input = input\n",
        "        # The number of patches, given a fxf filter is h-f+1 for height and w-f+1 for width\n",
        "        for b in range(batch_size):\n",
        "            for h in range(input_h-self.kernel_size+1):\n",
        "                for w in range(input_w-self.kernel_size+1):\n",
        "                    patch = input[b, h:(h+self.kernel_size), w:(w+self.kernel_size), :]\n",
        "                    yield patch, b, h, w\n",
        "\n",
        "    def forward(self, input):\n",
        "        \"\"\"\n",
        "        Perform forward propagation for the convolutional layer.\n",
        "        \"\"\"\n",
        "        # Extract input batch size, height, and width\n",
        "        batch_size, input_h, input_w, input_c = input.shape\n",
        "        # Initialize the convolution output volume of the correct size\n",
        "        convolution_output = np.zeros((batch_size, input_h-self.kernel_size+1, input_w-self.kernel_size+1, self.kernel_num))\n",
        "        # Unpack the generator\n",
        "        for patch, b, h, w in self.patches_generator(input):\n",
        "            # Perform convolution for each patch\n",
        "            convolution_output[b, h, w] = np.sum(patch*self.kernels, axis=(1,2,3))\n",
        "        return convolution_output\n",
        "\n",
        "    def backward(self, output_grad):\n",
        "        \"\"\"\n",
        "        Perform backward propagation for the convolutional layer.\n",
        "        \"\"\"\n",
        "        batch_size, input_h, input_w, input_c = self.input.shape\n",
        "        input_grad = np.zeros((batch_size, input_h, input_w, input_c))\n",
        "        dkernels = np.zeros_like(self.kernels)\n",
        "        for patch, b, h, w in self.patches_generator(self.input):\n",
        "            for k in range(self.kernel_num):\n",
        "                # Compute gradients with respect to kernel weights\n",
        "                dkernels[k] += patch * output_grad[b, h, w, k]\n",
        "                # Compute gradients with respect to inputs\n",
        "                input_grad[b, h:(h+self.kernel_size), w:(w+self.kernel_size), :] += self.kernels[k] * output_grad[b, h, w, k]\n",
        "        # Update the kernel weights using the gradients\n",
        "        self.dkernels = dkernels\n",
        "#         self.kernels -= learning_rate * dkernels\n",
        "        return input_grad\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "9446922b"
      },
      "outputs": [],
      "source": [
        "class MaxPoolingLayer:\n",
        "    def __init__(self, filter_size):\n",
        "        \"\"\"\n",
        "        Constructor takes as input the size of the kernel\n",
        "        \"\"\"\n",
        "        self.filter_size = filter_size\n",
        "\n",
        "    def image_region(self, input):\n",
        "        \"\"\"\n",
        "        Divide the input image in patches to be used during pooling.\n",
        "        Yields the tuples containing the patches and their coordinates.\n",
        "        \"\"\"\n",
        "        # Compute the ouput size\n",
        "        height_out = input.shape[1] // self.filter_size\n",
        "        width_out = input.shape[2] // self.filter_size\n",
        "        self.image = input\n",
        "        for i in range(input.shape[0]):  # loop through batch size\n",
        "            batch_patches = []\n",
        "            for h in range(height_out):\n",
        "                for w in range(width_out):\n",
        "                    patch = input[i, (h*self.filter_size):(h*self.filter_size + self.filter_size), (w*self.filter_size):(w*self.filter_size + self.filter_size), :]\n",
        "                    batch_patches.append(patch)\n",
        "            yield np.array(batch_patches), i\n",
        "    \n",
        "    def forward(self, image):\n",
        "        batch_size, height, width, num_channels = image.shape\n",
        "        out = np.zeros((batch_size, height//self.filter_size, width//self.filter_size, num_channels))\n",
        "        self.max_pooling_output_shape = (batch_size, height//self.filter_size, width//self.filter_size, num_channels)\n",
        "        for batch_patches, i in self.image_region(image):\n",
        "            out[i] = np.amax(batch_patches, axis=(1,2)).reshape((height//self.filter_size , width//self.filter_size, num_channels))\n",
        "        return out\n",
        "\n",
        "    def backward(self, dE_dY, dvalue_activation):\n",
        "        \"\"\"\n",
        "        Takes the gradient of the loss function with respect to the output and computes the gradients of the loss function with respect\n",
        "        to the kernels' weights.\n",
        "        dE_dY comes from the following layer, typically softmax.\n",
        "        There are no weights to update, but the output is needed to update the weights of the convolutional layer.\n",
        "        \"\"\"\n",
        "        dE_dY = dE_dY.reshape(self.max_pooling_output_shape)\n",
        "#         print(dE_dY, )\n",
        "        dE_dk = np.zeros(self.image.shape)\n",
        "        for batch_patches, i in self.patches_generator(self.image):\n",
        "            batch_size, image_h, image_w, num_channels = batch_patches.shape\n",
        "            max_val = np.amax(batch_patches, axis=(1,2))\n",
        "\n",
        "            for h in range(image_h):\n",
        "                for w in range(image_w):\n",
        "                    for idx_k in range(num_channels):\n",
        "                        for b in range(batch_size):\n",
        "                            if batch_patches[b,h,w,idx_k] == max_val[b,idx_k]:\n",
        "                                dE_dk[i, h*self.filter_size:h*self.filter_size+self.filter_size, w*self.filter_size:w*self.filter_size+self.filter_size, idx_k] += dE_dY[i, h, w, idx_k] * dvalue_activation[i, h*self.filter_size:h*self.filter_size+self.filter_size, w*self.filter_size:w*self.filter_size+self.filter_size, idx_k]\n",
        "        return dE_dk"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "0b69314a"
      },
      "outputs": [],
      "source": [
        "class dense_layer:\n",
        "    ##initializing weights, biases for the layer\n",
        "    def __init__(self, num_inputs, num_neurons):\n",
        "        self.weights                  = 0.01*np.random.randn(num_neurons, num_inputs)\n",
        "        self.bias                     = np.zeros((num_neurons, 1))\n",
        "    \n",
        "    def forward(self, inputs):\n",
        "        self.inputs                   = inputs\n",
        "        self.output                   = np.matmul(self.weights, self.inputs) + self.bias\n",
        "        return self.output\n",
        "    \n",
        "    def backward(self, dvalue, dvalue_activation):\n",
        "        self.dbias = np.sum(dvalue*dvalue_activation, axis = 1, keepdims = True)\n",
        "        self.dweights                 = np.matmul(dvalue, self.inputs.T)\n",
        "        self.dinput                   = np.matmul(self.weights.T, dvalue*dvalue_activation)\n",
        "        return self.dinput"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "77636da2"
      },
      "outputs": [],
      "source": [
        "class model:\n",
        "    \n",
        "    def __init__(self, input_channels, num_filters_layer, activ_func, num_input_fc, kernel_size):\n",
        "        '''num_filters_layer - array containg number of filters in each hidden layer\n",
        "        eg- [2,3,4] has 3 layers with 2, 3 and 4 filters in each layer respectively'''\n",
        "        \n",
        "        self.num_hidden_conv_layers = len(num_filters_layer)\n",
        "        self.filter_channels = [input_channels] + num_filters_layer\n",
        "        \n",
        "        self.conv_layers = []\n",
        "        self.max_pool    = []\n",
        "        self.activations = []\n",
        "        \n",
        "        \n",
        "        for i in range(self.num_hidden_conv_layers):\n",
        "            self.conv_layers.append(ConvolutionLayer(self.filter_channels[i+1], kernel_size, self.filter_channels[i] ))\n",
        "            self.max_pool.append(MaxPoolingLayer(2))\n",
        "            if activ_func == 'relu':\n",
        "                self.activations.append(activation_relu())\n",
        "         \n",
        "                \n",
        "        self.fc_layer = dense_layer(num_input_fc*self.filter_channels[self.num_hidden_conv_layers], 10)\n",
        "        self.softmax = activation_softmax()\n",
        "        \n",
        "    \n",
        "    def forward(self, input_):\n",
        "    \n",
        "        output = input_\n",
        "        for i in range(self.num_hidden_conv_layers):\n",
        "            output = self.conv_layers[i].forward(output)\n",
        "            output = self.max_pool[i].forward(output)\n",
        "            output = self.activations[i].forward(output)\n",
        "        \n",
        "        output = output.reshape((output.shape[0], output.shape[1]*output.shape[2]*output.shape[3]))\n",
        "        output = self.fc_layer.forward(output.T)\n",
        "        output = self.softmax.forward(output)\n",
        "        self.output = output\n",
        "        return output\n",
        "    \n",
        "    def backprop(self, y_one_hot):\n",
        "\n",
        "        delta = self.loss.delta(self.output,  y_one_hot, self.softmax.delta())\n",
        "        delta = self.fc_layer.backward(delta.T, np.array(1))\n",
        "        \n",
        "        for i in range(self.num_hidden_conv_layers - 1, -1, -1):\n",
        "            dvalue_activation = self.activations[i].delta()\n",
        "            delta = self.max_pool[i].backward(delta, dvalue_activation)\n",
        "            delta = self.conv_layers[i].backward(delta)\n",
        "            \n",
        "    def vectorized_result(self, y, num_classes):\n",
        "        one_hot = np.zeros((len(y), num_classes))\n",
        "        for i in range(len(y)):\n",
        "            one_hot[i,int(y[i])] = 1\n",
        "        return one_hot\n",
        "            \n",
        "    def train(self, training_data, loss, mini_batch_size, learning_rate, epochs):\n",
        "        self.loss = loss        \n",
        "        n = len(training_data)\n",
        "        epoch_acc = []\n",
        "        epoch_cost = []\n",
        "        \n",
        "        for epoch in range(epochs):\n",
        "            num_corrects = 0\n",
        "            np.random.shuffle(training_data)\n",
        "            \n",
        "            mini_batches = [ training_data[k:min(n, k+mini_batch_size)]\n",
        "                                for k in range(0, n, mini_batch_size)]\n",
        "            a_ = 0\n",
        "\n",
        "            for mini_batch in mini_batches:\n",
        "                mini_batch_x = mini_batch[:,1:].reshape(-1, 28,28,1)\n",
        "                mini_batch_y = mini_batch[:,0]\n",
        "                \n",
        "                mini_batch_y_one_hot = self.vectorized_result(mini_batch_y, 10)\n",
        "                mini_batch_outputs = self.forward(mini_batch_x)\n",
        "                mini_batch_y_pred = np.argmax(mini_batch_outputs, axis = 0)\n",
        "                \n",
        "               \n",
        "                num_corrects += np.count_nonzero(mini_batch_y_pred==mini_batch_y)\n",
        "                \n",
        "                self.backprop(mini_batch_y_one_hot)\n",
        "\n",
        "                self.fc_layer.weights = self.fc_layer.weights - (learning_rate/ len(mini_batch))*self.fc_layer.dweights\n",
        "                self.fc_layer.bias    = self.fc_layer.bias     -  (learning_rate/ len(mini_batch))*self.fc_layer.dbias\n",
        "                self.fc_layer.dweights = 0\n",
        "                self.fc_layer.dbias = 0\n",
        "                                    \n",
        "                for conv_layer in self.conv_layers:\n",
        "                    conv_layer.kernels = conv_layer.kernels  -  (learning_rate/ len(mini_batch))*conv_layer.dkernels\n",
        "                    \n",
        "                    conv_layer.dkernels = 0\n",
        "                a_+=1\n",
        "                    \n",
        "            \n",
        "            acc = num_corrects/n\n",
        "        \n",
        "            print('Epoch {} Accuracy - {}'.format(epoch+1, acc))\n",
        "            \n",
        "            epoch_acc.append(acc)\n",
        "            epoch_cost.append(self.total_loss(training_data))\n",
        "            \n",
        "            \n",
        "            \n",
        "        return epoch_acc, epoch_cost\n",
        "    \n",
        "   \n",
        "\n",
        "    \n",
        "    def test(self, test_data, mini_batch_size):\n",
        "            n = len(test_data)\n",
        "            num_corrects = 0\n",
        "            np.random.shuffle(test_data)\n",
        "            \n",
        "            mini_batches = [ test_data[k:min(n, k+mini_batch_size)]\n",
        "                                for k in range(0, n, mini_batch_size)]\n",
        "            \n",
        "            y_pred_ = []\n",
        "            y_true_ = test_data[:,0]\n",
        "            \n",
        "            for mini_batch in mini_batches:\n",
        "                mini_batch_x = mini_batch[:,1:].reshape(-1,28,28,1)\n",
        "                mini_batch_y = mini_batch[:,0]\n",
        "                \n",
        "                mini_batch_y_one_hot = self.vectorized_result(mini_batch_y, 10)\n",
        "                \n",
        "                mini_batch_outputs = self.forward(mini_batch_x)\n",
        "                mini_batch_y_pred = np.argmax(mini_batch_outputs, axis = 0)\n",
        "                \n",
        "               \n",
        "                num_corrects += np.count_nonzero(mini_batch_y_pred==mini_batch_y)\n",
        "                y_pred_.append(mini_batch_y_pred.flatten())\n",
        "                    \n",
        "            acc = num_corrects/n\n",
        "            print('\\033[1m'+'Test Accuracy - {}'.format(acc))\n",
        "            \n",
        "            \n",
        "            \n",
        "            \n",
        "            \n",
        "    def total_loss(self, data):\n",
        "        loss = 0\n",
        "\n",
        "        data_x = data[:,1:].reshape(-1, 28, 28, 1)\n",
        "        data_y = data[:,0]\n",
        "        y_one_hot = self.vectorized_result(data_y, 10)\n",
        "        a = self.forward(data_x)\n",
        "        loss += self.loss.forward(a, y_one_hot)\n",
        "            \n",
        "        return loss\n",
        "    \n",
        "        \n",
        "        "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train,y_train,X_test,y_test = split_data(Kmnist,y_kmnist,0.2)"
      ],
      "metadata": {
        "id": "aZUtijK6f5FX"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(X_train.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x64iHC4pg-kJ",
        "outputId": "8b7faf20-3cb3-4d83-e17d-e19241ace6f1"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(12000, 785)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setting 1"
      ],
      "metadata": {
        "id": "AJ7TmQY-hOSj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cnn = model(1, [1], 'relu', 13*13,3)\n",
        "\n",
        "cnn.train(X_train,cross_entropy_loss(), 256, 0.01, 5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "ctjAGVoohL4Y",
        "outputId": "7adaa2cb-d3c5-403c-a6a3-b2e7eff99dc4"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1 Accuracy - 0.8808333333333334\n",
            "Epoch 2 Accuracy - 0.9985833333333334\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-85d4494be977>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_entropy_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mepoc_acc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoc_cos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_cnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.01\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-18-c23009290ed6>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self, training_data, loss, mini_batch_size, learning_rate, epochs)\u001b[0m\n\u001b[1;32m    102\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m             \u001b[0mepoch_acc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m             \u001b[0mepoch_cost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtotal_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    105\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-18-c23009290ed6>\u001b[0m in \u001b[0;36mtotal_loss\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m    232\u001b[0m         \u001b[0mdata_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    233\u001b[0m         \u001b[0my_one_hot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvectorized_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 234\u001b[0;31m         \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    235\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_one_hot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-18-c23009290ed6>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_)\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput_\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_hidden_conv_layers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv_layers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     32\u001b[0m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivations\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-1-573d5544cd27>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mpatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatches_generator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m             \u001b[0;31m# Perform convolution for each patch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m             \u001b[0mconvolution_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mconvolution_output\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m   2294\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2295\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2296\u001b[0;31m     return _wrapreduction(a, np.add, 'sum', axis, dtype, out, keepdims=keepdims,\n\u001b[0m\u001b[1;32m   2297\u001b[0m                           initial=initial, where=where)\n\u001b[1;32m   2298\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[0;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[1;32m     84\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mreduction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     87\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cnn.test(X_test, 256)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xXeNI55Fkal2",
        "outputId": "3f40d5ef-a4a8-42f3-9665-9435315773e7"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1mTest Accuracy - 0.9995\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setting 2"
      ],
      "metadata": {
        "id": "wr7dU1JuhRUH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "79f6db9d",
        "outputId": "39b19330-5095-49d5-8f6d-7d2c76832cdd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1 Accuracy - 0.9239103258604884\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-26-f136b438da11>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mepoc_acc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoc_cos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_cnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcross_entropy_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.01\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-11-5d1c73a6183d>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self, training_data, loss, mini_batch_size, learning_rate, epochs)\u001b[0m\n\u001b[1;32m    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m             \u001b[0mepoch_acc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m             \u001b[0mepoch_cost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtotal_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    106\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    107\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-11-5d1c73a6183d>\u001b[0m in \u001b[0;36mtotal_loss\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m    233\u001b[0m         \u001b[0mdata_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    234\u001b[0m         \u001b[0my_one_hot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvectorized_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 235\u001b[0;31m         \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    236\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_one_hot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-11-5d1c73a6183d>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_)\u001b[0m\n\u001b[1;32m     30\u001b[0m         \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput_\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_hidden_conv_layers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv_layers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m             \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivations\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-8-573d5544cd27>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mpatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatches_generator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m             \u001b[0;31m# Perform convolution for each patch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m             \u001b[0mconvolution_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mconvolution_output\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "cnn = model(1, [3], 'relu', 12*12, 5)\n",
        "\n",
        "cnn.train(X_train, cross_entropy_loss(), 256, 0.01, 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3cffd79b",
        "outputId": "f2ea5739-1b13-4e35-b6e8-7805df78935a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1mTest Accuracy - 0.9816666666666667\n"
          ]
        }
      ],
      "source": [
        "cnn.test(X_test, 256)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setting 3"
      ],
      "metadata": {
        "id": "q6i7BbVahTwk"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "192f4e95",
        "outputId": "c84d07dc-cb37-433a-ce84-1f55d9a38737"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1 Accuracy - 0.28252354362863574\n",
            "Epoch 2 Accuracy - 0.9978331527627302\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-4c58703929bf>\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_entropy_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mepoc_acc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoc_cos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_cnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.01\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-11-5d1c73a6183d>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self, training_data, loss, mini_batch_size, learning_rate, epochs)\u001b[0m\n\u001b[1;32m     83\u001b[0m                 \u001b[0mnum_corrects\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount_nonzero\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmini_batch_y_pred\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mmini_batch_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     84\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 85\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackprop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmini_batch_y_one_hot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmini_batch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdweights\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-11-5d1c73a6183d>\u001b[0m in \u001b[0;36mbackprop\u001b[0;34m(self, y_one_hot)\u001b[0m\n\u001b[1;32m     50\u001b[0m             \u001b[0mdelta\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdvalue_activation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[0;31m#             print('liop',i)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 52\u001b[0;31m             \u001b[0mdelta\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv_layers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mvectorized_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_classes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-8-573d5544cd27>\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, output_grad)\u001b[0m\n\u001b[1;32m     52\u001b[0m                 \u001b[0mdkernels\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mpatch\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0moutput_grad\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m                 \u001b[0;31m# Compute gradients with respect to inputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m                 \u001b[0minput_grad\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernel_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernel_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernels\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0moutput_grad\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     55\u001b[0m         \u001b[0;31m# Update the kernel weights using the gradients\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdkernels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdkernels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "cnn = model(1, [3,5], 'relu', 4*4, 5)\n",
        "\n",
        "cnn.train(X_train, cross_entropy_loss(), 256, 0.01, 2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cnn.test(X_test, 256)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uSairtMlHfNz",
        "outputId": "94558f89-a7aa-4511-b92e-15012caf1225"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1mTest Accuracy - 0.9975833333333334\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q6 Inferences \n",
        "\n",
        "Code Source : ChatGpt and towards data science blog\n",
        "\n",
        "Setting 1 :    \n",
        "1. Convolution Layer (3 *3 filter , num = 1)\n",
        "2. Max Pool layer (2*2)\n",
        "3. Fully connected layer\n",
        "\n",
        "Epoch 1 Accuracy - 0.8808333333333334\n",
        "\n",
        "Epoch 2 Accuracy - 0.9985833333333334\n",
        "\n",
        "Test Accuracy - 0.9995\n",
        "\n",
        "Stopped after 2 epochs as we are getting good training accuracy in epoch 2 and it might overfit if we process further\n",
        "\n",
        "\n",
        "Setting 2 :    \n",
        "1. Convolution Layer (5 *5 filter , num = 3)\n",
        "2. Max Pool layer (2*2)\n",
        "3. Fully connected layer\n",
        "\n",
        "Test Accuracy : 0.98166\n",
        "\n",
        "\n",
        "Setting 3 :    \n",
        "1. Convolution Layer (5 *5 filter , num = 3)\n",
        "2. Max Pool layer (2*2)\n",
        "3. Convolution Layer (5 *5 filter , num = 5)\n",
        "4. Max Pool layer (2*2)\n",
        "5. Fully connected layer\n",
        "\n",
        "Test Accuracy : 0.9975\n",
        "\n",
        "we can say the follwing inferences from the accuracies in less epochs :    \n",
        "\n",
        "1. The network architecture is well-suited for the problem. It's possible that the network architecture is designed to effectively capture the underlying patterns in the data, resulting in high accuracies in a short amount of time.\n",
        "\n",
        "2. The dataset is not very complex. If the dataset is relatively simple, the network may be able to learn the patterns quickly and achieve high accuracies in fewer epochs.\n",
        "\n",
        "3. The dataset is well-preprocessed. If the dataset is well-preprocessed and the input features are well-conditioned, it can help the network to converge more quickly and achieve high accuracies in fewer epochs.\n",
        "\n",
        "4. The learning rate is appropriate. If the learning rate is set appropriately, the network can learn more efficiently and converge more quickly, resulting in high accuracies in fewer epochs.\n"
      ],
      "metadata": {
        "id": "QVS3yyc9mJGF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q7"
      ],
      "metadata": {
        "id": "j_1zGFgQ79z-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train = np.loadtxt('/content/drive/MyDrive/PCA_MNIST.csv',delimiter = ',', skiprows=1)\n",
        "X = np.array(train[:,[1,2,3,4,5,6,7,8,9,10]])\n",
        "y = np.array(train[:,0]).astype(int)"
      ],
      "metadata": {
        "id": "mct0Cas2-3Uq"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train,y_train,X_test,y_test = split_data(X,y,0.7)\n",
        "y_train = one_hot(y_train)\n",
        "X_train = minmaxNormalize(X_train)\n",
        "X_test = minmaxNormalize(X_test)"
      ],
      "metadata": {
        "id": "2oOBkmdc8mGo"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=10, hidden_sizes=[40,30,20], output_size=10)\n",
        "nn.train(X_train,y_train,loss_func=2,epochs=600)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xSVSCTyb9Asn",
        "outputId": "20fd6b59-1be0-4ede-eb7f-094b7b020e3d"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.5781 - Accuracy: 9.9167\n",
            "Epoch 10 - Loss: 0.2841 - Accuracy: 23.0690\n",
            "Epoch 20 - Loss: 0.2399 - Accuracy: 24.6667\n",
            "Epoch 30 - Loss: 0.2203 - Accuracy: 23.1738\n",
            "Epoch 40 - Loss: 0.2134 - Accuracy: 24.7262\n",
            "Epoch 50 - Loss: 0.2103 - Accuracy: 26.4357\n",
            "Epoch 60 - Loss: 0.2070 - Accuracy: 29.4190\n",
            "Epoch 70 - Loss: 0.2038 - Accuracy: 32.8738\n",
            "Epoch 80 - Loss: 0.2008 - Accuracy: 36.4143\n",
            "Epoch 90 - Loss: 0.1980 - Accuracy: 39.7238\n",
            "Epoch 100 - Loss: 0.1952 - Accuracy: 42.5619\n",
            "Epoch 110 - Loss: 0.1919 - Accuracy: 45.2905\n",
            "Epoch 120 - Loss: 0.1886 - Accuracy: 47.5810\n",
            "Epoch 130 - Loss: 0.1853 - Accuracy: 49.5310\n",
            "Epoch 140 - Loss: 0.1820 - Accuracy: 51.3119\n",
            "Epoch 150 - Loss: 0.1786 - Accuracy: 52.9071\n",
            "Epoch 160 - Loss: 0.1746 - Accuracy: 54.6810\n",
            "Epoch 170 - Loss: 0.1706 - Accuracy: 56.3476\n",
            "Epoch 180 - Loss: 0.1665 - Accuracy: 57.7190\n",
            "Epoch 190 - Loss: 0.1626 - Accuracy: 59.0905\n",
            "Epoch 200 - Loss: 0.1587 - Accuracy: 60.5619\n",
            "Epoch 210 - Loss: 0.1542 - Accuracy: 62.0262\n",
            "Epoch 220 - Loss: 0.1499 - Accuracy: 63.3262\n",
            "Epoch 230 - Loss: 0.1459 - Accuracy: 64.5595\n",
            "Epoch 240 - Loss: 0.1420 - Accuracy: 65.6667\n",
            "Epoch 250 - Loss: 0.1383 - Accuracy: 66.6786\n",
            "Epoch 260 - Loss: 0.1341 - Accuracy: 67.7190\n",
            "Epoch 270 - Loss: 0.1302 - Accuracy: 68.7286\n",
            "Epoch 280 - Loss: 0.1265 - Accuracy: 69.6738\n",
            "Epoch 290 - Loss: 0.1388 - Accuracy: 60.4905\n",
            "Epoch 300 - Loss: 0.1373 - Accuracy: 60.3333\n",
            "Epoch 310 - Loss: 0.1370 - Accuracy: 58.8048\n",
            "Epoch 320 - Loss: 0.1376 - Accuracy: 58.0548\n",
            "Epoch 330 - Loss: 0.1270 - Accuracy: 62.2786\n",
            "Epoch 340 - Loss: 0.1181 - Accuracy: 67.6929\n",
            "Epoch 350 - Loss: 0.1190 - Accuracy: 67.6405\n",
            "Epoch 360 - Loss: 0.1170 - Accuracy: 67.0857\n",
            "Epoch 370 - Loss: 0.1312 - Accuracy: 59.1833\n",
            "Epoch 380 - Loss: 0.1087 - Accuracy: 68.7190\n",
            "Epoch 390 - Loss: 0.0993 - Accuracy: 72.9976\n",
            "Epoch 400 - Loss: 0.0937 - Accuracy: 75.0738\n",
            "Epoch 410 - Loss: 0.1243 - Accuracy: 60.6714\n",
            "Epoch 420 - Loss: 0.1011 - Accuracy: 70.0690\n",
            "Epoch 430 - Loss: 0.0967 - Accuracy: 70.9667\n",
            "Epoch 440 - Loss: 0.0956 - Accuracy: 70.5429\n",
            "Epoch 450 - Loss: 0.0809 - Accuracy: 76.6071\n",
            "Epoch 460 - Loss: 0.1016 - Accuracy: 68.4071\n",
            "Epoch 470 - Loss: 0.1335 - Accuracy: 55.2119\n",
            "Epoch 480 - Loss: 0.0794 - Accuracy: 75.8238\n",
            "Epoch 490 - Loss: 0.0725 - Accuracy: 76.9952\n",
            "Epoch 500 - Loss: 0.0714 - Accuracy: 77.4667\n",
            "Epoch 510 - Loss: 0.0903 - Accuracy: 69.9262\n",
            "Epoch 520 - Loss: 0.1226 - Accuracy: 62.5548\n",
            "Epoch 530 - Loss: 0.0774 - Accuracy: 74.9119\n",
            "Epoch 540 - Loss: 0.0693 - Accuracy: 76.8500\n",
            "Epoch 550 - Loss: 0.0581 - Accuracy: 81.8881\n",
            "Epoch 560 - Loss: 0.1091 - Accuracy: 65.4762\n",
            "Epoch 570 - Loss: 0.0630 - Accuracy: 79.3333\n",
            "Epoch 580 - Loss: 0.0592 - Accuracy: 80.9452\n",
            "Epoch 590 - Loss: 0.0545 - Accuracy: 82.1738\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test)\n",
        "print('The accuracy of Neural network with setting 1 with cross entropy loss is :',np.mean(y_pred == y_test)*100)\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uThP6PYj_TMq",
        "outputId": "21fa00f0-14b1-475f-adb1-8c4e54fe593a"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with cross entropy loss is : 73.4\n",
            "Class 0: F1 score = 0.6796\n",
            "Class 1: F1 score = 0.8451\n",
            "Class 2: F1 score = 0.9006\n",
            "Class 3: F1 score = 0.1996\n",
            "Class 4: F1 score = 0.8534\n",
            "Class 5: F1 score = 0.8067\n",
            "Class 6: F1 score = 0.7471\n",
            "Class 7: F1 score = 0.5236\n",
            "Class 8: F1 score = 0.7661\n",
            "Class 9: F1 score = 0.8135\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=10, hidden_sizes=[45,30,20], output_size=10)\n",
        "nn.train(X_train,y_train,loss_func=1,epochs=400)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pkR7_nK09mrd",
        "outputId": "f0561211-5745-4097-de0c-91d1d4791cef"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.1427 - Accuracy: 10.0333\n",
            "Epoch 10 - Loss: 0.0905 - Accuracy: 16.9262\n",
            "Epoch 20 - Loss: 0.0883 - Accuracy: 17.6381\n",
            "Epoch 30 - Loss: 0.0875 - Accuracy: 19.5381\n",
            "Epoch 40 - Loss: 0.0868 - Accuracy: 22.6643\n",
            "Epoch 50 - Loss: 0.0861 - Accuracy: 25.5476\n",
            "Epoch 60 - Loss: 0.0852 - Accuracy: 29.0167\n",
            "Epoch 70 - Loss: 0.0843 - Accuracy: 31.9810\n",
            "Epoch 80 - Loss: 0.0834 - Accuracy: 34.7048\n",
            "Epoch 90 - Loss: 0.0823 - Accuracy: 36.9500\n",
            "Epoch 100 - Loss: 0.0813 - Accuracy: 38.9929\n",
            "Epoch 110 - Loss: 0.0800 - Accuracy: 41.2619\n",
            "Epoch 120 - Loss: 0.0787 - Accuracy: 43.3500\n",
            "Epoch 130 - Loss: 0.0805 - Accuracy: 34.0286\n",
            "Epoch 140 - Loss: 0.0817 - Accuracy: 32.4762\n",
            "Epoch 150 - Loss: 0.0788 - Accuracy: 37.0833\n",
            "Epoch 160 - Loss: 0.0793 - Accuracy: 35.4643\n",
            "Epoch 170 - Loss: 0.0773 - Accuracy: 37.5452\n",
            "Epoch 180 - Loss: 0.0754 - Accuracy: 39.8786\n",
            "Epoch 190 - Loss: 0.0733 - Accuracy: 42.6190\n",
            "Epoch 200 - Loss: 0.0713 - Accuracy: 45.6714\n",
            "Epoch 210 - Loss: 0.0738 - Accuracy: 46.7548\n",
            "Epoch 220 - Loss: 0.0736 - Accuracy: 38.8333\n",
            "Epoch 230 - Loss: 0.0693 - Accuracy: 49.4071\n",
            "Epoch 240 - Loss: 0.0723 - Accuracy: 46.0286\n",
            "Epoch 250 - Loss: 0.0664 - Accuracy: 47.8238\n",
            "Epoch 260 - Loss: 0.0700 - Accuracy: 41.0762\n",
            "Epoch 270 - Loss: 0.0676 - Accuracy: 48.1333\n",
            "Epoch 280 - Loss: 0.0663 - Accuracy: 49.6214\n",
            "Epoch 290 - Loss: 0.0689 - Accuracy: 48.7881\n",
            "Epoch 300 - Loss: 0.0677 - Accuracy: 45.8405\n",
            "Epoch 310 - Loss: 0.0771 - Accuracy: 34.6000\n",
            "Epoch 320 - Loss: 0.0694 - Accuracy: 42.7690\n",
            "Epoch 330 - Loss: 0.0665 - Accuracy: 55.3452\n",
            "Epoch 340 - Loss: 0.0559 - Accuracy: 59.7262\n",
            "Epoch 350 - Loss: 0.0640 - Accuracy: 48.1024\n",
            "Epoch 360 - Loss: 0.0717 - Accuracy: 39.0548\n",
            "Epoch 370 - Loss: 0.0715 - Accuracy: 42.0714\n",
            "Epoch 380 - Loss: 0.0583 - Accuracy: 57.9714\n",
            "Epoch 390 - Loss: 0.0507 - Accuracy: 65.8714\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test)\n",
        "print('The accuracy of Neural network with setting 1 with cross entropy loss is :',np.mean(y_pred == y_test)*100)\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-uCqJFKT_d_O",
        "outputId": "005f064c-38d4-4e2b-f162-ab937426759d"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with cross entropy loss is : 63.81666666666666\n",
            "Class 0: F1 score = 0.6152\n",
            "Class 1: F1 score = 0.7416\n",
            "Class 2: F1 score = 0.8452\n",
            "Class 3: F1 score = 0.1152\n",
            "Class 4: F1 score = 0.5959\n",
            "Class 5: F1 score = 0.7536\n",
            "Class 6: F1 score = 0.7027\n",
            "Class 7: F1 score = 0.3737\n",
            "Class 8: F1 score = 0.7080\n",
            "Class 9: F1 score = 0.6424\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=10, hidden_sizes=[40,20], output_size=10)\n",
        "nn.train(X_train,y_train,loss_func=2,epochs=600)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k5o3anGe_6hx",
        "outputId": "64a51fc0-e50a-4c7c-d477-2a678d1957a6"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.3871 - Accuracy: 9.9905\n",
            "Epoch 10 - Loss: 0.2708 - Accuracy: 11.2476\n",
            "Epoch 20 - Loss: 0.2484 - Accuracy: 11.7310\n",
            "Epoch 30 - Loss: 0.2376 - Accuracy: 10.6357\n",
            "Epoch 40 - Loss: 0.2313 - Accuracy: 11.0214\n",
            "Epoch 50 - Loss: 0.2278 - Accuracy: 12.5262\n",
            "Epoch 60 - Loss: 0.2249 - Accuracy: 15.1714\n",
            "Epoch 70 - Loss: 0.2225 - Accuracy: 17.9976\n",
            "Epoch 80 - Loss: 0.2202 - Accuracy: 20.8833\n",
            "Epoch 90 - Loss: 0.2180 - Accuracy: 23.8000\n",
            "Epoch 100 - Loss: 0.2158 - Accuracy: 26.5071\n",
            "Epoch 110 - Loss: 0.2132 - Accuracy: 29.8571\n",
            "Epoch 120 - Loss: 0.2106 - Accuracy: 33.1905\n",
            "Epoch 130 - Loss: 0.2080 - Accuracy: 36.3571\n",
            "Epoch 140 - Loss: 0.2054 - Accuracy: 39.4786\n",
            "Epoch 150 - Loss: 0.2027 - Accuracy: 42.2286\n",
            "Epoch 160 - Loss: 0.1993 - Accuracy: 44.9929\n",
            "Epoch 170 - Loss: 0.1959 - Accuracy: 47.7643\n",
            "Epoch 180 - Loss: 0.1923 - Accuracy: 50.1833\n",
            "Epoch 190 - Loss: 0.1886 - Accuracy: 52.1738\n",
            "Epoch 200 - Loss: 0.1849 - Accuracy: 54.0214\n",
            "Epoch 210 - Loss: 0.1805 - Accuracy: 56.2476\n",
            "Epoch 220 - Loss: 0.1762 - Accuracy: 58.3690\n",
            "Epoch 230 - Loss: 0.1719 - Accuracy: 60.1452\n",
            "Epoch 240 - Loss: 0.1676 - Accuracy: 61.9548\n",
            "Epoch 250 - Loss: 0.1634 - Accuracy: 63.7714\n",
            "Epoch 260 - Loss: 0.1584 - Accuracy: 65.8619\n",
            "Epoch 270 - Loss: 0.1534 - Accuracy: 67.5310\n",
            "Epoch 280 - Loss: 0.1485 - Accuracy: 68.9381\n",
            "Epoch 290 - Loss: 0.1436 - Accuracy: 70.2024\n",
            "Epoch 300 - Loss: 0.1388 - Accuracy: 71.3286\n",
            "Epoch 310 - Loss: 0.1331 - Accuracy: 72.6690\n",
            "Epoch 320 - Loss: 0.1278 - Accuracy: 73.9167\n",
            "Epoch 330 - Loss: 0.1226 - Accuracy: 74.9833\n",
            "Epoch 340 - Loss: 0.1178 - Accuracy: 75.8952\n",
            "Epoch 350 - Loss: 0.1133 - Accuracy: 76.6714\n",
            "Epoch 360 - Loss: 0.1083 - Accuracy: 77.5619\n",
            "Epoch 370 - Loss: 0.1038 - Accuracy: 78.2881\n",
            "Epoch 380 - Loss: 0.0996 - Accuracy: 78.8667\n",
            "Epoch 390 - Loss: 0.0957 - Accuracy: 79.3952\n",
            "Epoch 400 - Loss: 0.0922 - Accuracy: 79.7905\n",
            "Epoch 410 - Loss: 0.0883 - Accuracy: 80.3500\n",
            "Epoch 420 - Loss: 0.0848 - Accuracy: 80.8738\n",
            "Epoch 430 - Loss: 0.0817 - Accuracy: 81.3429\n",
            "Epoch 440 - Loss: 0.0788 - Accuracy: 81.8595\n",
            "Epoch 450 - Loss: 0.0762 - Accuracy: 82.2976\n",
            "Epoch 460 - Loss: 0.0733 - Accuracy: 82.7238\n",
            "Epoch 470 - Loss: 0.0707 - Accuracy: 83.0905\n",
            "Epoch 480 - Loss: 0.0684 - Accuracy: 83.4167\n",
            "Epoch 490 - Loss: 0.0663 - Accuracy: 83.7810\n",
            "Epoch 500 - Loss: 0.0643 - Accuracy: 84.1119\n",
            "Epoch 510 - Loss: 0.0628 - Accuracy: 84.1000\n",
            "Epoch 520 - Loss: 0.1041 - Accuracy: 64.7738\n",
            "Epoch 530 - Loss: 0.0664 - Accuracy: 80.9048\n",
            "Epoch 540 - Loss: 0.0615 - Accuracy: 82.5952\n",
            "Epoch 550 - Loss: 0.0585 - Accuracy: 83.7214\n",
            "Epoch 560 - Loss: 0.0831 - Accuracy: 73.1643\n",
            "Epoch 570 - Loss: 0.0832 - Accuracy: 71.7095\n",
            "Epoch 580 - Loss: 0.0554 - Accuracy: 83.9976\n",
            "Epoch 590 - Loss: 0.0531 - Accuracy: 84.3667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test)\n",
        "print('The accuracy of Neural network with setting 1 with cross entropy loss is :',np.mean(y_pred == y_test)*100)\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1fvc4wfFoUBS",
        "outputId": "62fcf392-d79c-4ebb-8c48-47e04134a0cf"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with cross entropy loss is : 75.60555555555555\n",
            "Class 0: F1 score = 0.7664\n",
            "Class 1: F1 score = 0.8381\n",
            "Class 2: F1 score = 0.8089\n",
            "Class 3: F1 score = 0.4132\n",
            "Class 4: F1 score = 0.8388\n",
            "Class 5: F1 score = 0.8154\n",
            "Class 6: F1 score = 0.7361\n",
            "Class 7: F1 score = 0.4822\n",
            "Class 8: F1 score = 0.8409\n",
            "Class 9: F1 score = 0.8585\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn = NeuralNetwork1(input_size=10, hidden_sizes=[40,20], output_size=10)\n",
        "nn.train(X_train,y_train,loss_func=1,epochs=400)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9tE7wjJfozgj",
        "outputId": "db3ec318-5f02-494e-90e9-01976a3c212f"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 - Loss: 0.1072 - Accuracy: 14.0762\n",
            "Epoch 10 - Loss: 0.0883 - Accuracy: 19.5476\n",
            "Epoch 20 - Loss: 0.0859 - Accuracy: 24.1381\n",
            "Epoch 30 - Loss: 0.0843 - Accuracy: 30.9833\n",
            "Epoch 40 - Loss: 0.0826 - Accuracy: 35.5262\n",
            "Epoch 50 - Loss: 0.0811 - Accuracy: 38.5905\n",
            "Epoch 60 - Loss: 0.0793 - Accuracy: 41.6976\n",
            "Epoch 70 - Loss: 0.0774 - Accuracy: 44.7595\n",
            "Epoch 80 - Loss: 0.0754 - Accuracy: 49.5000\n",
            "Epoch 90 - Loss: 0.0734 - Accuracy: 53.7452\n",
            "Epoch 100 - Loss: 0.0716 - Accuracy: 56.8905\n",
            "Epoch 110 - Loss: 0.0695 - Accuracy: 60.5405\n",
            "Epoch 120 - Loss: 0.0673 - Accuracy: 64.0738\n",
            "Epoch 130 - Loss: 0.0652 - Accuracy: 67.1214\n",
            "Epoch 140 - Loss: 0.0631 - Accuracy: 69.5881\n",
            "Epoch 150 - Loss: 0.0610 - Accuracy: 71.5905\n",
            "Epoch 160 - Loss: 0.0587 - Accuracy: 73.3119\n",
            "Epoch 170 - Loss: 0.0565 - Accuracy: 74.7000\n",
            "Epoch 180 - Loss: 0.0543 - Accuracy: 75.9119\n",
            "Epoch 190 - Loss: 0.0523 - Accuracy: 76.8643\n",
            "Epoch 200 - Loss: 0.0505 - Accuracy: 77.7310\n",
            "Epoch 210 - Loss: 0.0483 - Accuracy: 78.5833\n",
            "Epoch 220 - Loss: 0.0463 - Accuracy: 79.3190\n",
            "Epoch 230 - Loss: 0.0445 - Accuracy: 79.9619\n",
            "Epoch 240 - Loss: 0.0428 - Accuracy: 80.5524\n",
            "Epoch 250 - Loss: 0.0412 - Accuracy: 81.0667\n",
            "Epoch 260 - Loss: 0.0394 - Accuracy: 81.5476\n",
            "Epoch 270 - Loss: 0.0378 - Accuracy: 82.0214\n",
            "Epoch 280 - Loss: 0.0363 - Accuracy: 82.3571\n",
            "Epoch 290 - Loss: 0.0350 - Accuracy: 82.6762\n",
            "Epoch 300 - Loss: 0.0338 - Accuracy: 82.9143\n",
            "Epoch 310 - Loss: 0.0324 - Accuracy: 83.2095\n",
            "Epoch 320 - Loss: 0.0313 - Accuracy: 83.4667\n",
            "Epoch 330 - Loss: 0.0302 - Accuracy: 83.7548\n",
            "Epoch 340 - Loss: 0.0292 - Accuracy: 84.0071\n",
            "Epoch 350 - Loss: 0.0283 - Accuracy: 84.2429\n",
            "Epoch 360 - Loss: 0.0524 - Accuracy: 59.7500\n",
            "Epoch 370 - Loss: 0.0328 - Accuracy: 78.5881\n",
            "Epoch 380 - Loss: 0.0292 - Accuracy: 81.6524\n",
            "Epoch 390 - Loss: 0.0275 - Accuracy: 82.9119\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = nn.predict(X_test)\n",
        "print('The accuracy of Neural network with setting 1 with cross entropy loss is :',np.mean(y_pred == y_test)*100)\n",
        "get_f1scores(y_test,y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RRXG9VTZpHUV",
        "outputId": "3b1ea053-fae9-4809-cce5-4d36f83ee532"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The accuracy of Neural network with setting 1 with cross entropy loss is : 85.35000000000001\n",
            "Class 0: F1 score = 0.8680\n",
            "Class 1: F1 score = 0.8927\n",
            "Class 2: F1 score = 0.9199\n",
            "Class 3: F1 score = 0.8444\n",
            "Class 4: F1 score = 0.8963\n",
            "Class 5: F1 score = 0.8950\n",
            "Class 6: F1 score = 0.7872\n",
            "Class 7: F1 score = 0.6509\n",
            "Class 8: F1 score = 0.9010\n",
            "Class 9: F1 score = 0.8828\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yy34TrWnpTf3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Q7 Inferences**\n",
        "\n",
        "**In Setting 1 **: 3 hidden layers are taken with 300,100,50 nodes , following are the observations \n",
        "\n",
        "Squared error loss :\n",
        "\n",
        "*   Training Loss : 0.0504\n",
        "*   Training Accuracy : 65%\n",
        "*   Test Accuracy : 63%\n",
        "\n",
        "Cross Entropy Loss : \n",
        "\n",
        "*   Training Loss : 0.0545\n",
        "*   Training Accuracy : 82.27%\n",
        "*   Test Accuracy : 73.35%\n",
        "\n",
        "**In Setting 2 **: 2 hidden layers are taken with 200,100 nodes , following are the observations \n",
        "\n",
        "Squared error loss :\n",
        "\n",
        "*   Training Loss : 0.0275\n",
        "*   Training Accuracy : 82.82%\n",
        "*   Test Accuracy : 85.36%\n",
        "\n",
        "Cross Entropy Loss : \n",
        "\n",
        "*   Training Loss : 0.0531\n",
        "*   Training Accuracy : 84.27%\n",
        "*   Test Accuracy : 75.35%\n",
        "\n",
        "\n",
        "\n",
        "1.   In setting 1 and 2 , neural network with cross entropy loss has performed better than that of a squared error loss. Also we can see that squared error loss has similar test and training accuracy which implies it is generalising the data better.\n",
        "2.   One observation to make here is that the neural network is converging faster with a lower number of hidden layers, it may suggest that the problem at hand does not require a complex model with many layers. In general adding more layers to a neural network allows it to learn more complex representations of the input data. If lower number of hidden layers is able to achieve comparable or even better performance than a more complex network, it may be more efficient and effective solution.\n",
        "\n",
        "3.   Here if we observe it is taking very high epochs to get a good accuracy, we can possibily say that the learning rate is too low. A low learning rate can cause the network to converge slowly, which may be why it's taking so many epochs to achieve a high accuracy. I tried to increase the learning rate but increasing it too much resulted in higher loss therefore took a lower learning rate. \n",
        "\n",
        "4.   As we can see that in all the settings the f1 scores of class 3 and class 7 are not good which implies that our model is not able to identify these classes well. This can be because the number of examples of these classes might be less than other classes. Or it may be possible that the model is confusing those classes with others."
      ],
      "metadata": {
        "id": "JxqIjrP9hoVA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q1"
      ],
      "metadata": {
        "id": "YpBpWGx-wUgM"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "y5YLfh83lCcW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "cbfRXZmqg6yt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63e6c056-673d-4a0c-cd17-7e8e940de9cb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting libsvm-official\n",
            "  Downloading libsvm-official-3.31.0.tar.gz (39 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.9/dist-packages (from libsvm-official) (1.10.1)\n",
            "Requirement already satisfied: numpy<1.27.0,>=1.19.5 in /usr/local/lib/python3.9/dist-packages (from scipy->libsvm-official) (1.22.4)\n",
            "Building wheels for collected packages: libsvm-official\n",
            "  Building wheel for libsvm-official (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for libsvm-official: filename=libsvm_official-3.31.0-cp39-cp39-linux_x86_64.whl size=125898 sha256=38fc35953d7fa5c7230af54cec3a6a9daa52c23abf7c5b6843d3e4f909d4422a\n",
            "  Stored in directory: /root/.cache/pip/wheels/1b/a9/b4/fb374019f74d51e7744b8e1e95d693c449ec79674cf720c1a3\n",
            "Successfully built libsvm-official\n",
            "Installing collected packages: libsvm-official\n",
            "Successfully installed libsvm-official-3.31.0\n",
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "!pip install libsvm-official\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from libsvm.svmutil import *\n",
        "from tabulate import tabulate\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting Confusion Matrix\n",
        "def plot_confusion_matrix(data, labels, classifier):\n",
        "    import seaborn\n",
        "    seaborn.set(color_codes=True)\n",
        "    plt.figure(1, figsize=(7,7))\n",
        " \n",
        "    plt.title(\"Confusion Matrix for {}\".format(classifier))\n",
        " \n",
        "    seaborn.set(font_scale=1)\n",
        "    ax = seaborn.heatmap(data, annot=True, cmap=\"YlGnBu\", cbar_kws={'label': 'Scale'}, fmt='g')\n",
        " \n",
        "    ax.set_xticklabels(labels.astype(int))\n",
        "    ax.set_yticklabels(labels.astype(int))\n",
        " \n",
        "    ax.set(ylabel=\"True Label\", xlabel=\"Predicted Label\")\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "# calculating Confusion Matrix and F1 Scores\n",
        "def confusion_matrix_and_F1_score(y_pred,y_true,string):\n",
        "  num_classes = len(np.unique(y_true))\n",
        "  first_label = int(np.min(y_true))\n",
        "\n",
        "  # initialize confusion matrix with zeros\n",
        "  confusion_matrix = np.zeros((num_classes+first_label, num_classes+first_label))\n",
        "\n",
        "  # loop over all samples\n",
        "  for i in range(len(y_true)):\n",
        "      # increment count of true-predicted label pair\n",
        "      confusion_matrix[int(y_true[i]), int(y_pred[i])] += 1\n",
        "\n",
        "  confusion_matrix = confusion_matrix[first_label:,first_label:]\n",
        "  # plot_confusion_matrix(confusion_matrix, np.unique(y_true),string)\n",
        "\n",
        "\n",
        "  # calculate precision, recall, and F1 score for each class\n",
        "  class_precision = np.zeros(num_classes)\n",
        "  class_recall = np.zeros(num_classes)\n",
        "  class_f1 = np.zeros(num_classes)\n",
        "  for i in range(num_classes):\n",
        "      class_precision[i] = confusion_matrix[i,i] / np.sum(confusion_matrix[:,i])\n",
        "      class_recall[i] = confusion_matrix[i,i] / np.sum(confusion_matrix[i,:])\n",
        "      class_f1[i] = 2 * (class_precision[i] * class_recall[i]) / (class_precision[i] + class_recall[i])\n",
        "  print(\"F1- Scores: \",class_f1)\n",
        "  plot_confusion_matrix(confusion_matrix, np.unique(y_true),string)\n",
        "\n"
      ],
      "metadata": {
        "id": "xQ4kG6HShr4q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "GRID SEARCH"
      ],
      "metadata": {
        "id": "XTHEnhlsh1ej"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def grid_search(X, y, gamma_start, gamma_end, gamma_interval, C_start, C_end, KERNEL):\n",
        "    graph_C = []\n",
        "    graph_Gamma = []\n",
        "    graph_z = []\n",
        "    optimal_model = None\n",
        "    max_acc = 0.0\n",
        "    for C_value in np.arange(C_start, C_end, 0.2):\n",
        "        graph_x_row = []\n",
        "        graph_y_row = []\n",
        "        graph_z_row = []\n",
        "        for gamma_value in np.arange(gamma_start, gamma_end, gamma_interval):\n",
        "            print(f\"Accuracy for C = {C_value}, gamma = {gamma_value}\")\n",
        "            #hyperparams = (alpha_value,gamma_value)\n",
        "            problem = svm_problem(y, X, isKernel=True)\n",
        "            model = svm_train(problem, svm_parameter('-t '+str(KERNEL)+' -g '+str(gamma_value)+' -c ' + str(C_value) + ' -q'))\n",
        "            p_labels, p_acc, p_vals = svm_predict(y, X, model)\n",
        "            acc = p_acc[0]\n",
        "            \n",
        "            if(acc > max_acc):\n",
        "                optimal_model = model\n",
        "            graph_x_row.append(C_value)\n",
        "            graph_y_row.append(gamma_value)\n",
        "            graph_z_row.append(acc)\n",
        "        graph_C.append(graph_x_row)\n",
        "        graph_Gamma.append(graph_y_row)\n",
        "        graph_z.append(graph_z_row)\n",
        "        print('')\n",
        "    graph_C = np.array(graph_C)\n",
        "    graph_Gamma = np.array(graph_Gamma)\n",
        "    graph_z = np.array(graph_z)\n",
        "    max_z = np.max(graph_z)\n",
        "    pos_max_z = np.argwhere(graph_z == np.max(graph_z))[0]\n",
        "    print('maximum ACC: %.4f' %(max_z))\n",
        "    print('Optimum C: %f' %(graph_C[pos_max_z[0],pos_max_z[1]]))\n",
        "    print('Optimum gamma: %f' %(graph_Gamma[pos_max_z[0],pos_max_z[1]]))\n",
        "    return graph_C[pos_max_z[0],pos_max_z[1]] ,graph_Gamma[pos_max_z[0], pos_max_z[1]], max_z, optimal_model"
      ],
      "metadata": {
        "id": "Xvf0h1Lph4mK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def one_vs_rest(y, class_type):\n",
        "    temp_y = np.zeros(len(y))\n",
        "    temp_y[(y==class_type)] = 1\n",
        "    temp_y[y != class_type] = 0\n",
        "    return temp_y"
      ],
      "metadata": {
        "id": "3I6rz2HHh_Ff"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "IMPORTING DATA SETS"
      ],
      "metadata": {
        "id": "fsmhzkx9iH5q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Training Data\n",
        "p3_train = np.genfromtxt(\"/content/drive/MyDrive/data/p3_train.csv\", delimiter=\",\", dtype=float)\n",
        "\n",
        "# Testing Data\n",
        "p3_test = np.genfromtxt(\"/content/drive/MyDrive/data/p3_test.csv\", delimiter=\",\", dtype=float)\n",
        "\n",
        "# splitting \n",
        "x3_train, y3_train = p3_train[:4000, 0:-1], p3_train[:4000, -1]\n",
        "x3_test, y3_test = p3_test[4000:, 0:-1], p3_test[4000:, -1]\n",
        "\n",
        "\n",
        "# Importing Data\n",
        "p4 = np.genfromtxt(\"/content/drive/MyDrive/data/p4_data.csv\", delimiter=\",\", dtype=float)\n",
        "\n",
        "# Normalizing\n",
        "p4_normalized = p4.copy()\n",
        "p4_normalized[:,0:-1] = p4_normalized[:,0:-1]/255\n",
        "\n",
        "# Splitting \n",
        "p4_train_20_80 = p4_normalized[0:12000,:]\n",
        "x4_train, y4_train = p4_train_20_80[:, 0:-1], p4_train_20_80[:, -1]\n",
        "\n",
        "p4_test_20_80 = p4_normalized[12000:,:]\n",
        "x4_test, y4_test = p4_test_20_80[:, 0:-1], p4_test_20_80[:, -1]\n",
        "\n",
        "\n",
        "p5 = np.genfromtxt(\"/content/drive/MyDrive/data/PCA_MNIST.csv\", delimiter=\",\", dtype=float)\n",
        "l = p5[1:,:][:,0]\n",
        "t  =p5[1:,:][:,1:]\n",
        "p5 = np.column_stack((t,l))\n",
        "\n",
        "\n",
        "p5_normalized = p5.copy()\n",
        "for i in range(10):\n",
        "  p5_normalized[:,i] = (p5_normalized[:,i] - np.min(p5_normalized[:,i]))/(np.max(p5_normalized[:,i])-np.min(p5_normalized[:,i]))\n",
        "\n",
        "p5_train_20_80 = p5_normalized[0:12000,:]\n",
        "p5_test_20_80 = p5_normalized[12000:,:]\n",
        "\n",
        "x5_train, y5_train = p5_train_20_80[:, 0:-1], p5_train_20_80[:, -1]\n",
        "x5_test, y5_test = p5_test_20_80[:, 0:-1], p5_test_20_80[:, -1]\n"
      ],
      "metadata": {
        "id": "BvlAOQlxiJko"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "WITH SLACK\n",
        "FOR P3"
      ],
      "metadata": {
        "id": "Y23THEU_h_wf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. POLYNOMIAL"
      ],
      "metadata": {
        "id": "YZZCJ_4WikCb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uu6QivwsvmvM",
        "outputId": "6b1010a2-d19d-4776-ab0f-a1b75a92b72c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy = 55.0818% (6059/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "KERNEL = 1\n",
        "\n",
        "problem3 = svm_problem(y3_train, x3_train)\n",
        "\n",
        "param3 = svm_parameter(\"-t 1 -g 0.065 -c 1\")\n",
        "model3 = svm_train(problem3, param3)\n",
        "p3_poly_pred_labels, p3_poly_acc_test, vals3 = svm_predict(y3_test, x3_test, model3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SebRNUwpbgt0",
        "outputId": "3f3f9d46-34c4-4382-c425-4b47f9f5590f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 61.625% (2465/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_poly_pred_labels, p3_poly_acc_train, vals3 = svm_predict(y3_train, x3_train, model3)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ugYl3g14bssI",
        "outputId": "480c4852-3d37-4ff0-a4a5-31ab16de267a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 55.0818% (6059/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_poly_pred_labels, p3_poly_acc_test, vals3 = svm_predict(y3_test, x3_test, model3)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. RADIAL BASIS "
      ],
      "metadata": {
        "id": "0gjOcinvjE8e"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OmbNnW5i2ghG",
        "outputId": "6ead4dd5-59a9-4a2f-d4d9-4708f0a62345"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy = 58.1909% (6401/11000) (classification)\n",
            "(58.190909090909095, 2.279272727272727, 0.20041586961765914)\n"
          ]
        }
      ],
      "source": [
        "KERNEL = 2\n",
        "\n",
        "problem3_RBF = svm_problem(y3_train, x3_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param3_RBF = svm_parameter(\"-t 2 -g 0.008 -c 2\")\n",
        "model3_RBF = svm_train(problem3_RBF, param3_RBF)\n",
        "p3_RBF_pred_labels, p3_RBF_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_RBF)\n",
        "print(p3_RBF_acc_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SylauEa_5DZL",
        "outputId": "34d32e08-ed07-46fb-80ef-c507e7271eb8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 58.7% (2348/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_RBF_pred_labels, p3_RBF_acc_train, vals3 = svm_predict(y3_train, x3_train, model3_RBF)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "waWN2Ruu5D_L",
        "outputId": "dc9309b2-1d50-46c2-9802-4690a4230352"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 58.1909% (6401/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_RBF_pred_labels, p3_RBF_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_RBF)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. SIGMOID"
      ],
      "metadata": {
        "id": "6ESQ3dGkjRpZ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p3sBNY7VvmvO",
        "outputId": "5c13bcc4-ac89-4aa3-a21c-a427dbf1b9d1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy = 56.6636% (6233/11000) (classification)\n",
            "(56.66363636363636, 2.355909090909091, 0.1785857880512794)\n"
          ]
        }
      ],
      "source": [
        "KERNEL = 3\n",
        "\n",
        "problem3_Sigm = svm_problem(y3_train, x3_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param3_Sigm = svm_parameter(\"-t 3 -g 0.008 -c 2\")\n",
        "model3_Sigm = svm_train(problem3_Sigm, param3_Sigm)\n",
        "p3_Sigm_pred_labels, p3_Sigm_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_Sigm)\n",
        "print(p3_Sigm_acc_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rGj8Ado_8-GU",
        "outputId": "824be426-0371-4171-b891-468ae3a43ddb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 55.025% (2201/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_Sigm_pred_labels, p3_Sigm_acc_train, vals3 = svm_predict(y3_train, x3_train, model3_Sigm)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J6TlrrtE891W",
        "outputId": "571547ec-91a7-4030-92d9-7ff510b40537"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 56.6636% (6233/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_Sigm_pred_labels, p3_Sigm_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_Sigm)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qsjoom1evmvO"
      },
      "source": [
        "### For P4 (Assignment 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eOG0UtkyvmvP"
      },
      "source": [
        "### 1. Polynomial: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lo1TU6oOvmvP"
      },
      "outputs": [],
      "source": [
        "KERNEL = 1\n",
        "\n",
        "problem4_poly = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_poly = svm_parameter(\"-t 1 -g 0.1 -c 1\")\n",
        "model4_poly = svm_train(problem4_poly, param4_poly)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NQnn1ejAF10U",
        "outputId": "e9592cd6-64cb-4ec3-cbbd-6051dc824bc4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 100% (12000/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p4_poly_pred_labels, p4_poly_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_poly)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "99SKFs9B-Y70",
        "outputId": "cbf8bb78-3db3-48e0-ff0d-f5516c34ef2a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 95.3229% (45755/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p4_poly_pred_labels, p4_poly_acc_train, vals4 = svm_predict(y4_test, x4_test, model4_poly)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I8XRvB80vmvP"
      },
      "source": [
        "### 2. Radial Basis Function: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C2jqeMyQvmvP"
      },
      "outputs": [],
      "source": [
        "KERNEL = 2\n",
        "\n",
        "problem4_RBF = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_RBF = svm_parameter(\"-t 2 -g 0.008 -c 2\")\n",
        "model4_RBF = svm_train(problem4_RBF, param4_RBF)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "273Jjio4CZ33",
        "outputId": "8e228a6c-d4de-432d-b812-acf7f7e1e9ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy\n",
            "Accuracy = 98.65% (11838/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy\")\n",
        "p4_RBF_pred_labels, p4_RBF_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_RBF)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YFYfcWWFCZrG",
        "outputId": "4096c6ba-abef-4438-dac3-f24cd523dace"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy\n",
            "Accuracy = 95.3229% (45755/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy\")\n",
        "p4_RBF_pred_labels, p4_RBF_acc_test, vals4 = svm_predict(y4_test, x4_test, model4_RBF)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgvDDLNEvmvP"
      },
      "source": [
        "### 3. Sigmoid: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hW7FSCxdvmvQ"
      },
      "outputs": [],
      "source": [
        "KERNEL = 3\n",
        "\n",
        "problem4_Sigm = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_Sigm = svm_parameter(\"-t 3 -g 0.008 -c 2\")\n",
        "model4_Sigm = svm_train(problem4_Sigm, param4_Sigm)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l4AdrRhAl_uR",
        "outputId": "f379e8d9-617f-4650-ff9a-e0f22f27d776"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy\n",
            "Accuracy = 97.1583% (11659/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy\")\n",
        "p4_Sigm_pred_labels, p4_Sigm_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_Sigm)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G6v62P8tDMAg",
        "outputId": "d9bbbd43-e24c-41b3-dfca-74dd6dc4011f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy\n",
            "Accuracy = 94.0938% (45165/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy\")\n",
        "p4_Sigm_pred_labels, p4_Sigm_acc_train, vals4 = svm_predict(y4_test, x4_test, model4_Sigm)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tGrbPBVWvmvQ"
      },
      "source": [
        "### For P5 (Assignment 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqRrL_nQvmvQ"
      },
      "source": [
        "### 1. Polynomial: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fOt4j38YvmvR"
      },
      "outputs": [],
      "source": [
        "KERNEL = 1\n",
        "\n",
        "problem5_poly = svm_problem(y5_train, x5_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param5_poly = svm_parameter(\"-t 1 -g 2.8 -c 2\")\n",
        "model5_poly = svm_train(problem5_poly, param5_poly)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GO5N_BJ1GchW",
        "outputId": "923d6425-2a3c-457b-c658-968286189e6f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy\n",
            "Accuracy = 96.575% (11589/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy\")\n",
        "p5_poly_pred_labels, p5_poly_acc_train, vals5 = svm_predict(y5_train, x5_train, model5_poly)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9icSj29TGcRv",
        "outputId": "155f4fd5-696c-4afe-9476-8b5c501a745c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy\n",
            "Accuracy = 93.1104% (44693/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy\")\n",
        "p5_poly_pred_labels, p5_poly_acc_test, vals5 = svm_predict(y5_test, x5_test, model5_poly)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "89mimW_qvmvR"
      },
      "source": [
        "### 2. Radial Basis Function: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F3dn93wfvmvR"
      },
      "outputs": [],
      "source": [
        "KERNEL = 2\n",
        "\n",
        "problem5_RBF = svm_problem(y5_train, x5_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param5_RBF = svm_parameter(\"-t 2 -g 3 -c 2\")\n",
        "model5_RBF = svm_train(problem5_RBF, param5_RBF)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jWvuq0hgKEoL",
        "outputId": "83189e4b-7b03-4a72-e86f-4cd7417bc33a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training Accuracy\n",
            "Accuracy = 95.6417% (11477/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy\")\n",
        "p5_RBF_pred_labels, p5_RBF_acc_train, vals5 = svm_predict(y5_train, x5_train, model5_RBF)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vgh_y33yKERi",
        "outputId": "78fb6970-0d65-43f5-d208-be109d66fd01"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Testing Accuracy\n",
            "Accuracy = 93.4083% (44836/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy\")\n",
        "p5_RBF_pred_labels, p5_RBF_acc_test, vals5 = svm_predict(y5_test, x5_test, model5_RBF)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G7YQW4KovmvS"
      },
      "source": [
        "### Without Slack Formulation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sR4hiviPvmvS"
      },
      "source": [
        "### For P3 (Assignment 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kC0Q2T50vmvS"
      },
      "source": [
        "### 1. Polynomial: (gamma*u'*v + coef0)^degree"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-yCgdJqfvmvS",
        "outputId": "b74d4f76-4a65-4182-80dd-1dacf8c79fec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy = 37.9273% (4172/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "KERNEL = 1\n",
        "\n",
        "problem3 = svm_problem(y3_train, x3_train)\n",
        "\n",
        "param3 = svm_parameter(\"-t 1 -g 0.08 -c \" + str(np.inf))\n",
        "model3 = svm_train(problem3, param3)\n",
        "p3_poly_pred_labels, p3_poly_acc_test, vals3 = svm_predict(y3_test, x3_test, model3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "shjbEAONPC2P",
        "outputId": "81efc7c7-a532-46e6-972f-89ee40811fdd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 41.65% (1666/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_poly_pred_labels, p3_poly_acc_train, vals3 = svm_predict(y3_train, x3_train, model3)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3iw66VFsbAlY",
        "outputId": "ab10f56b-0c1e-495e-ce98-ab2d3ce5e7bb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 37.9273% (4172/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_poly_pred_labels, p3_poly_acc_test, vals3 = svm_predict(y3_test, x3_test, model3)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4C0JECg8vmvT"
      },
      "source": [
        "### 2. Radial Basis Function: exp(-gamma*|u-v|^2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IShQ6XHJvmvT",
        "outputId": "3805c249-9fc6-418e-d937-8ae1429d0825"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy = 43.2% (4752/11000) (classification)\n",
            "(43.2, 3.1792727272727275, 0.06243576792006738)\n"
          ]
        }
      ],
      "source": [
        "KERNEL = 2\n",
        "\n",
        "problem3_RBF = svm_problem(y3_train, x3_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param3_RBF = svm_parameter(\"-t 2 -g 0.008 -c \"+ str(np.inf))\n",
        "model3_RBF = svm_train(problem3_RBF, param3_RBF)\n",
        "p3_RBF_pred_labels, p3_RBF_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_RBF)\n",
        "print(p3_RBF_acc_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QIgK_0FXvmvT",
        "outputId": "b2deba1e-0ebe-4b13-ea9e-ebefbcc037f7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 98.95% (3958/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_RBF_pred_labels, p3_RBF_acc_train, vals3 = svm_predict(y3_train, x3_train, model3_RBF)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vYcqs6CWe_5X",
        "outputId": "f57d0226-35e5-438e-df4c-7f13f962c224"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 43.2% (4752/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_RBF_pred_labels, p3_RBF_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_RBF)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S_zmbCZ4vmvT"
      },
      "source": [
        "### 3. Sigmoid: tanh(gamma*u'*v + coef0) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ViT0Zj0pvmvT"
      },
      "outputs": [],
      "source": [
        "KERNEL = 3\n",
        "\n",
        "problem3_Sigm = svm_problem(y3_train, x3_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param3_Sigm = svm_parameter(\"-t 3 -g 0.008 -c \"+ str(np.inf))\n",
        "model3_Sigm = svm_train(problem3_Sigm, param3_Sigm)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2M8dnruceAET",
        "outputId": "125cc98d-aded-4c1c-e2b8-37815e83185e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 23.15% (926/4000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p3_Sigm_pred_labels, p3_Sigm_acc_train, vals3 = svm_predict(y3_train, x3_train, model3_Sigm)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "btf1sl5neSma",
        "outputId": "404381aa-f678-4a82-91b0-2158c6f171b0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 22.4727% (2472/11000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p3_Sigm_pred_labels, p3_Sigm_acc_test, vals3 = svm_predict(y3_test, x3_test, model3_Sigm)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-lf7dYEQvmvU"
      },
      "source": [
        "### For P4 (Assignment 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k-2OZyk2vmvU"
      },
      "source": [
        "### 1. Polynomial: (gamma*u'*v + coef0)^degree"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hEuOJ5agvmvU"
      },
      "outputs": [],
      "source": [
        "KERNEL = 1\n",
        "\n",
        "problem4_poly = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_poly = svm_parameter(\"-t 1 -g 0.1 -c \"+ str(np.inf))\n",
        "model4_poly = svm_train(problem4_poly, param4_poly)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TNSPjz9XvTqi",
        "outputId": "02444e3f-6846-4440-c700-5a90b9438615"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 100% (12000/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p4_poly_pred_labels, p4_poly_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_poly)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hGSA6w0qvTb-",
        "outputId": "d230875f-bae0-46e0-f836-7d0c85346f27"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 95.3229% (45755/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p4_poly_pred_labels, p4_poly_acc_test, vals4 = svm_predict(y4_test, x4_test, model4_poly)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CdkLvI5FvmvU"
      },
      "source": [
        "### 2. Radial Basis Function: exp(-gamma*|u-v|^2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5FYWLha-vmvU"
      },
      "outputs": [],
      "source": [
        "KERNEL = 2\n",
        "\n",
        "problem4_RBF = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_RBF = svm_parameter(\"-t 2 -g 0.008 -c \"+str(np.inf))\n",
        "model4_RBF = svm_train(problem4_RBF, param4_RBF)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GXyyx0DBwL3n",
        "outputId": "b81ee1ae-a5bc-42ed-fd1d-8e229d121218"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 100% (12000/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p4_RBF_pred_labels, p4_RBF_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_RBF)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "evORzop6wLkf",
        "outputId": "b6ca4922-62fa-4486-92b2-b9e2a4526282"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 95.1292% (45662/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p4_RBF_pred_labels, p4_RBF_acc_test, vals4 = svm_predict(y4_test, x4_test, model4_RBF)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yayJIgogvmvU"
      },
      "source": [
        "### 3. Sigmoid: tanh(gamma * u' * v + coef0)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cd6pSbBGvmvV"
      },
      "outputs": [],
      "source": [
        "KERNEL = 3\n",
        "\n",
        "problem4_Sigm = svm_problem(y4_train, x4_train)\n",
        "# print(\"Accuracy for Training\")\n",
        "param4_Sigm = svm_parameter(\"-t 3 -g 0.008 -c \"+str(np.inf))\n",
        "model4_Sigm = svm_train(problem4_Sigm, param4_Sigm)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kcUcrgxDw_Hy",
        "outputId": "71d160e1-5a24-47ec-f1bb-1e9bebfd5769"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: \n",
            "Accuracy = 93.7667% (11252/12000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Training Accuracy: \")\n",
        "p4_Sigm_pred_labels, p4_Sigm_acc_train, vals4 = svm_predict(y4_train, x4_train, model4_Sigm)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wVfojJaDw-5u",
        "outputId": "373162b7-3d4d-4f4a-8de3-472d87582725"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Accuracy: \n",
            "Accuracy = 87.4479% (41975/48000) (classification)\n"
          ]
        }
      ],
      "source": [
        "print(\"Testing Accuracy: \")\n",
        "p4_Sigm_pred_labels, p4_Sigm_acc_test, vals4 = svm_predict(y4_test, x4_test, model4_Sigm)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Q1 Inferences\n",
        "\n",
        "1. A noticeable trend is that when a slack variable is incorporated into the SVM formulation, there is an improvement \n",
        "in accuracy for all associated kernels. However, as the value of the slack variable is increased beyond a certain point, the accuracy begins to decrease, likely because further optimization is no longer achievable.\n",
        "2. In general, the initial results that incorporate the slack formulation exhibit higher accuracies across all datasets and kernels when compared to the second set of results without the slack formulation. The reason for this is that the slack formulation permits some misclassification errors during training, which can ultimately enhance the model's ability to generalize to the test data.\n",
        "3. For the majority of the datasets, the RBF kernel outperforms the other kernels in both sets of results. This is likely due to the RBF kernel's strong ability to capture non-linear relationships between the input features and the target variable.\n",
        "4. Both sets of results indicate that the sigmoid and polynomial kernels tend to yield lower accuracy scores than the RBF kernel. One potential explanation for this trend is that the sigmoid kernel has a tendency to overfit the training data and struggle with generalization to the test data. Additionally, the polynomial kernel can be sensitive to the scaling of the input features and may not be suitable for high-dimensional or complex datasets."
      ],
      "metadata": {
        "id": "oat4UFUZuIA0"
      }
    }
  ]
}