9_Neural_Networks.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7feeb2b59610>"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import sigmoid\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np\n",
        "torch.manual_seed(0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [],
      "source": [
        "# class for Neural Network\n",
        "class Net(nn.Module): # we call the class NET for Network\n",
        "    def __init__(self,D_in,H,D_out): \n",
        "        # D_in is the size of input\n",
        "        # H is the number of Neurons\n",
        "        # D_out is the size of output layer\n",
        "        super(Net,self).__init__()\n",
        "        self.linear1=nn.Linear(D_in,H) # Hidden Layer\n",
        "        self.linear2=nn.Linear(H, D_out) # Output Layer\n",
        "    def forward(self,x):# Forward Method\n",
        "        x = sigmoid(self.linear1(x)) # this is for hidden layer\n",
        "        x = sigmoid(self.linear2(x)) # this is for output layer\n",
        "        return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Then we have to train this model "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {},
      "outputs": [],
      "source": [
        "def train(Y, X, model, optimizer, criterion, epochs=1000):\n",
        "    cost = []\n",
        "    total=0\n",
        "    for epoch in range(epochs):\n",
        "        total=0\n",
        "        for y, x in zip(Y, X):\n",
        "            yhat = model(x)\n",
        "            loss = criterion(yhat, y)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            optimizer.zero_grad()\n",
        "            #cumulative loss \n",
        "            total+=loss.item() \n",
        "        cost.append(total)\n",
        "    return cost"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "`Cross entropy loss function `"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {},
      "outputs": [],
      "source": [
        "def criterion_cross(outputs, labels):\n",
        "    out = -1 * torch.mean(labels * torch.log(outputs) + (1 - labels) * torch.log(1 - outputs))\n",
        "    return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "`Now its the time to create a dataset, optimizer, and loss function`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {},
      "outputs": [],
      "source": [
        "X = torch.arange(-20, 20, 1).view(-1, 1).type(torch.FloatTensor)\n",
        "Y = torch.zeros(X.shape[0])\n",
        "Y[(X[:, 0] > -4) & (X[:, 0] < 4)] = 1.0\n",
        "criterion = criterion_cross\n",
        "model = Net(D_in=1,H=2,D_out=1)\n",
        "optimizer = torch.optim.SGD(model.parameters(),lr = 0.1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {},
      "outputs": [],
      "source": [
        "cost  = train(Y,X, model,optimizer,criterion,epochs=1000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "`prediction part`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([0.9979], grad_fn=<SigmoidBackward0>)"
            ]
          },
          "execution_count": 60,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x=torch.tensor([0.0])\n",
        "yhat=model(x)\n",
        "yhat"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.9979],\n",
              "        [0.9974],\n",
              "        [0.0016]], grad_fn=<SigmoidBackward0>)"
            ]
          },
          "execution_count": 62,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_=torch.tensor([[0.0],[2.0],[7.0]])\n",
        "Yhat=model(X_)\n",
        "Yhat"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Now we want to` add more neuron` to our hidden layer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 131,
      "metadata": {},
      "outputs": [],
      "source": [
        "# import necessary moduls\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import sigmoid\n",
        "from torch.utils.data import Dataset,DataLoader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 132,
      "metadata": {},
      "outputs": [],
      "source": [
        "# class of statset\n",
        "class Data(Dataset):\n",
        "    def __init__(self):\n",
        "        self.x = torch.linspace(-20,20,100).view(-1,1)\n",
        "        self.y = torch.zeros(self.x.shape[0])\n",
        "        self.y[(self.x[:,0]>-10) & (self.x[:,0]<-5)]=1\n",
        "        self.y[(self.x[:,0]> 5) & (self.x[:,0]< 10)]=1\n",
        "        self.y = self.y.view(-1,1)\n",
        "        self.len = self.x.shape[0]\n",
        "    def __getitem__(self, index):\n",
        "        return self.x[index],self.y[index]\n",
        "    def __len__(self):\n",
        "        return self.len"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 152,
      "metadata": {},
      "outputs": [],
      "source": [
        "def train(data_set, model, criterion,train_loader,optimizer,epochs):\n",
        "    cost = []\n",
        "    for epoch in range(epochs):\n",
        "        total=0\n",
        "        for x,y in train_loader:\n",
        "            optimizer.zero_grad()\n",
        "            yhat = model(x)\n",
        "            loss = criterion(yhat, y)\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            #cumulative loss \n",
        "            total+=loss.item() \n",
        "        cost.append(total)\n",
        "    return cost"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 160,
      "metadata": {},
      "outputs": [],
      "source": [
        "torch.manual_seed(0)\n",
        "data_set =Data()\n",
        "train_loader = DataLoader(dataset=data_set,batch_size=100)\n",
        "criterion = nn.BCELoss()\n",
        "model_m = torch.nn.Sequential(\n",
        "    torch.nn.Linear(1, 9), \n",
        "    torch.nn.Sigmoid(),\n",
        "    torch.nn.Linear(9,1),\n",
        "    torch.nn.Sigmoid())\n",
        "optimizer = torch.optim.Adam(model_m.parameters(),lr = 0.1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 161,
      "metadata": {},
      "outputs": [],
      "source": [
        "cost = train(data_set,model_m,criterion,train_loader,optimizer,epochs=600)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 162,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7feddb4e06a0>]"
            ]
          },
          "execution_count": 162,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(cost)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 164,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[3.7013e-04],\n",
              "        [3.8348e-03],\n",
              "        [9.9939e-01]], grad_fn=<SigmoidBackward0>)"
            ]
          },
          "execution_count": 164,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# we have to bear in mindthat by increasing the number of hiddenn layers we will achieve the best result\n",
        "X=torch.tensor([[0.0],[11.0],[7.0]])\n",
        "Yhat=model_m(X)\n",
        "Yhat"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### `Now we want to evaluate how we can work with multiple input`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 193,
      "metadata": {},
      "outputs": [],
      "source": [
        "# we need to input essentioal libraries\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import sigmoid\n",
        "from torch.utils.data import Dataset, DataLoader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 194,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Make dataset\n",
        "\n",
        "class XOR_Data(Dataset):\n",
        "\n",
        "    # Constructor\n",
        "    def __init__(self,N_s=100):\n",
        "        self.x = torch.zeros((N_s,2))\n",
        "        self.y = torch.zeros((N_s,1))\n",
        "        for i in range(N_s//4):\n",
        "\n",
        "            self.x[i,:] = torch.Tensor([0.0,0.0])\n",
        "            self.y[i,0] = torch.Tensor([0.0])\n",
        "\n",
        "            self.x[i+N_s//4,:] = torch.Tensor([0.0,1.0])\n",
        "            self.y[i+N_s//4,0] = torch.Tensor([1.0])\n",
        "\n",
        "            self.x[i+N_s//2,:] = torch.Tensor([1.0,0.0])\n",
        "            self.y[i+N_s//2,0] = torch.Tensor([1.0])\n",
        "\n",
        "            self.x[i+3*N_s//4,:] = torch.Tensor([1.0,1.0])\n",
        "            self.y[i+3*N_s//4,0] = torch.Tensor([0.0])\n",
        "\n",
        "            self.x = self.x +0.01*torch.randn((N_s,2))\n",
        "        \n",
        "        self.len = N_s\n",
        "\n",
        "    # Getetr\n",
        "    def __getitem__(self, index):\n",
        "        return self.x[index],self.y[index]\n",
        "    \n",
        "    # Get Length\n",
        "    def __len__(self):\n",
        "        return self.len\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 195,
      "metadata": {},
      "outputs": [],
      "source": [
        "def train(data_set, model, criterion,train_loader,optimizer,epochs=5):\n",
        "    cost = []\n",
        "    #acc =[]\n",
        "    for epoch in range(epochs):\n",
        "        total=0\n",
        "        for x,y in train_loader:\n",
        "            optimizer.zero_grad()\n",
        "            yhat = model(x)\n",
        "            loss = criterion(yhat, y)\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            #cumulative loss \n",
        "            total+=loss.item() \n",
        "        #acc.append(nn.accuracy(model,data_set))\n",
        "        cost.append(total)\n",
        "    return cost"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 196,
      "metadata": {},
      "outputs": [],
      "source": [
        "criterion = nn.BCELoss()\n",
        "data_set = XOR_Data()\n",
        "train_loader = DataLoader(dataset=data_set,batch_size=1)\n",
        "model = torch.nn.Sequential(torch.nn.Linear(2, 9), torch.nn.Sigmoid(),torch.nn.Linear(9,1),torch.nn.Sigmoid())\n",
        "optimizer = torch.optim.SGD(model.parameters(),lr=0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 197,
      "metadata": {},
      "outputs": [],
      "source": [
        "cost =train(data_set, model, criterion,train_loader,optimizer,epochs=500)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "`prediction`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 210,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8577],\n",
              "        [0.0031],\n",
              "        [0.0031]], grad_fn=<SigmoidBackward0>)"
            ]
          },
          "execution_count": 210,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X=torch.tensor([[10.0,40.0],[20.0,20.0],[99.0,86.0]])\n",
        "Yhat=model(X)\n",
        "Yhat"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### `Now its time to work with Multi_class Neural Network`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 211,
      "metadata": {},
      "outputs": [],
      "source": [
        "import torch \n",
        "import torch.nn as nn\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.datasets as dsets\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 213,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Define a function to plot accuracy and loss\n",
        "def plot_accuracy_loss(training_results): \n",
        "    plt.subplot(2, 1, 1)\n",
        "    plt.plot(training_results['training_loss'], 'r')\n",
        "    plt.ylabel('loss')\n",
        "    plt.title('training loss iterations')\n",
        "    plt.subplot(2, 1, 2)\n",
        "    plt.plot(training_results['validation_accuracy'])\n",
        "    plt.ylabel('accuracy')\n",
        "    plt.xlabel('epochs')\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 219,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Define a Neural Network class\n",
        "class Net(nn.Module):\n",
        "    \n",
        "    # Constructor\n",
        "    def __init__(self, D_in, H, D_out):\n",
        "        super(Net, self).__init__()\n",
        "        self.linear1 = nn.Linear(D_in, H)\n",
        "        self.linear2 = nn.Linear(H, D_out)\n",
        "\n",
        "    # Prediction    \n",
        "    def forward(self, x):\n",
        "        x = torch.sigmoid(self.linear1(x))  \n",
        "        x = self.linear2(x) # this is the difference when we use multi-class form\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 222,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create the model with 100 neurons\n",
        "input_dim = 28 * 28\n",
        "hidden_dim = 100\n",
        "output_dim = 10\n",
        "model = Net(input_dim, hidden_dim, output_dim)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 218,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Dataset\n",
        "train_dataset = dsets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())\n",
        "validation_dataset = dsets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 221,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create data loader for both train dataset and valdiate dataset\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=2000, shuffle=True)\n",
        "validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=5000, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 223,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Set the learning rate and the optimizer\n",
        "learning_rate = 0.01\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 224,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create criterion function\n",
        "criterion = nn.CrossEntropyLoss()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 225,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Define a training function to train the model\n",
        "\n",
        "def train(model, criterion, train_loader, validation_loader, optimizer, epochs=100):\n",
        "    i = 0\n",
        "    useful_stuff = {'training_loss': [],'validation_accuracy': []}  \n",
        "    for epoch in range(epochs):\n",
        "        for i, (x, y) in enumerate(train_loader): \n",
        "            optimizer.zero_grad()\n",
        "            z = model(x.view(-1, 28 * 28))\n",
        "            loss = criterion(z, y)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "             #loss for every iteration\n",
        "            useful_stuff['training_loss'].append(loss.data.item())\n",
        "        correct = 0\n",
        "        for x, y in validation_loader:\n",
        "            #validation \n",
        "            z = model(x.view(-1, 28 * 28))\n",
        "            _, label = torch.max(z, 1)\n",
        "            correct += (label == y).sum().item()\n",
        "        accuracy = 100 * (correct / len(validation_dataset))\n",
        "        useful_stuff['validation_accuracy'].append(accuracy)\n",
        "    return useful_stuff"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 226,
      "metadata": {},
      "outputs": [],
      "source": [
        "training_results = train(model, criterion, train_loader, validation_loader, optimizer, epochs=30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 227,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_accuracy_loss(training_results)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### `Now its the time to evaluate different forms of the activation in comapare with each other (Sigmoid, RelU, Tanh)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 228,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Import the libraries we need\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.datasets as dsets\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 229,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Build the model with sigmoid function\n",
        "\n",
        "class Net(nn.Module):\n",
        "    \n",
        "    # Constructor\n",
        "    def __init__(self, D_in, H, D_out):\n",
        "        super(Net, self).__init__()\n",
        "        self.linear1 = nn.Linear(D_in, H)\n",
        "        self.linear2 = nn.Linear(H, D_out)\n",
        "    \n",
        "    # Prediction\n",
        "    def forward(self, x):\n",
        "        x = torch.sigmoid(self.linear1(x))  \n",
        "        x = self.linear2(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 230,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Build the model with Tanh function\n",
        "\n",
        "class NetTanh(nn.Module):\n",
        "\n",
        "    # Constructor\n",
        "    def __init__(self, D_in, H, D_out):\n",
        "        super(NetTanh, self).__init__()\n",
        "        self.linear1 = nn.Linear(D_in, H)\n",
        "        self.linear2 = nn.Linear(H, D_out)\n",
        "\n",
        "    # Prediction\n",
        "    def forward(self, x):\n",
        "        x = torch.tanh(self.linear1(x))\n",
        "        x = self.linear2(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 231,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Build the model with Relu function\n",
        "\n",
        "class NetRelu(nn.Module):\n",
        "\n",
        "    # Constructor\n",
        "    def __init__(self, D_in, H, D_out):\n",
        "        super(NetRelu, self).__init__()\n",
        "        self.linear1 = nn.Linear(D_in, H)\n",
        "        self.linear2 = nn.Linear(H, D_out)\n",
        "\n",
        "    # Prediction\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.linear1(x))\n",
        "        x = self.linear2(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 232,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Define the function for training the model\n",
        "\n",
        "def train(model, criterion, train_loader, validation_loader, optimizer, epochs = 100):\n",
        "    i = 0\n",
        "    useful_stuff = {'training_loss':[], 'validation_accuracy':[]}  \n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        for i, (x, y) in enumerate(train_loader):\n",
        "            optimizer.zero_grad()\n",
        "            z = model(x.view(-1, 28 * 28))\n",
        "            loss = criterion(z, y)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            useful_stuff['training_loss'].append(loss.item())\n",
        "\n",
        "        correct = 0\n",
        "        for x, y in validation_loader:\n",
        "            z = model(x.view(-1, 28 * 28))\n",
        "            _, label=torch.max(z, 1)\n",
        "            correct += (label == y).sum().item()\n",
        "        accuracy = 100 * (correct / len(validation_dataset))\n",
        "        useful_stuff['validation_accuracy'].append(accuracy)\n",
        "\n",
        "    return useful_stuff"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 234,
      "metadata": {},
      "outputs": [],
      "source": [
        "train_dataset = dsets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())\n",
        "validation_dataset = dsets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 236,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create the training data loader and validation data loader object\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=2000, shuffle=True)\n",
        "validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=5000, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 237,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create the criterion function\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 238,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create the model object\n",
        "\n",
        "input_dim = 28 * 28\n",
        "hidden_dim = 100\n",
        "output_dim = 10\n",
        "\n",
        "model = Net(input_dim, hidden_dim, output_dim)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 239,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Train a model with sigmoid function\n",
        "\n",
        "learning_rate = 0.01\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "training_results = train(model, criterion, train_loader, validation_loader, optimizer, epochs=30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 240,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Train a model with Tanh function\n",
        "\n",
        "model_Tanh = NetTanh(input_dim, hidden_dim, output_dim)\n",
        "optimizer = torch.optim.SGD(model_Tanh.parameters(), lr=learning_rate)\n",
        "training_results_tanch = train(model_Tanh, criterion, train_loader, validation_loader, optimizer, epochs=30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 241,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Train a model with Relu function\n",
        "\n",
        "modelRelu = NetRelu(input_dim, hidden_dim, output_dim)\n",
        "optimizer = torch.optim.SGD(modelRelu.parameters(), lr=learning_rate)\n",
        "training_results_relu = train(modelRelu, criterion, train_loader, validation_loader, optimizer, epochs=30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 242,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Compare the training loss\n",
        "\n",
        "plt.plot(training_results_tanch['training_loss'], label='tanh')\n",
        "plt.plot(training_results['training_loss'], label='sigmoid')\n",
        "plt.plot(training_results_relu['training_loss'], label='relu')\n",
        "plt.ylabel('loss')\n",
        "plt.title('training loss iterations')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 243,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Compare the validation loss\n",
        "\n",
        "plt.plot(training_results_tanch['validation_accuracy'], label='tanh')\n",
        "plt.plot(training_results['validation_accuracy'], label='sigmoid')\n",
        "plt.plot(training_results_relu['validation_accuracy'], label='relu') \n",
        "plt.ylabel('validation accuracy')\n",
        "plt.xlabel('epochs ')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}