Airfoil_Self-NoisePrediction_MLP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d71b67ce",
   "metadata": {},
   "source": [
    "# Welcome to This Project\n",
    "\n",
    "Here, we will be implementing a neural network in order to perform regression on the Airfoil Self-Noise data set. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b078d440",
   "metadata": {},
   "source": [
    "## The imports and helper functions should not be modified in any way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "39ca4710",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f4e991b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, test_data):\n",
    "\n",
    "    test_loader = DataLoader(Dataset(test_data), batch_size=1)\n",
    "    loss_fn = torch.nn.MSELoss()\n",
    "    with torch.no_grad():\n",
    "        total_loss = 0\n",
    "        for x, y in test_loader:\n",
    "            pred = model(x)\n",
    "            total_loss += loss_fn(pred, y).item()\n",
    "    print(\"TOTAL EVALUATION LOSS: {0:.5f}\".format(total_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "99e84b54",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_training_curves(train_loss, val_loss, loss_fn_name, reduction):\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(8,6))\n",
    "    ax.plot(train_loss, label=\"Train Loss\")\n",
    "    ax.plot(val_loss, label=\"Validation Loss\")\n",
    "    ax.legend(loc='best')\n",
    "    ax.set_title(\"Loss During Training\", fontsize=16)\n",
    "    ax.set_xlabel(\"Epochs\", fontsize=14)\n",
    "    ax.set_ylabel(\"Loss: {}(reduction={})\".format(loss_fn_name, reduction), fontsize=14)\n",
    "    plt.savefig(\"./example_loss.pdf\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae7fa49e",
   "metadata": {},
   "source": [
    "## a) Implement  dataset object.\n",
    "\n",
    "Please note that the first five columns of the airfoil data are features and the last column is the target. The dataset should have one attribute for the features, one attribute for the targets, and should return the specified features and target in `__getitem__()` as separate values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "59749439",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset(torch.utils.data.Dataset):\n",
    "    \"\"\"Create your dataset here.\"\"\"\n",
    "\n",
    "    def __init__(self, airfoil_data):\n",
    "        \"\"\"\n",
    "            Initialize your Dataset object with features and labels\n",
    "        \"\"\"\n",
    "        ### Define your features and labels here\n",
    "        self.features = airfoil_data[:, :-1] \n",
    "        self.targets = airfoil_data[:, -1]\n",
    "\n",
    "    def __len__(self):\n",
    "        ### Define the length of your data set\n",
    "        return len(self.features)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        ### Return the features and labels of your data for a given index\n",
    "        feature = torch.tensor(self.features[idx], dtype=torch.float32)\n",
    "        target = torch.tensor(self.targets[idx], dtype=torch.float32)\n",
    "        target = target.unsqueeze(-1)\n",
    "        return feature, target"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "601ab911",
   "metadata": {},
   "source": [
    "## b) Implement the model architecture and `forward` function.\n",
    "\n",
    "We will need to define input, hidden, and output layers, as well as the activation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0479005d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, input_dimension=5, output_dimension=1, hidden=[32], activation=nn.ReLU()):\n",
    "        super(NeuralNetwork, self).__init__()\n",
    "        '''\n",
    "            Implement your neural network here. You will need to add layers and an activation function.\n",
    "            You are free to modify the number of layers in the hidden list.\n",
    "        '''\n",
    "        ### Define your input, hidden and output layers here\n",
    "        \n",
    "        ### Set your activation function here\n",
    "        \n",
    "        self.seq = nn.Sequential(\n",
    "            nn.Linear(input_dimension, 32),\n",
    "            activation,\n",
    "            nn.Linear(32, 64),\n",
    "            activation,\n",
    "            nn.Linear(64, 84),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(84, 84),\n",
    "            activation,\n",
    "            nn.Linear(84, 84),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(84, 64),\n",
    "            activation,\n",
    "            nn.Linear(64, 34),\n",
    "            activation,\n",
    "            nn.Linear(34, 24),\n",
    "            activation,\n",
    "            nn.Linear(24, 10),\n",
    "            activation,\n",
    "            nn.Linear(10, output_dimension)\n",
    "        )  \n",
    "\n",
    "    def forward(self, x):\n",
    "        '''\n",
    "            Implement the forward function using the layers and activation function you defined above.\n",
    "        '''\n",
    "        ### Call your hidden layers and activation function to do the forward pass through your network.\n",
    "        \n",
    "        return self.seq(x) #self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "578f9c68",
   "metadata": {},
   "source": [
    "## c, d) Define hyperparameters and implement the training loop.\n",
    "\n",
    "We will need to choose your loss function, number of epochs, optimizer learning rate, optimizer weight decay, and batch size for part (c). We should set up the DataLoader, implement the forward pass, and implement the backpropagation update."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "45bac6f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, train_data, validation_data):\n",
    "\n",
    "    ###\n",
    "    #  Modify these parameters\n",
    "    ###\n",
    "    loss_fn = torch.nn.MSELoss()\n",
    "    epochs = 2500\n",
    "    learning_rate = 0.001\n",
    "    weight_decay = 0.001\n",
    "    batch_size = 600\n",
    "\n",
    "    # Set up data\n",
    "    train_loader = DataLoader(Dataset(train_data), batch_size=batch_size, shuffle=True)\n",
    "    validation_loader = DataLoader(Dataset(validation_data), batch_size=batch_size)\n",
    "\n",
    "    \n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n",
    "\n",
    "    train_losses, val_losses = [], []\n",
    "    for ep in tqdm(range(epochs)):\n",
    "        \n",
    "        model.train()\n",
    "        train_loss = 0\n",
    "        for x, y in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            pred = model(x)\n",
    "            loss = loss_fn(pred, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            train_loss += loss.item()\n",
    "            \n",
    "        model.eval()\n",
    "        val_loss = 0\n",
    "            \n",
    "        with torch.no_grad():\n",
    "            for x, y in validation_loader:\n",
    "                \n",
    "                pred = model(x)\n",
    "                loss = loss_fn(pred, y)\n",
    "                val_loss += loss.item()\n",
    "                \n",
    "        train_losses.append(train_loss / len(train_loader))\n",
    "        val_losses.append(val_loss / len(validation_loader))\n",
    "\n",
    "\n",
    "        \n",
    "        if(ep%500 == 0):\n",
    "            print(\"Train Loss: {0:.4f}\\tValidation Loss: {1:.4f}\".format(train_loss, val_loss))\n",
    "\n",
    "        \n",
    "    \n",
    "    # Save losses as .npy files\n",
    "    np.save(\"./train_losses.npy\", train_losses)\n",
    "    np.save(\"./val_losses.npy\", val_losses)\n",
    "\n",
    "    # Save the model as ./p1_model.pt\n",
    "    torch.save(model.state_dict(), \"./hw1_model.pt\")\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03442346",
   "metadata": {},
   "source": [
    "## e) Load your data, then train and evaluate your model before plotting the training curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "25d032de",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(903, 6)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|▎                                        | 17/2500 [00:00<00:28, 87.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 2.0128\tValidation Loss: 1.0505\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|████████▏                              | 521/2500 [00:04<00:15, 125.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0649\tValidation Loss: 0.0882\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|███████████████▍                      | 1015/2500 [00:08<00:12, 114.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0374\tValidation Loss: 0.0669\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|███████████████████████▏              | 1522/2500 [00:12<00:07, 125.97it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0319\tValidation Loss: 0.0677\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|██████████████████████████████▋       | 2015/2500 [00:16<00:04, 107.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0254\tValidation Loss: 0.0693\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████| 2500/2500 [00:20<00:00, 121.97it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TOTAL EVALUATION LOSS: 12.85392\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    torch.manual_seed(137)\n",
    "    \n",
    "    # Load in the provided data\n",
    "    train_data = np.load('train_data.npy')\n",
    "    print(train_data.shape)\n",
    "    validation_data = np.load('validation_data.npy')\n",
    "    test_data = np.load('test_data.npy')\n",
    "\n",
    "    model = NeuralNetwork()\n",
    "    \n",
    "    trained_model = train(model, train_data, validation_data)\n",
    "    evaluate(trained_model, test_data)\n",
    "\n",
    "    # Load training data and call the provided plot function. Loss function and reduction scheme are\n",
    "    # required for the plotting function.\n",
    "    train_losses = np.load(\"./train_losses.npy\")\n",
    "    val_losses = np.load(\"./val_losses.npy\")\n",
    "\n",
    "    plot_training_curves(train_losses, val_losses, \"MSE\", \"mean\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}