NeuralNetworksFromScratchwithRegularization (1).ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "b6078e50-8791-4818-891a-edaa3045a44e",
      "metadata": {
        "id": "b6078e50-8791-4818-891a-edaa3045a44e",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.datasets import mnist"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "5bee2ac1-7383-4cc9-9fcd-007c67373c5f",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5bee2ac1-7383-4cc9-9fcd-007c67373c5f",
        "outputId": "6accc4ed-5227-403b-aeb9-e3d0d9a5676f"
      },
      "outputs": [],
      "source": [
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "1c114fbe-a575-42a7-97ab-9f83a10e1f76",
      "metadata": {
        "id": "1c114fbe-a575-42a7-97ab-9f83a10e1f76"
      },
      "outputs": [],
      "source": [
        "assert x_train.shape == (60000, 28, 28)\n",
        "assert x_test.shape == (10000, 28, 28)\n",
        "assert y_train.shape == (60000,)\n",
        "assert y_test.shape == (10000,)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9355a3bd-99c2-41cf-b75d-75d3628b0a52",
      "metadata": {
        "id": "9355a3bd-99c2-41cf-b75d-75d3628b0a52"
      },
      "source": [
        "## Load the MNIST Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "712741fc-359a-47b9-878d-84292c52c469",
      "metadata": {
        "id": "712741fc-359a-47b9-878d-84292c52c469"
      },
      "source": [
        "`Flattening`: The reshape(x_train.shape[0], -1) method transforms the training data (x_train) from its original multi-dimensional shape (e.g., for images, this could be width x height x channels) into a two-dimensional array. Each sample is converted into a single row, where the first dimension is the number of samples, and the second dimension contains all the pixel values in a flattened format. This is essential for feeding the data into models that expect a flat input, such as fully connected layers in neural networks.\n",
        "\n",
        "`Normalization`: The division by 255.0 scales the pixel values to a range between 0 and 1, as pixel values in images typically range from 0 to 255. Normalization helps improve model training by ensuring that the input features have similar scales, which enhances convergence speed and overall model performance.\n",
        "\n",
        "`Combined Effect`: By flattening and normalizing the data simultaneously, the code prepares the input data for effective processing by machine learning models, ensuring that they can learn efficiently from the data while reducing the risk of issues caused by varying input scales."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "af3d578c-66f5-4be6-a3b7-b5d024a882e5",
      "metadata": {
        "id": "af3d578c-66f5-4be6-a3b7-b5d024a882e5"
      },
      "outputs": [],
      "source": [
        "x_train = x_train.reshape(x_train.shape[0], -1) / 255.0\n",
        "x_test = x_test.reshape(x_test.shape[0], -1) / 255.0"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e6c2485-b7d0-451f-94a8-09c421990157",
      "metadata": {
        "id": "6e6c2485-b7d0-451f-94a8-09c421990157"
      },
      "source": [
        "## Time to one-hot encode the data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "b4a769a6-84ae-4311-8022-2f4086b2444f",
      "metadata": {
        "id": "b4a769a6-84ae-4311-8022-2f4086b2444f"
      },
      "outputs": [],
      "source": [
        "def one_hot_encode(y, num_classes):\n",
        "    return np.eye(num_classes)[y]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "90a3d17d-bfa2-440c-b802-071b8c9eca74",
      "metadata": {
        "id": "90a3d17d-bfa2-440c-b802-071b8c9eca74"
      },
      "source": [
        "One-hot encoding is applied only to the target variable (y_train and y_test) to convert categorical class labels into a binary format suitable for classification tasks. This transformation allows the model to output probabilities for each class and avoids implying any ordinal relationships. The input features (x_train and x_test) are typically left in their original format to preserve their numerical or categorical significance for effective model training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "52680bb7-54f1-4437-9014-ad69814c0eee",
      "metadata": {
        "id": "52680bb7-54f1-4437-9014-ad69814c0eee"
      },
      "outputs": [],
      "source": [
        "y_train_encoded = one_hot_encode(y_train, 10)\n",
        "y_test_encoded = one_hot_encode(y_test, 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1c2a899d-f109-4809-83aa-b6a9cef5b1f9",
      "metadata": {
        "id": "1c2a899d-f109-4809-83aa-b6a9cef5b1f9"
      },
      "source": [
        "# Let's define a Neural Network Now:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "89de8137-141b-415a-80eb-09d74aa8fffe",
      "metadata": {
        "id": "89de8137-141b-415a-80eb-09d74aa8fffe"
      },
      "outputs": [],
      "source": [
        "import numpy as np  # Import NumPy for numerical operations\n",
        "\n",
        "class NeuralNetwork:\n",
        "    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.01):\n",
        "        # Initialize weights and biases for input to hidden layer\n",
        "        self.W1 = np.random.randn(input_size, hidden_size) * 0.01  # Small random weights\n",
        "        self.b1 = np.zeros((1, hidden_size))  # Biases initialized to zero\n",
        "\n",
        "        # Initialize weights and biases for hidden to output layer\n",
        "        self.W2 = np.random.randn(hidden_size, output_size) * 0.01  # Small random weights\n",
        "        self.b2 = np.zeros((1, output_size))  # Biases initialized to zero\n",
        "\n",
        "        self.learning_rate = learning_rate  # Set learning rate\n",
        "\n",
        "    def softmax(self, x):\n",
        "        # Compute the softmax of the input for multi-class classification\n",
        "        exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))  # For numerical stability\n",
        "        return exp_x / np.sum(exp_x, axis=1, keepdims=True)  # Normalize to get probabilities\n",
        "\n",
        "    def forward(self, X):\n",
        "        # Perform forward propagation\n",
        "        self.z1 = np.dot(X, self.W1) + self.b1  # Linear combination for hidden layer\n",
        "        self.a1 = np.tanh(self.z1)  # Activation function for hidden layer (tanh)\n",
        "        self.z2 = np.dot(self.a1, self.W2) + self.b2  # Linear combination for output layer\n",
        "        self.a2 = self.softmax(self.z2)  # Softmax activation for output layer\n",
        "        return self.a2  # Return the output probabilities\n",
        "\n",
        "    def backward(self, X, y, output):\n",
        "        # Perform backward propagation to update weights and biases\n",
        "        m = X.shape[0]  # Number of samples\n",
        "\n",
        "        # Calculate the error at the output layer\n",
        "        output_error = output - y  # Derivative of loss w.r.t. output\n",
        "\n",
        "        # Calculate the error at the hidden layer\n",
        "        hidden_error = np.dot(output_error, self.W2.T) * (1 - np.tanh(self.z1) ** 2)  # Derivative of tanh\n",
        "\n",
        "        # Compute gradients\n",
        "        dW2 = np.dot(self.a1.T, output_error) / m  # Gradient for W2\n",
        "        db2 = np.sum(output_error, axis=0, keepdims=True) / m  # Gradient for b2\n",
        "        dW1 = np.dot(X.T, hidden_error) / m  # Gradient for W1\n",
        "        db1 = np.sum(hidden_error, axis=0, keepdims=True) / m  # Gradient for b1\n",
        "\n",
        "        # Update weights and biases using gradient descent\n",
        "        self.W1 -= self.learning_rate * dW1  # Update W1\n",
        "        self.b1 -= self.learning_rate * db1  # Update b1\n",
        "        self.W2 -= self.learning_rate * dW2  # Update W2\n",
        "        self.b2 -= self.learning_rate * db2  # Update b2\n",
        "\n",
        "    def train(self, X, y, epochs):\n",
        "        # Train the neural network for a specified number of epochs\n",
        "        for epoch in range(epochs):\n",
        "            output = self.forward(X)  # Forward pass\n",
        "            self.backward(X, y, output)  # Backward pass\n",
        "\n",
        "            # Print loss every 100 epochs\n",
        "            if epoch % 100 == 0:\n",
        "                loss = -np.mean(np.sum(y * np.log(output + 1e-10), axis=1))  # Cross-entropy loss\n",
        "                print(f\"Epoch {epoch}, Loss: {loss:.4f}\")\n",
        "\n",
        "    def predict(self, X):\n",
        "        # Make predictions for input data\n",
        "        output = self.forward(X)  # Forward pass to get output\n",
        "        return np.argmax(output, axis=1)  # Return the class with the highest probability\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "d55b1aa5-d8ca-41d5-9714-858a37683f3c",
      "metadata": {
        "id": "d55b1aa5-d8ca-41d5-9714-858a37683f3c"
      },
      "outputs": [],
      "source": [
        "# Hyperparameters\n",
        "input_size = 784  # 28x28 pixels\n",
        "hidden_size = 128  # Number of neurons in the hidden layer\n",
        "output_size = 10   # 10 classes for digits 0-9\n",
        "learning_rate = 0.01\n",
        "epochs = 100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "e149f221-b151-47ec-ae51-42af6012e6da",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e149f221-b151-47ec-ae51-42af6012e6da",
        "outputId": "b10d3d09-823b-48ea-fe92-99bfdbc01684"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 0, Loss: 2.3033\n"
          ]
        }
      ],
      "source": [
        "nn = NeuralNetwork(input_size, hidden_size, output_size, learning_rate)\n",
        "nn.train(x_train, y_train_encoded, epochs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "e27d6278-aa88-4c27-84ad-cae423c1e5b2",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e27d6278-aa88-4c27-84ad-cae423c1e5b2",
        "outputId": "90c39543-960a-4545-b641-f46987b14a7c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.5208\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model\n",
        "predictions = nn.predict(x_test)\n",
        "accuracy = np.mean(predictions == y_test)\n",
        "print(f\"Test Accuracy: {accuracy:.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "dc559ff4-f301-4e68-aeb9-743492193342",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 494
        },
        "id": "dc559ff4-f301-4e68-aeb9-743492193342",
        "outputId": "1a409b2d-ff07-4b9e-c621-dc81578aefee"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x500 with 10 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize some predictions\n",
        "def plot_predictions(X, y_true, y_pred, num_images=10):\n",
        "    plt.figure(figsize=(10, 5))\n",
        "    for i in range(num_images):\n",
        "        plt.subplot(2, 5, i + 1)\n",
        "        plt.imshow(X[i].reshape(28, 28), cmap='gray')\n",
        "        plt.title(f'True: {y_true[i]}\\nPred: {y_pred[i]}')\n",
        "        plt.axis('off')\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "# Visualize predictions on test set\n",
        "plot_predictions(x_test, y_test, predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ZWoBe8DhO_v7",
      "metadata": {
        "id": "ZWoBe8DhO_v7"
      },
      "source": [
        "## Now Lets try the same with Regularization!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "fppzhKqqOdi_",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 508
        },
        "id": "fppzhKqqOdi_",
        "outputId": "5fbb2462-0088-4fa7-8658-7546c9d0defa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 0, Loss: 6.3188\n",
            "Epoch 0, Loss: 2.3547\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Let's modify the neural network code to add the comparison between L1 and L2 regularization.\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "class NeuralNetwork:\n",
        "    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.01, l1_lambda=0.0, l2_lambda=0.0):\n",
        "        self.W1 = np.random.randn(input_size, hidden_size) * 0.01\n",
        "        self.b1 = np.zeros((1, hidden_size))\n",
        "        self.W2 = np.random.randn(hidden_size, output_size) * 0.01\n",
        "        self.b2 = np.zeros((1, output_size))\n",
        "        self.learning_rate = learning_rate\n",
        "        self.l1_lambda = l1_lambda\n",
        "        self.l2_lambda = l2_lambda\n",
        "        self.loss_history = []\n",
        "\n",
        "    def softmax(self, x):\n",
        "        exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))\n",
        "        return exp_x / (np.sum(exp_x, axis=1, keepdims=True) + 1e-10)\n",
        "\n",
        "    def forward(self, X):\n",
        "        self.z1 = np.dot(X, self.W1) + self.b1\n",
        "        self.a1 = np.tanh(self.z1)\n",
        "        self.z2 = np.dot(self.a1, self.W2) + self.b2\n",
        "        self.a2 = self.softmax(self.z2)\n",
        "        return self.a2\n",
        "\n",
        "    def backward(self, X, y, output):\n",
        "        m = X.shape[0]\n",
        "        output_error = output - y\n",
        "        hidden_error = np.dot(output_error, self.W2.T) * (1 - np.tanh(self.z1) ** 2)\n",
        "\n",
        "        dW2 = np.dot(self.a1.T, output_error) / m\n",
        "        db2 = np.sum(output_error, axis=0, keepdims=True) / m\n",
        "        dW1 = np.dot(X.T, hidden_error) / m\n",
        "        db1 = np.sum(hidden_error, axis=0, keepdims=True) / m\n",
        "\n",
        "        # L1 regularization\n",
        "        dW1 += self.l1_lambda * np.sign(self.W1)\n",
        "        dW2 += self.l1_lambda * np.sign(self.W2)\n",
        "\n",
        "        # L2 regularization\n",
        "        dW1 += self.l2_lambda * self.W1\n",
        "        dW2 += self.l2_lambda * self.W2\n",
        "\n",
        "        self.W1 -= self.learning_rate * dW1\n",
        "        self.b1 -= self.learning_rate * db1\n",
        "        self.W2 -= self.learning_rate * dW2\n",
        "        self.b2 -= self.learning_rate * db2\n",
        "\n",
        "    def train(self, X, y, epochs, regularization_type=\"L2\"):\n",
        "        for epoch in range(epochs):\n",
        "            output = self.forward(X)\n",
        "            self.backward(X, y, output)\n",
        "\n",
        "            # Calculate loss with regularization penalties\n",
        "            if regularization_type == \"L1\":\n",
        "                penalty = self.l1_lambda * (np.sum(np.abs(self.W1)) + np.sum(np.abs(self.W2)))\n",
        "            else:  # L2 Regularization by default\n",
        "                penalty = self.l2_lambda * (np.sum(np.square(self.W1)) + np.sum(np.square(self.W2)))\n",
        "\n",
        "            loss = -np.mean(np.sum(y * np.log(output + 1e-10), axis=1)) + penalty\n",
        "            self.loss_history.append(loss)\n",
        "\n",
        "            if epoch % 100 == 0:\n",
        "                print(f\"Epoch {epoch}, Loss: {loss:.4f}\")\n",
        "\n",
        "    def predict(self, X):\n",
        "        output = self.forward(X)\n",
        "        return np.argmax(output, axis=1)\n",
        "\n",
        "\n",
        "# Create two neural network instances: one with L1 and one with L2 regularization\n",
        "nn_l1 = NeuralNetwork(input_size=784, hidden_size=64, output_size=10, learning_rate=0.01, l1_lambda=0.01)\n",
        "nn_l2 = NeuralNetwork(input_size=784, hidden_size=64, output_size=10, learning_rate=0.01, l2_lambda=0.01)\n",
        "\n",
        "# Train the neural networks\n",
        "epochs = 100\n",
        "nn_l1.train(x_train, y_train_encoded, epochs=epochs, regularization_type=\"L1\")\n",
        "nn_l2.train(x_train, y_train_encoded, epochs=epochs, regularization_type=\"L2\")\n",
        "\n",
        "# Plot the loss curves for L1 and L2\n",
        "plt.plot(nn_l1.loss_history, label='L1 Regularization')\n",
        "plt.plot(nn_l2.loss_history, label='L2 Regularization')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('L1 vs L2 Regularization')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "base",
      "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.12.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}