vision_transformer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ee0c701d-0b6e-40e1-9827-6478d1cf6914",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import torch\n",
    "from torch import nn\n",
    "\n",
    "class NewGELUActivation(nn.Module):\n",
    "    \"\"\"\n",
    "    Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT). Also see\n",
    "    the Gaussian Error Linear Units paper: https://arxiv.org/abs/1606.08415\n",
    "\n",
    "    Taken from https://github.com/huggingface/transformers/blob/main/src/transformers/activations.py\n",
    "    \"\"\"\n",
    "\n",
    "    def forward(self, input):\n",
    "        return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (input + 0.044715 * torch.pow(input, 3.0))))\n",
    "\n",
    "class PatchEmbeddings(nn.Module):\n",
    "    #Convert the image into patches and then projection \n",
    "\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.image_size = config[\"image_size\"]\n",
    "        self.patch_size = config[\"patch_size\"]\n",
    "        self.num_channels = config[\"num_channels\"]\n",
    "        self.hidden_size = config[\"hidden_size\"]\n",
    "\n",
    "        self.num_patches = (self.image_size // self.patch_size) ** 2\n",
    "\n",
    "        self.projection = nn.Conv2d(self.num_channels, self.hidden_size, kernel_size=self.patch_size, stride=self.patch_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.projection(x)\n",
    "        x = x.flatten(2).transpose(1, 2)\n",
    "        return x\n",
    "\n",
    "class Embeddings(nn.Module):\n",
    "    #Combine the patch embeddings with the class token and position embeddings.\n",
    "\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.config = config\n",
    "        self.patch_embeddings = PatchEmbeddings(config)\n",
    "\n",
    "        #making a token that can be added to input sequence and used to classify\n",
    "        self.classify_t = nn.Parameter(torch.randn(1, 1, config[\"hidden_size\"]))\n",
    "\n",
    "        #create position embeddings for the token and patch embeddings and adding 1 to sequence length for the token\n",
    "        self.position_embeddings = \\\n",
    "            nn.Parameter(torch.randn(1, self.patch_embeddings.num_patches + 1, config[\"hidden_size\"]))\n",
    "        self.Dropout = nn.Dropout(config[\"hidden_dropout_prob\"])\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.patch_embeddings(x)\n",
    "        batch_size, _, _ = x.size()\n",
    "\n",
    "        classify_ts = self.classify_token.expand(batch_size, -1, -1)\n",
    "\n",
    "        x = torch.cat((classify_ts, x), dim=1)\n",
    "        x = x + self.position_embeddings\n",
    "        x = self.dropout(x)\n",
    "        return x\n",
    "\n",
    "class AttentionHead(nn.Module):\n",
    "    #single attention head\n",
    "    #multiple of these are used in multihead attention\n",
    "\n",
    "    def __init__(self, hidden_size, attention_head_size, dropout, bias=True):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.attention_head_size = attention_head_size\n",
    "\n",
    "        #creating query, key and value projection layers\n",
    "        self.query = nn.Linear(hidden_size, attention_head_size, bias=bias)\n",
    "        self.key = nn.Linear(hidden_size, attention_head_size, bias=bias)\n",
    "        self.value = nn.Linear(hidden_size, attention_head_size, bias=bias)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        #projecting the input in query, key and value\n",
    "        #then using the same to generate the query, value, and key\n",
    "        query = self.query(x)\n",
    "        key = self.key(x)\n",
    "        value = self.value(x)\n",
    "\n",
    "        #attention scores\n",
    "        #softmax(Q*K.T/sqrt(head_size))*V\n",
    "        attention_scores = torch.matmul(query, key.transpose(-1, -2))\n",
    "        attention_score = attention_scores / math.sqrt(self.attention_head_size)\n",
    "        attention_probs = nn.functional.softmax(attention_scores, dim=-1)\n",
    "        attention_probs = self.Dropout(attention_probs)\n",
    "\n",
    "        #calculate the attention output\n",
    "        attention_output = torch.matmul(attention_probs, value)\n",
    "        return (attention_output, attention_probs)\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    #multi head attention\n",
    "    #this module is used in Transformer encode module\n",
    "\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.hidden_size = config[\"hidden_size\"]\n",
    "        self.num_attention_heads = config[\"num_attention_heads\"]\n",
    "\n",
    "        #calculation attention head size\n",
    "        self.attention_head_size = self.hidden_size // self.num_attention_heads\n",
    "        self.all_head_size = self.num_attention_heads * self.attention_head_size\n",
    "\n",
    "        #to use bias or not in projections\n",
    "        self.qkv_bias = config[\"bias\"]\n",
    "        \n",
    "        #Create a list of attention heads\n",
    "        self.heads = nn.ModuleList([])\n",
    "        for _ in range(self.num_attention_heads):\n",
    "            head = AttentionHead(self.hidden_size, self.attention_head_size, config[\"attention_probs_dropout_prob\"], self.qkv_bias)\n",
    "            self.heads.append(head)\n",
    "            \n",
    "        #Creating a linear layer to project the attention output back to hidden size\n",
    "        self.output_projection = nn.Linear(self.all_head_size, self.hidden_size)\n",
    "        self.output_dropout = nn.Dropout(config[\"hidden_output_prob\"])\n",
    "\n",
    "    def forward(self, x, output_attentions=False):\n",
    "        #Calculation attention for each attention head\n",
    "        attention_outputs = [head(x) for head in self.heads]\n",
    "        #Concatenate the attention outputs from each attention heads\n",
    "        attention_output = torch.cat([attention_output for attention_output, _ in attention_outputs], dim=-1)\n",
    "        #Projecting the concatenated attention ouput back to hidden_size\n",
    "        attention_output = self.output_projection(attention_output)\n",
    "        attention_output = self.output_dropout(attention_output)\n",
    "        #Return the attention output and the attention probabalities\n",
    "        if not output_attentions:\n",
    "            return(attention_output, None)\n",
    "        else:\n",
    "            attention_probs = torch.stack([attention_probs for _, attention_probs in attention_outputs], dim=1)\n",
    "            return (attention_output, attention_probs)\n",
    "\n",
    "class MLP(nn.Module):\n",
    "   # Multilayer perceptron module\n",
    "   \n",
    "   def __init__(self, config):\n",
    "      super().__init__()\n",
    "      self.dense1 = nn.Linear(config[\"hidden_size\"], config[\"intermediate_size\"])\n",
    "      self.activation = NewGELUActivation()\n",
    "      self.dense2 = nn.Linear(config[\"intermediate_size\"], config[\"hidden_size\"])\n",
    "      self.dropout = nn.Dropout(config[\"hidden_dropout_prob\"])\n",
    "      \n",
    "   def forward(self, x):\n",
    "      x = self.dense1(x)\n",
    "      x = self.activation(x)\n",
    "      x = self.dense2(x)\n",
    "      x = self.dropout(x)\n",
    "      return x\n",
    "\n",
    "class Block(nn.Module):\n",
    "   #a single transformer block\n",
    "   \n",
    "   def __init__(self, config):\n",
    "      super().__init__()\n",
    "      self.attention = MultiHeadAttention(config)\n",
    "      self.layernorm1 = nn.LayerNorm(config[\"hidden_size\"])\n",
    "      self.mlp = MLP(config)\n",
    "      self.layernorm2 = nn.LayerNorm(config[\"hidden_size\"])\n",
    "      \n",
    "   def forward(self, x, output_attentions=False):\n",
    "      #Self attention\n",
    "      attention_output, attention_probs = \\\n",
    "         self.attention(self.layernorm1(x), output_attentions=output_attentions)\n",
    "      #skip connection\n",
    "      x += attention_output\n",
    "      #Feed forward network\n",
    "      mlp_output = self.mlp(self.layernorm2(x))\n",
    "      #skip connection\n",
    "      x += mlp_output\n",
    "      #Returning the transformer's block output and the attention probabilities\n",
    "      if not output_attentions:\n",
    "         return(x, None)\n",
    "      else:\n",
    "         return(x, attention_probs)\n",
    "\n",
    "class Encoder(nn.Module):\n",
    "   # transformer encoder module\n",
    "   \n",
    "   def __init__(self, config):\n",
    "      super().__init__()\n",
    "      #Creating a transformer block\n",
    "      self.blocks = nn.ModuleList([])\n",
    "      for _ in range(config[\"num_hidden_layers\"]):\n",
    "         block = Block(config)\n",
    "         self.blocks.append(block)\n",
    "         \n",
    "   def forward(self, x, output_attentions=False):\n",
    "      #Caculate the transformer block's output for each block\n",
    "      all_attentions = []\n",
    "      for block  in self.blocks:\n",
    "         x, attention_probs = block(x, output_attentions=output_attentions)\n",
    "         if output_attentions:\n",
    "            all_attentions.append(attention_probs)\n",
    "      #Return encoder's output and the attention probabilities\n",
    "      if not output_attentions:\n",
    "         return(x, None)\n",
    "      else:\n",
    "         return(x, all_attentions)\n",
    "\n",
    "class ViTForClassification(nn.Module):\n",
    "   #the Vision transformer for classfication\n",
    "   \n",
    "   def __init__(self, config):\n",
    "      super().__init__()\n",
    "      self.config = config\n",
    "      self.image_size = config[\"image_size\"]\n",
    "      self.hidden_size = config[\"hidden_size\"]\n",
    "      self.num_classes = config[\"num_classes\"]\n",
    "      #Create embedding module\n",
    "      self.embedding = Embeddings(config)\n",
    "      #Create the transformer encoder module\n",
    "      self.encoder = Encoder(config)\n",
    "      #Create a linear layer to project the encoder's output to the number of classes\n",
    "      self.classifier = nn.Linear(self.hidden_size, self.num_classes)\n",
    "      #Initialize the weights\n",
    "      self.apply(self._init_weights)\n",
    "      \n",
    "   def forward(self, x, output_attentions=False):\n",
    "      #Calculate the embedding output\n",
    "      embedding_output = self.embedding(x)\n",
    "      #Calculate the encoder's output\n",
    "      encoder_output, all_attentions = self.encoder(embedding_output, output_attentions=output_attentions)\n",
    "      #Calculate the logits, taking the Classify token's output as feature for classfication\n",
    "      logits = self.classifier(encoder_output[:, 0])\n",
    "      #Return the logits and the attention probabailities\n",
    "      if not output_attentions:\n",
    "         return(logits, None)\n",
    "      else:\n",
    "         return(logits, all_attentions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4d219d5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import librariesnn.Relu\n",
    "import torch\n",
    "import torch.utils.data\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "\n",
    "def prepare_data(batch_size=4, num_workers=2, train_sample_size=None, test_sample_size=None):\n",
    "    train_transform = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.RandomHorizontalFlip(p=0.5),\n",
    "        transforms.RandomResizedCrop((32, 32), scale=(0.8, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=2),\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                            download=True, transform=train_transform)\n",
    "    if train_sample_size is not None:\n",
    "        # Randomly sample a subset of the training set\n",
    "        indices = torch.randperm(len(trainset))[:train_sample_size]\n",
    "        trainset = torch.utils.data.Subset(trainset, indices)\n",
    "    \n",
    "\n",
    "\n",
    "    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                            shuffle=True, num_workers=num_workers)\n",
    "    \n",
    "    test_transform = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "    testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                        download=True, transform=test_transform)\n",
    "    if test_sample_size is not None:\n",
    "        # Randomly sample a subset of the test set\n",
    "        indices = torch.randperm(len(testset))[:test_sample_size]\n",
    "        testset = torch.utils.data.Subset(testset, indices)\n",
    "    \n",
    "    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\n",
    "    classes = ('deer', 'car', 'frog', 'horse', 'ship', 'truck', 'cat', 'bird', 'plane', 'dog')\n",
    "    return trainloader, testloader, classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "abf9b8f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json, os, math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.nn import functional as F\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "from vit import ViTForClassification\n",
    "\n",
    "def save_experiment(experiment_name, config, model, train_losses, test_losses, accuracies, base_dir=\"experiments\"):\n",
    "    outdir = os.path.join(base_dir, experiment_name)\n",
    "    os.makedirs(outdir, exist_ok=True)\n",
    "\n",
    "    #Save the config\n",
    "    configfile = os.path.join(outdir, 'config.json')\n",
    "    try:\n",
    "        with open(configfile, 'w') as f:\n",
    "            json.dump(config, f, sort_keys=True, indent=4)\n",
    "    except TypeError as e:\n",
    "        print(f\"Error saving config: {e}\")\n",
    "        raise\n",
    "\n",
    "    #Save the metrics\n",
    "    jsonfile = os.path.join(outdir, 'metrics.json')\n",
    "    data = {\n",
    "        'train_losses': train_losses,\n",
    "        'test_losses': test_losses,\n",
    "        'accuracies': accuracies,\n",
    "    }\n",
    "    \n",
    "    try:\n",
    "        with open(jsonfile, 'w') as f:\n",
    "            json.dump(data, f, sort_keys=True, indent=4)\n",
    "    except:\n",
    "        print(f\"Error saving metrics: {e}\")\n",
    "        for key, value in data.items():\n",
    "            try:\n",
    "                json.dumps(value)\n",
    "            except ValueError as ve:\n",
    "                print(f\"Circular reference found in {key}: {ve}\")\n",
    "        raise\n",
    "\n",
    "    #Save the model\n",
    "    save_checkpoint(experiment_name, model, \"final\", base_dir=base_dir)\n",
    "\n",
    "def save_checkpoint(experiment_name, model, epoch, base_dir=\"experiments\"):\n",
    "    outdir = os.path.join(base_dir, experiment_name)\n",
    "    os.makedirs(outdir, exist_ok=True)\n",
    "    model_path = os.path.join(outdir, f\"model_epoch_{epoch}.pth\")\n",
    "    torch.save(model.state_dict(), model_path)\n",
    " \n",
    "def load_experiment(experiment_name, checkpoint_name=\"model_final.pt\", base_dir=\"experiments\"):\n",
    "    outdir = os.path.join(base_dir, experiment_name)\n",
    "\n",
    "    #Load the config\n",
    "    configfile = os.path.join(outdir,'config.json')\n",
    "    with open(configfile, 'r') as f:\n",
    "        config = json.load(f)\n",
    "    #Load the metrics\n",
    "    jsonfile = os.path.join(outdir, 'metrics.json')\n",
    "    with open(jsonfile, 'metrics.json'):\n",
    "        data = json.load(f)\n",
    "    train_losses = data['train_losses']\n",
    "    test_losses = data['test_losses']\n",
    "    accuracies = data['accuracies']\n",
    "\n",
    "    #Load the model\n",
    "    model = ViTForClassification(config)\n",
    "    cpfile = os.path.join(outdir, checkpoint_name)\n",
    "    model.load_state_dict(torch.load(cpfile))\n",
    "    return config, model, train_losses, test_losses, accuracies\n",
    "\n",
    "def visualize_images():\n",
    "    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True)\n",
    "\n",
    "    classes = ('deer', 'car', 'frog', 'horse', 'ship', 'truck', 'cat', 'bird', 'plane', 'dog')\n",
    "    #pick any 30 samples randomly\n",
    "    indices = torch.randperm(len(trainset))[:30]\n",
    "    images = [np.asarray(trainset[i][0]) for i in indices]\n",
    "    labels = [trainset[i][1] for i in indices]\n",
    "    \n",
    "    #Visualizing using matplotlib\n",
    "    fig = plt.figure(figsize=(10, 10))\n",
    "    for i in range(30):\n",
    "        ax = fig.add_subplot(6, 5, i+1, xticks=[], yticks=[])\n",
    "        ax.imshow(images[1])\n",
    "        ax.set_title(classes[labels[i]])\n",
    "\n",
    "@torch.no_grad()\n",
    "def visualize_attention(model, output=None, device=\"cuda\"):\n",
    "    #Attention maps for first 5 images\n",
    "    model.eval()\n",
    "    num_images = 30\n",
    "    testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True)\n",
    "    classes = ('deer', 'car', 'frog', 'horse', 'ship', 'truck', 'cat', 'bird', 'plane', 'dog')\n",
    "    #Pick any 30 samples randomly\n",
    "    indices = torch.randperm(len(testset))[:num_images]\n",
    "    raw_images = [np.asarray(testset[i][0]) for i in indices]\n",
    "    labels = [testset[i][1] for i in indices]\n",
    "    #Convert the images to tensors\n",
    "    test_transform = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Resize((32, 32)),\n",
    "         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "    images = torch.stack([test_transform(image) for image in raw_images])\n",
    "    #Move images to the device\n",
    "    images = images.to(device)\n",
    "    model = model.to(device)\n",
    "    #Get the attention maps from the last block\n",
    "    logits, attention_maps = model(images, output_attention=True)\n",
    "    #Get the predictions\n",
    "    predictions = torch.argmax(logits, dim=1)\n",
    "    #Concatenate the attention maps from all blocks\n",
    "    attention_maps = attention_maps[:, :, 0, 1:]\n",
    "    #Then average the attention of CLS token over all the heads\n",
    "    attention_maps = attention_maps.mean(dim=1)\n",
    "    #Reshape the attention maps to a square\n",
    "    num_patches = attention_maps.view(-1)\n",
    "    size = int(math.sqrt(num_patches))\n",
    "    attention_maps = attention_maps.view(-1, size, size)\n",
    "    #Resize the map to the size and the attention maps\n",
    "    attention_maps = attention_maps.unsqueeze(1)\n",
    "    attention_maps = F.interpolate(attention_maps, size=(32, 32), mode='bilinear', align_corners=False)\n",
    "    attention_maps = attention_maps.squeeze(1)\n",
    "    #Plot the images and the attentions maps\n",
    "    fig = plt.figure(figsize=(20, 10))\n",
    "    mask = np.concatenate([np.ones((32, 32)), np.zeros((32, 32))], axis=1)\n",
    "    for i in range(num_images):\n",
    "        ax = fig.add_subplot(6, 5, i+1, xticks=[], yticks=[])\n",
    "        img = np.concatenate((raw_images[i], raw_images[i]), axis=1)\n",
    "        ax.imshow(img)\n",
    "        #Mask out the attention map of the left image\n",
    "        extended_attention_map = np.concatenate((np.zeros((32, 32)), attention_maps[i].cpu()), axis=1)\n",
    "        extended_attention_map = np.ma.masked_where(mask==1, extended_attention_map)\n",
    "        ax.imshow(extended_attention_map, alpha=0.5, cmap='jet')\n",
    "        #Show the ground truth and the predictions\n",
    "        gt = classes[labels[i]]\n",
    "        pred = classes[predictions[i]]\n",
    "        ax.set_title(f\"gt: {gt} / pred: {pred}\", color=(\"green\" if gt==pred else \"red\"))\n",
    "    if output is not None:\n",
    "        plt.savefig(output)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5c3d3fdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Epoch: 1, Train loss: 1.8398, Test loss: 1.6948, Accuracy: 0.3901\n",
      "Epoch: 2, Train loss: 1.5717, Test loss: 1.4778, Accuracy: 0.4630\n",
      "Epoch: 3, Train loss: 1.4797, Test loss: 1.4290, Accuracy: 0.4842\n",
      "Epoch: 4, Train loss: 1.4340, Test loss: 1.4635, Accuracy: 0.4872\n",
      "Epoch: 5, Train loss: 1.3974, Test loss: 1.3556, Accuracy: 0.5038\n",
      "Epoch: 6, Train loss: 1.3614, Test loss: 1.3428, Accuracy: 0.5203\n",
      "Epoch: 7, Train loss: 1.3290, Test loss: 1.3253, Accuracy: 0.5201\n",
      "Epoch: 8, Train loss: 1.3134, Test loss: 1.2637, Accuracy: 0.5420\n",
      "Epoch: 9, Train loss: 1.2931, Test loss: 1.3221, Accuracy: 0.5298\n",
      "Epoch: 10, Train loss: 1.2812, Test loss: 1.2662, Accuracy: 0.5498\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Circular reference detected",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[4], line 134\u001b[0m\n\u001b[1;32m    131\u001b[0m     trainer\u001b[38;5;241m.\u001b[39mtrain(trainloader, testloader, epochs, save_model_every_n_epochs\u001b[38;5;241m=\u001b[39msave_model_every_n_epochs)\n\u001b[1;32m    133\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 134\u001b[0m     \u001b[43mmain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[4], line 131\u001b[0m, in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m    129\u001b[0m loss_fn \u001b[38;5;241m=\u001b[39m nn\u001b[38;5;241m.\u001b[39mCrossEntropyLoss()\n\u001b[1;32m    130\u001b[0m trainer \u001b[38;5;241m=\u001b[39m Trainer(model, optimizer, loss_fn, exp_name, device\u001b[38;5;241m=\u001b[39mdevice)\n\u001b[0;32m--> 131\u001b[0m \u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrainloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtestloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msave_model_every_n_epochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msave_model_every_n_epochs\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[4], line 59\u001b[0m, in \u001b[0;36mTrainer.train\u001b[0;34m(self, trainloader, testloader, epochs, save_model_every_n_epochs)\u001b[0m\n\u001b[1;32m     57\u001b[0m       \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[38;5;124mSave checkpoint at epoch\u001b[39m\u001b[38;5;124m'\u001b[39m, i\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m     58\u001b[0m       save_checkpoint(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexp_name, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel, i\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m---> 59\u001b[0m \u001b[43msave_experiment\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexp_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_losses\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_losses\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccuracies\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/coding-mess/V-transformer/utils.py:28\u001b[0m, in \u001b[0;36msave_experiment\u001b[0;34m(experiment_name, config, model, train_losses, test_losses, accuracies, base_dir)\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(jsonfile, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m     23\u001b[0m     data \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m     24\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_losses\u001b[39m\u001b[38;5;124m'\u001b[39m: train_losses,\n\u001b[1;32m     25\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtest_losses\u001b[39m\u001b[38;5;124m'\u001b[39m: test_losses,\n\u001b[1;32m     26\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracies\u001b[39m\u001b[38;5;124m'\u001b[39m: accuracies,\n\u001b[1;32m     27\u001b[0m     }\n\u001b[0;32m---> 28\u001b[0m     \u001b[43mjson\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdump\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msort_keys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;66;03m#Save the model\u001b[39;00m\n\u001b[1;32m     31\u001b[0m save_checkpoint(experiment_name, model, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfinal\u001b[39m\u001b[38;5;124m\"\u001b[39m, base_dir\u001b[38;5;241m=\u001b[39mbase_dir)\n",
      "File \u001b[0;32m/usr/lib/python3.10/json/__init__.py:179\u001b[0m, in \u001b[0;36mdump\u001b[0;34m(obj, fp, skipkeys, ensure_ascii, check_circular, allow_nan, cls, indent, separators, default, sort_keys, **kw)\u001b[0m\n\u001b[1;32m    173\u001b[0m     iterable \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m(skipkeys\u001b[38;5;241m=\u001b[39mskipkeys, ensure_ascii\u001b[38;5;241m=\u001b[39mensure_ascii,\n\u001b[1;32m    174\u001b[0m         check_circular\u001b[38;5;241m=\u001b[39mcheck_circular, allow_nan\u001b[38;5;241m=\u001b[39mallow_nan, indent\u001b[38;5;241m=\u001b[39mindent,\n\u001b[1;32m    175\u001b[0m         separators\u001b[38;5;241m=\u001b[39mseparators,\n\u001b[1;32m    176\u001b[0m         default\u001b[38;5;241m=\u001b[39mdefault, sort_keys\u001b[38;5;241m=\u001b[39msort_keys, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw)\u001b[38;5;241m.\u001b[39miterencode(obj)\n\u001b[1;32m    177\u001b[0m \u001b[38;5;66;03m# could accelerate with writelines in some versions of Python, at\u001b[39;00m\n\u001b[1;32m    178\u001b[0m \u001b[38;5;66;03m# a debuggability cost\u001b[39;00m\n\u001b[0;32m--> 179\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m chunk \u001b[38;5;129;01min\u001b[39;00m iterable:\n\u001b[1;32m    180\u001b[0m     fp\u001b[38;5;241m.\u001b[39mwrite(chunk)\n",
      "File \u001b[0;32m/usr/lib/python3.10/json/encoder.py:431\u001b[0m, in \u001b[0;36m_make_iterencode.<locals>._iterencode\u001b[0;34m(o, _current_indent_level)\u001b[0m\n\u001b[1;32m    429\u001b[0m     \u001b[38;5;28;01myield from\u001b[39;00m _iterencode_list(o, _current_indent_level)\n\u001b[1;32m    430\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(o, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m--> 431\u001b[0m     \u001b[38;5;28;01myield from\u001b[39;00m _iterencode_dict(o, _current_indent_level)\n\u001b[1;32m    432\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    433\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m markers \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/usr/lib/python3.10/json/encoder.py:405\u001b[0m, in \u001b[0;36m_make_iterencode.<locals>._iterencode_dict\u001b[0;34m(dct, _current_indent_level)\u001b[0m\n\u001b[1;32m    403\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    404\u001b[0m             chunks \u001b[38;5;241m=\u001b[39m _iterencode(value, _current_indent_level)\n\u001b[0;32m--> 405\u001b[0m         \u001b[38;5;28;01myield from\u001b[39;00m chunks\n\u001b[1;32m    406\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m newline_indent \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    407\u001b[0m     _current_indent_level \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
      "File \u001b[0;32m/usr/lib/python3.10/json/encoder.py:325\u001b[0m, in \u001b[0;36m_make_iterencode.<locals>._iterencode_list\u001b[0;34m(lst, _current_indent_level)\u001b[0m\n\u001b[1;32m    323\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    324\u001b[0m             chunks \u001b[38;5;241m=\u001b[39m _iterencode(value, _current_indent_level)\n\u001b[0;32m--> 325\u001b[0m         \u001b[38;5;28;01myield from\u001b[39;00m chunks\n\u001b[1;32m    326\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m newline_indent \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    327\u001b[0m     _current_indent_level \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
      "File \u001b[0;32m/usr/lib/python3.10/json/encoder.py:284\u001b[0m, in \u001b[0;36m_make_iterencode.<locals>._iterencode_list\u001b[0;34m(lst, _current_indent_level)\u001b[0m\n\u001b[1;32m    282\u001b[0m     markerid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mid\u001b[39m(lst)\n\u001b[1;32m    283\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m markerid \u001b[38;5;129;01min\u001b[39;00m markers:\n\u001b[0;32m--> 284\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCircular reference detected\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    285\u001b[0m     markers[markerid] \u001b[38;5;241m=\u001b[39m lst\n\u001b[1;32m    286\u001b[0m buf \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m[\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mValueError\u001b[0m: Circular reference detected"
     ]
    }
   ],
   "source": [
    "exp_name = 'vit-with-10-epochs' #@param {type:\"string\"}\n",
    "batch_size = 32 #@param {type: \"integer\"}\n",
    "epochs = 10 #@param {type: \"integer\"}\n",
    "lr = 1e-2  #@param {type: \"number\"}\n",
    "save_model_every = 0 #@param {type: \"integer\"}\n",
    "\n",
    "import torch\n",
    "from torch import autograd, clone, nn, optim, cuda\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "from utils import save_experiment, save_checkpoint\n",
    "from data import prepare_data\n",
    "from vit import ViTForClassification\n",
    "\n",
    "config = {\n",
    "   \"patch_size\": 4,\n",
    "   \"hidden_size\": 48,\n",
    "   \"num_hidden_layers\": 4,\n",
    "   \"num_attention_heads\": 4,\n",
    "   \"intermediate_size\": 4 * 48,\n",
    "   \"hidden_dropout_prob\": 0.0,\n",
    "   \"attention_probs_dropout_prob\": 0.0,\n",
    "   \"initializer_range\": 0.02,\n",
    "   \"image_size\": 32,\n",
    "   \"num_classes\": 10,\n",
    "   \"num_channels\": 3,\n",
    "   \"qkv_bias\": True,\n",
    "   \"use_faster_attention\": True,\n",
    "}\n",
    "\n",
    "assert config[\"hidden_size\"] % config[\"num_attention_heads\"] == 0\n",
    "assert config[\"intermediate_size\"] == 4 * config[\"hidden_size\"]\n",
    "assert config[\"image_size\"] % config[\"patch_size\"] == 0\n",
    "\n",
    "class Trainer:\n",
    "   \n",
    "   def __init__(self, model, optimizer, loss_fn, exp_name, device):\n",
    "      self.model = model.to(device)\n",
    "      self.optimizer = optimizer\n",
    "      self.loss_fn = loss_fn\n",
    "      self.exp_name = exp_name\n",
    "      self.device = device\n",
    "      \n",
    "   def train(self, trainloader, testloader, epochs, save_model_every_n_epochs=0):\n",
    "      train_losses, test_losses, accuracies = [], [], []\n",
    "      \n",
    "      #Train the model\n",
    "      for i in range(epochs):\n",
    "         train_loss = self.train_epoch(trainloader)\n",
    "         accuracy, test_loss = self.evaluate(testloader)\n",
    "         train_losses.append(train_losses)\n",
    "         test_losses.append(test_loss)\n",
    "         accuracies.append(accuracy)\n",
    "         print(f\"Epoch: {i+1}, Train loss: {train_loss:.4f}, Test loss: {test_loss:.4f}, Accuracy: {accuracy:.4f}\")\n",
    "         if save_model_every_n_epochs > 0 and (i+1) % save_model_every_n_epochs == 0 and i+1 != epochs:\n",
    "            print('\\tSave checkpoint at epoch', i+1)\n",
    "            save_checkpoint(self.exp_name, self.model, i+1)\n",
    "      save_experiment(self.exp_name, config, self.model, train_losses, test_losses, accuracies)\n",
    "         \n",
    "   def train_epoch(self, trainloader):\n",
    "      torch.autograd.set_detect_anomaly(True)\n",
    "      self.model.train()\n",
    "      total_loss = 0\n",
    "      for batch in trainloader:\n",
    "         batch = [t.to(self.device) for t in batch]\n",
    "         images, labels = batch\n",
    "         self.optimizer.zero_grad()\n",
    "         loss = self.loss_fn(self.model(images)[0], labels)\n",
    "         loss = clone(loss) \n",
    "         loss.backward()\n",
    "         self.optimizer.step()\n",
    "         total_loss = total_loss + loss.item() * len(images)\n",
    "      return total_loss / len(trainloader.dataset)\n",
    "   \n",
    "   @torch.no_grad()\n",
    "   def evaluate(self, testloader):\n",
    "      self.model.eval()\n",
    "      total_loss = 0\n",
    "      correct = 0\n",
    "      with torch.no_grad():\n",
    "         for batch in testloader:\n",
    "            batch = [t.to(self.device) for t in batch]\n",
    "            images, labels = batch\n",
    "            \n",
    "            logits, _ = self.model(images)\n",
    "            \n",
    "            loss = self.loss_fn(logits, labels)\n",
    "            total_loss = total_loss + loss.item() * len(images)\n",
    "            \n",
    "            predictions = torch.argmax(logits, dim=1)\n",
    "            correct += torch.sum(predictions == labels).item()\n",
    "      accuracy = correct / len(testloader.dataset)\n",
    "      avg_loss = total_loss / len(testloader.dataset)\n",
    "      return accuracy, avg_loss\n",
    "   \n",
    "#def parse_args():\n",
    "#   import argparse\n",
    "#   parser = argparse.ArgumentParser()\n",
    "#   parser.add_argument(\"--exp-name\", type=str, required=True)\n",
    "#   parser.add_argument(\"--batch-size\", type=int, default=256)\n",
    "#   parser.add_argument(\"--epochs\", type=int, default=100)\n",
    "#   parser.add_argument(\"--lr\", type=float, default=1e-2)\n",
    "#   parser.add_argument(\"--device\", type=str)\n",
    "#   parser.add_argument(\"--save-model-every\", type=int, default=0)\n",
    "   \n",
    "#   args = parser.parse_args()\n",
    "#   if args.device is None:\n",
    "#      args.device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "#   print(args.device) \n",
    "#   return args\n",
    "\n",
    "def main():\n",
    "    #args = parse_args()\n",
    "    #batch_size = args.batch_size\n",
    "    #epochs = args.epochs\n",
    "    #lr = args.lr\n",
    "    #device = args.device\n",
    "    #save_model_every_n_epochs = args.save_model_every\n",
    "    \n",
    "    #Training parameters\n",
    "    save_model_every_n_epochs = save_model_every\n",
    "    #Load the CIFAR10 dataset\n",
    "    trainloader, testloader, _ = prepare_data(batch_size=batch_size)\n",
    "   \n",
    "    #Create the model, optimizer, loss function and trainer\n",
    "    model = ViTForClassification(config)\n",
    "    optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-2)\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    trainer = Trainer(model, optimizer, loss_fn, exp_name, device=device)\n",
    "    trainer.train(trainloader, testloader, epochs, save_model_every_n_epochs=save_model_every_n_epochs)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f0a84471",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_images()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "290185bb",
   "metadata": {},
   "source": [
    "### Plot Training Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "47cded9e",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid mode: 'metrics.json'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m config, model, train_losses, test_losses, accuracies \u001b[38;5;241m=\u001b[39m \u001b[43mload_experiment\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexp_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m      5\u001b[0m fig, (ax1, ax2) \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m15\u001b[39m, \u001b[38;5;241m5\u001b[39m))\n",
      "Cell \u001b[0;32mIn[3], line 48\u001b[0m, in \u001b[0;36mload_experiment\u001b[0;34m(experiment_name, checkpoint_name, base_dir)\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[38;5;66;03m#Load the metrics\u001b[39;00m\n\u001b[1;32m     47\u001b[0m jsonfile \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(outdir, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmetrics.json\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mjsonfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmetrics.json\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m:\n\u001b[1;32m     49\u001b[0m     data \u001b[38;5;241m=\u001b[39m json\u001b[38;5;241m.\u001b[39mload(f)\n\u001b[1;32m     50\u001b[0m train_losses \u001b[38;5;241m=\u001b[39m data[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_losses\u001b[39m\u001b[38;5;124m'\u001b[39m]\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/IPython/core/interactiveshell.py:324\u001b[0m, in \u001b[0;36m_modified_open\u001b[0;34m(file, *args, **kwargs)\u001b[0m\n\u001b[1;32m    317\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[1;32m    318\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    319\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    320\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    321\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    322\u001b[0m     )\n\u001b[0;32m--> 324\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid mode: 'metrics.json'"
     ]
    }
   ],
   "source": [
    "config, model, train_losses, test_losses, accuracies = load_experiment(exp_name)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
    "ax1.plot(train_losses, label='Train loss')\n",
    "ax2.plot(test_losses, label='Test loss')\n",
    "ax1.set_xlabel(\"Epoch\")\n",
    "ax1.set_ylabel(\"Loss\")\n",
    "ax1.legend()\n",
    "ax2.plot(accuracies)\n",
    "ax2.set_xlabel(\"Epoch\")\n",
    "ax2.set_xlabel(\"Accuracy\")\n",
    "plt.savefig(\"metrics.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5eaf457",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m visualize_attention(\u001b[43mmodel\u001b[49m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mattention.png\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "visualize_attention(model, \"attention.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f42624e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}