MobileViT_Mini_Project_(5).ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xjgb5vzp-QiZ",
        "outputId": "859bc2c1-dd0e-42db-b67d-a43e787128fd"
      },
      "outputs": [],
      "source": [
        "#!pip install --upgrade tensorflow\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s35QOVwl-QXN"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jG7rT5qB-dbs",
        "outputId": "84e2e965-7606-4c7c-ba9d-f63795647f2a"
      },
      "outputs": [],
      "source": [
        "# from google.colab import drive\n",
        "\n",
        "# # Mount Google Drive\n",
        "# drive.mount('/content/drive')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 830
        },
        "id": "MRYdnmbLDMpC",
        "outputId": "162b6d1e-f7d0-46c4-ef68-322ca72dd325"
      },
      "outputs": [
        {
          "ename": "ModuleNotFoundError",
          "evalue": "No module named 'matplotlib'",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[1;32m/Users/akarsh/Downloads/MobileViT_Mini_Project_(5).ipynb Cell 4\u001b[0m line \u001b[0;36m2\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/akarsh/Downloads/MobileViT_Mini_Project_%285%29.ipynb#W3sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mos\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/akarsh/Downloads/MobileViT_Mini_Project_%285%29.ipynb#W3sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/akarsh/Downloads/MobileViT_Mini_Project_%285%29.ipynb#W3sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mkeras\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpreprocessing\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mimage\u001b[39;00m \u001b[39mimport\u001b[39;00m ImageDataGenerator\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/akarsh/Downloads/MobileViT_Mini_Project_%285%29.ipynb#W3sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39m# Set your dataset paths\u001b[39;00m\n",
            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'matplotlib'"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "# Set your dataset paths\n",
        "train_dir = \"/content/drive/MyDrive/archive (5)/train\"\n",
        "validation_dir = \"/content/drive/MyDrive/archive (5)/val\"\n",
        "test_dir = \"/content/drive/MyDrive/archive (5)/test\"\n",
        "\n",
        "# Set your image size\n",
        "img_size = (256, 256)\n",
        "\n",
        "# Create data generators for training and validation sets\n",
        "train_datagen = ImageDataGenerator(rescale=1./255)\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "    train_dir,\n",
        "    target_size=img_size,\n",
        "    batch_size=32,\n",
        "    class_mode='categorical'\n",
        ")\n",
        "\n",
        "validation_datagen = ImageDataGenerator(rescale=1./255)\n",
        "validation_generator = validation_datagen.flow_from_directory(\n",
        "    validation_dir,\n",
        "    target_size=img_size,\n",
        "    batch_size=32,\n",
        "    class_mode='categorical'\n",
        ")\n",
        "\n",
        "# Display images from the training set in matrix box form\n",
        "print(\"Displaying images from the training set:\")\n",
        "fig, axes = plt.subplots(1, 5, figsize=(15, 3))\n",
        "\n",
        "for i in range(5):\n",
        "    img, label = train_generator.next()\n",
        "    axes[i].imshow(img[0])\n",
        "    axes[i].set_title(f\"Label: {label[0]}\")\n",
        "    axes[i].axis('off')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "# Display images from the validation set in matrix box form\n",
        "print(\"Displaying images from the validation set:\")\n",
        "fig, axes = plt.subplots(1, 5, figsize=(15, 3))\n",
        "\n",
        "for i in range(5):\n",
        "    img, label = validation_generator.next()\n",
        "    axes[i].imshow(img[0])\n",
        "    axes[i].set_title(f\"Label: {label[0]}\")\n",
        "    axes[i].axis('off')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "# Display images from the test set in matrix box form\n",
        "print(\"Displaying images from the test set:\")\n",
        "fig, axes = plt.subplots(1, 5, figsize=(15, 3))\n",
        "\n",
        "for i in range(5):\n",
        "    img, label = validation_generator.next()\n",
        "    axes[i].imshow(img[0])\n",
        "    axes[i].set_title(f\"Label: {label[0]}\")\n",
        "    axes[i].axis('off')\n",
        "\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wi3QK3NrsW7O"
      },
      "source": [
        "# BINARY LOSS FUNCTION"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hCBVsDhUl_Id",
        "outputId": "f9df76fa-4531-4008-84a9-1b550798b11f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 4946 images belonging to 2 classes.\n",
            "Found 120 images belonging to 2 classes.\n",
            "Epoch 1/10\n",
            "155/155 [==============================] - 1034s 6s/step - loss: 0.5568 - accuracy: 0.7153 - val_loss: 0.7042 - val_accuracy: 0.2333\n",
            "Epoch 2/10\n",
            "155/155 [==============================] - 887s 6s/step - loss: 0.4762 - accuracy: 0.7750 - val_loss: 0.9195 - val_accuracy: 0.2333\n",
            "Epoch 3/10\n",
            "155/155 [==============================] - 891s 6s/step - loss: 0.4451 - accuracy: 0.7871 - val_loss: 0.9296 - val_accuracy: 0.2833\n",
            "Epoch 4/10\n",
            "155/155 [==============================] - 877s 6s/step - loss: 0.4246 - accuracy: 0.8057 - val_loss: 0.5109 - val_accuracy: 0.8083\n",
            "Epoch 5/10\n",
            "155/155 [==============================] - 926s 6s/step - loss: 0.3972 - accuracy: 0.8192 - val_loss: 0.4773 - val_accuracy: 0.8250\n",
            "Epoch 6/10\n",
            "155/155 [==============================] - 912s 6s/step - loss: 0.3972 - accuracy: 0.8265 - val_loss: 1.1320 - val_accuracy: 0.7750\n",
            "Epoch 7/10\n",
            "155/155 [==============================] - 915s 6s/step - loss: 0.3796 - accuracy: 0.8308 - val_loss: 1.0057 - val_accuracy: 0.7833\n",
            "Epoch 8/10\n",
            "155/155 [==============================] - 911s 6s/step - loss: 0.3667 - accuracy: 0.8340 - val_loss: 1.6147 - val_accuracy: 0.7583\n",
            "Epoch 9/10\n",
            "155/155 [==============================] - 919s 6s/step - loss: 0.3602 - accuracy: 0.8354 - val_loss: 0.5705 - val_accuracy: 0.7833\n",
            "Epoch 10/10\n",
            "155/155 [==============================] - 922s 6s/step - loss: 0.3372 - accuracy: 0.8478 - val_loss: 0.7079 - val_accuracy: 0.7167\n",
            "Found 126 images belonging to 2 classes.\n",
            "4/4 [==============================] - 43s 13s/step - loss: 0.6229 - accuracy: 0.7857\n",
            "Test accuracy: 0.7857142686843872\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "# Custom Self-Attention Layer\n",
        "class SelfAttention(layers.Layer):\n",
        "    def __init__(self, units):\n",
        "        super(SelfAttention, self).__init__()\n",
        "        self.units = units\n",
        "        self.W_q = layers.Dense(units)\n",
        "        self.W_k = layers.Dense(units)\n",
        "        self.W_v = layers.Dense(units)\n",
        "        self.attention = layers.Attention()\n",
        "\n",
        "    def call(self, inputs):\n",
        "        query = self.W_q(inputs)\n",
        "        key = self.W_k(inputs)\n",
        "        value = self.W_v(inputs)\n",
        "        attention_output = self.attention([query, key, value])\n",
        "        return attention_output\n",
        "\n",
        "def inverted_residual_block(inputs, num_filters, strides=1, expansion_ratio=1):\n",
        "    # Point-Wise Convolution\n",
        "    x = layers.Conv2D(\n",
        "        filters=expansion_ratio*inputs.shape[-1],\n",
        "        kernel_size=1,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # Depth-Wise Convolution\n",
        "    x = layers.DepthwiseConv2D(\n",
        "        kernel_size=3,\n",
        "        strides=strides,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(x)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # Point-Wise Convolution\n",
        "    x = layers.Conv2D(\n",
        "        filters=num_filters,\n",
        "        kernel_size=1,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(x)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "\n",
        "    # Residual Connection\n",
        "    if strides == 1 and (inputs.shape == x.shape):\n",
        "        return layers.Add()([inputs, x])\n",
        "    return x\n",
        "\n",
        "def mlp(x, mlp_dim, dim, dropout_rate=0.1):\n",
        "    x = layers.Dense(mlp_dim, activation=\"swish\")(x)\n",
        "    x = layers.Dropout(dropout_rate)(x)\n",
        "    x = layers.Dense(dim)(x)\n",
        "    x = layers.Dropout(dropout_rate)(x)\n",
        "    return x\n",
        "\n",
        "def transformer_encoder(x, num_heads, dim, mlp_dim):\n",
        "    skip_1 = x\n",
        "    x = layers.LayerNormalization()(x)\n",
        "    x = layers.MultiHeadAttention(\n",
        "        num_heads=num_heads, key_dim=dim\n",
        "    )(x, x)\n",
        "    x = layers.Add()([x, skip_1])\n",
        "\n",
        "    skip_2 = x\n",
        "    x = layers.LayerNormalization()(x)\n",
        "    x = mlp(x, mlp_dim, dim)\n",
        "    x = layers.Add()([x, skip_2])\n",
        "\n",
        "    return x\n",
        "\n",
        "def mobile_vit_block(inputs, num_filters, dim, patch_size=2, num_layers=1):\n",
        "    B, H, W, C = inputs.shape\n",
        "\n",
        "    # 3x3 conv\n",
        "    x = layers.Conv2D(\n",
        "        filters=C,\n",
        "        kernel_size=3,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # 1x1 conv: d-dimension\n",
        "    x = layers.Conv2D(\n",
        "        filters=dim,\n",
        "        kernel_size=1,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # Reshape x to flattened patches\n",
        "    P = patch_size*patch_size\n",
        "    N = int(H*W//P)\n",
        "    x = layers.Reshape((P, N, dim))(x)\n",
        "\n",
        "    # Transformer Encoder\n",
        "    for _ in range(num_layers):\n",
        "        x = transformer_encoder(x, 1, dim, dim*2)\n",
        "\n",
        "    # Reshape\n",
        "    x = layers.Reshape((H, W, dim))(x)\n",
        "\n",
        "    # 1x1 conv: C-dimension\n",
        "    x = layers.Conv2D(\n",
        "        filters=C,\n",
        "        kernel_size=1,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # Concatenation\n",
        "    x = layers.Concatenate()([x, inputs])\n",
        "\n",
        "    # 3x3 conv\n",
        "    x = layers.Conv2D(\n",
        "        filters=num_filters,\n",
        "        kernel_size=3,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    return x\n",
        "\n",
        "def MobileViT(input_shape, num_classes):\n",
        "    num_channels = [16, 16, 24, 24, 24, 48, 64, 64, 80, 80, 96, 320]\n",
        "    dim = [64, 80, 96]\n",
        "    expansion_ratio = 2\n",
        "\n",
        "    # Input layer\n",
        "    inputs = layers.Input(input_shape)\n",
        "\n",
        "    # Stem\n",
        "    x = layers.Conv2D(\n",
        "        filters=num_channels[0],\n",
        "        kernel_size=3,\n",
        "        strides=2,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(inputs)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "    x = inverted_residual_block(x, num_channels[1], strides=1, expansion_ratio=expansion_ratio)\n",
        "\n",
        "    # Stage 1\n",
        "    x = inverted_residual_block(x, num_channels[2], strides=2, expansion_ratio=expansion_ratio)\n",
        "    x = inverted_residual_block(x, num_channels[3], strides=1, expansion_ratio=expansion_ratio)\n",
        "    x = inverted_residual_block(x, num_channels[4], strides=1, expansion_ratio=expansion_ratio)\n",
        "\n",
        "    # Stage 2\n",
        "    x = inverted_residual_block(x, num_channels[5], strides=2, expansion_ratio=expansion_ratio)\n",
        "    x = mobile_vit_block(x, num_channels[6], dim[0], num_layers=1)\n",
        "\n",
        "    # Stage 3\n",
        "    x = inverted_residual_block(x, num_channels[7], strides=2, expansion_ratio=expansion_ratio)\n",
        "    x = mobile_vit_block(x, num_channels[8], dim[1], num_layers=4)\n",
        "\n",
        "    # Stage 4\n",
        "    x = inverted_residual_block(x, num_channels[9], strides=2, expansion_ratio=expansion_ratio)\n",
        "    x = mobile_vit_block(x, num_channels[10], dim[2], num_layers=3)\n",
        "    x = layers.Conv2D(\n",
        "        filters=num_channels[11],\n",
        "        kernel_size=1,\n",
        "        padding=\"same\",\n",
        "        use_bias=False\n",
        "    )(x)\n",
        "    x = layers.BatchNormalization()(x)\n",
        "    x = layers.Activation(\"swish\")(x)\n",
        "\n",
        "    # Classifier\n",
        "    x = layers.GlobalAveragePooling2D()(x)\n",
        "    outputs = layers.Dense(1, activation=\"sigmoid\")(x)  # Change num_classes to 1\n",
        "\n",
        "    model = tf.keras.models.Model(inputs, outputs)\n",
        "    return model\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    # Set your dataset paths\n",
        "    train_dir = \"/content/drive/MyDrive/archive (5)/train\"\n",
        "    validation_dir = \"/content/drive/MyDrive/archive (5)/val\"\n",
        "    test_dir = \"/content/drive/MyDrive/archive (5)/test\"\n",
        "\n",
        "    # Set your image size and number of classes\n",
        "    img_size = (256, 256)\n",
        "    num_classes = 2  # Binary classification\n",
        "\n",
        "    # Create data generators with data augmentation for the training set\n",
        "    train_datagen = ImageDataGenerator(\n",
        "        rescale=1./255,\n",
        "        rotation_range=20,\n",
        "        width_shift_range=0.2,\n",
        "        height_shift_range=0.2,\n",
        "        shear_range=0.2,\n",
        "        zoom_range=0.2,\n",
        "        horizontal_flip=True,\n",
        "        fill_mode='nearest'\n",
        "    )\n",
        "\n",
        "    train_generator = train_datagen.flow_from_directory(\n",
        "        train_dir,\n",
        "        target_size=img_size,\n",
        "        batch_size=32,\n",
        "        class_mode='binary'  # Change class_mode to 'binary'\n",
        "    )\n",
        "\n",
        "    validation_datagen = ImageDataGenerator(rescale=1./255)\n",
        "    validation_generator = validation_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=img_size,\n",
        "        batch_size=32,\n",
        "        class_mode='binary'  # Change class_mode to 'binary'\n",
        "    )\n",
        "\n",
        "    # Build and compile the MobileViT model\n",
        "    model = MobileViT(input_shape=(*img_size, 3), num_classes=num_classes)\n",
        "    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
        "\n",
        "    # Train the model\n",
        "    model.fit(train_generator, epochs=10, validation_data=validation_generator)\n",
        "\n",
        "    # Evaluate on the test set\n",
        "    test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "    test_generator = test_datagen.flow_from_directory(\n",
        "        test_dir,\n",
        "        target_size=img_size,\n",
        "        batch_size=32,\n",
        "        class_mode='binary'\n",
        "    )\n",
        "\n",
        "    loss, accuracy = model.evaluate(test_generator)\n",
        "    print(f'Test accuracy: {accuracy}')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_BHBwXjgnssp"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EYI76tdHD7rX"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D2b73kRWZ1zq"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "from sklearn.metrics import precision_recall_curve, roc_curve, auc\n",
        "from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score\n",
        "from sklearn.preprocessing import label_binarize\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ALIyShWf3wr",
        "outputId": "dd4b6117-e3c4-43c0-9fd2-feb7772e53f5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Precision: 0.6679\n",
            "Recall: 0.7143\n",
            "F1-Score: 0.6824\n",
            "Accuracy: 0.7143\n"
          ]
        }
      ],
      "source": [
        "# Calculate Precision, Recall, F1-Score, and Accuracy\n",
        "precision = precision_score(y_true, y_pred, average='weighted')\n",
        "recall = recall_score(y_true, y_pred, average='weighted')\n",
        "f1 = f1_score(y_true, y_pred, average='weighted')\n",
        "accuracy = accuracy_score(y_true, y_pred)\n",
        "\n",
        "print(f'Precision: {precision:.4f}')\n",
        "print(f'Recall: {recall:.4f}')\n",
        "print(f'F1-Score: {f1:.4f}')\n",
        "print(f'Accuracy: {accuracy:.4f}')\n",
        "\n",
        "# Binarize the labels for ROC and PR curves\n",
        "n_classes = num_classes\n",
        "y_true_bin = label_binarize(y_true, classes=np.arange(n_classes))\n",
        "y_pred_bin = label_binarize(y_pred, classes=np.arange(n_classes))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vOBP57yyf3jj"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hqVh7G9Nf3W4"
      },
      "outputs": [],
      "source": []
    }
  ],
  "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.9.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}