Neural Networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Lab 1: Grade Point Average Prediction\n",
    "\n",
    "In this Lab we are tasked with designing a system to make admission decisions at the University of Pennsylvania (Penn). In order to design this system we need to acquire data and create a model to substantiate our decisions.\n",
    "\n",
    "## Lab 1C Neural Networks\n",
    "\n",
    "## 0. Environment setup\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of students: 600\n",
      "Number of variables: 5\n",
      "\n",
      "Example student: \n",
      "High-school GPA: 3.79 \t SAT score: 1540.0\t Penn GPA: 3.53\t Female 0.0\t Male 1.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.functional import relu\n",
    "import random\n",
    "#random generator seed for reproducibility\n",
    "np.random.seed(1)\n",
    "torch.manual_seed(1)\n",
    "random.seed(1)\n",
    "# configuration\n",
    "torch.set_default_dtype(torch.float64)\n",
    "plt.style.use('default')\n",
    "\n",
    "data = torch.from_numpy( np.genfromtxt ('data.csv', delimiter=\",\", skip_header=1, dtype = float ) )\n",
    "\n",
    "# Compute the mean and standard deviation of each variable.\n",
    "means = torch.mean(data[:,:3], dim = 0)\n",
    "stds = torch.std(data[:,:3], dim = 0)\n",
    "\n",
    "# Substract the mean and divide by the std each variable.\n",
    "data_norm = data.clone()\n",
    "data_norm[:, :3] = (data[:, :3] - means) / stds \n",
    "\n",
    "# We use both the normalized HS GPA and the SAT scores\n",
    "x = data_norm[:,:2] \n",
    "\n",
    "# The targets are the normalized Penn GPA values\n",
    "y = data_norm[:,2]\n",
    "\n",
    "print(f\"Number of students: {data.shape[0]}\")\n",
    "print(f\"Number of variables: {data.shape[1]}\")\n",
    "print(f\"\\nExample student: \\nHigh-school GPA: {data[0, 0]} \\t SAT score: {data[0, 1]}\\t Penn GPA: {data[0, 2]}\\t Female {data[0, 3]}\\t Male {data[0, 4]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 Neural networks\n",
    "\n",
    "Neural Networks are information processing architectures made up of a composition of layers, each of which is itself the composition of a linear transformation with a pointwise nonlinearity. \n",
    "\n",
    "For a network with an arbitrary number of layers $L$ we define the input output relationship through the recursion\n",
    "\n",
    "\\begin{equation}  \n",
    "   \\mathbf{x}_0 \n",
    "      = \\mathbf{x}, \\qquad      \n",
    "   \\mathbf{x}_\\ell \n",
    "      = \\sigma \\Big(\\, \\mathbf{z}_\\ell       \\,\\Big)\n",
    "      = \\sigma \\Big(\\, \\mathbf{A}_\\ell\\mathbf{x}_{\\ell-1} \\,\\Big)  ,\\qquad\n",
    "   \\mathbf{x}_L \n",
    "      = \\mathbf{\\Phi}(\\mathbf{x}; \\mathcal{A}).\n",
    "\\end{equation}\n",
    "\n",
    "In this recursion the output of Layer $\\ell-1$ produces the output of Layer $\\ell$ as $\\mathbf{x}_\\ell = \\sigma ( \\mathbf{A}_\\ell \\mathbf{x}_{\\ell-1})$. This operation is a composition of the linear map $\\mathbf{A}_\\ell\\mathbf{x}_{\\ell-1}$ with a pointwise nonlinear function $\\sigma$. This is a function that acts separately on each individual components. To complete the recursion we redefine the input $\\mathbf{x}$ as the output of Layer 0, $\\mathbf{x}_0 = \\mathbf{x}$. The output of the neural network is the output of layer $L$, $\\mathbf{x}_L = \\mathbf{\\Phi}(\\mathbf{x}; \\mathcal{A})$. In this notation $\\mathcal{A}$ is the tensor $\\mathcal{A} := [\\mathbf{A}_1,\\ldots,\\mathbf{A}_L]$ that groups the $L$ matrices that are used at each of the $L$ layers.\n",
    "\n",
    "This training process entails solutions of an empirical risk minimization problem (ERM). For clarity, recall that we are given data pairs $(\\mathbf{x}_i, \\mathbf{y}_i)$ in which $\\mathbf{x}_i$ is the input to a system of interest and $\\mathbf{y}_i$ is the respective observed output. In the ERM problem we evaluate the neural network outputs $\\hat{\\mathbf{y}}_i:=\\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A})$ and compare them with the corresponding system outputs $\\mathbf{y}_i$ using a given loss functions $\\ell(\\mathbf{y}, \\hat{\\mathbf{y}})$. The ERM objective is the average of these individual losses. Thus, training a neural network implies finding the tensor $\\mathcal{A}^*$ that solves the ERM problem,\n",
    "\n",
    "\\begin{equation}\\tag{1}   \n",
    "   \\mathcal{A}^* \n",
    "      ~=~ \\operatorname{argmin}_\\mathcal{A} \n",
    "             \\frac{1}{N} \n",
    "                \\sum_{i=1}^{N} \n",
    "                   \\ell \\Big( \\mathbf{y}_i, \\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A}) \\Big) ~\n",
    "\\end{equation}\n",
    "\n",
    "Notice that in (1) we must have that the dimensions of the system outputs $\\mathbf{y}_i$ and the dimensions of the neural network outputs $\\hat{\\mathbf{y}}_i:=\\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A})$ must be the same. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Neural network specification\n",
    "\n",
    "The input to each layer of a neural network is a vector and the output is another vector. We say that we specify a neural network when we specify the number of entries of each of these vectors. Thus, if $p_0=p$ is the number of components of the input $\\mathbf{x}_0$ and $p_\\ell$ is the number of components at the output $\\mathbf{x}_\\ell$ of layer $\\ell$ of a neural network with $L$ layers, the neural network is specified by the numbers $L$ and $p_0, p_1, \\ldots, p_L$. Of these numbers $p_0$ and $p_L$ are determined by the data because $p_0$ is the dimension of the input $\\mathbf{x}$ and $p_L$ matches the dimension of the output $\\mathbf{y}$.\n",
    "\n",
    "To complete the specification of a neural network we must also specify the nonlinearities that are used at each layer. In most cases, the same activation function is used in all layers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1 \n",
    "Define a class to represent a neural network to process scholastic achievement data. The inputs are high school GPA and SAT scores. The output is an estimate of the Penn GPA. This neural network has 2 layers and the output of Layer 1 has dimension $p_1 = 20$. The neural network uses ReLU nonlinearities in both layers. \n",
    "\n",
    "Endow the object with a method that takes as inputs vectors $\\mathbf{x} = [\\text{HS GPA}; \\text{SAT}]$ with high school GPA and SAT scores and produces estimates of Penn GPAs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will define a class that inherits from torch.nn.Module as seen in tutorial 1.X Neural Networks with pytorch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class TwoL2ayerNN(torch.nn.Module):\n",
    "    def __init__(self,p1=20):\n",
    "        super().__init__()\n",
    "        # we create the linear maps for both layers by instantiating\n",
    "        # the torch.nn.Linear class\n",
    "        # the first layer has input dim 2 (SAT, GPA) and output dim p1\n",
    "        self.A1 = nn.parameter.Parameter(torch.rand(2, p1)-0.5)\n",
    "        # the second layer has input dim p1 and output dim 1 (predicted gpa)\n",
    "        self.A2 = nn.parameter.Parameter(torch.rand(p1, 1)-0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We begin by defining a class that inherits from nn.module and implements our to layer NN.\n",
    "To do so, we in the init method we need to define the parameters of our model.\n",
    "\n",
    "The input layer needs to have input dimension 2 (SAT, GPA) and has output diension $p_1$. The output layer has input dimension   $p_1$ and output dimension 1. In order to implement the linear transformation of each layer, we create randomly initialised parameter matrices A1 and A2 with the corresponding the input and output dimensions.\n",
    "\n",
    "Now we need to implement the forward method that given an input computes the predictions of our neural network using these previously defined parameters (A1, A2).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "class TwoLayerNN(torch.nn.Module):\n",
    "    def __init__(self, p1=20):\n",
    "        super().__init__()\n",
    "        # the first layer has input dim 2 (SAT, GPA) and output dim p1\n",
    "        self.A1 = nn.parameter.Parameter(torch.rand(2, p1)-0.5)\n",
    "        # the second layer has input dim p1 and output dim 1 (predicted gpa)\n",
    "        self.A2 = nn.parameter.Parameter(torch.rand(p1, 1)-0.5)\n",
    "    def forward(self, x0):\n",
    "        # compute output of first layer\n",
    "        x1 = relu(torch.matmul(x0, self.A1))\n",
    "        # compute output of second layer\n",
    "        x2 = relu(torch.matmul(x1,self.A2))\n",
    "        return x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The forward method is a straightforward implementation of the NN parametrization. We compute the linear transformation of the inputs $A_1 x_0$ in the first layer by calling *torch.matmul(x0, self.A1)* and then apply the pointwise non linearity *relu()* to obtain the first layer output (x1). We then use x1 as an input to the second layer, which is implemented in the same way (*relu(torch.matmul(x,self.A2))*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Train and test sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The minimization of empirical risks carries a subtle challenge. To see which one, consider an ERM problem in which we do not choose a parameterization. In this case we are simply seeking an artificial intelligence $\\mathbf{\\Phi}(\\mathbf{x})$ that solves the following problem\n",
    " \n",
    "\\begin{equation}\\tag{2}\\label{eqn_erm_nonsensical}   \n",
    "   \\mathbf{\\Phi}^* \n",
    "      ~=~ \\operatorname{argmin}_{\\mathbf{\\Phi}}\n",
    "             \\frac{1}{N} \n",
    "                \\sum_{i=1}^{N} \n",
    "                   \\ell \\Big( \\mathbf{y}_i, \\mathbf{\\Phi}(\\mathbf{x}_i) \\Big) ~.\n",
    "\\end{equation}\n",
    " \n",
    "This problem is the opposite of challenging. We just choose the map $\\mathbf{\\Phi}(\\mathbf{x}_i)=y_i$ and select $\\mathbf{\\Phi}(\\mathbf{x})$ at random for any other $\\mathbf{x}$. This solution is as easy as it is nonsensical. It does not solve the artificial intelligence problem of finding a function $\\mathbf{\\Phi}(\\mathbf{x})$ that can make predictions about the future. It memorizes the past perfectly but it says nothing about future inputs that are not exact matches of some past inputs. \n",
    "\n",
    "Given that it is nonsensical there is no point in working with (2). And, indeed, we are not attempting to solve (2). We are attempting to solve the ERM problem in (1) in which predictions $\\hat{\\mathbf{y}}=\\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A})$ are outputs of a family of neural networks that follow some specification -- as discussed in Section 1.2. Nevertheless, there is the mystifying fact that from the perspective of empirical risk a function $\\mathbf{\\Phi}^*$ that solves (2) is at least as good, and in all likelihood better, than a function $\\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A}^*)$ that solves (1). Indeed, since the empirical risk of $\\mathbf{\\Phi}^*$ is null and the empirical risk is nonnegative, we must have,\n",
    " \n",
    "\\begin{equation}\\label{eqn_erm_nonsensical_better_nn}\\tag{3}   \n",
    "   ~0~ =    \\frac{1}{N} \n",
    "             \\sum_{i=1}^{N} \n",
    "                \\ell \\Big( \\mathbf{y}_i, \\mathbf{\\Phi}^*(\\mathbf{x}_i) \\Big) \n",
    "     ~\\leq~ \\frac{1}{N} \n",
    "             \\sum_{i=1}^{N} \n",
    "                \\ell \\Big( \\mathbf{y}_i, \\mathbf{\\Phi}(\\mathbf{x}_i; \\mathcal{A}^*) \\Big) .\n",
    "\\end{equation}\n",
    " \n",
    "The answer to this riddle is that the merit of an artificial intelligence is not its empirical risk but the risk it attains during operation. \n",
    "\n",
    "Suppose then that we observe $\\tilde{N}$ points $(\\tilde{\\mathbf{x}}_j, \\tilde{\\mathbf{y}}_j)$ during operation of the neural network. The true metric of performance of the neural network is its ability to make predictions $\\mathbf{\\Phi}(\\tilde{\\mathbf{x}}_j; \\mathcal{A})$ that are close to observed outcomes. This is measured but the operational risk  \n",
    "\n",
    " \n",
    "\\begin{equation}\\label{eqn_test_risk}   \n",
    "   \\tilde{r}(\\mathcal{A}) \n",
    "      ~=~ \\frac{1}{\\tilde{N}} \n",
    "             \\sum_{j=1}^{\\tilde{N}} \n",
    "                \\ell \\Big( \\tilde{\\mathbf{y}}_j, \\mathbf{\\Phi}(\\tilde{\\mathbf{x}}_j; \\mathcal{A}) \\Big) ~.\n",
    "\\end{equation}\n",
    " \n",
    "This solves the riddle of (3) because it is possible that the operational risk of the neural network is better than the operational risk of the function $\\mathbf{\\Phi}^*$. This is not just possible but does happen in practice. The reasons why this may happen or not are the subject matter of statistical learning theory. We will not study this here.\n",
    "\n",
    "Observe that the operational risk becomes available a posteriori; after the neural network goes into service and starts making predictions. To gain a handle on operational risk before service we divide available data into two sets. A training set with the $N$ samples $(\\mathbf{x}_i, \\mathbf{y}_i)$ that we use for solving (1) and a \\emph{test} set with $\\tilde{N}$ samples $(\\tilde{\\mathbf{x}}_i, \\tilde{\\mathbf{y}}_i)$ that we can use to estimate the operational risk. It is important that the test set is \\emph{not} used in training and it is important that the test set is representative of the data as a whole. In this context the operational risk is also called to test error."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2\n",
    "\n",
    "Divide the data of Lab 1A into a test set with $\\tilde{N} = 100$ samples and use the remaining samples as a training set. Use it to train the neural network of Task 1. Try with a learning rate of $0.02$ and train for 300 epochs. Evaluate the training error and the test error. They will be different."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by partiotioning the data in two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num Train = 500, numTest = 100\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "\n",
    "# Creating data indices for training and validation splits:\n",
    "dataset_size = len(x)\n",
    "indices = list(range(dataset_size))\n",
    "np.random.shuffle(indices)\n",
    "numTest = 100\n",
    "numTrain = dataset_size - numTest\n",
    "print(f\"Num Train = {numTrain}, numTest = {numTest}\")\n",
    "train_indices, test_indices = indices[numTest:], indices[:numTest]\n",
    "# Data\n",
    "train_dataset = TensorDataset(x[train_indices], y[train_indices])\n",
    "test_dataset = TensorDataset(x[test_indices], y[test_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(dataloader, estimator):\n",
    "    mse = 0\n",
    "    with torch.no_grad():\n",
    "        for x_batch, y_batch in dataloader:\n",
    "            yHat = estimator.forward(x_batch).squeeze()\n",
    "            mse += torch.sum((yHat-y_batch)**2)\n",
    "    numSamples = len(dataloader.dataset)\n",
    "    mse /= numSamples\n",
    "    return mse.item()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.8016419321041909 \n",
      "Test loss: 0.9168196891837828 \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Specification of learning parametrization.\n",
    "estimator = TwoLayerNN(40)\n",
    "\n",
    "# Parameters used in training loop\n",
    "epsilon=0.01\n",
    "batch_size = 64\n",
    "\n",
    "# Specify the optimizer that is used to perform descent updates\n",
    "optimizer = optim.SGD(estimator.parameters(), lr=epsilon, momentum=0)\n",
    "\n",
    "\n",
    "# Instantiate Data Loaders\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size)\n",
    "\n",
    "mse_evolution = []\n",
    "mse_evolution_test = []\n",
    "\n",
    "\n",
    "# Training loop\n",
    "n_epochs = 200\n",
    "# Iterate n_epochs times over the whole dataset.\n",
    "\n",
    "for _ in range(n_epochs):\n",
    "    #iterate over all batches in the dataset\n",
    "    for x_batch, y_batch in train_loader:\n",
    "        \n",
    "        # set gradients to zero\n",
    "        estimator.zero_grad() \n",
    "        \n",
    "        # Compute predictions\n",
    "        yHat = estimator.forward(x_batch).squeeze()\n",
    "        # Compute error\n",
    "        mse = torch.mean((yHat-y_batch)**2)\n",
    "\n",
    "        # Compute gradients\n",
    "        mse.backward()\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer.step()\n",
    "\n",
    "    epoch_mse = evaluate(train_loader, estimator)    \n",
    "    mse_evolution.append(epoch_mse)\n",
    "    \n",
    "    mseTest = evaluate(test_loader, estimator)  \n",
    "    mse_evolution_test.append(mseTest)\n",
    "\n",
    "# Print train results\n",
    "print(f\"Train loss: {mse_evolution[-1]} \")\n",
    "\n",
    "# Print test results\n",
    "print(f\"Test loss: {mse_evolution_test[-1]} \")\n",
    "_ = plt.plot(mse_evolution, \".\", label=\"train\")\n",
    "_ = plt.title(\"Mean squared error evolution\")\n",
    "_ = plt.xlabel(\"Epoch\")\n",
    "_ = plt.ylabel(\"MSE\")\n",
    "_ = plt.plot(mse_evolution_test, \"-\", label=\"test\")\n",
    "_ = plt.legend()\n",
    "_ = plt.savefig(\"1Ctasfk2.pdf\")\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3\n",
    "\n",
    "We will incorporate the gender data that we have so far ignored. To that end encode gender as $\\text{Female} = 1$ and $\\text{Male} = -1$. Redefine the object in Task 1 so that it can now process this information. In this neural network we use a single intermediate layer with $20$ hidden neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "class TwoLayerNN(torch.nn.Module):\n",
    "    def __init__(self, p1=20):\n",
    "        super().__init__()\n",
    "        # we just modify the input dimension to 3\n",
    "        self.A1 = nn.parameter.Parameter((torch.rand(3, p1)-0.5))\n",
    "        self.A2 = nn.parameter.Parameter((torch.rand(p1, 1)-0.5))\n",
    "    def forward(self, x0):\n",
    "        # compute output of first layer\n",
    "        x1 = relu(torch.matmul(x0, self.A1))\n",
    "        # compute output of second layer\n",
    "        x2 = relu(torch.matmul(x1,self.A2))\n",
    "        return x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4\n",
    "\n",
    "Divide the data of Lab 1A into a test set with $\\tilde{N} = 100$ samples and use the remaining samples as a training set. Use it to train the neural network of Task 1. \\blue{Add step size suggestions.} Evaluate the training error and the test error. \n",
    "\n",
    "Given that we have decided to use gender information in our decisions, it is fair that we are asked what effect this choice has. Evaluate the average predicted GPA for Female and Male applicants and observe that data can be perilous. Or not. Comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use both the normalized HS GPA and the SAT scores\n",
    "# The targets are the normalized Penn GPA values\n",
    "gender =  data_norm[:,3] -  data_norm[:,4]\n",
    "gender = (gender-torch.mean(gender))/torch.std(gender)\n",
    "x = torch.hstack((data_norm[:,:2], gender.unsqueeze(1)))\n",
    "y = data_norm[:,2]\n",
    "\n",
    "# Data\n",
    "train_dataset = TensorDataset(x[train_indices], y[train_indices])\n",
    "test_dataset = TensorDataset(x[test_indices], y[test_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.7897461291032101 \n",
      "Test loss: 0.8599131732834959 \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Specification of learning parametrization.\n",
    "estimator = TwoLayerNN(40)\n",
    "\n",
    "# Parameters used in training loop\n",
    "epsilon=0.01\n",
    "batch_size = 64\n",
    "\n",
    "# Specify the optimizer that is used to perform descent updates\n",
    "optimizer = optim.SGD(estimator.parameters(), lr=epsilon, momentum=0)\n",
    "\n",
    "\n",
    "# Instantiate Data Loaders\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size)\n",
    "\n",
    "mse_evolution = []\n",
    "mse_evolution_test = []\n",
    "\n",
    "\n",
    "# Training loop\n",
    "n_epochs = 200\n",
    "# Iterate n_epochs times over the whole dataset.\n",
    "\n",
    "for _ in range(n_epochs):\n",
    "    #iterate over all batches in the dataset\n",
    "    for x_batch, y_batch in train_loader:\n",
    "        \n",
    "        # set gradients to zero\n",
    "        estimator.zero_grad() \n",
    "        \n",
    "        # Compute predictions\n",
    "        yHat = estimator.forward(x_batch).squeeze()\n",
    "        # Compute error\n",
    "        mse = torch.mean((yHat-y_batch)**2)\n",
    "        # Compute gradients\n",
    "        mse.backward()\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer.step()\n",
    "    epoch_mse = evaluate(train_loader, estimator)    \n",
    "    mse_evolution.append(epoch_mse)\n",
    "    \n",
    "    mseTest = evaluate(test_loader, estimator)  \n",
    "    mse_evolution_test.append(mseTest)\n",
    "\n",
    "# Print train results\n",
    "print(f\"Train loss: {mse_evolution[-1]} \")\n",
    "\n",
    "# Print test results\n",
    "print(f\"Test loss: {mse_evolution_test[-1]} \")\n",
    "_ = plt.plot(mse_evolution[2:], \".\", label=\"train\")\n",
    "_ = plt.title(\"Mean squared error evolution\")\n",
    "_ = plt.xlabel(\"Epoch\")\n",
    "_ = plt.ylabel(\"MSE\")\n",
    "_ = plt.plot(mse_evolution_test[2:], \"-\", label=\"test\")\n",
    "_ = plt.legend()\n",
    "_ = plt.savefig(\"1Ctasfk4.pdf\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Male GPA: 3.5958956072204615 \n",
      "Average Female GPA: 3.6118699134595706\n"
     ]
    }
   ],
   "source": [
    "male_indexes = gender < 0\n",
    "male_yHat = torch.mean(estimator.forward(x[male_indexes]).squeeze())\n",
    "\n",
    "female_indexes = gender > 0\n",
    "female_yHat = torch.mean(estimator.forward(x[female_indexes]).squeeze())\n",
    "\n",
    "print(f\"Average Male GPA: {stds[2] * male_yHat + means[2]} \")\n",
    "print(f\"Average Female GPA: {stds[2] * female_yHat + means[2]}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupy",
   "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.8.16"
  },
  "vscode": {
   "interpreter": {
    "hash": "c5718435856700c01991336cb4f6da84b203bf2342c9407134d97da30a70f8ef"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}