hw1/src/P4.ipynb

{
    "cells": [
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {
                "azdata_cell_guid": "f5df938f-45e5-4db5-9376-74917addd876",
                "language": "python"
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Dataset Shape:(158, 6) \n",
                        "\n",
                        "   Weight  Length1  Length2  Length3   Height   Width\n",
                        "0   242.0     23.2     25.4     30.0  11.5200  4.0200\n",
                        "1   290.0     24.0     26.3     31.2  12.4800  4.3056\n",
                        "2   340.0     23.9     26.5     31.1  12.3778  4.6961\n",
                        "3   363.0     26.3     29.0     33.5  12.7300  4.4555\n",
                        "4   430.0     26.5     29.0     34.0  12.4440  5.1340 \n",
                        "\n",
                        "<class 'pandas.core.frame.DataFrame'>\n",
                        "RangeIndex: 158 entries, 0 to 157\n",
                        "Data columns (total 6 columns):\n",
                        " #   Column   Non-Null Count  Dtype  \n",
                        "---  ------   --------------  -----  \n",
                        " 0   Weight   158 non-null    float64\n",
                        " 1   Length1  158 non-null    float64\n",
                        " 2   Length2  158 non-null    float64\n",
                        " 3   Length3  158 non-null    float64\n",
                        " 4   Height   158 non-null    float64\n",
                        " 5   Width    158 non-null    float64\n",
                        "dtypes: float64(6)\n",
                        "memory usage: 7.5 KB\n",
                        "None \n",
                        "\n",
                        "Weight     0\n",
                        "Length1    0\n",
                        "Length2    0\n",
                        "Length3    0\n",
                        "Height     0\n",
                        "Width      0\n",
                        "dtype: int64\n"
                    ]
                }
            ],
            "source": [
                "import matplotlib.pyplot as plt\n",
                "import pandas as pd\n",
                "import numpy as np\n",
                "import seaborn as sns\n",
                "import math\n",
                "\n",
                "import warnings\n",
                "warnings.filterwarnings('ignore')\n",
                "\n",
                "# darkgrid, whitegrid, dark, white, ticks\n",
                "# talk, paper, notebook, poster\n",
                "sns.reset_defaults()\n",
                "sns.set_theme(rc={'figure.dpi': 72, 'savefig.dpi': 300,\n",
                "              'figure.autolayout': True})\n",
                "sns.set_style('ticks')\n",
                "sns.set_context('paper')\n",
                "\n",
                "df = pd.read_csv('data/Fish.csv')\n",
                "X = df[['Length1', 'Length2', 'Length3', 'Height', 'Width']]\n",
                "y = df['Weight']\n",
                "\n",
                "print('Dataset Shape:{}'.format(df.shape), '\\n')\n",
                "print(df.head(), '\\n')\n",
                "print(df.info(), '\\n')\n",
                "print(df.isnull().sum())\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {
                "azdata_cell_guid": "8e28484e-392a-4beb-add9-cfdbc50e7757",
                "language": "python",
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Gradient Descent\n",
                        "R-Squared: 0.8849\n",
                        "R-Squared Prediction: 0.8690\n",
                        "\n",
                        "Normal Equation\n",
                        "R-Squared: 0.8855\n",
                        "R-Squared Prediction: 0.8694\n",
                        "\n"
                    ]
                }
            ],
            "source": [
                "# Part a\n",
                "def press_statistic(y_true, y_pred, X):\n",
                "    \"\"\"\n",
                "    Calculation of the `Press Statistics <https://www.otexts.org/1580>`_\n",
                "    \"\"\"\n",
                "    res = y_pred - y_true\n",
                "    hat = X.dot(np.linalg.pinv(X))\n",
                "    den = (1 - np.diagonal(hat))\n",
                "    sqr = np.square(res / den)\n",
                "    return sqr.sum()\n",
                "\n",
                "\n",
                "def predicted_r2(y_true, y_pred, X):\n",
                "    \"\"\"\n",
                "    Calculation of the `Predicted R-squared <https://rpubs.com/RatherBit/102428>`_\n",
                "    \"\"\"\n",
                "    press = press_statistic(y_true=y_true, y_pred=y_pred, X=X)\n",
                "    sst = np.square(y_true - y_true.mean()).sum()\n",
                "    return 1 - press / sst\n",
                "\n",
                "\n",
                "def r2(y_true, y_pred):\n",
                "    \"\"\"\n",
                "    Calculation of the unadjusted r-squared, goodness of fit metric\n",
                "    \"\"\"\n",
                "    sse = np.square(y_pred - y_true).sum()\n",
                "    sst = np.square(y_true - y_true.mean()).sum()\n",
                "    return 1 - sse/sst\n",
                "\n",
                "\n",
                "def prep(X, deg=1):\n",
                "    X = X.copy()\n",
                "    for i in range(X.shape[1]):\n",
                "        X[:, i] = (X[:, i] - np.mean(X[:, i])) / np.std(X[:, i])\n",
                "    intercept = np.ones((X.shape[0], 1))\n",
                "    X_new = np.c_[intercept, X]\n",
                "    for i in range(X.shape[1]):\n",
                "        for d in range(2, deg + 1):\n",
                "            X_new = np.c_[X_new, X[:, i] ** d]\n",
                "    return X_new\n",
                "\n",
                "\n",
                "def h(x, w):\n",
                "    return x.dot(w)\n",
                "\n",
                "\n",
                "def mse(x, y, w):\n",
                "    m = len(y)\n",
                "    p = h(x, w)\n",
                "    err = np.sum((p - y) ** 2) / 2 / m\n",
                "    return err\n",
                "\n",
                "\n",
                "def RegressionTrainerGD(X, y, learning_rate=0.01, iteration=1000, l2=0, prepr=True):\n",
                "    if prepr:\n",
                "        X = prep(X)\n",
                "    m = X.shape[0]\n",
                "    w = np.zeros(X.shape[1])\n",
                "    e = [0] * iteration\n",
                "    for it in range(iteration):\n",
                "        g = X.T.dot(h(X, w) - y) + 2 * l2 * np.sum(w)\n",
                "        w = w - learning_rate * g\n",
                "        e[it] = mse(X, y, w)\n",
                "    return w, e\n",
                "\n",
                "\n",
                "def RegressionTrainerNQ(X, y, prepr=True):\n",
                "    if prepr:\n",
                "        X = prep(X)\n",
                "    w = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)\n",
                "    return w\n",
                "\n",
                "\n",
                "def eval(X, y, deg=1, display=True, learning_rate=1e-3, iteration=5000):\n",
                "    X = prep(X.values, deg)\n",
                "    y = y.values\n",
                "    r = {}\n",
                "\n",
                "    w, e = RegressionTrainerGD(\n",
                "        X, y, learning_rate=learning_rate, iteration=iteration, prepr=False)\n",
                "    y_pred = h(X, w)\n",
                "    r2_err = r2(y, y_pred)\n",
                "    pr2_err = predicted_r2(y, y_pred, X)\n",
                "    r['GD'] = [r2_err, pr2_err]\n",
                "    if display:\n",
                "        print('Gradient Descent')\n",
                "        print(f'R-Squared: {r2_err:.4f}')\n",
                "        print(f'R-Squared Prediction: {pr2_err:.4f}')\n",
                "        print()\n",
                "\n",
                "    w = RegressionTrainerNQ(X, y, prepr=False)\n",
                "    y_pred = h(X, w)\n",
                "    r2_err = r2(y, y_pred)\n",
                "    pr2_err = predicted_r2(y, y_pred, X)\n",
                "    r['NQ'] = [r2_err, pr2_err]\n",
                "    if display:\n",
                "        print('Normal Equation')\n",
                "        print(f'R-Squared: {r2_err:.4f}')\n",
                "        print(f'R-Squared Prediction: {pr2_err:.4f}')\n",
                "        print()\n",
                "\n",
                "    if not display:\n",
                "        return r\n",
                "\n",
                "\n",
                "eval(X, y)\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "azdata_cell_guid": "71d6b1be-024b-4ce5-bdca-47e3b99d8545",
                "language": "python"
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "╒══════════════════════════════════════════════════════╤═════════╤══════════╤═════════╤══════════╕\n",
                        "│ Feature Set                                          │   GD RS │   GD RSP │   NE RS │   NE RSP │\n",
                        "╞══════════════════════════════════════════════════════╪═════════╪══════════╪═════════╪══════════╡\n",
                        "│ ['Length1', 'Length3', 'Height']                     │  0.8842 │   0.8721 │  0.8845 │   0.8722 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Length3', 'Height']          │  0.8842 │   0.8709 │  0.8845 │   0.8710 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Length3', 'Height']                     │  0.8822 │   0.8705 │  0.8826 │   0.8708 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length3', 'Height', 'Width']            │  0.8850 │   0.8703 │  0.8854 │   0.8707 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Height', 'Width']                       │  0.8828 │   0.8698 │  0.8828 │   0.8698 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Length3', 'Height', 'Width'] │  0.8849 │   0.8690 │  0.8855 │   0.8694 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Length3', 'Height', 'Width']            │  0.8830 │   0.8686 │  0.8836 │   0.8693 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Height', 'Width']            │  0.8828 │   0.8683 │  0.8835 │   0.8688 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Height', 'Width']                       │  0.8817 │   0.8687 │  0.8817 │   0.8687 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Height']                                │  0.8764 │   0.8673 │  0.8764 │   0.8673 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Height']                     │  0.8763 │   0.8658 │  0.8769 │   0.8663 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Height']                                │  0.8753 │   0.8662 │  0.8753 │   0.8662 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length3', 'Width']                                 │  0.8773 │   0.8662 │  0.8773 │   0.8662 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length3', 'Height', 'Width']                       │  0.8781 │   0.8648 │  0.8781 │   0.8648 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length3', 'Width']                      │  0.8775 │   0.8647 │  0.8775 │   0.8647 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Length3', 'Width']                      │  0.8774 │   0.8646 │  0.8774 │   0.8646 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Length3', 'Width']           │  0.8775 │   0.8632 │  0.8778 │   0.8634 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Width']                                 │  0.8739 │   0.8623 │  0.8739 │   0.8623 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Width']                                 │  0.8733 │   0.8616 │  0.8733 │   0.8616 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Width']                      │  0.8738 │   0.8607 │  0.8740 │   0.8609 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length3', 'Height']                                │  0.8633 │   0.8537 │  0.8633 │   0.8537 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length3']                                          │  0.8521 │   0.8470 │  0.8521 │   0.8470 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2', 'Length3']                               │  0.8522 │   0.8450 │  0.8522 │   0.8450 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length3']                               │  0.8521 │   0.8446 │  0.8521 │   0.8446 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2', 'Length3']                    │  0.8529 │   0.8435 │  0.8538 │   0.8445 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1', 'Length2']                               │  0.8460 │   0.8376 │  0.8500 │   0.8419 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length2']                                          │  0.8438 │   0.8386 │  0.8438 │   0.8386 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Length1']                                          │  0.8385 │   0.8331 │  0.8385 │   0.8331 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Width']                                            │  0.7862 │   0.7790 │  0.7862 │   0.7790 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Height', 'Width']                                  │  0.7874 │   0.7767 │  0.7874 │   0.7767 │\n",
                        "├──────────────────────────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤\n",
                        "│ ['Height']                                           │  0.5240 │   0.5156 │  0.5240 │   0.5156 │\n",
                        "╘══════════════════════════════════════════════════════╧═════════╧══════════╧═════════╧══════════╛\n",
                        "\n"
                    ]
                }
            ],
            "source": [
                "# Part b\n",
                "from itertools import chain, combinations\n",
                "from tabulate import tabulate\n",
                "\n",
                "\n",
                "def powerset(s):\n",
                "    return list(chain.from_iterable(combinations(s, r) for r in range(1, len(s)+1)))\n",
                "\n",
                "\n",
                "def checkall(X, y, deg=1):\n",
                "    psf = powerset(X.columns)\n",
                "    header = ['Feature Set', 'GD RS', 'GD RSP', 'NE RS', 'NE RSP']\n",
                "    rows = []\n",
                "    for fs in psf:\n",
                "        fs = list(fs)\n",
                "        r = eval(X[fs], y, deg, False)\n",
                "        rows.append([fs, r['GD'][0], r['GD'][1], r['NQ'][0], r['NQ'][1]])\n",
                "    rows = sorted(rows, key=lambda x: x[4], reverse=True)\n",
                "    rows = [header] + rows\n",
                "    table = tabulate(rows, headers='firstrow',\n",
                "                     tablefmt='fancy_grid', floatfmt='.4f')\n",
                "    print(table, end='\\n\\n')\n",
                "\n",
                "    with open('P4_b.csv', 'w', encoding='utf-8') as f:\n",
                "        for r in rows:\n",
                "            f.write(','.join(map(lambda x: str(x).replace(',', ''), r)))\n",
                "            f.write('\\n')\n",
                "\n",
                "\n",
                "checkall(X, y)\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {
                "azdata_cell_guid": "052e80cd-0af4-4b29-bde3-b973d2acf231",
                "language": "python"
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Best selected features using Backward Regression:\n",
                        "['Length1', 'Length3', 'Height']\n"
                    ]
                }
            ],
            "source": [
                "# Part c\n",
                "from scipy.stats import t\n",
                "\n",
                "\n",
                "def pvalues(X, y):\n",
                "    X = prep(X)\n",
                "    m = X.shape[0]\n",
                "    n = X.shape[1]\n",
                "    w = RegressionTrainerNQ(X, y, prepr=False)\n",
                "    y_pred = h(X, w)\n",
                "    sigma_hat = np.sqrt(np.sum(np.square(y - y_pred)) / (m - n))\n",
                "    cov = np.linalg.inv(X.T @ X)\n",
                "    t_vals = w / (sigma_hat * np.sqrt(np.diagonal(cov)))\n",
                "    p_vals = t.sf(np.abs(t_vals), m - n) * 2\n",
                "    return p_vals\n",
                "\n",
                "\n",
                "def backward_reg(X, y, thr_out=0.15):\n",
                "    included = list(X.columns)\n",
                "    while True:\n",
                "        changed = False\n",
                "        pvals = pvalues(X[included].values, y.values)[1:]\n",
                "        worst_pval = pvals.max()\n",
                "        if worst_pval > thr_out:\n",
                "            changed = True\n",
                "            worst_feature = pvals.argmax()\n",
                "            del included[worst_feature]\n",
                "        if not changed:\n",
                "            break\n",
                "    return included\n",
                "\n",
                "\n",
                "print('Best selected features using Backward Regression:')\n",
                "print(backward_reg(X, y, thr_out=0.15))\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {
                "azdata_cell_guid": "1fec446b-a38b-4ef7-bd7c-be10ebab3411",
                "language": "python"
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 460.8x345.6 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Part d\n",
                "sns.heatmap(X.corr(), annot=True)\n",
                "plt.title(\n",
                "    'Correlation of The Dependent Variables Before Fixing The Multicollinearity Problem')\n",
                "plt.savefig('P4_d.png')\n",
                "plt.show()\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {
                "azdata_cell_guid": "e3353728-f1b4-4f5a-84b6-9a4496230ba4",
                "language": "python"
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 864x360 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Part e\n",
                "def cook_distance(X, y):\n",
                "    d = np.zeros(X.shape[0])\n",
                "    X = prep(X)\n",
                "    w = RegressionTrainerNQ(X, y, False)\n",
                "    y_pred = h(X, w)\n",
                "    thr = 4 / X.shape[0]\n",
                "    for i in range(X.shape[0]):\n",
                "        X_ = np.delete(X, i, 0)\n",
                "        y_ = np.delete(y, i)\n",
                "        w_ = RegressionTrainerNQ(X_, y_, False)\n",
                "        y_pred_ = h(X, w_)\n",
                "        sse = np.square(y_pred - y_pred_).sum()\n",
                "        mse = np.square(y_pred_ - y).sum() / len(y)\n",
                "        d[i] = sse / (len(w) * mse)\n",
                "    return d, thr\n",
                "\n",
                "\n",
                "def dffits(X, y):\n",
                "    d = np.zeros(X.shape[0])\n",
                "    X = prep(X)\n",
                "    w = RegressionTrainerNQ(X, y, False)\n",
                "    H = X.dot(np.linalg.inv(X.T.dot(X))).dot(X.T)\n",
                "    y_pred = h(X, w)\n",
                "    thr = 2 * np.sqrt((len(w) + 1) / (len(y) - len(w) - 1))\n",
                "    for i in range(X.shape[0]):\n",
                "        X_ = np.delete(X, i, 0)\n",
                "        y_ = np.delete(y, i)\n",
                "        w_ = RegressionTrainerNQ(X_, y_, False)\n",
                "        y_pred_ = h(X, w_)\n",
                "        se = y_pred[i] - y_pred_[i]\n",
                "        mse = np.square(y_pred_ - y).sum() / len(y)\n",
                "        d[i] = se / np.sqrt(mse * H[i, i])\n",
                "    return d, thr\n",
                "\n",
                "\n",
                "def cook_plot(X, y, ax):\n",
                "    cd, thr = cook_distance(X.values, y.values)\n",
                "    for i in range(len(cd)):\n",
                "        sns.lineplot(x=[i, i], y=[0, cd[i]], color='blue', ax=ax)\n",
                "    ax.axhline(thr, color='red', ls='--',)\n",
                "    ax.axhline(0, color='red')\n",
                "    ax.set(xlabel='Instance Index', ylabel=\"Cook's Distance\")\n",
                "\n",
                "\n",
                "def dffits_plot(X, y, ax):\n",
                "    cd, thr = dffits(X.values, y.values)\n",
                "    for i in range(len(cd)):\n",
                "        sns.lineplot(x=[i, i], y=[0, cd[i]], color='blue', ax=ax)\n",
                "    ax.axhline(thr, color='red', ls='--')\n",
                "    ax.axhline(-thr, color='red', ls='--')\n",
                "    ax.axhline(0, color='red')\n",
                "    ax.set(xlabel='Instance Index', ylabel=\"DFFITS\")\n",
                "\n",
                "\n",
                "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n",
                "cook_plot(X, y, ax[0])\n",
                "dffits_plot(X, y, ax[1])\n",
                "fig.suptitle(\"Cook's Distance and DFFITS for Instances\")\n",
                "fig.savefig('P4_e.png')\n",
                "plt.show()\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {
                "azdata_cell_guid": "8d2244d9-ace9-4106-a71f-3fe9f56e8fd3",
                "language": "python"
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 460.8x345.6 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Part f1\n",
                "def re_plot(X, y):\n",
                "    y = y.values\n",
                "    X = prep(X.values)\n",
                "    w = RegressionTrainerNQ(X, y, False)\n",
                "    y_pred = h(X, w)\n",
                "    H = np.diag(X.dot(np.linalg.inv(X.T.dot(X))).dot(X.T))\n",
                "    re = y_pred - y\n",
                "    fig, ax = plt.subplots(1, 2, sharey=True, gridspec_kw={\n",
                "                           'width_ratios': [3, 1]})\n",
                "    sns.scatterplot(x=y_pred, y=re, size=H, ax=ax[0])\n",
                "    sns.distplot(x=re, vertical=True, ax=ax[1])\n",
                "    ax[0].axhline(0, color='red')\n",
                "    ax[1].axhline(0, color='red')\n",
                "    ax[0].set(xlabel='Predicted Value', ylabel='Residual')\n",
                "    return fig\n",
                "\n",
                "\n",
                "fig = re_plot(X, y)\n",
                "fig.suptitle(f'Distribution of Residual Error Before Removing Influentials')\n",
                "fig.savefig('P4_f1.png')\n",
                "plt.show()\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {
                "azdata_cell_guid": "88dd50f5-892f-4630-bb81-62e73e1d9ff7",
                "language": "python"
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Performance of the models, after removing 13 Influentials:\n",
                        "\n",
                        "Gradient Descent\n",
                        "R-Squared: 0.9142\n",
                        "R-Squared Prediction: 0.9049\n",
                        "\n",
                        "Normal Equation\n",
                        "R-Squared: 0.9168\n",
                        "R-Squared Prediction: 0.9075\n",
                        "\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 460.8x345.6 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Part f2\n",
                "def remove_influentials(X, y, method='or'):\n",
                "    cd, cthr = cook_distance(X.values, y.values)\n",
                "    dd, dthr = dffits(X.values, y.values)\n",
                "    cds = (cd > cthr)\n",
                "    dds = (dd > dthr) | (dd < -dthr)\n",
                "    if method == 'or':\n",
                "        influentials = cds | dds\n",
                "    elif method == 'and':\n",
                "        influentials = cds & dds\n",
                "    elif method == 'cook':\n",
                "        influentials = cds\n",
                "    elif method == 'dffits':\n",
                "        influentials = dds\n",
                "    X_ = X[~influentials]\n",
                "    y_ = y[~influentials]\n",
                "    return X_, y_\n",
                "\n",
                "\n",
                "X_, y_ = remove_influentials(X, y, 'or')\n",
                "print(\n",
                "    f'Performance of the models, after removing {len(y) - len(y_)} Influentials:\\n')\n",
                "eval(X_, y_)\n",
                "\n",
                "fig = re_plot(X_, y_)\n",
                "fig.suptitle(\n",
                "    f'Distribution of Residual Error After Removing {len(y) - len(y_)} Influentials')\n",
                "fig.savefig('P4_f2.png')\n",
                "plt.show()\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {
                "azdata_cell_guid": "b9aeba4e-61c3-4e3c-8791-c755b501a0d8",
                "language": "python",
                "tags": []
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 460.8x345.6 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 460.8x345.6 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Gradient Descent\n",
                        "R-Squared: 0.9926\n",
                        "R-Squared Prediction: 0.9909\n",
                        "\n",
                        "Normal Equation\n",
                        "R-Squared: 0.9926\n",
                        "R-Squared Prediction: 0.9909\n",
                        "\n"
                    ]
                }
            ],
            "source": [
                "# Part g\n",
                "X_, y_ = remove_influentials(X, y, 'dffits')\n",
                "for i in range(8):\n",
                "    X_, y_ = remove_influentials(X_, y_, 'dffits')\n",
                "\n",
                "fig = re_plot(X_, y_)\n",
                "fig.suptitle(\n",
                "    f'Distribution of Residual Error After Removing {len(y) - len(y_)} Influentials Using DFFITS')\n",
                "fig.savefig('P4_g1.png')\n",
                "plt.show()\n",
                "\n",
                "X_['diff_l23'] = X_['Length2'] - X_['Length3']\n",
                "sns.heatmap(X_.drop(['Length2', 'Length3'], axis=1).corr(), annot=True)\n",
                "plt.title(\n",
                "    'Correlation of The Dependent Variables After Fixing The Multicollinearity Problem')\n",
                "plt.savefig('P4_g2.png')\n",
                "plt.show()\n",
                "\n",
                "eval(X_[['Length1', 'Height', 'Width', 'diff_l23']],\n",
                "     y_, 2, iteration=1100, learning_rate=1e-3)\n"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3.10.2 64-bit",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.10.2"
        },
        "vscode": {
            "interpreter": {
                "hash": "2b324498af64d22b4773901be112d66dec816013b7f64fed368c8550f7daba2d"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}