trainMobileNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train model with MobileNetV3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "from pathlib import Path\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import transforms\n",
    "\n",
    "from vocab import Vocab\n",
    "from dataset import Paint2CodeDataset\n",
    "from utils import collate_fn, save_model\n",
    "from modelArchitecture.modelMobileNetV3 import Encoder, Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_transformation(img_crop_size):\n",
    "    return transforms.Compose([\n",
    "        transforms.Resize((img_crop_size, img_crop_size)),  # Resize the image\n",
    "        transforms.ToTensor(),  # Convert the image to tensor\n",
    "        transforms.Normalize([0.930213], [0.216819]),  # Normalize the image\n",
    "    ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = Path(\"data\", \"all_data\")\n",
    "vocab_file_path = Path(data_path.parent, \"vocab.txt\")\n",
    "use_cuda = True  \n",
    "img_size = 224\n",
    "save_after_epochs = 101\n",
    "models_dir = Path(\"./modelsMobileNet/models\")\n",
    "batch_size = 4\n",
    "epochs = 150\n",
    "lr = 0.001\n",
    "seed = 42\n",
    "\n",
    "# Seed setup for reproducibility\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"START\": 0,\n",
      "  \"END\": 1,\n",
      "  \"PADDING\": 2,\n",
      "  \"UNKNOWN\": 3,\n",
      "  \",\": 4,\n",
      "  \"btn-body\": 5,\n",
      "  \"btn-header\": 6,\n",
      "  \"double\": 7,\n",
      "  \"header\": 8,\n",
      "  \"image\": 9,\n",
      "  \"quadruple\": 10,\n",
      "  \"row\": 11,\n",
      "  \"single\": 12,\n",
      "  \"small-title\": 13,\n",
      "  \"text\": 14,\n",
      "  \"{\": 15,\n",
      "  \"}\": 16\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "vocab = Vocab(vocab_file_path)\n",
    "assert len(vocab) > 0, \"Vocabulary must be non-empty\"\n",
    "\n",
    "print(vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup GPU for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() and use_cuda else \"cpu\")\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data loader for train created successfully.\n",
      "Data loader for val  created successfully.\n"
     ]
    }
   ],
   "source": [
    "transform_imgs = img_transformation(img_size)\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    Paint2CodeDataset(data_path, \"train\", vocab, transform=transform_imgs),\n",
    "    batch_size=batch_size,\n",
    "    collate_fn=lambda data: collate_fn(data, vocab=vocab),\n",
    "    pin_memory=True if use_cuda else False,\n",
    "    drop_last=True\n",
    ")\n",
    "print(\"Data loader for train created successfully.\")\n",
    "\n",
    "val_loader = DataLoader(\n",
    "    Paint2CodeDataset(data_path,\"validation\", vocab, transform=transform_imgs),\n",
    "    batch_size=batch_size,\n",
    "    collate_fn=lambda data: collate_fn(data, vocab=vocab),\n",
    "    pin_memory=True if use_cuda else False,\n",
    "    drop_last=True\n",
    ")\n",
    "print(\"Data loader for val  created successfully.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set model parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Models are initialized and moved to the designated device.\n"
     ]
    }
   ],
   "source": [
    "embed_size = 64\n",
    "hidden_size = 256\n",
    "num_layers = 2\n",
    "\n",
    "# Initialize the Encoder and Decoder\n",
    "encoder = Encoder(embed_size).to(device)\n",
    "decoder = Decoder(embed_size, hidden_size, len(vocab), num_layers).to(device)\n",
    "\n",
    "print(\"Models are initialized and moved to the designated device.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define loss function and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss function and optimizer are set.\n"
     ]
    }
   ],
   "source": [
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "params = list(decoder.parameters()) + list(encoder.parameters())\n",
    "optimizer = torch.optim.Adam(params, lr=lr)\n",
    "\n",
    "print(\"Loss function and optimizer are set.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training...\n",
      "Epoch 0: Training Loss 0.3794, val Loss 0.1190\n",
      "Epoch 1: Training Loss 0.1181, val Loss 0.1065\n",
      "Epoch 2: Training Loss 0.1054, val Loss 0.0910\n",
      "Epoch 3: Training Loss 0.0966, val Loss 0.0867\n",
      "Epoch 4: Training Loss 0.0997, val Loss 0.0830\n",
      "Epoch 5: Training Loss 0.0891, val Loss 0.0784\n",
      "Epoch 6: Training Loss 0.0846, val Loss 0.0729\n",
      "Epoch 7: Training Loss 0.0821, val Loss 0.0707\n",
      "Epoch 8: Training Loss 0.0799, val Loss 0.0824\n",
      "Epoch 9: Training Loss 0.0789, val Loss 0.0717\n",
      "Epoch 10: Training Loss 0.0769, val Loss 0.0698\n",
      "Epoch 11: Training Loss 0.0762, val Loss 0.0706\n",
      "Epoch 12: Training Loss 0.0781, val Loss 0.0710\n",
      "Epoch 13: Training Loss 0.0792, val Loss 0.0690\n",
      "Epoch 14: Training Loss 0.0759, val Loss 0.0699\n",
      "Epoch 15: Training Loss 0.0740, val Loss 0.0989\n",
      "Epoch 16: Training Loss 0.0756, val Loss 0.0678\n",
      "Epoch 17: Training Loss 0.0767, val Loss 0.0684\n",
      "Epoch 18: Training Loss 0.0756, val Loss 0.0678\n",
      "Epoch 19: Training Loss 0.0726, val Loss 0.0675\n",
      "Epoch 20: Training Loss 0.0723, val Loss 0.0671\n",
      "Epoch 21: Training Loss 0.0729, val Loss 0.0672\n",
      "Epoch 22: Training Loss 0.0718, val Loss 0.0670\n",
      "Epoch 23: Training Loss 0.0711, val Loss 0.0669\n",
      "Epoch 24: Training Loss 0.0742, val Loss 0.0677\n",
      "Epoch 25: Training Loss 0.0745, val Loss 0.0673\n",
      "Epoch 26: Training Loss 0.0718, val Loss 0.0682\n",
      "Epoch 27: Training Loss 0.0711, val Loss 0.0671\n",
      "Epoch 28: Training Loss 0.0712, val Loss 0.0672\n",
      "Epoch 29: Training Loss 0.0711, val Loss 0.0672\n",
      "Epoch 30: Training Loss 0.0706, val Loss 0.0670\n",
      "Epoch 31: Training Loss 0.0712, val Loss 0.0677\n",
      "Epoch 32: Training Loss 0.0707, val Loss 0.0670\n",
      "Epoch 33: Training Loss 0.0701, val Loss 0.0670\n",
      "Epoch 34: Training Loss 0.0701, val Loss 0.0667\n",
      "Epoch 35: Training Loss 0.0710, val Loss 0.0666\n",
      "Epoch 36: Training Loss 0.0709, val Loss 0.0671\n",
      "Epoch 37: Training Loss 0.0721, val Loss 0.0668\n",
      "Epoch 38: Training Loss 0.0733, val Loss 0.0677\n",
      "Epoch 39: Training Loss 0.0724, val Loss 0.0674\n",
      "Epoch 40: Training Loss 0.0702, val Loss 0.0672\n",
      "Epoch 41: Training Loss 0.0695, val Loss 0.0669\n",
      "Epoch 42: Training Loss 0.0703, val Loss 0.0668\n",
      "Epoch 43: Training Loss 0.0694, val Loss 0.0670\n",
      "Epoch 44: Training Loss 0.0692, val Loss 0.0669\n",
      "Epoch 45: Training Loss 0.0697, val Loss 0.0671\n",
      "Epoch 46: Training Loss 0.0700, val Loss 0.0670\n",
      "Epoch 47: Training Loss 0.0685, val Loss 0.0666\n",
      "Epoch 48: Training Loss 0.0681, val Loss 0.0664\n",
      "Epoch 49: Training Loss 0.0681, val Loss 0.0663\n",
      "Epoch 50: Training Loss 0.0685, val Loss 0.0685\n",
      "Epoch 51: Training Loss 0.0704, val Loss 0.0677\n",
      "Epoch 52: Training Loss 0.0685, val Loss 0.0662\n",
      "Epoch 53: Training Loss 0.0684, val Loss 0.0663\n",
      "Epoch 54: Training Loss 0.0690, val Loss 0.0643\n",
      "Epoch 55: Training Loss 0.0687, val Loss 0.0646\n",
      "Epoch 56: Training Loss 0.0681, val Loss 0.0647\n",
      "Epoch 57: Training Loss 0.0673, val Loss 0.0635\n",
      "Epoch 58: Training Loss 0.0670, val Loss 0.0628\n",
      "Epoch 59: Training Loss 0.0669, val Loss 0.0630\n",
      "Epoch 60: Training Loss 0.0666, val Loss 0.0641\n",
      "Epoch 61: Training Loss 0.0660, val Loss 0.0615\n",
      "Epoch 62: Training Loss 0.0657, val Loss 0.0715\n",
      "Epoch 63: Training Loss 0.0657, val Loss 0.0741\n",
      "Epoch 64: Training Loss 0.0671, val Loss 0.0616\n",
      "Epoch 65: Training Loss 0.0641, val Loss 0.0610\n",
      "Epoch 66: Training Loss 0.0647, val Loss 0.0581\n",
      "Epoch 67: Training Loss 0.0640, val Loss 0.0598\n",
      "Epoch 68: Training Loss 0.0633, val Loss 0.0586\n",
      "Epoch 69: Training Loss 0.0629, val Loss 0.0626\n",
      "Epoch 70: Training Loss 0.0633, val Loss 0.0575\n",
      "Epoch 71: Training Loss 0.0627, val Loss 0.0562\n",
      "Epoch 72: Training Loss 0.0618, val Loss 0.0562\n",
      "Epoch 73: Training Loss 0.0635, val Loss 0.0562\n",
      "Epoch 74: Training Loss 0.0628, val Loss 0.0562\n",
      "Epoch 75: Training Loss 0.0604, val Loss 0.0561\n",
      "Epoch 76: Training Loss 0.0593, val Loss 0.0549\n",
      "Epoch 77: Training Loss 0.0599, val Loss 0.0549\n",
      "Epoch 78: Training Loss 0.0592, val Loss 0.0545\n",
      "Epoch 79: Training Loss 0.0601, val Loss 0.0540\n",
      "Epoch 80: Training Loss 0.0599, val Loss 0.0555\n",
      "Epoch 81: Training Loss 0.0585, val Loss 0.0552\n",
      "Epoch 82: Training Loss 0.0585, val Loss 0.0557\n",
      "Epoch 83: Training Loss 0.0604, val Loss 0.0590\n",
      "Epoch 84: Training Loss 0.0599, val Loss 0.0548\n",
      "Epoch 85: Training Loss 0.0583, val Loss 0.0559\n",
      "Epoch 86: Training Loss 0.0582, val Loss 0.0556\n",
      "Epoch 87: Training Loss 0.0600, val Loss 0.0589\n",
      "Epoch 88: Training Loss 0.0600, val Loss 0.0545\n",
      "Epoch 89: Training Loss 0.0588, val Loss 0.0544\n",
      "Epoch 90: Training Loss 0.0580, val Loss 0.0550\n",
      "Epoch 91: Training Loss 0.0595, val Loss 0.0556\n",
      "Epoch 92: Training Loss 0.0590, val Loss 0.0545\n",
      "Epoch 93: Training Loss 0.0585, val Loss 0.0557\n",
      "Epoch 94: Training Loss 0.0587, val Loss 0.0561\n",
      "Epoch 95: Training Loss 0.0573, val Loss 0.0545\n",
      "Epoch 96: Training Loss 0.0582, val Loss 0.0560\n",
      "Epoch 97: Training Loss 0.0596, val Loss 0.0558\n",
      "Epoch 98: Training Loss 0.0576, val Loss 0.0547\n",
      "Epoch 99: Training Loss 0.0568, val Loss 0.0536\n",
      "Epoch 100: Training Loss 0.0563, val Loss 0.0538\n",
      "Epoch 101: Training Loss 0.0566, val Loss 0.0536\n",
      "Saved model checkpoint at epoch: 101\n",
      "Epoch 102: Training Loss 0.0557, val Loss 0.0532\n",
      "Epoch 103: Training Loss 0.0548, val Loss 0.0556\n",
      "Epoch 104: Training Loss 0.0559, val Loss 0.0536\n",
      "Epoch 105: Training Loss 0.0556, val Loss 0.0545\n",
      "Epoch 106: Training Loss 0.0561, val Loss 0.0548\n",
      "Epoch 107: Training Loss 0.0588, val Loss 0.0707\n",
      "Epoch 108: Training Loss 0.0573, val Loss 0.0543\n",
      "Epoch 109: Training Loss 0.0561, val Loss 0.0544\n",
      "Epoch 110: Training Loss 0.0558, val Loss 0.0552\n",
      "Epoch 111: Training Loss 0.0571, val Loss 0.0541\n",
      "Epoch 112: Training Loss 0.0564, val Loss 0.0535\n",
      "Epoch 113: Training Loss 0.0550, val Loss 0.0552\n",
      "Epoch 114: Training Loss 0.0605, val Loss 0.0666\n",
      "Epoch 115: Training Loss 0.0642, val Loss 0.0540\n",
      "Epoch 116: Training Loss 0.0584, val Loss 0.0554\n",
      "Epoch 117: Training Loss 0.0567, val Loss 0.0530\n",
      "Epoch 118: Training Loss 0.0546, val Loss 0.0527\n",
      "Epoch 119: Training Loss 0.0541, val Loss 0.0527\n",
      "Epoch 120: Training Loss 0.0540, val Loss 0.0522\n",
      "Epoch 121: Training Loss 0.0529, val Loss 0.0539\n",
      "Epoch 122: Training Loss 0.0537, val Loss 0.0526\n",
      "Epoch 123: Training Loss 0.0534, val Loss 0.0534\n",
      "Epoch 124: Training Loss 0.0528, val Loss 0.0535\n",
      "Epoch 125: Training Loss 0.0532, val Loss 0.0541\n",
      "Epoch 126: Training Loss 0.0541, val Loss 0.0511\n",
      "Epoch 127: Training Loss 0.0533, val Loss 0.0514\n",
      "Epoch 128: Training Loss 0.0549, val Loss 0.0553\n",
      "Epoch 129: Training Loss 0.0536, val Loss 0.0524\n",
      "Epoch 130: Training Loss 0.0528, val Loss 0.0517\n",
      "Epoch 131: Training Loss 0.0521, val Loss 0.0512\n",
      "Epoch 132: Training Loss 0.0515, val Loss 0.0526\n",
      "Epoch 133: Training Loss 0.0514, val Loss 0.0576\n",
      "Epoch 134: Training Loss 0.0520, val Loss 0.0542\n",
      "Epoch 135: Training Loss 0.0508, val Loss 0.0528\n",
      "Epoch 136: Training Loss 0.0512, val Loss 0.0528\n",
      "Epoch 137: Training Loss 0.0508, val Loss 0.0517\n",
      "Epoch 138: Training Loss 0.0500, val Loss 0.0511\n",
      "Epoch 139: Training Loss 0.0503, val Loss 0.0499\n",
      "Epoch 140: Training Loss 0.0514, val Loss 0.0587\n",
      "Epoch 141: Training Loss 0.0523, val Loss 0.0512\n",
      "Epoch 142: Training Loss 0.0504, val Loss 0.0509\n",
      "Epoch 143: Training Loss 0.0498, val Loss 0.0685\n",
      "Epoch 144: Training Loss 0.0503, val Loss 0.0509\n",
      "Epoch 145: Training Loss 0.0507, val Loss 0.0521\n",
      "Epoch 146: Training Loss 0.0496, val Loss 0.0534\n",
      "Epoch 147: Training Loss 0.0503, val Loss 0.0511\n",
      "Epoch 148: Training Loss 0.0494, val Loss 0.0505\n",
      "Epoch 149: Training Loss 0.0484, val Loss 0.0508\n",
      "Training completed!\n"
     ]
    }
   ],
   "source": [
    "# Initialize lists to store the average losses per epoch\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "\n",
    "print(\"Starting training...\")\n",
    "for epoch in range(epochs):\n",
    "    # Training phase\n",
    "    encoder.train()  # Set the encoder to training mode\n",
    "    decoder.train()  # Set the decoder to training mode\n",
    "    total_train_loss = 0\n",
    "    num_batches = 0\n",
    "\n",
    "    for images, captions, lengths in train_loader:\n",
    "        images = images.to(device)\n",
    "        captions = captions.to(device)\n",
    "        targets = torch.nn.utils.rnn.pack_padded_sequence(captions, lengths, batch_first=True)[0]\n",
    "\n",
    "        # Zero the gradients\n",
    "        encoder.zero_grad()\n",
    "        decoder.zero_grad()\n",
    "\n",
    "        # Forward pass\n",
    "        features = encoder(images)\n",
    "        output = decoder(features, captions, lengths)\n",
    "\n",
    "        # Calculate loss\n",
    "        loss = criterion(output, targets)\n",
    "        total_train_loss += loss.item()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        num_batches += 1\n",
    "\n",
    "    avg_train_loss = total_train_loss / num_batches\n",
    "    train_losses.append(avg_train_loss)  # Append the average training loss\n",
    "\n",
    "    # val phase\n",
    "    encoder.eval()  # Set the encoder to evaluation mode\n",
    "    decoder.eval()  # Set the decoder to evaluation mode\n",
    "    total_val_loss = 0\n",
    "    num_val_batches = 0\n",
    "\n",
    "    with torch.no_grad():  # No need to track gradients during val\n",
    "        for images, captions, lengths in val_loader:\n",
    "            images = images.to(device)\n",
    "            captions = captions.to(device)\n",
    "            targets = torch.nn.utils.rnn.pack_padded_sequence(captions, lengths, batch_first=True)[0]\n",
    "\n",
    "            # Forward pass\n",
    "            features = encoder(images)\n",
    "            output = decoder(features, captions, lengths)\n",
    "\n",
    "            # Calculate loss\n",
    "            loss = criterion(output, targets)\n",
    "            total_val_loss += loss.item()\n",
    "            num_val_batches += 1\n",
    "\n",
    "    avg_val_loss = total_val_loss / num_val_batches\n",
    "    val_losses.append(avg_val_loss)  # Append the average val loss\n",
    "\n",
    "    # Print integrated loss statistics in one line\n",
    "    print(f'Epoch {epoch}: Training Loss {avg_train_loss:.4f}, val Loss {avg_val_loss:.4f}')\n",
    "\n",
    "    #Save model checkpoint\n",
    "    if epoch != 0 and epoch % save_after_epochs == 0:\n",
    "        save_model(models_dir, encoder, decoder, optimizer, epoch, avg_val_loss, batch_size, vocab)\n",
    "        print(\"Saved model checkpoint at epoch:\", epoch)\n",
    "\n",
    "print(\"Training completed!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the training and val losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(train_losses, label='Training Loss')\n",
    "plt.plot(val_losses, label='val Loss')\n",
    "plt.title('Training and val Losses Across Epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}