ff-mnist-fully-connected.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8c05389e",
   "metadata": {},
   "source": [
    "# Implementation of Hinton's Forward-Forward Algorithm on MNIST dataset using Fully Connected Layers\n",
    "\n",
    "This notebook contains an implementation of Geoffrey Hinton's Forward-Forward Algorithm. Details about this algorithm can be found in Hinton's [paper](https://arxiv.org/abs/2212.13345#:~:text=The%20Forward%2DForward%20algorithm%20replaces,generated%20by%20the%20network%20itself).\n",
    "\n",
    "Demonstrated below is 3.3. A simple supervised example of FF\n",
    "## Preparation:\n",
    "\n",
    "- **Import Libraries:** Set up the coding environment with the required libraries.\n",
    "\n",
    "## Definition of Necessary Functions and Classes:\n",
    "\n",
    "- **A. Function to Generate Negative Labels:** Generate negative samples for training.\n",
    "\n",
    "- **B. Function to Overlay Label onto the Input Data:** Overlay the correct class onto the input data for positive forward pass.\n",
    "\n",
    "- **C. Custom Net Class:** Definition of the network using the custom forward-forward approach.\n",
    "\n",
    "- **D. Custom Layer Class:** Definition of a custom layer class to be used in the network.\n",
    "\n",
    "- **E. Network Hyperparameters and Device Setup:** Set the hyperparameters for the network and configure the computation device.\n",
    "\n",
    "## Implementation Steps:\n",
    "\n",
    "- **1. Load Data:** Load the MNIST dataset for training and testing.\n",
    "\n",
    "- **2. Create Network:** Instantiate the network architecture.\n",
    "\n",
    "- **3. Train the Network:** Train the network using the forward-forward algorithm.\n",
    "\n",
    "- **4. Test the Network:** Test the network's performance on the MNIST test set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "095c14e9",
   "metadata": {},
   "source": [
    "### Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4a5d660a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import clear_output\n",
    "import torch \n",
    "import torch.nn as nn  \n",
    "from torchvision.datasets import MNIST \n",
    "from torchvision.transforms import Compose, ToTensor, Normalize, Lambda \n",
    "from torch.utils.data import DataLoader \n",
    "from torch.optim import Adam "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ddb1f7a",
   "metadata": {},
   "source": [
    "### A. Function to generate negative labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4cdefb0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generates negative labels for the training data, which are required for contrastive divergence training\n",
    "\n",
    "def get_y_neg(y):\n",
    "\n",
    "    # clone the original labels\n",
    "    y_neg = y.clone()\n",
    "\n",
    "    # loop through each sample in the labels\n",
    "    for idx, y_samp in enumerate(y):\n",
    "        \n",
    "        # create a list of all possible class labels\n",
    "        allowed_indices = list(range(10))\n",
    "\n",
    "        # remove the correct label from the list, leaving only incorrect labels\n",
    "        allowed_indices.remove(y_samp.item())\n",
    "\n",
    "        # assigning a random label from allowed_indices to y_neg[idx].\n",
    "        y_neg[idx] = torch.tensor(allowed_indices)[torch.randint(len(allowed_indices), size=(1,))].item()\n",
    "\n",
    "    # return the labels with incorrect class, moved to the specified device (CPU or GPU)\n",
    "    return y_neg.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eadc5f64",
   "metadata": {},
   "source": [
    "### B. Function to overlay label onto the input data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7e3647e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Overlays label info onto the input data, making a certain position in the tensor representative of the label\n",
    "\n",
    "def overlay_y_on_x(x, y, classes=10):\n",
    "    \n",
    "    # Create a copy of the input tensor x\n",
    "    x_ = x.clone()\n",
    "\n",
    "    # for all samples, set the first 10 column values to 0\n",
    "    x_[:, :classes] *= 0.0\n",
    "\n",
    "    # For each sample, set the feature at index corresponding to the class y to be the max value in x\n",
    "    x_[range(x.shape[0]), y] = x.max()\n",
    "\n",
    "    # Return the transformed tensor\n",
    "    return x_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58738dc6",
   "metadata": {},
   "source": [
    "### C. Custom Net Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "879c3966",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a Net class that inherits from torch.nn.Module which is the base class for all neural network modules in PyTorch.\n",
    "class Net(torch.nn.Module):\n",
    "\n",
    "    # Initialize the Net class with dimensions of the neural network layers\n",
    "    def __init__(self, dims):\n",
    "\n",
    "        # Initialize the parent class torch.nn.Module, Net is the subclass and torch.nn.Module is the parent class\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize an empty layers list that will store the layers of the neural network\n",
    "        self.layers = []\n",
    "\n",
    "        # Create the layers of the neural network\n",
    "        for d in range(len(dims) - 1):\n",
    "            \n",
    "            # Append a new layer to the layers list and move it to the appropriate device\n",
    "            self.layers = self.layers + [Layer(dims[d], dims[d + 1]).to(device)]\n",
    "\n",
    "    # Define a function to make predictions using the neural network\n",
    "    def predict(self, x):\n",
    "\n",
    "        # This list will store a measure of how much the input tensor x looks like each possible digit (from 0 to 9).\n",
    "        goodness_per_label = []\n",
    "\n",
    "        # For each possible label (0 to 9)\n",
    "        for label in range(10):\n",
    "\n",
    "            # Apply the label overlay to the input to make h tensor (50000, 784) of same size as x \n",
    "            h = overlay_y_on_x(x, label)\n",
    "\n",
    "            '''\n",
    "            h is 2D tensor of shape (10000, 784):\n",
    "\n",
    "            h = \n",
    "                tensor([[0.0, 0.0, ......., 0.7],   # sample 1\n",
    "                        [0.0, 0.0, ......., 0.6],   # sample 2\n",
    "                        [0.0, 0.0, ......., 0.7],   # sample 3\n",
    "                        [0.0, 1.0, ......., 0.7],   # sample 4\n",
    "                        [0.0, 0.0, ......., 0.7],   # sample 5\n",
    "                        ...\n",
    "                        [0.0, 0.0, ......., 0.7],   # sample 9,996\n",
    "                        [1.0, 0.0, ......., 0.7],   # sample 9,997\n",
    "                        [0.0, 0.0, ......., 0.7],   # sample 9,998\n",
    "                        [1.0, 0.0, ......., 0.7],   # sample 9,999\n",
    "                        [0.0, 1.0, ......., 0.7]])  # sample 10,000          \n",
    "                '''\n",
    "\n",
    "            # Create a list to store the goodness of each layer for this label\n",
    "            goodness = []\n",
    "\n",
    "            # Pass the input through each Layer class element in layers list. \n",
    "            for layer in self.layers:\n",
    "                \n",
    "                # Apply the current layer to the transformed input tensor h, and then stores the result back into h.\n",
    "                h = layer(h)\n",
    "\n",
    "                # after layer 1, h size: (10000, 500)\n",
    "                # after layer 2, h size: (10000, 500)\n",
    "\n",
    "                # Add the squared mean (mean along each rows) of the output of this layer to the goodness list\n",
    "                goodness = goodness + [h.pow(2).mean(1)]\n",
    "\n",
    "                '''\n",
    "                goodness_of_a_layer is 1D tensor of shape (50000,):\n",
    "\n",
    "                goodness_layer1 = [\n",
    "                    tensor([0.1, 0.2, ...................................., 0.1]),  # 10,000 mean squared activations for layer 1\n",
    "                ]\n",
    "                goodness_layer2 = [\n",
    "                    tensor([0.1, 0.2, ...................................., 0.1]),  # 10,000 mean squared activations for layer 2\n",
    "                ]\n",
    "                '''\n",
    "            \n",
    "                '''\n",
    "                goodness is a list of 1D tensors. list size is (50000,2):\n",
    "\n",
    "                goodness = [\n",
    "                    tensor([0.1, 0.2, ...................................., 0.1]),  # 10,000 mean squared activations for layer 1\n",
    "                    tensor([0.3, 0.2, ...................................., 0.2])   # 10,000 mean squared activations for layer 2\n",
    "                ]\n",
    "                '''\n",
    "\n",
    "            # Add the sum of the goodness of all layers for this label to the goodness_per_label list\n",
    "            goodness_per_label += [sum(goodness).unsqueeze(1)]\n",
    "\n",
    "            '''\n",
    "            sum(goodness) is 1D tensor of shape (10000,):\n",
    "\n",
    "            sum_of_goodness = tensor([0.4, 0.4, ...................................., 0.3]) # 10,000 sums of mean squared activations\n",
    "\n",
    "            sum(goodness).unsqueeze(1) then adds an extra dimension to this tensor, \n",
    "            It is 2D tensor of shape (10000, 1):\n",
    "\n",
    "            sum_of_goodness_unsqueezed = \n",
    "                tensor([[0.4], [0.4], ...................................., [0.3]])     \n",
    "            '''\n",
    "            \n",
    "            '''\n",
    "            This tensor is then added to the goodness_per_label list. For 10 lables, goodness_per_label might look something like this after 10 iterations:\n",
    "            \n",
    "            size of list is 10, each of 2D tensor shape (10000, 1):\n",
    "            goodness_per_label = [\n",
    "                tensor([[0.1], [0.5], ...................................., [0.6]]),   # sum of goodness for label 0\n",
    "                tensor([[0.6], [0.6], ...................................., [0.7]]),   # sum of goodness for label 1\n",
    "                tensor([[0.1], [0.6], ...................................., [0.7]]),   # sum of goodness for label 2\n",
    "                tensor([[0.2], [0.6], ...................................., [0.7]]),   # sum of goodness for label 3\n",
    "                tensor([[0.3], [0.6], ...................................., [0.7]]),   # sum of goodness for label 4\n",
    "                tensor([[0.2], [0.6], ...................................., [0.7]]),   # sum of goodness for label 5\n",
    "                tensor([[0.1], [0.6], ...................................., [0.7]]),   # sum of goodness for label 6\n",
    "                tensor([[0.7], [0.6], ...................................., [0.7]]),   # sum of goodness for label 7\n",
    "                tensor([[0.1], [0.6], ...................................., [0.7]]),   # sum of goodness for label 8\n",
    "                tensor([[0.3], [0.6], ...................................., [0.7]])    # sum of goodness for label 9\n",
    "            ]\n",
    "            \n",
    "            '''\n",
    "\n",
    "        # Concatenate all the goodness_per_label tensors along dimension 1\n",
    "        goodness_per_label = torch.cat(goodness_per_label, 1)\n",
    "\n",
    "        '''\n",
    "        tensor of shape (10000, 10):\n",
    "\n",
    "        goodness_per_label = \n",
    "            tensor([[0.6, 0.7, ..., 0.7],   # goodness for sample 1\n",
    "                    [0.5, 0.6, ..., 0.6],   # goodness for sample 2\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 3\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 4\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 5\n",
    "                    ...\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 9,996\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 9,997\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 9,998\n",
    "                    [0.7, 0.6, ..., 0.7],   # goodness for sample 9,999\n",
    "                    [0.6, 0.7, ..., 0.7]])  # goodness for sample 10,000\n",
    "                \n",
    "        '''\n",
    "\n",
    "        # Return the label with the highest goodness\n",
    "        return goodness_per_label.argmax(1)\n",
    "    \n",
    "        '''\n",
    "        return the indices of maximum values along dimension 1 (columns):\n",
    "        1D tensor of shape (10000,):\n",
    "\n",
    "        tensor([1, 9, ...................................., 1]) \n",
    "        '''\n",
    "\n",
    "    # Define a function to train the neural network\n",
    "    def train(self, x_pos, x_neg):\n",
    "\n",
    "        # Initialize the positive and negative inputs\n",
    "        h_pos, h_neg = x_pos, x_neg\n",
    "\n",
    "        # For each layer in the neural network\n",
    "        for i, layer in enumerate(self.layers):\n",
    "\n",
    "            # Print which layer is currently being trained\n",
    "            print(\"training layer: \", i)\n",
    "\n",
    "            # Train the layer using the positive and negative inputs\n",
    "            # layer.train() returns the positive and negative outputs of the layer which are 2d tensors of shape (50000, 500) for layer 1 and (50000, 500) for layer 2\n",
    "            h_pos, h_neg = layer.train(h_pos, h_neg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6bcfaa3",
   "metadata": {},
   "source": [
    "### D. Custom Layer Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "21e3ace7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Net is the main network and contains several instances of Layer, which represents individual layers of the network.\n",
    "class Layer(nn.Linear):\n",
    "\n",
    "    def __init__(self, in_features, out_features, bias=True, device=None, dtype=None):\n",
    "\n",
    "        # Initialize the parent class, torch.nn.Linear\n",
    "        super().__init__(in_features, out_features, bias, device, dtype)\n",
    "\n",
    "        # Define a ReLU (Rectified Linear Unit) activation function\n",
    "        self.relu = torch.nn.ReLU()\n",
    "\n",
    "        # Define an Adam optimizer for this layer, with the learning rate defined by args.lr\n",
    "        self.opt = Adam(self.parameters(), lr=args.lr)\n",
    "\n",
    "        '''\n",
    "        learning rate = 0.3\n",
    "        '''\n",
    "\n",
    "        # Define a threshold for the loss function, specified by args.threshold\n",
    "        self.threshold = args.threshold\n",
    "\n",
    "        '''\n",
    "        3\n",
    "        '''\n",
    "\n",
    "        # Define the number of training epochs for this layer, specified by args.epochs\n",
    "        self.num_epochs = args.epochs\n",
    "\n",
    "        '''\n",
    "        1000\n",
    "        '''\n",
    "\n",
    "    # Make each sample as unit magnitude then do A = X*W.T + B\n",
    "    def forward(self, x):\n",
    "\n",
    "        # Normalize the input tensor along each row\n",
    "        # Each row in x_direction is a unit vector in the direction of the corresponding row in x\n",
    "        x_direction = x / (x.norm(2, 1, keepdim=True) + 1e-4)\n",
    "\n",
    "        '''\n",
    "        x_direction is 2D tensor of shape (50000, 784):\n",
    "\n",
    "        x_direction = \n",
    "            tensor([[0.14, 0.25, ......., 0.09],   # sample 1\n",
    "                    [0.32, 0.51, ......., 0.72],   # sample 2\n",
    "                    [0.85, 0.17, ......., 0.37],   # sample 3\n",
    "                    [0.92, 0.45, ......., 0.88],   # sample 4\n",
    "                    [0.12, 0.93, ......., 0.76],   # sample 5\n",
    "                    ...\n",
    "                    [0.41, 0.18, ......., 0.14],   # sample 49,996\n",
    "                    [0.36, 0.74, ......., 0.59],   # sample 49,997\n",
    "                    [0.95, 0.21, ......., 0.86],   # sample 49,998\n",
    "                    [0.73, 0.41, ......., 0.32],   # sample 49,999\n",
    "                    [0.58, 0.66, ......., 0.09]])  # sample 50,000         \n",
    "            '''\n",
    "        \n",
    "        # Compute the linear transformation followed by a ReLU activation\n",
    "        # weight.T is 2D tensor of shape (784, 500)\n",
    "        return self.relu(torch.mm(x_direction, self.weight.T) + self.bias.unsqueeze(0))\n",
    "    \n",
    "        '''\n",
    "        weight is a 2D tensor of shape (500, 784):\n",
    "\n",
    "        weight = \n",
    "            tensor([[0.14, 0.25, ......., 0.09],   # node 1\n",
    "                    [0.32, 0.51, ......., 0.72],   # node 2\n",
    "                    [0.85, 0.17, ......., 0.37],   # node 3\n",
    "                    [0.92, 0.45, ......., 0.88],   # node 4\n",
    "                    [0.12, 0.93, ......., 0.76],   # node 5\n",
    "                    ...\n",
    "                    [0.41, 0.18, ......., 0.14],   # node 496\n",
    "                    [0.36, 0.74, ......., 0.59],   # node 497\n",
    "                    [0.95, 0.21, ......., 0.86],   # node 498\n",
    "                    [0.73, 0.41, ......., 0.32],   # node 499\n",
    "                    [0.58, 0.66, ......., 0.09]])  # node 500\n",
    "\n",
    "        bias is a 1D tensor of shape (500,):\n",
    "\n",
    "        bias = tensor([0.1, 0.2, 0.3, ..., 0.498, 0.499, 0.500])\n",
    "\n",
    "        bias.unsqueeze(0) is a 2D tensor of shape (1,500)\n",
    "\n",
    "        bias_unsqueezed = tensor([[0.1, 0.2, 0.3, ..., 0.498, 0.499, 0.500]])\n",
    "        '''\n",
    "\n",
    "    # train a layer\n",
    "    def train(self, x_pos, x_neg):\n",
    "        \n",
    "        # initialize lists to hold values\n",
    "        loss_values = []\n",
    "        g_pos_values = []\n",
    "        g_neg_values = []\n",
    "\n",
    "        # initialize figure\n",
    "        fig = plt.figure(figsize=(12,8))\n",
    "\n",
    "        # For each layer epoch \n",
    "        for i in range(self.num_epochs):\n",
    "\n",
    "            # Compute the goodness for the positive and negative samples\n",
    "            g_pos = self.forward(x_pos).pow(2).mean(1)\n",
    "\n",
    "            '''\n",
    "            g_pos is 1D tensor of shape (50000,):\n",
    "            g_pos = tensor([0.7, 0.9, ...................................., 0.8])\n",
    "\n",
    "            '''\n",
    "            g_neg = self.forward(x_neg).pow(2).mean(1)\n",
    "\n",
    "            '''\n",
    "            g_neg is 1D tensor of shape (50000,):\n",
    "            g_neg = tensor([0.1, 0.2, ...................................., 0.1])\n",
    "\n",
    "            '''\n",
    "            \n",
    "            # Compute the loss using the computed goodness and the specified threshold\n",
    "            loss = torch.log(1 + torch.exp(torch.cat([-g_pos + self.threshold, g_neg - self.threshold]))).mean()\n",
    "\n",
    "            '''\n",
    "            torch.cat([-g_pos + self.threshold, g_neg - self.threshold]) \n",
    "            is 1D tensor of shape (100000,)\n",
    "\n",
    "            torch.exp(torch.cat([-g_pos + self.threshold, g_neg - self.threshold])) \n",
    "            to ensure that all values are positive and to increase the difference between larger and smaller values\n",
    "            is 1D tensor of shape (100000,)\n",
    "\n",
    "            '1 + ...' adds 1 to each of these exponential scores. This ensures that even if all the scores are zero, the loss will not be negative.\n",
    "            still a 1D tensor of shape (100000,)\n",
    "\n",
    "            log()\n",
    "            still a 1D tensor of shape (100000,)\n",
    "\n",
    "            .mean() to take avg of all 100000 values\n",
    "            loss is scalar\n",
    "\n",
    "            '''\n",
    "\n",
    "            # Zero the gradients\n",
    "            self.opt.zero_grad()\n",
    "\n",
    "            '''\n",
    "            After self.opt.zero_grad() is called: The gradients of weights and biases are now zero\n",
    "\n",
    "            weight is a 2D tensor of shape (500, 784) for layer 1 and (500,500) for layer 2:\n",
    "\n",
    "            self.weight.grad = tensor([[0.00, 0.00, ...., 0.00],   # node 1\n",
    "                                       [0.00, 0.00, ...., 0.00],   # node 2\n",
    "                                       ...\n",
    "                                       [0.00, 0.00, ...., 0.00],   # node 499\n",
    "                                       [0.00, 0.00, ...., 0.00]])  # node 500\n",
    "\n",
    "            bias is a 1D tensor of shape (500,) for layer 1 and (500,) for layer 2:\n",
    "\n",
    "            self.bias.grad = tensor([0.00, 0.00, ..., 0.00, 0.00]) \n",
    "            \n",
    "            '''\n",
    "\n",
    "            # Compute the backward pass\n",
    "            loss.backward()\n",
    "\n",
    "            '''\n",
    "            Assume the gradients of weights and biases after backpropagation are:\n",
    "\n",
    "            weight is a 2D tensor of shape (500, 784) for layer 1 and (500,500) for layer 2:\n",
    "            \n",
    "            self.weight.grad = tensor([[0.01, 0.02, ...., 0.02],   # node 1\n",
    "                                       [0.03, 0.01, ...., 0.01],   # node 2\n",
    "                                       ...\n",
    "                                       [0.01, 0.02, ...., 0.03],   # node 499\n",
    "                                       [0.02, 0.01, ...., 0.01]])  # node 500\n",
    "\n",
    "            bias is a 1D tensor of shape (500,) for layer 1 and (500,) for layer 2:\n",
    "\n",
    "            self.bias.grad = tensor([0.01, 0.02, ..., 0.02, 0.01])  \n",
    "            \n",
    "            '''\n",
    "\n",
    "            # Perform a step of optimization\n",
    "            self.opt.step()\n",
    "\n",
    "            '''\n",
    "            After opt.step(): weight and bias has been updated\n",
    "\n",
    "            weight is a 2D tensor of shape (500, 784) for layer 1 and (500, 500) for layer 2:\n",
    "            weight = \n",
    "                tensor([[0.13, 0.26, ......., 0.08],   # node 1\n",
    "                        [0.31, 0.52, ......., 0.73],   # node 2\n",
    "                        [0.86, 0.16, ......., 0.38],   # node 3\n",
    "                        [0.93, 0.44, ......., 0.89],   # node 4\n",
    "                        [0.11, 0.94, ......., 0.75],   # node 5\n",
    "                        ...\n",
    "                        [0.42, 0.17, ......., 0.13],   # node 496\n",
    "                        [0.35, 0.75, ......., 0.58],   # node 497\n",
    "                        [0.96, 0.20, ......., 0.87],   # node 498\n",
    "                        [0.74, 0.42, ......., 0.33],   # node 499\n",
    "                        [0.59, 0.65, ......., 0.10]])  # node 500\n",
    "\n",
    "            bias is a 1D tensor of shape (500,) for layer 1 and (500,) for layer 2:\n",
    "\n",
    "            bias = \n",
    "                tensor([0.099, 0.201, 0.298, ..., 0.498, 0.501, 0.500])\n",
    "            '''\n",
    "\n",
    "            if i % args.log_interval == 0:\n",
    "                loss_values.append(loss.item())\n",
    "                g_pos_values.append(g_pos.mean().item())  # take mean of all batch values\n",
    "                g_neg_values.append(g_neg.mean().item())  # take mean of all batch values\n",
    "\n",
    "                # plotting\n",
    "                plt.subplot(3,1,1)\n",
    "                plt.plot(loss_values, color='blue')\n",
    "                plt.title(\"Loss during training\")\n",
    "\n",
    "                plt.subplot(3,1,2)\n",
    "                plt.plot(g_pos_values, color='green')\n",
    "                plt.title(\"g_pos during training\")\n",
    "\n",
    "                plt.subplot(3,1,3)\n",
    "                plt.plot(g_neg_values, color='red')\n",
    "                plt.title(\"g_neg during training\")\n",
    "\n",
    "                plt.tight_layout()\n",
    "                clear_output(wait=True)  # this clears the output of the cell, useful for updating the plots\n",
    "                plt.show()\n",
    "\n",
    "            # Print the loss at each step\n",
    "            print(f'Loss at step {i}: {loss.item()}')\n",
    "\n",
    "        # compute the output of the layer (A) for both positive and negative samples\n",
    "        return self.forward(x_pos).detach(), self.forward(x_neg).detach()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae11a7b4",
   "metadata": {},
   "source": [
    "### E. Network Hyperparameters and device setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "35d91f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Args:\n",
    "    train_size = 50000\n",
    "    test_size = 10000\n",
    "    epochs = 1000\n",
    "    lr = 0.05\n",
    "    no_cuda = False\n",
    "    no_mps = False\n",
    "    save_model = False \n",
    "    threshold = 0\n",
    "    seed = 1234\n",
    "    log_interval = 10\n",
    "    \n",
    "args = Args()\n",
    "\n",
    "use_cuda = not args.no_cuda and torch.cuda.is_available()\n",
    "use_mps = not args.no_mps and torch.backends.mps.is_available()\n",
    "\n",
    "if use_cuda:\n",
    "    device = torch.device(\"cuda\")\n",
    "elif use_mps:\n",
    "    device = torch.device(\"mps\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "\n",
    "train_kwargs = {\"batch_size\": args.train_size} # dictionary specifying train batch size\n",
    "test_kwargs = {\"batch_size\": args.test_size} # dictionary specifying test batch size\n",
    "\n",
    "# If CUDA is available\n",
    "if use_cuda:\n",
    "    cuda_kwargs = {\"num_workers\": 1, \"pin_memory\": True, \"shuffle\": True}\n",
    "    train_kwargs.update(cuda_kwargs)\n",
    "    test_kwargs.update(cuda_kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c16d01f",
   "metadata": {},
   "source": [
    "### 1. Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6cc415cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1) Converted to a tensor. MNIST are PIL images, so convert them to tensors to use with PyTorch\n",
    "# 2) Normalized for the MNIST dataset\n",
    "# 3) Flattened to a 1D tensor of 784 elements (28x28 pixels)\n",
    "transform = Compose( \n",
    "    [\n",
    "        ToTensor(),                                                                   \n",
    "        Normalize((0.1307,), (0.3081,)),       \n",
    "        Lambda(lambda x: torch.flatten(x)),    \n",
    "    ]\n",
    ")\n",
    "\n",
    "# Create train and test DataLoader instances using the MNIST dataset\n",
    "train_loader = DataLoader(MNIST(\"./data/\", train=True, download=True, transform=transform), **train_kwargs) \n",
    "test_loader = DataLoader(MNIST(\"./data/\", train=False, download=True, transform=transform), **test_kwargs) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c4ce8d3",
   "metadata": {},
   "source": [
    "### 2. Create network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4658e5d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an instance of Net class with an input dim of 784 neurons to match the flattened 28x28 pixel MNIST images\n",
    "# and two intermediate dims of 500 each. 3 dims so we will have a 2 layer network.\n",
    "net =  Net([784, 2000, 2000, 2000, 2000])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "521e97e5",
   "metadata": {},
   "source": [
    "### 3. Train the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ec0910f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# x is a 2D tensor of size (batch_size, 784) and y is a 1D tensor of size (batch_size,).\n",
    "x, y = next(iter(train_loader))\n",
    "\n",
    "# Move the input data and labels to the specified device (CPU or GPU).\n",
    "x, y = x.to(device), y.to(device)\n",
    "\n",
    "# overlay_y_on_x() function returns a 2D tensor of size (batch_size, 784)\n",
    "x_pos = overlay_y_on_x(x, y)\n",
    "\n",
    "# get_y_neg() function returns a 1D tensor of size (batch_size,) with the negative labels.\n",
    "y_neg = get_y_neg(y)\n",
    "\n",
    "# overlay_y_on_x() function returns a 2D tensor of size (batch_size, 784)\n",
    "x_neg = overlay_y_on_x(x, y_neg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "de4d7619",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAC6CAYAAAAzgU7DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAYzElEQVR4nO3deXRU5f3H8c+YZEISkkjCkpTIIm3BKhAWAQkILggkUAQiIAgYaqGiPSCoHARZhMpywKKUYLEQQkE2Uda6QAMclaElInCKPa2cghKUHZQ1hPD8/uCXkfFOSIKBZPK8X+fkj3znmXufmXy9frjz3DsuY4wRAACw1m1lPQEAAFC2CAMAAFiOMAAAgOUIAwAAWI4wAACA5QgDAABYjjAAAIDlCAMAAFiOMAAAgOUqbBjYvn27HnvsMcXHx8vtdisuLk6pqanyeDzF3saECRPkcrluaP9btmyRy+XSli1bbuj5xdW+fXu1b9/+pu4Dt8bChQvlcrm8P8HBwUpISFBaWpoOHTpU6vtzuVyaMGGC9/cvvvhCEyZM0IEDBxxjn3zySdWpU6fU54DAU9CnlSpV0ldffeV4vH379rrnnnvKYGZOr776qlavXu2o36rjcyCpkGFg9uzZSkpKUk5OjqZPn65NmzZpxowZOnTokNq0aaM//elPxdrOU089VaLwcK2mTZvK4/GoadOmN/R82CsjI0Mej0cbN27Ub3/7Wy1dulRt27bVuXPnSnU/Ho9HTz31lPf3L774QhMnTvQbBl5++WW99957pbp/BLbc3FyNHTu2rKdxXYWFAY7PTsFlPYHS9umnn2r48OFKTk7We++9p+DgH15inz591L17dw0bNkxNmjRRUlKS322cP39e4eHhSkhIUEJCwg3NIyoqSq1atbqh58Ju99xzj5o3by5JeuCBB5Sfn69JkyZp9erV6tevX6ntpyT9Wa9evVLbLyqGTp066e2339bzzz+vxo0bl/V0SoTjs1OFOzMwZcoUuVwuzZ071ycISFJwcLDS09Plcrk0depUST98FLBz506lpqaqSpUq3gOfv48JcnNzNXLkSMXFxSk8PFz333+/PvvsM9WpU0dPPvmkd5y/01BPPvmkKleurH379ik5OVmVK1fWHXfcoZEjRyo3N9dnPxMnTlTLli0VExOjqKgoNW3aVPPnzxffK2WfgoPWV199pYsXL2r06NGqW7eu3G63atasqWeeeUanT5/2eU5WVpbat2+v2NhYhYWFqVatWurZs6fOnz/vHXPtxwQLFy7UY489JulqACn4qGLhwoWSnB8TNGnSRG3btnXMNT8/XzVr1lSPHj28tUuXLmny5Mlq0KCBQkNDVa1aNaWlpenYsWOl8O6grLz44ouKjY3VqFGjrjvOGKP09HQlJiYqLCxMVapUUWpqqv73v/85xr366quqXbu2KlWqpObNm2vjxo2Oj0IvXryokSNHKjExUdHR0YqJidF9992nNWvW+GzP5XLp3LlzyszM9PZzwXZ+fHyeNWuWXC6X9u3b55j/qFGj5Ha7dfz4cW9t06ZNeuihhxQVFaXw8HAlJSXp73//ewnevfKnQoWB/Px8bd68Wc2bNy/0X/R33HGHmjVrpqysLOXn53vrPXr00M9//nOtXLlSb775ZqH7SEtL06xZs5SWlqY1a9aoZ8+e6t69u+NgXJi8vDz9+te/1kMPPaQ1a9Zo0KBB+uMf/6hp06b5jDtw4ICGDBmiFStW6N1331WPHj30+9//XpMmTSrWflBxFBygqlWrpkcffVQzZsxQ//79tWHDBo0YMUKZmZl68MEHvYHywIEDSklJkdvt1oIFC/TBBx9o6tSpioiI0KVLl/zuIyUlRa+++qokac6cOfJ4PPJ4PEpJSfE7Pi0tTZ988om+/PJLn/pHH32kb775RmlpaZKkK1euqFu3bpo6dar69u2rDRs2aOrUqd6D/IULF0rlPcKtFxkZqbFjx+rDDz9UVlZWoeOGDBmi4cOH6+GHH9bq1auVnp6uvXv3qnXr1jpy5Ih33JgxYzRmzBh16tRJa9as0e9+9zs99dRT+u9//+uzvdzcXJ08eVLPP/+8Vq9eraVLl6pNmzbq0aOHFi1a5B3n8XgUFham5ORkbz+np6f7neMTTzwht9vtDb8F8vPztXjxYnXt2lVVq1aVJC1evFiPPPKIoqKilJmZqRUrVigmJkYdO3YM7EBgKpDDhw8bSaZPnz7XHde7d28jyRw5csSMHz/eSDLjxo1zjCt4rMDevXuNJDNq1CifcUuXLjWSzMCBA721zZs3G0lm8+bN3trAgQONJLNixQqf5ycnJ5v69esXOt/8/HyTl5dnXnnlFRMbG2uuXLnifaxdu3amXbt21329CAwZGRlGktm+fbvJy8szZ86cMevXrzfVqlUzkZGRZtmyZUaSmT59us/zli9fbiSZefPmGWOMeeedd4wks2vXruvuT5IZP3689/eVK1c6erbAwIEDTe3atb2/Hz9+3LjdbvPSSy/5jOvVq5epUaOGycvLM8b88N/GqlWrfMbt2LHDSDLp6elFvS0oZwr6dMeOHSY3N9fceeedpnnz5t7jUrt27czdd99tjDHG4/EYSWbmzJk+2zh48KAJCwszL774ojHGmJMnT5rQ0FDTu3dvn3EFz7/eMe7y5csmLy/P/OY3vzFNmjTxeSwiIsLnuFzA3/G5R48eJiEhweTn53trf/vb34wks27dOmOMMefOnTMxMTGma9euPtvLz883jRs3Ni1atCh0nuVdhTozUFzm/0+1X/sRQM+ePYt83tatWyVJvXr18qmnpqY6PpIojMvlUteuXX1qjRo1cqzKzcrK0sMPP6zo6GgFBQUpJCRE48aN04kTJ3T06NFi7QuBqVWrVgoJCVFkZKS6dOmiuLg4vf/++9q5c6ck+XwcJUmPPfaYIiIivP8qSUxMlNvt1uDBg5WZmek4HVsaYmNj1bVrV2VmZurKlSuSpFOnTmnNmjUaMGCA97+H9evX6/bbb1fXrl11+fJl709iYqLi4uJYzR3g3G63Jk+erOzsbK1YscLx+Pr16+VyufTEE0/4/P3j4uLUuHFj799/+/btys3NdRxbW7Vq5fcqlpUrVyopKUmVK1dWcHCwQkJCNH/+fP373/++4deSlpamnJwcbdq0yVvLyMhQXFycOnfuLEnatm2bTp48qYEDB/q8nitXrqhTp07asWNHqS/0vVUqVBioWrWqwsPDtX///uuOO3DggMLDwxUTE+OtxcfHF7n9EydOSJJq1KjhUw8ODlZsbGyx5hgeHq5KlSr51EJDQ3Xx4kXv7//85z/1yCOPSJLeeustffrpp9qxY4fGjBkjSZxareAWLVqkHTt26PPPP9c333yjPXv2KCkpSSdOnFBwcLCqVavmM97lcikuLs7bn/Xq1dOmTZtUvXp1PfPMM6pXr57q1aun119/vVTnOWjQIB06dEgbN26UJC1dulS5ubk+YeXIkSM6ffq03G63QkJCfH4OHz7s8zksAlOfPn3UtGlTjRkzRnl5eT6PHTlyRMYY1ahRw/H33759u/fvX9ix1V/t3XffVa9evVSzZk0tXrxYHo9HO3bs0KBBg3yOoyXVuXNnxcfHKyMjQ9LVcLt27VoNGDBAQUFB3tcjXf0H4I9fz7Rp02SM0cmTJ294DmWpQl1NEBQUpAceeEAffPCBcnJy/K4byMnJ0WeffabOnTt7/8CSinU/gYL/4R85ckQ1a9b01i9fvuxt5tKwbNkyhYSEaP369T7Bwd8lMqh47rrrLu/VBNeKjY3V5cuXdezYMZ9AYIzR4cOHde+993prbdu2Vdu2bZWfn6/s7GzNnj1bw4cPV40aNdSnT59SmWfHjh31s5/9TBkZGerYsaMyMjLUsmVL/epXv/KOqVq1qmJjY/XBBx/43UZkZGSpzAVlx+Vyadq0aerQoYPmzZvn81jVqlXlcrn08ccfKzQ01PHcgtq1x9YfO3z4sM/ZgcWLF6tu3bpavny5z3H7x4uwSyooKEj9+/fXG2+8odOnT+vtt99Wbm6ud/1LweuRrl6+XtjVCP4CTSCoUGcGJGn06NEyxmjo0KE+CwSlq4tBnn76aRljNHr06BJv+/7775ckLV++3Kf+zjvv6PLlyzc+6R8puOHMtWHlwoUL+utf/1pq+0DgeeihhyRdPRhea9WqVTp37pz38WsFBQWpZcuWmjNnjiR5P2rwp+DAXNwzTwUHz9WrV+vjjz9Wdna2Bg0a5DOmS5cuOnHihPLz89W8eXPHT/369Yu1L5RvDz/8sDp06KBXXnlFZ8+e9da7dOkiY4wOHTrk9+/fsGFDSVLLli0VGhrqOLZu377d8RGqy+WS2+32CQKHDx92XE0gXe3pkpxJTUtL08WLF7V06VItXLhQ9913nxo0aOB9PCkpSbfffru++OILv6+nefPmcrvdxd5feVKhzgxIV/9Ys2bN0vDhw9WmTRs9++yzqlWrlr7++mvNmTNH//jHPzRr1iy1bt26xNu+++679fjjj2vmzJkKCgrSgw8+qL1792rmzJmKjo7WbbeVTrZKSUnRa6+9pr59+2rw4ME6ceKEZsyY4TdZwx4dOnRQx44dNWrUKH3//fdKSkrSnj17NH78eDVp0kT9+/eXJL355pvKyspSSkqKatWqpYsXL2rBggWSrh60C1Nw17h58+YpMjJSlSpVUt26da/7EdigQYM0bdo09e3bV2FhYerdu7fP43369NGSJUuUnJysYcOGqUWLFgoJCVFOTo42b96sbt26qXv37j/1rUE5MG3aNDVr1kxHjx7V3XffLenq8Xjw4MFKS0tTdna27r//fkVEROjbb7/VJ598ooYNG+rpp59WTEyMRowYoSlTpqhKlSrq3r27cnJyNHHiRMXHx/scW7t06aJ3331XQ4cOVWpqqg4ePKhJkyYpPj7ecXVLw4YNtWXLFq1bt07x8fGKjIy8bgBt0KCB7rvvPk2ZMkUHDx50nOmoXLmyZs+erYEDB+rkyZNKTU1V9erVdezYMe3evVvHjh3T3LlzS/FdvYXKcPHiTeXxeExqaqqpUaOGCQ4ONtWrVzc9evQw27Zt8xlXcMXAsWPHHNv48dUExhhz8eJFM2LECFO9enVTqVIl06pVK+PxeEx0dLR57rnnvOMKu5ogIiKiWPtZsGCBqV+/vgkNDTV33nmnmTJlipk/f76RZPbv3+8dx9UEFce1q7QLc+HCBTNq1ChTu3ZtExISYuLj483TTz9tTp065R3j8XhM9+7dTe3atU1oaKiJjY017dq1M2vXrvXZln50NYExxsyaNcvUrVvXBAUFGUkmIyPDGOO8muBarVu3NpJMv379/D6el5dnZsyYYRo3bmwqVapkKleubBo0aGCGDBlivvzyyyLfF5Qv1+vTvn37GkneqwkKLFiwwLRs2dJERESYsLAwU69ePTNgwACTnZ3tHXPlyhUzefJkk5CQYNxut2nUqJFZv369ady4senevbvP9qZOnWrq1KljQkNDzV133WXeeustv8fRXbt2maSkJBMeHu5zVYK/43OBefPmGUkmLCzMfPfdd37fg61bt5qUlBQTExNjQkJCTM2aNU1KSopZuXJlcd7CcsllDHex+am2bdumpKQkLVmyRH379i3r6QBAhbB//341aNBA48eP10svvVTW06nQCAMltHHjRnk8HjVr1kxhYWHavXu3pk6dqujoaO3Zs8dxpQAAoGi7d+/W0qVL1bp1a0VFRek///mPpk+fru+//17/+te/AnZhXqCocGsGbraoqCh99NFHmjVrls6cOaOqVauqc+fOmjJlCkEAAG5QRESEsrOzNX/+fJ0+fVrR0dFq3769/vCHPxAEbgHODAAAYLkKd2khAAAoGcIAAACWIwwAAGA5wgAAAJYr9tUExbl3P1CU8rJetW7dumU9hRt24MCBsp6Clcqid4vbp4V9OVt563N6t2wUp3c5MwAAgOUIAwAAWI4wAACA5QgDAABYrth3IGQBIUpDWSzCondRGuhdBCoWEAIAgCIRBgAAsBxhAAAAyxEGAACwHGEAAADLEQYAALAcYQAAAMsRBgAAsBxhAAAAyxEGAACwHGEAAADLEQYAALAcYQAAAMsRBgAAsBxhAAAAywWX9QQqumbNmjlqzz77rN+xAwYMcNQWLVrkqM2ePdtR27lz5w3MDigcvYtARe+WHGcGAACwHGEAAADLEQYAALAcYQAAAMu5jDGmWANdrps9l4CXmJjoqGVlZTlqUVFRP2k/3333naMWGxv7k7Z5qxSz3UoVvVs0erdo9G75RO8WrTi9y5kBAAAsRxgAAMByhAEAACxHGAAAwHLcgfAGtWjRwlFbtWqVoxYdHe2oFbaY48yZM47apUuXHDV/i1ZatWrlqBV2dyx/24Q96F0EKnr35uHMAAAAliMMAABgOcIAAACWIwwAAGA57kB4jfDwcL/1pk2bOmqLFy921BISEhw1f+9bYW+5v4Un06dPd9SWLVtWrP2MHTvW736mTJnit34rcBe3m4Pevfno3ZuD3r35uAMhAAAoEmEAAADLEQYAALAcYQAAAMsRBgAAsBy3I77Gn//8Z7/1xx9//Jbs39/q2cqVKztqW7duddTat2/vqDVq1KhU5oXyj95FoKJ3ywfODAAAYDnCAAAAliMMAABgOcIAAACWs3YBYbNmzRy1lJQUv2OLe0tQfwtM1q1b56jNmDHD7/O/+eYbR+3zzz931E6dOuWoPfjgg46aDbcytRG9i0BF75ZfnBkAAMByhAEAACxHGAAAwHKEAQAALOcyxfyS7kBdFCFJiYmJjlpWVpajFhUVVextvv/++46avztmtWvXzlEr7A5Vf/nLXxy1Y8eOFWs++fn5jtr58+f9jvU3J3/f6X0z8J3wJUPvFj0nerd8oneLnlN56l3ODAAAYDnCAAAAliMMAABgOcIAAACWq3B3IPzlL3/pqL3wwguOWnR0tKN2/Phxv9v89ttvHbXMzExH7ezZs47ahg0bilW7GcLCwvzWR44c6aj169fvZk8HRaB3f0DvBhZ69weB2rucGQAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByAXs1QWhoqN+6v++sTk5OdtTOnDnjqA0YMMDvNrOzsx21wlaMBoJatWqV9RSsRu/eOHq3bNG7N6689y5nBgAAsBxhAAAAyxEGAACwHGEAAADLBewCwiZNmvit+1u04k+3bt0cta1bt/6kOQHFQe8iUNG7FRdnBgAAsBxhAAAAyxEGAACwHGEAAADLBewCwtdee81v3eVyOWr+FqhUtEUrt93mzHVXrlwpg5mgKPSuL3o3cNC7vipS73JmAAAAyxEGAACwHGEAAADLEQYAALBcQCwg7NKli6OWmJjod6wxxlFbu3ZtaU+p3PG3aMXfeyFJu3btusmzQQF6t2j0bvlE7xatIvUuZwYAALAcYQAAAMsRBgAAsBxhAAAAywXEAsKwsDBHze12+x179OhRR2358uWlPqdbJTQ01FGbMGFCsZ6blZXltz569OifMiWUAL3ri94NHPSur4reu5wZAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHIBcTVBSeTm5jpq3377bRnMpOT8rWAdO3aso/bCCy84ajk5OY7azJkz/e7n7NmzNzA73Gz07g/o3cBC7/4gUHuXMwMAAFiOMAAAgOUIAwAAWI4wAACA5SrcAsJA+A7twr4T3N8Cld69eztqa9ascdR69uz5k+eFskXvIlDRu4GPMwMAAFiOMAAAgOUIAwAAWI4wAACA5QJiAaHL5SpWTZIeffRRR23YsGGlPaVie+655xy1l19+2e/Y6OhoR23JkiWO2oABA376xHBL0Lu+6N3AQe/6qui9y5kBAAAsRxgAAMByhAEAACxHGAAAwHIBsYDQGFOsmiTFxcU5am+88YajtmDBAkftxIkTfrfZqlUrR61///6OWuPGjR21hIQER+3rr7/2u58PP/zQUUtPT/c7FoGB3kWgonftwpkBAAAsRxgAAMByhAEAACxHGAAAwHIBsYCwJIKCghy1oUOHOmr+vnry+++/97vNX/ziFzc8n23btjlqmzdv9jt23LhxN7wfBD56F4GK3g18nBkAAMByhAEAACxHGAAAwHKEAQAALEcYAADAci5T2P0lfzywkO+xvhX83Vpy5cqVfsfee++9xdqmv9dTzLdCkv9baC5btsxRK8vv9C6PSvIelxZ61xe9e2PoXXo3UBXnPebMAAAAliMMAABgOcIAAACWIwwAAGC5gFhA6E98fLzf+pAhQxy1sWPHOmolWcjy+uuvO2pz58511Pbt2+f3+fiBbYuw/KF3AxO9S+8GKhYQAgCAIhEGAACwHGEAAADLEQYAALBcwC4gRGBiERYCFb2LQMUCQgAAUCTCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAlnMZY0xZTwIAAJQdzgwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYLn/A3pCT7xoLMCaAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert the tensors back to numpy arrays for plotting\n",
    "x_np = x.cpu().numpy()\n",
    "x_pos_np = x_pos.cpu().numpy()\n",
    "x_neg_np = x_neg.cpu().numpy()\n",
    "\n",
    "# Reshape the images from 784 to 28x28 if necessary\n",
    "x_np = x_np.reshape(-1, 28, 28)\n",
    "x_pos_np = x_pos_np.reshape(-1, 28, 28)\n",
    "x_neg_np = x_neg_np.reshape(-1, 28, 28)\n",
    "\n",
    "# Plot 5 samples\n",
    "for i in range(5):\n",
    "    fig, axs = plt.subplots(1, 3)\n",
    "    \n",
    "    # Original images\n",
    "    axs[0].imshow(x_np[i], cmap='gray')\n",
    "    axs[0].set_title('Original')\n",
    "    axs[0].axis('off')\n",
    "\n",
    "    # Positive images\n",
    "    axs[1].imshow(x_pos_np[i], cmap='gray')\n",
    "    axs[1].set_title('Positive')\n",
    "    axs[1].axis('off')\n",
    "\n",
    "    # Negative images\n",
    "    axs[2].imshow(x_neg_np[i], cmap='gray')\n",
    "    axs[2].set_title('Negative')\n",
    "    axs[2].axis('off')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b04e982e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss at step 990: 0.4747256934642792\n",
      "Loss at step 991: 0.47471755743026733\n",
      "Loss at step 992: 0.4747093617916107\n",
      "Loss at step 993: 0.4747011959552765\n",
      "Loss at step 994: 0.47469303011894226\n",
      "Loss at step 995: 0.4746849238872528\n",
      "Loss at step 996: 0.47467678785324097\n",
      "Loss at step 997: 0.47466862201690674\n",
      "Loss at step 998: 0.4746604859828949\n",
      "Loss at step 999: 0.47465240955352783\n"
     ]
    }
   ],
   "source": [
    "# Train the network with the positive and negative examples.\n",
    "net.train(x_pos, x_neg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d89a4b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 93.29%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nnet.predict(x) = tensor([0, 9, 7, ...., 8, 7, 4])\\n\\nsay Actual labels are y = tensor([0, 9, 1, ...., 8, 1, 5])])\\n\\nnet.predict(x).eq(y) = tensor([True, True, False, ...., True, False, False])\\n\\nTrue becomes 1.0 and False becomes 0.0.\\nnet.predict(x).eq(y).float() = tensor([1.0, 1.0, 0.0, ...., 1.0, 0.0, 0.0])\\n\\nTake average of the tensor\\nnet.predict(x).eq(y).float().mean() = tensor([0.6667])\\n\\nError rate = 1 - accuracy\\n1 - net.predict(x).eq(y).float().mean().item() = 1 - 0.6667 \\n'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict the labels for the training data, compare them to the actual labels, and calculate the error rate.\n",
    "#print(\"train error:\", 1.0 - net.predict(x).eq(y).float().mean().item())\n",
    "print(\"Train Accuracy: {:.2f}%\".format(100 * net.predict(x).eq(y).float().mean().item()))\n",
    "\n",
    "'''\n",
    "net.predict(x) = tensor([0, 9, 7, ...., 8, 7, 4])\n",
    "\n",
    "say Actual labels are y = tensor([0, 9, 1, ...., 8, 1, 5])])\n",
    "\n",
    "net.predict(x).eq(y) = tensor([True, True, False, ...., True, False, False])\n",
    "\n",
    "True becomes 1.0 and False becomes 0.0.\n",
    "net.predict(x).eq(y).float() = tensor([1.0, 1.0, 0.0, ...., 1.0, 0.0, 0.0])\n",
    "\n",
    "Take average of the tensor\n",
    "net.predict(x).eq(y).float().mean() = tensor([0.6667])\n",
    "\n",
    "Error rate = 1 - accuracy\n",
    "1 - net.predict(x).eq(y).float().mean().item() = 1 - 0.6667 \n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d255817d",
   "metadata": {},
   "source": [
    "### 4. Test the Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "389d35f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 93.18%\n"
     ]
    }
   ],
   "source": [
    "# Fetch one batch of the test data.\n",
    "x_te, y_te = next(iter(test_loader))\n",
    "\n",
    "# Move the test data and labels to the specified device (CPU or GPU).\n",
    "x_te, y_te = x_te.to(device), y_te.to(device)\n",
    "\n",
    "# If the 'save_model' argument is true, save the current state of the trained network.\n",
    "if args.save_model:\n",
    "    torch.save(net.state_dict(), \"mnist_ff.pt\")\n",
    "\n",
    "# Predict the labels for the test data, compare them to the actual labels, and calculate the error rate.\n",
    "#print(\"test error:\", 1.0 - net.predict(x_te).eq(y_te).float().mean().item())\n",
    "print(\"Test Accuracy: {:.2f}%\".format(100 * net.predict(x_te).eq(y_te).float().mean().item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68c820e7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10 (tensorflow)",
   "language": "python",
   "name": "tensorflow"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}