MMTD.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNsLHgTo7Wwy1t5XL08RJjm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/chibuezedev/MMTD/blob/main/MMTD.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.model_selection import train_test_split\n",
        "import os\n",
        "import random\n",
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torchvision.models as models\n",
        "import torchvision.transforms as transforms\n",
        "from transformers import BertModel, BertTokenizer, RobertaModel, RobertaTokenizer, XLMRobertaTokenizer, XLMRobertaModel, XLMRobertaTokenizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "\n",
        "# Set random seed for reproducibility\n",
        "torch.manual_seed(42)\n",
        "np.random.seed(42)"
      ],
      "metadata": {
        "id": "uBoKxWz-3C7R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the dataset\n",
        "df = pd.read_csv('data-en-hi-de-fr.csv')\n",
        "\n",
        "# Display basic information\n",
        "print(df.info())\n",
        "print(df.head())\n",
        "\n",
        "# Check class distribution\n",
        "plt.figure(figsize=(10, 6))\n",
        "sns.countplot(x='labels', data=df)\n",
        "plt.title('Distribution of Spam and Ham')\n",
        "plt.show()\n",
        "\n",
        "# Preprocess the dataset\n",
        "# Ensure 'labels' column is binary (0 for ham, 1 for spam)\n",
        "df['labels'] = df['labels'].map({'ham': 0, 'spam': 1})\n",
        "\n",
        "# Restructure the dataframe to have a single 'text' column and a 'language' column\n",
        "languages = ['en', 'hi', 'de', 'fr']\n",
        "new_rows = []\n",
        "\n",
        "for _, row in df.iterrows():\n",
        "    for lang in languages:\n",
        "        if lang == 'en':\n",
        "            text_col = 'text'\n",
        "        else:\n",
        "            text_col = f'text_{lang}'\n",
        "        new_rows.append({\n",
        "            'label': row['labels'],\n",
        "            'text': row[text_col],\n",
        "            'language': lang\n",
        "        })\n",
        "\n",
        "new_df = pd.DataFrame(new_rows)\n",
        "\n",
        "# Check language distribution\n",
        "plt.figure(figsize=(10, 6))\n",
        "sns.countplot(x='language', data=new_df)\n",
        "plt.title('Distribution of Languages')\n",
        "plt.show()\n",
        "\n",
        "# Split the dataset into train and test sets\n",
        "train_df, test_df = train_test_split(new_df, test_size=0.2, stratify=new_df[['label', 'language']], random_state=42)\n",
        "\n",
        "print(f\"Training set shape: {train_df.shape}\")\n",
        "print(f\"Test set shape: {test_df.shape}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "iIWqPHEei9Sz",
        "outputId": "254a513a-1004-43cb-906e-fbe6eebfe966"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 5572 entries, 0 to 5571\n",
            "Data columns (total 5 columns):\n",
            " #   Column   Non-Null Count  Dtype \n",
            "---  ------   --------------  ----- \n",
            " 0   labels   5572 non-null   object\n",
            " 1   text     5572 non-null   object\n",
            " 2   text_hi  5572 non-null   object\n",
            " 3   text_de  5572 non-null   object\n",
            " 4   text_fr  5572 non-null   object\n",
            "dtypes: object(5)\n",
            "memory usage: 217.8+ KB\n",
            "None\n",
            "  labels                                               text  \\\n",
            "0    ham  Go until jurong point, crazy.. Available only ...   \n",
            "1    ham                      Ok lar... Joking wif u oni...   \n",
            "2   spam  Free entry in 2 a wkly comp to win FA Cup fina...   \n",
            "3    ham  U dun say so early hor... U c already then say...   \n",
            "4    ham  Nah I don't think he goes to usf, he lives aro...   \n",
            "\n",
            "                                             text_hi  \\\n",
            "0  Dakag बिंदु तक जाओ, पागल. केवल Bag Non महान वि...   \n",
            "1                         ओके लामर.... if if uue पर.   \n",
            "2  Fktatatat 21 मई को प्राप्त करने के लिए मुफ्त प...   \n",
            "3  Uden इतना जल्दी कहते हैं... तो पहले से ही यूसी...   \n",
            "4  नहीं, मुझे नहीं लगता कि वह हमारे लिए चला जाता ...   \n",
            "\n",
            "                                             text_de  \\\n",
            "0  Gehen Sie bis jurong Punkt, verrückt.. Verfügb...   \n",
            "1                      Ok Lar... joking wif u oni...   \n",
            "2  Freier Eintritt in 2 a wkly comp zum Gewinn FA...   \n",
            "3     U dun sagen so früh... U c schon dann sagen...   \n",
            "4  Nein, ich glaube nicht, dass er zu unsf geht, ...   \n",
            "\n",
            "                                             text_fr  \n",
            "0  Allez jusqu'à Jurong point, fou.. Disponible s...  \n",
            "1           J'ai fait une blague sur le wif u oni...  \n",
            "2  Entrée libre dans 2 a wkly comp pour gagner FA...  \n",
            "3     U dun dit si tôt hor... U c déjà dire alors...  \n",
            "4  Non, je ne pense pas qu'il va à usf, il vit da...  \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training set shape: (17830, 3)\n",
            "Test set shape: (4458, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "# Now, let's add an image component\n",
        "spam_images = os.listdir('spam_images')\n",
        "ham_images = os.listdir('ham_images')\n",
        "\n",
        "def assign_image(row):\n",
        "    if row['label'] == 1:  # spam\n",
        "        return f\"spam_images/{random.choice(spam_images)}\"\n",
        "    else:  # ham\n",
        "        return f\"ham_images/{random.choice(ham_images)}\"\n",
        "\n",
        "# Add image paths to both train and test dataframes\n",
        "train_df['image_path'] = train_df.apply(assign_image, axis=1)\n",
        "test_df['image_path'] = test_df.apply(assign_image, axis=1)\n",
        "\n",
        "# Save the preprocessed datasets\n",
        "train_df.to_csv('train_multilingual_multimodal_spam.csv', index=False)\n",
        "test_df.to_csv('test_multilingual_multimodal_spam.csv', index=False)\n",
        "\n",
        "print(\"Preprocessing complete. Datasets saved as CSV files.\")\n",
        "\n",
        "# Display sample of the final dataset\n",
        "print(train_df.head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qJp-CyKkrxqp",
        "outputId": "9d5259c8-09aa-4fa4-e53a-5e2c7cd78527"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preprocessing complete. Datasets saved as CSV files.\n",
            "       label                                               text language  \\\n",
            "7466       0  Rufen Sie die Nummer an, die nach Vereinbarung...       de   \n",
            "8041       0  मैं इस के माध्यम से आगे नहीं बढ़ सकता. यह कभी ...       hi   \n",
            "14135      0  En fait, mon mobile est plein de msg. Et je fa...       fr   \n",
            "3261       1  Smamawawavon520 पर Smaka Pyr. 2 को फिर से करने...       hi   \n",
            "11972      0          K.i did't see you.:)k:)where are you now?       en   \n",
            "\n",
            "                                      image_path  \n",
            "7466   ham_images/zzz_412523576_045b3e623c_m.jpg  \n",
            "8041       ham_images/zzz_82495_d51590f351_m.jpg  \n",
            "14135      ham_images/zzz_65443_8037b212d7_m.jpg  \n",
            "3261                  spam_images/D2gfNHPSLU.jpg  \n",
            "11972       ham_images/zzz_7359_449584eb9a_m.jpg  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print some statistics\n",
        "print(\"\\nDataset Statistics:\")\n",
        "print(f\"Total samples: {len(train_df) + len(test_df)}\")\n",
        "print(f\"Training samples: {len(train_df)}\")\n",
        "print(f\"Testing samples: {len(test_df)}\")\n",
        "print(\"\\nLabel distribution in training set:\")\n",
        "print(train_df['label'].value_counts(normalize=True))\n",
        "print(\"\\nLanguage distribution in training set:\")\n",
        "print(train_df['language'].value_counts(normalize=True))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "60ClliEmz_Yc",
        "outputId": "ee548adf-4eec-4dd5-913d-6012cbc0b17b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Dataset Statistics:\n",
            "Total samples: 22288\n",
            "Training samples: 17830\n",
            "Testing samples: 4458\n",
            "\n",
            "Label distribution in training set:\n",
            "label\n",
            "0    0.865956\n",
            "1    0.134044\n",
            "Name: proportion, dtype: float64\n",
            "\n",
            "Language distribution in training set:\n",
            "language\n",
            "hi    0.250028\n",
            "en    0.250028\n",
            "de    0.249972\n",
            "fr    0.249972\n",
            "Name: proportion, dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "# Check image availability\n",
        "print(\"\\nChecking image availability...\")\n",
        "missing_images = 0\n",
        "for idx, row in tqdm(train_df.iterrows(), total=len(train_df)):\n",
        "    if not os.path.exists(row['image_path']):\n",
        "        missing_images += 1\n",
        "print(f\"Number of missing images in training set: {missing_images}\")\n",
        "\n",
        "missing_images = 0\n",
        "for idx, row in tqdm(test_df.iterrows(), total=len(test_df)):\n",
        "    if not os.path.exists(row['image_path']):\n",
        "        missing_images += 1\n",
        "print(f\"Number of missing images in test set: {missing_images}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yHR2qLn60GaT",
        "outputId": "7b022127-c0c5-4fa3-a2f4-75f11c678b74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Checking image availability...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 17830/17830 [00:01<00:00, 16116.91it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of missing images in training set: 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4458/4458 [00:00<00:00, 13736.36it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of missing images in test set: 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Load the CSV files\n",
        "train_df = pd.read_csv('train_multilingual_multimodal_spam.csv')\n",
        "test_df = pd.read_csv('test_multilingual_multimodal_spam.csv')\n",
        "\n",
        "# Print basic information\n",
        "print(\"Train DataFrame:\")\n",
        "print(train_df.info())\n",
        "print(\"\\nTest DataFrame:\")\n",
        "print(test_df.info())\n",
        "\n",
        "# Display a few rows\n",
        "print(\"\\nSample rows from train_df:\")\n",
        "print(train_df.head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0cxgS9MfHGRZ",
        "outputId": "36e61085-cf58-420c-c700-458c7a7acd23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train DataFrame:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 17830 entries, 0 to 17829\n",
            "Data columns (total 4 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   label       17830 non-null  int64 \n",
            " 1   text        17830 non-null  object\n",
            " 2   language    17830 non-null  object\n",
            " 3   image_path  17830 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 557.3+ KB\n",
            "None\n",
            "\n",
            "Test DataFrame:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 4458 entries, 0 to 4457\n",
            "Data columns (total 4 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   label       4458 non-null   int64 \n",
            " 1   text        4458 non-null   object\n",
            " 2   language    4458 non-null   object\n",
            " 3   image_path  4458 non-null   object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 139.4+ KB\n",
            "None\n",
            "\n",
            "Sample rows from train_df:\n",
            "   label                                               text language  \\\n",
            "0      0  Rufen Sie die Nummer an, die nach Vereinbarung...       de   \n",
            "1      0  मैं इस के माध्यम से आगे नहीं बढ़ सकता. यह कभी ...       hi   \n",
            "2      0  En fait, mon mobile est plein de msg. Et je fa...       fr   \n",
            "3      1  Smamawawavon520 पर Smaka Pyr. 2 को फिर से करने...       hi   \n",
            "4      0          K.i did't see you.:)k:)where are you now?       en   \n",
            "\n",
            "                                  image_path  \n",
            "0  ham_images/zzz_412523576_045b3e623c_m.jpg  \n",
            "1      ham_images/zzz_82495_d51590f351_m.jpg  \n",
            "2      ham_images/zzz_65443_8037b212d7_m.jpg  \n",
            "3                 spam_images/D2gfNHPSLU.jpg  \n",
            "4       ham_images/zzz_7359_449584eb9a_m.jpg  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "from sklearn.model_selection import train_test_split\n",
        "from transformers import XLMRobertaTokenizer\n",
        "import torchvision.transforms as transforms\n",
        "import pandas as pd\n",
        "\n",
        "class SpamDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, texts, image_paths, labels, languages, tokenizer, transform):\n",
        "        self.texts = texts\n",
        "        self.image_paths = image_paths\n",
        "        self.labels = labels\n",
        "        self.languages = languages\n",
        "        self.tokenizer = tokenizer\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.labels)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        text = str(self.texts[idx])  # Ensure text is a string\n",
        "        image_path = self.image_paths[idx]\n",
        "        label = self.labels[idx]\n",
        "        language = self.languages[idx]\n",
        "\n",
        "        # Tokenize text\n",
        "        encoding = self.tokenizer(\n",
        "            text,\n",
        "            add_special_tokens=True,\n",
        "            max_length=512,\n",
        "            padding='max_length',\n",
        "            truncation=True,\n",
        "            return_tensors='pt'\n",
        "        )\n",
        "\n",
        "        # Load and transform image\n",
        "        try:\n",
        "            image = Image.open(image_path).convert('RGB')\n",
        "            image = self.transform(image)\n",
        "        except Exception as e:\n",
        "            print(f\"Error loading image {image_path}: {str(e)}\")\n",
        "            # Use a blank image as a fallback\n",
        "            image = torch.zeros(3, 224, 224)\n",
        "\n",
        "        return {\n",
        "            'input_ids': encoding['input_ids'].flatten(),\n",
        "            'attention_mask': encoding['attention_mask'].flatten(),\n",
        "            'image': image,\n",
        "            'label': torch.tensor(label, dtype=torch.long),\n",
        "            'language': language\n",
        "\n",
        "        }\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "sZo0u6nVP0Au"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import os\n",
        "\n",
        "\n",
        "def load_and_preprocess_data(csv_path, batch_size=32):\n",
        "    # Load data from CSV\n",
        "    df = pd.read_csv(csv_path)\n",
        "    print(f\"Loaded {len(df)} rows from {csv_path}\")\n",
        "\n",
        "    # Prepend the base directory to the image paths\n",
        "    # base_dir = 'sample_data'  # Adjust this if your directory structure is different\n",
        "    # df['image_path'] = df['image_path'].apply(lambda x: os.path.join(base_dir, x))\n",
        "    # Get the current working directory\n",
        "    base_dir = os.getcwd()\n",
        "\n",
        "    # Prepend the base directory to the image paths\n",
        "    df['image_path'] = df['image_path'].apply(lambda x: os.path.join(base_dir, x))\n",
        "\n",
        "    # Check if image files exist\n",
        "    existing_images = df[df['image_path'].apply(os.path.exists)]\n",
        "    missing_images = len(df) - len(existing_images)\n",
        "    print(f\"Found {len(existing_images)} images. {missing_images} images are missing.\")\n",
        "\n",
        "    # Print a few example paths\n",
        "    print(\"Example image paths:\")\n",
        "    print(df['image_path'].head())\n",
        "\n",
        "    # Define transforms for images\n",
        "    transform = transforms.Compose([\n",
        "        transforms.Resize((224, 224)),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "    ])\n",
        "\n",
        "    # Create datasets\n",
        "    tokenizer = XLMRobertaTokenizer.from_pretrained('xlm-roberta-base')\n",
        "    print(\"Tokenizer loaded\")\n",
        "\n",
        "    try:\n",
        "        train_dataset = SpamDataset(\n",
        "            train_df['text'].tolist(),\n",
        "            train_df['image_path'].tolist(),\n",
        "            train_df['label'].tolist(),\n",
        "            train_df['language'].tolist(),\n",
        "            tokenizer,\n",
        "            transform\n",
        "        )\n",
        "        print(\"Train dataset created successfully\")\n",
        "\n",
        "        test_dataset = SpamDataset(\n",
        "            test_df['text'].tolist(),\n",
        "            test_df['image_path'].tolist(),\n",
        "            test_df['label'].tolist(),\n",
        "            test_df['language'].tolist(),\n",
        "            tokenizer,\n",
        "            transform\n",
        "        )\n",
        "        print(\"Test dataset created successfully\")\n",
        "\n",
        "        # Create DataLoaders\n",
        "        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "        test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "        return train_loader, test_loader\n",
        "    except Exception as e:\n",
        "        print(f\"Error creating datasets: {str(e)}\")\n",
        "        raise"
      ],
      "metadata": {
        "id": "uH7_4rDnjEhc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.models as models\n",
        "from transformers import XLMRobertaModel\n",
        "\n",
        "\n",
        "class FeatureExtractor(nn.Module):\n",
        "    print(\"Class definition reached\")\n",
        "\n",
        "    def __init__(self):\n",
        "        print(\"Initializing FeatureExtractor\")\n",
        "        super(FeatureExtractor, self).__init__()\n",
        "\n",
        "        print(\"Loading ResNet152\")\n",
        "        self.image_encoder = models.resnet152(weights=models.ResNet152_Weights.DEFAULT)\n",
        "        self.image_encoder.fc = nn.Identity()\n",
        "\n",
        "        print(\"Loading XLM-RoBERTa\")\n",
        "        self.text_encoder = XLMRobertaModel.from_pretrained('xlm-roberta-base')\n",
        "\n",
        "        print(\"FeatureExtractor initialized\")\n",
        "\n",
        "    def forward(self, images, input_ids, attention_mask):\n",
        "        print(\"Forward method called\")\n",
        "        image_features = self.image_encoder(images)\n",
        "        text_outputs = self.text_encoder(input_ids=input_ids, attention_mask=attention_mask)\n",
        "        text_features = text_outputs.last_hidden_state[:, 0, :]\n",
        "        print(f\"Image features shape: {image_features.shape}\")\n",
        "        print(f\"Text features shape: {text_features.shape}\")\n",
        "        return image_features, text_features\n",
        "\n",
        "print(\"Creating FeatureExtractor instance\")\n",
        "feature_extractor = FeatureExtractor()\n",
        "print(\"FeatureExtractor instance created\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wJNYjcnxkwtC",
        "outputId": "d41b9b2b-43bd-438a-a41c-502276b49dfd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Class definition reached\n",
            "Creating FeatureExtractor instance\n",
            "Initializing FeatureExtractor\n",
            "Loading ResNet152\n",
            "Loading XLM-RoBERTa\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:89: UserWarning: \n",
            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
            "You will be able to reuse this secret in all of your notebooks.\n",
            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "FeatureExtractor initialized\n",
            "FeatureExtractor instance created\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Model Selection\n",
        "\n",
        "class AdvancedMMTD(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(AdvancedMMTD, self).__init__()\n",
        "\n",
        "        self.feature_extractor = FeatureExtractor()\n",
        "        print(\"Feature extractor loaded\")\n",
        "        # Multimodal Fusion Module\n",
        "        self.fusion = nn.Sequential(\n",
        "            nn.Linear(2048 + 768, 1024),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "            nn.Linear(1024, 512),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "            nn.Linear(512, 256),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "            nn.Linear(256, num_classes)\n",
        "        )\n",
        "\n",
        "        # Attention mechanism\n",
        "        self.attention = nn.MultiheadAttention(embed_dim=2048 + 768, num_heads=8)\n",
        "\n",
        "    def forward(self, images, input_ids, attention_mask):\n",
        "        # Extract features\n",
        "        image_features, text_features = self.feature_extractor(images, input_ids, attention_mask)\n",
        "\n",
        "        # Concatenate features\n",
        "        combined_features = torch.cat((image_features, text_features), dim=1)\n",
        "\n",
        "        # Apply attention mechanism\n",
        "        attended_features, _ = self.attention(combined_features.unsqueeze(0), combined_features.unsqueeze(0), combined_features.unsqueeze(0))\n",
        "        attended_features = attended_features.squeeze(0)\n",
        "\n",
        "        # Fusion and classification\n",
        "        output = self.fusion(attended_features)\n",
        "\n",
        "        return output\n"
      ],
      "metadata": {
        "id": "dQoyl0DElFbM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# 4. Training Process\n",
        "\n",
        "def train_model(model, train_loader, val_loader, num_epochs, lr, device, accumulation_steps=1):\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=0.01)\n",
        "    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5)\n",
        "\n",
        "    best_val_loss = float('inf')\n",
        "    for epoch in range(num_epochs):\n",
        "        model.train()\n",
        "        train_loss = 0.0\n",
        "        for i, batch in enumerate(train_loader):\n",
        "            input_ids = batch['input_ids'].to(device)\n",
        "            attention_mask = batch['attention_mask'].to(device)\n",
        "            images = batch['image'].to(device)\n",
        "            labels = batch['label'].to(device)\n",
        "\n",
        "            outputs = model(images, input_ids, attention_mask)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss = loss / accumulation_steps  # Normalize the loss\n",
        "            loss.backward()\n",
        "\n",
        "            if (i + 1) % accumulation_steps == 0:\n",
        "                optimizer.step()\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "            train_loss += loss.item() * accumulation_steps\n",
        "\n",
        "        # Calculate average training loss\n",
        "        train_loss /= len(train_loader)\n",
        "\n",
        "        # Validation loop\n",
        "        model.eval()\n",
        "        val_loss = 0.0\n",
        "        val_correct = 0\n",
        "        val_total = 0\n",
        "        with torch.no_grad():\n",
        "            for batch in val_loader:\n",
        "                input_ids = batch['input_ids'].to(device)\n",
        "                attention_mask = batch['attention_mask'].to(device)\n",
        "                images = batch['image'].to(device)\n",
        "                labels = batch['label'].to(device)\n",
        "\n",
        "                outputs = model(images, input_ids, attention_mask)\n",
        "                loss = criterion(outputs, labels)\n",
        "                val_loss += loss.item()\n",
        "\n",
        "                _, predicted = torch.max(outputs.data, 1)\n",
        "                val_total += labels.size(0)\n",
        "                val_correct += (predicted == labels).sum().item()\n",
        "\n",
        "        # Calculate average validation loss and accuracy\n",
        "        val_loss /= len(val_loader)\n",
        "        val_accuracy = val_correct / val_total\n",
        "\n",
        "        # Print epoch results\n",
        "        print(f'Epoch [{epoch+1}/{num_epochs}], '\n",
        "              f'Train Loss: {train_loss:.4f}, '\n",
        "              f'Val Loss: {val_loss:.4f}, '\n",
        "              f'Val Accuracy: {val_accuracy:.4f}')\n",
        "\n",
        "        # Learning rate scheduler step\n",
        "        scheduler.step(val_loss)\n",
        "\n",
        "        # Save the best model\n",
        "        if val_loss < best_val_loss:\n",
        "            best_val_loss = val_loss\n",
        "            torch.save(model.state_dict(), 'best_model.pth')\n",
        "            print(f'Best model saved with validation loss: {best_val_loss:.4f}')\n",
        "\n",
        "    print('Training completed.')\n",
        "    return model"
      ],
      "metadata": {
        "id": "2p1qYvDVlJ2k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# 5. Model Evaluation\n",
        "\n",
        "def evaluate_model(model, test_loader, device):\n",
        "    model.eval()\n",
        "    all_preds = []\n",
        "    all_labels = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for batch in test_loader:\n",
        "            input_ids = batch['input_ids'].to(device)\n",
        "            attention_mask = batch['attention_mask'].to(device)\n",
        "            images = batch['image'].to(device)\n",
        "            labels = batch['label'].to(device)\n",
        "\n",
        "            outputs = model(images, input_ids, attention_mask)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "\n",
        "            all_preds.extend(preds.cpu().numpy())\n",
        "            all_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    accuracy = accuracy_score(all_labels, all_preds)\n",
        "    precision = precision_score(all_labels, all_preds, average='weighted')\n",
        "    recall = recall_score(all_labels, all_preds, average='weighted')\n",
        "    f1 = f1_score(all_labels, all_preds, average='weighted')\n",
        "\n",
        "    print(f'Accuracy: {accuracy:.4f}')\n",
        "    print(f'Precision: {precision:.4f}')\n",
        "    print(f'Recall: {recall:.4f}')\n",
        "    print(f'F1 Score: {f1:.4f}')\n",
        "\n",
        "    # Confusion Matrix\n",
        "    cm = confusion_matrix(all_labels, all_preds)\n",
        "    plt.figure(figsize=(10,7))\n",
        "    sns.heatmap(cm, annot=True, fmt='d')\n",
        "    plt.title('Confusion Matrix')\n",
        "    plt.ylabel('Actual')\n",
        "    plt.xlabel('Predicted')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "yxeaTV88lMcD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vuU-IYzlcpeS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6fe615b4-c8c9-4a73-fa5b-bc3d87239dde"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cpu\n",
            "Loaded 17830 rows from train_multilingual_multimodal_spam.csv\n",
            "Found 17830 images. 0 images are missing.\n",
            "Example image paths:\n",
            "0    /content/ham_images/zzz_412523576_045b3e623c_m...\n",
            "1       /content/ham_images/zzz_82495_d51590f351_m.jpg\n",
            "2       /content/ham_images/zzz_65443_8037b212d7_m.jpg\n",
            "3                  /content/spam_images/D2gfNHPSLU.jpg\n",
            "4        /content/ham_images/zzz_7359_449584eb9a_m.jpg\n",
            "Name: image_path, dtype: object\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:1601: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted in transformers v4.45, and will be then set to `False` by default. For more details check this issue: https://github.com/huggingface/transformers/issues/31884\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenizer loaded\n",
            "Train dataset created successfully\n",
            "Test dataset created successfully\n",
            "Data loaded and preprocessed\n",
            "Initializing FeatureExtractor\n",
            "Loading ResNet152\n",
            "Loading XLM-RoBERTa\n",
            "FeatureExtractor initialized\n",
            "Feature extractor loaded\n",
            "Model initialized\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n",
            "Image features shape: torch.Size([4, 2048])\n",
            "Text features shape: torch.Size([4, 768])\n",
            "Forward method called\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Main execution\n",
        "if __name__ == '__main__':\n",
        "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "    print(f\"Using device: {device}\")\n",
        "\n",
        "    # Reduce batch size\n",
        "    batch_size = 4  # Start with a small batch size\n",
        "    train_loader, test_loader = load_and_preprocess_data('train_multilingual_multimodal_spam.csv', batch_size=batch_size)\n",
        "    print(\"Data loaded and preprocessed\")\n",
        "\n",
        "    # Use a smaller model for testing\n",
        "    model = AdvancedMMTD(num_classes=2).to(device)\n",
        "    print(\"Model initialized\")\n",
        "\n",
        "    # Reduce number of epochs for testing\n",
        "    num_epochs = 5\n",
        "    learning_rate = 2e-5\n",
        "\n",
        "    # Implement gradient accumulation\n",
        "    accumulation_steps = 8  # Accumulate gradients over 8 mini-batches\n",
        "    trained_model = train_model(model, train_loader, test_loader, num_epochs=num_epochs,\n",
        "                                lr=learning_rate, device=device, accumulation_steps=accumulation_steps)\n",
        "    print(\"Model training completed\")\n",
        "\n",
        "    # Evaluate model\n",
        "    print(\"Evaluating model...\")\n",
        "    evaluate_model(trained_model, test_loader, device)\n",
        "    print(\"Model evaluation completed\")\n",
        "\n",
        "    # Test model\n",
        "    print(\"Testing model...\")\n",
        "    test_predictions = test_model(trained_model, test_loader, device)\n",
        "    print(\"Model testing completed. Predictions are stored in 'test_predictions'.\")\n",
        "\n",
        "    # Save the trained model\n",
        "    print(\"Saving model...\")\n",
        "    torch.save(trained_model.state_dict(), 'trained_spam_model.pth')\n",
        "    print(\"Trained model saved to 'trained_spam_model.pth'\")\n",
        "\n",
        "    # Optional: Save test predictions to a file\n",
        "    import pandas as pd\n",
        "    test_df = pd.read_csv('test_multilingual_multimodal_spam.csv')\n",
        "    test_df['predicted_label'] = test_predictions\n",
        "    test_df.to_csv('test_results_with_predictions.csv', index=False)\n",
        "    print(\"Test results with predictions saved to 'test_results_with_predictions.csv'\")\n",
        "\n",
        "    print(\"All processes completed successfully!\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# 6. Model Testing\n",
        "\n",
        "def test_model(model, test_loader, device):\n",
        "    model.eval()\n",
        "    all_preds = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for batch in test_loader:\n",
        "            input_ids = batch['input_ids'].to(device)\n",
        "            attention_mask = batch['attention_mask'].to(device)\n",
        "            images = batch['image'].to(device)\n",
        "\n",
        "            outputs = model(images, input_ids, attention_mask)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "\n",
        "            all_preds.extend(preds.cpu().numpy())\n",
        "\n",
        "    return all_preds\n"
      ],
      "metadata": {
        "id": "mu_M1ZNOlPyr"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}