Fasion_retest_3.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",
        "import tensorflow as tf"
      ]
    },
    {
      "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": [
        "fashion_mnist = tf.keras.datasets.fashion_mnist\n",
        "\n",
        "(x_train, y_train), (x_test, y_test) = fashion_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": "code",
      "execution_count": 4,
      "id": "af3d578c-66f5-4be6-a3b7-b5d024a882e5",
      "metadata": {
        "id": "af3d578c-66f5-4be6-a3b7-b5d024a882e5"
      },
      "outputs": [],
      "source": [
        "x_train = x_train.reshape(-1, 28*28).astype(np.float32) / 255.0\n",
        "x_test = x_test.reshape(-1, 28*28).astype(np.float32) / 255.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "89de8137-141b-415a-80eb-09d74aa8fffe",
      "metadata": {
        "id": "89de8137-141b-415a-80eb-09d74aa8fffe"
      },
      "outputs": [],
      "source": [
        "def softmax(logits):\n",
        "    exp_logits = np.exp(logits - np.max(logits, axis=1, keepdims=True))\n",
        "    return exp_logits / np.sum(exp_logits, axis=1, keepdims=True)\n",
        "\n",
        "def cross_entropy_loss(y_true, y_pred):\n",
        "    m = y_true.shape[0]\n",
        "    log_likelihood = -np.log(y_pred[range(m), y_true])\n",
        "    loss = np.sum(log_likelihood) / m\n",
        "    return loss\n",
        "\n",
        "def one_hot(y, num_classes):\n",
        "    one_hot_y = np.zeros((y.size, num_classes))\n",
        "    one_hot_y[np.arange(y.size), y] = 1\n",
        "    return one_hot_y\n",
        "\n",
        "# Adam optimizer helper\n",
        "class AdamOptimizer:\n",
        "    def __init__(self, learning_rate=0.01, beta1=0.9, beta2=0.999, epsilon=1e-9):\n",
        "        self.learning_rate = learning_rate\n",
        "        self.beta1 = beta1\n",
        "        self.beta2 = beta2\n",
        "        self.epsilon = epsilon\n",
        "        self.m = None\n",
        "        self.v = None\n",
        "        self.t = 0\n",
        "\n",
        "    def update(self, weights, grad):\n",
        "        if self.m is None:\n",
        "            self.m = np.zeros_like(weights)\n",
        "            self.v = np.zeros_like(weights)\n",
        "\n",
        "        # Update biased first and second moment estimates\n",
        "        self.t += 1\n",
        "        self.m = self.beta1 * self.m + (1 - self.beta1) * grad\n",
        "        self.v = self.beta2 * self.v + (1 - self.beta2) * (grad ** 2)\n",
        "\n",
        "        # Bias-corrected moment estimates\n",
        "        m_hat = self.m / (1 - self.beta1 ** self.t)\n",
        "        v_hat = self.v / (1 - self.beta2 ** self.t)\n",
        "\n",
        "        # Update weights\n",
        "        weights -= self.learning_rate * m_hat / (np.sqrt(v_hat) + self.epsilon)\n",
        "\n",
        "        return weights\n",
        "\n",
        "# Neural Network with L2 regularization and Adam optimizer\n",
        "class NeuralNetwork:\n",
        "    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.001, dropout_rate=0.1, reg_lambda=0.00001):\n",
        "        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2.0 / input_size)\n",
        "        self.b1 = np.zeros((1, hidden_size))\n",
        "        self.W2 = np.random.randn(hidden_size, hidden_size) * np.sqrt(2.0 / hidden_size)\n",
        "        self.b2 = np.zeros((1, hidden_size))\n",
        "        self.W3 = np.random.randn(hidden_size, hidden_size) * np.sqrt(2.0 / hidden_size)\n",
        "        self.b3 = np.zeros((1, hidden_size))\n",
        "        self.W4 = np.random.randn(hidden_size, hidden_size) * np.sqrt(2.0 / hidden_size)\n",
        "        self.b4 = np.zeros((1, hidden_size))\n",
        "        self.W5 = np.random.randn(hidden_size, output_size) * np.sqrt(2.0 / hidden_size)\n",
        "        self.b5 = np.zeros((1, output_size))\n",
        "        self.learning_rate = learning_rate\n",
        "        self.dropout_rate = dropout_rate\n",
        "        self.reg_lambda = reg_lambda\n",
        "        \n",
        "        # Adam optimizers for weights and biases\n",
        "        self.optimizer_W1 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_b1 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_W2 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_b2 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_W3 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_b3 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_W4 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_b4 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_W5 = AdamOptimizer(learning_rate)\n",
        "        self.optimizer_b5 = AdamOptimizer(learning_rate)\n",
        "\n",
        "    def leaky_relu(self, Z, alpha=0.01):\n",
        "        return np.where(Z > 0, Z, alpha * Z)\n",
        "\n",
        "    def leaky_relu_derivative(self, Z, alpha=0.01):\n",
        "        return np.where(Z > 0, 1, alpha)\n",
        "\n",
        "    def dropout(self, A):\n",
        "        mask = (np.random.rand(*A.shape) > self.dropout_rate)\n",
        "        return A * mask / (1 - self.dropout_rate)\n",
        "\n",
        "    def forward(self, X):\n",
        "        self.Z1 = np.dot(X, self.W1) + self.b1\n",
        "        self.A1 = self.leaky_relu(self.Z1)\n",
        "        self.A1 = self.dropout(self.A1)\n",
        "        \n",
        "        self.Z2 = np.dot(self.A1, self.W2) + self.b2\n",
        "        self.A2 = self.leaky_relu(self.Z2)\n",
        "        self.A2 = self.dropout(self.A2)\n",
        "\n",
        "        self.Z3 = np.dot(self.A2, self.W3) + self.b3\n",
        "        self.A3 = self.leaky_relu(self.Z3)\n",
        "        self.A3 = self.dropout(self.A3)\n",
        "\n",
        "        self.Z4 = np.dot(self.A3, self.W4) + self.b4\n",
        "        self.A4 = self.leaky_relu(self.Z4)\n",
        "        self.A4 = self.dropout(self.A4)\n",
        "        \n",
        "        self.Z5 = np.dot(self.A4, self.W5) + self.b5\n",
        "        self.A5 = softmax(self.Z5)\n",
        "        \n",
        "        return self.A5\n",
        "    \n",
        "    def backward(self, X, y_true):\n",
        "        m = X.shape[0]\n",
        "        y_true_one_hot = one_hot(y_true, self.A4.shape[1])\n",
        "        \n",
        "        # Calculate gradients\n",
        "        dZ5 = self.A5 - y_true_one_hot\n",
        "        dW5 = np.dot(self.A4.T, dZ5) / m + (self.reg_lambda / m) * self.W5\n",
        "        db5 = np.sum(dZ5, axis=0, keepdims=True) / m\n",
        "        \n",
        "        dA4 = np.dot(dZ5, self.W5.T)\n",
        "        dZ4 = dA4 * self.leaky_relu_derivative(self.Z4)\n",
        "        dW4 = np.dot(self.A3.T, dZ4) / m + (self.reg_lambda / m) * self.W4\n",
        "        db4 = np.sum(dZ4, axis=0, keepdims=True) / m\n",
        "\n",
        "        dA3 = np.dot(dZ4, self.W4.T)\n",
        "        dZ3 = dA3 * self.leaky_relu_derivative(self.Z3)\n",
        "        dW3 = np.dot(self.A2.T, dZ3) / m + (self.reg_lambda / m) * self.W3\n",
        "        db3 = np.sum(dZ3, axis=0, keepdims=True) / m\n",
        "\n",
        "        dA2 = np.dot(dZ3, self.W3.T)\n",
        "        dZ2 = dA2 * self.leaky_relu_derivative(self.Z2)\n",
        "        dW2 = np.dot(self.A1.T, dZ2) / m + (self.reg_lambda / m) * self.W2\n",
        "        db2 = np.sum(dZ2, axis=0, keepdims=True) / m\n",
        "        \n",
        "        dA1 = np.dot(dZ2, self.W2.T)\n",
        "        dZ1 = dA1 * self.leaky_relu_derivative(self.Z1)\n",
        "        dW1 = np.dot(X.T, dZ1) / m + (self.reg_lambda / m) * self.W1\n",
        "        db1 = np.sum(dZ1, axis=0, keepdims=True) / m\n",
        "\n",
        "        # Update weights and biases using Adam optimizer\n",
        "        self.W1 = self.optimizer_W1.update(self.W1, dW1)\n",
        "        self.b1 = self.optimizer_b1.update(self.b1, db1)\n",
        "        self.W2 = self.optimizer_W2.update(self.W2, dW2)\n",
        "        self.b2 = self.optimizer_b2.update(self.b2, db2)\n",
        "        self.W3 = self.optimizer_W3.update(self.W3, dW3)\n",
        "        self.b3 = self.optimizer_b3.update(self.b3, db3)\n",
        "        self.W4 = self.optimizer_W4.update(self.W4, dW4)\n",
        "        self.b4 = self.optimizer_b4.update(self.b4, db4)\n",
        "        self.W5 = self.optimizer_W5.update(self.W4, dW5)\n",
        "        self.b5 = self.optimizer_b5.update(self.b4, db5)\n",
        "\n",
        "    def train(self, X, y, epochs):\n",
        "        for epoch in range(epochs):\n",
        "            y_pred = self.forward(X)\n",
        "            loss = cross_entropy_loss(y, y_pred) + (self.reg_lambda / (2 * X.shape[0])) * (\n",
        "                np.sum(np.square(self.W1)) + np.sum(np.square(self.W2)) + np.sum(np.square(self.W3)) + np.sum(np.square(self.W4)))\n",
        "            \n",
        "            self.backward(X, y)\n",
        "            \n",
        "            if epoch % 20 == 0:\n",
        "                print(f\"Epoch {epoch}, Loss: {loss:.4f}\")\n",
        "\n",
        "    def predict(self, X):\n",
        "        y_pred = self.forward(X)\n",
        "        return np.argmax(y_pred, axis=1)\n",
        "\n",
        "    def accuracy(self, X, y_true):\n",
        "        y_pred = self.predict(X)\n",
        "        accuracy = np.mean(y_pred == y_true)\n",
        "        return accuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "d55b1aa5-d8ca-41d5-9714-858a37683f3c",
      "metadata": {
        "id": "d55b1aa5-d8ca-41d5-9714-858a37683f3c"
      },
      "outputs": [],
      "source": [
        "# Hyperparameters\n",
        "input_size = 28 * 28\n",
        "hidden_size = 512\n",
        "output_size = 10\n",
        "learning_rate = 0.001\n",
        "epochs = 500\n",
        "reg_lambda = 0.00001\n",
        "\n",
        "nn = NeuralNetwork(input_size, hidden_size, output_size, learning_rate, reg_lambda=reg_lambda)\n",
        "\n",
        "(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()\n",
        "x_train = x_train.reshape(-1, 28*28).astype(np.float32) / 255.0\n",
        "x_test = x_test.reshape(-1, 28*28).astype(np.float32) / 255.0\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "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.5862\n",
            "Epoch 20, Loss: 0.6197\n",
            "Epoch 40, Loss: 0.5029\n",
            "Epoch 60, Loss: 0.4391\n",
            "Epoch 80, Loss: 0.4012\n",
            "Epoch 100, Loss: 0.3810\n",
            "Epoch 120, Loss: 0.3610\n",
            "Epoch 140, Loss: 0.3444\n",
            "Epoch 160, Loss: 0.3233\n",
            "Epoch 180, Loss: 0.3139\n",
            "Epoch 200, Loss: 0.3007\n",
            "Epoch 220, Loss: 0.2865\n",
            "Epoch 240, Loss: 0.2773\n",
            "Epoch 260, Loss: 0.2647\n",
            "Epoch 280, Loss: 0.2620\n",
            "Epoch 300, Loss: 0.2547\n",
            "Epoch 320, Loss: 0.2403\n",
            "Epoch 340, Loss: 0.2387\n",
            "Epoch 360, Loss: 0.2320\n",
            "Epoch 380, Loss: 0.2273\n",
            "Epoch 400, Loss: 0.2167\n",
            "Epoch 420, Loss: 0.2110\n",
            "Epoch 440, Loss: 0.2060\n",
            "Epoch 460, Loss: 0.2008\n",
            "Epoch 480, Loss: 0.1972\n"
          ]
        }
      ],
      "source": [
        "nn.train(x_train, y_train, epochs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "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: 88.26%\n"
          ]
        }
      ],
      "source": [
        "predictions = nn.predict(x_test)\n",
        "accuracy = nn.accuracy(x_test, y_test)\n",
        "print(f\"Test Accuracy: {accuracy * 100:.2f}%\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "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)"
      ]
    }
  ],
  "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
}