doodle-analysis-and-prediction.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\npd.options.mode.chained_assignment = None  # default='warn'\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nfrom PIL import Image\n\nimport os\ni = 0\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n        i+=1\n        if i == 4:\n            break\n    if i == 4:\n        break    \n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-09-22T20:41:23.991892Z","iopub.execute_input":"2024-09-22T20:41:23.992915Z","iopub.status.idle":"2024-09-22T20:41:27.470171Z","shell.execute_reply.started":"2024-09-22T20:41:23.992862Z","shell.execute_reply":"2024-09-22T20:41:27.469237Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"/kaggle/input/doodle-dataset/master_doodle_dataframe.csv\n/kaggle/input/doodle-dataset/doodle/fan/5145146800734208.png\n/kaggle/input/doodle-dataset/doodle/fan/6319036524658688.png\n/kaggle/input/doodle-dataset/doodle/fan/4788222250975232.png\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# **Exploratory data analysis**","metadata":{}},{"cell_type":"code","source":"path_to_csv = \"/kaggle/input/doodle-dataset/master_doodle_dataframe.csv\"\nwhole_df = pd.read_csv(path_to_csv)","metadata":{"execution":{"iopub.status.busy":"2024-09-22T20:41:29.767583Z","iopub.execute_input":"2024-09-22T20:41:29.768485Z","iopub.status.idle":"2024-09-22T20:41:39.073804Z","shell.execute_reply.started":"2024-09-22T20:41:29.768444Z","shell.execute_reply":"2024-09-22T20:41:39.072977Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"whole_df.head()","metadata":{"execution":{"iopub.status.busy":"2024-09-22T20:41:41.834015Z","iopub.execute_input":"2024-09-22T20:41:41.834771Z","iopub.status.idle":"2024-09-22T20:41:41.854787Z","shell.execute_reply.started":"2024-09-22T20:41:41.834731Z","shell.execute_reply":"2024-09-22T20:41:41.853911Z"},"trusted":true},"execution_count":4,"outputs":[{"execution_count":4,"output_type":"execute_result","data":{"text/plain":"  countrycode                                            drawing  \\\n0          RO  [[[0, 5, 3, 4, 10, 72, 82, 91, 99, 98, 87, 71,...   \n1          US  [[[0, 255], [3, 4]], [[86, 73, 73, 76, 85, 130...   \n2          ZA  [[[39, 33, 34, 39, 52, 61, 66, 65, 67, 71], [2...   \n3          VN  [[[12, 9], [128, 255]], [[0, 23, 36, 37, 42, 5...   \n4          HU  [[[9, 7, 0, 19, 49, 90, 96, 99, 93, 94, 62, 16...   \n\n             key_id  recognized           word  \\\n0  5613582005829632        True  traffic light   \n1  5769631006457856        True  traffic light   \n2  4999795544424448        True  traffic light   \n3  4878417906368512        True  traffic light   \n4  5572841187573760        True  traffic light   \n\n                                image_path  \n0  data/traffic light/5613582005829632.png  \n1  data/traffic light/5769631006457856.png  \n2  data/traffic light/4999795544424448.png  \n3  data/traffic light/4878417906368512.png  \n4  data/traffic light/5572841187573760.png  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>countrycode</th>\n      <th>drawing</th>\n      <th>key_id</th>\n      <th>recognized</th>\n      <th>word</th>\n      <th>image_path</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>RO</td>\n      <td>[[[0, 5, 3, 4, 10, 72, 82, 91, 99, 98, 87, 71,...</td>\n      <td>5613582005829632</td>\n      <td>True</td>\n      <td>traffic light</td>\n      <td>data/traffic light/5613582005829632.png</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>US</td>\n      <td>[[[0, 255], [3, 4]], [[86, 73, 73, 76, 85, 130...</td>\n      <td>5769631006457856</td>\n      <td>True</td>\n      <td>traffic light</td>\n      <td>data/traffic light/5769631006457856.png</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>ZA</td>\n      <td>[[[39, 33, 34, 39, 52, 61, 66, 65, 67, 71], [2...</td>\n      <td>4999795544424448</td>\n      <td>True</td>\n      <td>traffic light</td>\n      <td>data/traffic light/4999795544424448.png</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>VN</td>\n      <td>[[[12, 9], [128, 255]], [[0, 23, 36, 37, 42, 5...</td>\n      <td>4878417906368512</td>\n      <td>True</td>\n      <td>traffic light</td>\n      <td>data/traffic light/4878417906368512.png</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>HU</td>\n      <td>[[[9, 7, 0, 19, 49, 90, 96, 99, 93, 94, 62, 16...</td>\n      <td>5572841187573760</td>\n      <td>True</td>\n      <td>traffic light</td>\n      <td>data/traffic light/5572841187573760.png</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"code","source":"# The drawing format is: within a list, each stroke is represented as a list of x coordinates and a list of y coordinates\ndata = [\n    [[0, 5, 3, 4, 10, 72, 82, 91, 99, 98, 87, 71, 67, 54, 20, 18], [5, 176, 245, 253, 255, 248, 243, 142, 106, 60, 32, 10, 6, 3, 0, 6]],\n    [[33, 28, 32, 37, 51, 58, 64, 67, 63, 57, 42], [36, 60, 73, 78, 78, 73, 63, 47, 37, 33, 40]],\n    [[42, 36, 35, 38, 41, 52, 80, 84, 82, 71, 61], [130, 139, 150, 162, 166, 165, 144, 139, 127, 110, 105]],\n    [[67, 54, 47, 27, 29], [117, 112, 115, 144, 152]],\n    [[43, 33, 33, 38, 41, 48, 58, 57, 49, 41], [203, 218, 226, 238, 238, 233, 214, 203, 192, 190]]\n]\n\n# Create a new figure\nplt.figure(figsize = (3,3))\n\n# Iterate through each line in the data\nfor line in data:\n    x_coords, y_coords = line # breaks down the line into an array of x's and array od y's\n    plt.plot(x_coords, y_coords, color='black')\n    \n# Display the plot\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.124103Z","iopub.execute_input":"2024-09-22T14:08:12.124719Z","iopub.status.idle":"2024-09-22T14:08:12.299201Z","shell.execute_reply.started":"2024-09-22T14:08:12.124683Z","shell.execute_reply":"2024-09-22T14:08:12.298295Z"},"trusted":true},"execution_count":4,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"df_length = len(whole_df)\ndf_length","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.300625Z","iopub.execute_input":"2024-09-22T14:08:12.301590Z","iopub.status.idle":"2024-09-22T14:08:12.307949Z","shell.execute_reply.started":"2024-09-22T14:08:12.301525Z","shell.execute_reply":"2024-09-22T14:08:12.306981Z"},"trusted":true},"execution_count":5,"outputs":[{"execution_count":5,"output_type":"execute_result","data":{"text/plain":"1020000"},"metadata":{}}]},{"cell_type":"code","source":"# We can see the recognized column does not add any valuable input\nwhole_df[\"recognized\"].unique()","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.309324Z","iopub.execute_input":"2024-09-22T14:08:12.309758Z","iopub.status.idle":"2024-09-22T14:08:12.324536Z","shell.execute_reply.started":"2024-09-22T14:08:12.309704Z","shell.execute_reply":"2024-09-22T14:08:12.323710Z"},"trusted":true},"execution_count":6,"outputs":[{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"array([ True])"},"metadata":{}}]},{"cell_type":"markdown","source":"## Limiting the distribution of country codes","metadata":{}},{"cell_type":"code","source":"coutry_codes = whole_df[\"countrycode\"].value_counts()","metadata":{"execution":{"iopub.status.busy":"2024-09-22T20:41:53.915094Z","iopub.execute_input":"2024-09-22T20:41:53.915831Z","iopub.status.idle":"2024-09-22T20:41:54.074702Z","shell.execute_reply.started":"2024-09-22T20:41:53.915790Z","shell.execute_reply":"2024-09-22T20:41:54.073572Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"n=50\ndoodled_covered_by_n = coutry_codes.head(n).sum()\n\nprint(f\"The top {n} country codes cover about {round(doodled_covered_by_n/df_length,3)}% of the dataset doodles\")\n\ntop_countries = coutry_codes.head(n).index","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.491694Z","iopub.execute_input":"2024-09-22T14:08:12.492053Z","iopub.status.idle":"2024-09-22T14:08:12.498644Z","shell.execute_reply.started":"2024-09-22T14:08:12.492015Z","shell.execute_reply":"2024-09-22T14:08:12.497641Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"The top 50 country codes cover about 0.962% of the dataset doodles\n","output_type":"stream"}]},{"cell_type":"markdown","source":"## Limiting the distribution of the doodled object","metadata":{}},{"cell_type":"code","source":"words = whole_df[\"word\"].value_counts()","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.499964Z","iopub.execute_input":"2024-09-22T14:08:12.500861Z","iopub.status.idle":"2024-09-22T14:08:12.626267Z","shell.execute_reply.started":"2024-09-22T14:08:12.500814Z","shell.execute_reply":"2024-09-22T14:08:12.625411Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"n=50\ndoodled_covered_by_n = words.head(n).sum()\n\nprint(f\"The top {n} doodled objects cover about {round(doodled_covered_by_n/df_length,3)}% of the dataset doodles\")\n\ntop_words = words.head(n).index","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.629688Z","iopub.execute_input":"2024-09-22T14:08:12.630011Z","iopub.status.idle":"2024-09-22T14:08:12.636249Z","shell.execute_reply.started":"2024-09-22T14:08:12.629960Z","shell.execute_reply":"2024-09-22T14:08:12.635397Z"},"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"The top 50 doodled objects cover about 0.147% of the dataset doodles\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# **Trimming down the data**\n\nThe dataset contains 1,019,868 doodles of 340 unique categories drown by people from 198 different countries.\nWorking with these sizes is, at least in this early stage, not desired and might make for a model that will have a hard time capuring the relationship between the data and the labels.\n\nThe dataset will be sized down to 144,171 images of 50 categories and 50 country codes.\n</br>\nWe might be able to work with this, instead.","metadata":{}},{"cell_type":"code","source":"df = whole_df.loc[whole_df['countrycode'].isin(top_countries) & whole_df['word'].isin(top_words)]\ndf.drop(\"recognized\", axis=1, inplace=True)","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.637626Z","iopub.execute_input":"2024-09-22T14:08:12.638329Z","iopub.status.idle":"2024-09-22T14:08:12.772572Z","shell.execute_reply.started":"2024-09-22T14:08:12.638282Z","shell.execute_reply":"2024-09-22T14:08:12.771540Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"markdown","source":"We'll end up disregarding the countrycode feature as well, despite the possibility of it proving useful.\n</br>\nThis is because incorporating additional non-photo data would require a much more complex model.\n\nMore on that [here](https://stackoverflow.com/questions/52802678/i-have-an-image-data-and-metadata-containing-the-description-of-the-image-how-c).","metadata":{}},{"cell_type":"code","source":"df.drop(\"countrycode\", axis=1, inplace=True)","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.773872Z","iopub.execute_input":"2024-09-22T14:08:12.774289Z","iopub.status.idle":"2024-09-22T14:08:12.787831Z","shell.execute_reply.started":"2024-09-22T14:08:12.774242Z","shell.execute_reply":"2024-09-22T14:08:12.786879Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"markdown","source":"As one might imagine, loading many photos onto the memory and converting them into an array is a long process.\n\n\n[Here](https://medium.com/@laassairi.abdellah/image-loading-benchmark-fastest-way-to-load-large-images-from-disk-into-gpu-e92cee4ca585) is a helpful post comparing different tools for this purpose.","metadata":{}},{"cell_type":"markdown","source":"# **Creating the train, test Datasets and Dataloaders**","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import LabelEncoder\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nfrom torchvision import transforms\nfrom torch.utils.data import Dataset, DataLoader, random_split","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"label_encoder = LabelEncoder()\n\n# To be able to send the labels to the GPU, they need to have a method that Tensors have, but lists do not.\n# A tensor cannot contain strings, so the list of labels needs to n=be transformed to a tensor of integers.\n\nlabels_numeric = label_encoder.fit_transform(df[\"word\"])\ny = torch.tensor(labels_numeric, dtype=torch.long)\n\nX_source = df[\"image_path\"].to_list()\nX_source = [string.replace(\"data\", \"/kaggle/input/doodle-dataset/doodle\") for string in X_source]\n","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:12.789179Z","iopub.execute_input":"2024-09-22T14:08:12.789555Z","iopub.status.idle":"2024-09-22T14:08:12.883553Z","shell.execute_reply.started":"2024-09-22T14:08:12.789512Z","shell.execute_reply":"2024-09-22T14:08:12.882521Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"class PNGDataset(Dataset):\n    def __init__(self, image_paths, image_labels, transform=None):\n        self.image_paths = image_paths\n        self.image_labels = image_labels\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, idx):\n        img_path = self.image_paths[idx]\n        image = Image.open(img_path).convert('L')\n\n        if self.transform:\n            image = self.transform(image)\n        \n        label = self.image_labels[idx]\n        \n        return image, label\n\n\ntransform = transforms.Compose([\n    transforms.ToTensor(),  # Convert PIL image to tensor and normalize to [0, 1]\n    transforms.Normalize(mean=[0.485], std=[0.229])\n])\ndataset = PNGDataset(image_paths=X_source, image_labels=y, transform=transform)\n\n# Split the dataset into training and testing sets\ndataset_size    = len(dataset)\ntrain_size      = int(0.7 * dataset_size)   # 70% for training\nvalidation_size = int(0.15 * dataset_size)  # 15% for validation\ntest_size       = dataset_size - train_size - validation_size  # 15% for testing\ntrain_dataset, validation_dataset, test_dataset = random_split(dataset, [train_size, validation_size, test_size])\n\n# Create DataLoaders for training and testing sets\ntrain_loader      = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True)\nvalidation_loader = DataLoader(validation_dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True)\ntest_loader       = DataLoader(test_dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True)","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:16:36.704431Z","iopub.execute_input":"2024-09-22T14:16:36.705131Z","iopub.status.idle":"2024-09-22T14:16:36.731799Z","shell.execute_reply.started":"2024-09-22T14:16:36.705086Z","shell.execute_reply":"2024-09-22T14:16:36.730827Z"},"trusted":true},"execution_count":26,"outputs":[]},{"cell_type":"markdown","source":"# **Building the model**","metadata":{}},{"cell_type":"code","source":"class BasicCNN(nn.Module):\n    def __init__(self):\n        super(BasicCNN, self).__init__()\n\n        # Convolutional Layers with Batch Normalization\n        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5, padding=0)\n        self.bn1 = nn.BatchNorm2d(32)\n        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=3, padding=0)  # Output: 32x83x83\n\n        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)\n        self.bn2 = nn.BatchNorm2d(64)\n        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # Output: 64x41x41\n\n        self.conv3 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)\n        self.bn3 = nn.BatchNorm2d(128)\n        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # Output: 128x20x20\n\n        self.conv4 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1)\n        self.bn4 = nn.BatchNorm2d(256)\n        self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # Output: 256x10x10\n        \n        # Fully Connected Layers\n        self.fc1 = nn.Linear(256 * 10 * 10, 1024)  # Input: 256*10*10, Output: 1024\n        self.fc2 = nn.Linear(1024, 50)  # Input: 1024, Output: 50\n\n    def forward(self, x):\n        # print(f\"Input shape: {x.shape}\")\n        x = self.pool1(F.relu(self.bn1(self.conv1(x))))\n        # print(f\"After conv1 + pool1: {x.shape}\")\n        x = self.pool2(F.relu(self.bn2(self.conv2(x))))\n        # print(f\"After conv2 + pool2: {x.shape}\")\n        x = self.pool3(F.relu(self.bn3(self.conv3(x))))\n        # print(f\"After conv3 + pool3: {x.shape}\")\n        x = self.pool4(F.relu(self.bn4(self.conv4(x))))\n        # print(f\"After conv4 + pool4: {x.shape}\")\n        x = x.view(-1, 256 * 10 * 10)\n        # print(f\"Flattened shape: {x.shape}\")\n        x = F.relu(self.fc1(x))\n        x = self.fc2(x)\n        x = F.log_softmax(x, dim=1)\n        return x\n\n# Instantiate the model, define the loss function and the optimizer\nmodel = BasicCNN().to('cuda')\nif torch.cuda.device_count() > 1:\n    model = nn.DataParallel(model) # Share the load between multiple GPU's\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=0.01)\n\n# Early stopping parameters\npatience = 3\nbest_loss = float('inf')\ntrigger_times = 0","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:16:39.333819Z","iopub.execute_input":"2024-09-22T14:16:39.334544Z","iopub.status.idle":"2024-09-22T14:16:39.611152Z","shell.execute_reply.started":"2024-09-22T14:16:39.334502Z","shell.execute_reply":"2024-09-22T14:16:39.610269Z"},"trusted":true},"execution_count":27,"outputs":[]},{"cell_type":"markdown","source":"# **Training the model using the DataLoader**","metadata":{}},{"cell_type":"code","source":"import time","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:08:13.066827Z","iopub.execute_input":"2024-09-22T14:08:13.067225Z","iopub.status.idle":"2024-09-22T14:08:13.073418Z","shell.execute_reply.started":"2024-09-22T14:08:13.067182Z","shell.execute_reply":"2024-09-22T14:08:13.072224Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"# Lists to store losses for plotting\ntrain_losses = []\nvalidation_losses = []\n\nnum_epochs = 10  # Number of epochs to train the model\nstart = time.time()\nprint(\"Training started\")\n\n# Training loop\nfor epoch in range(num_epochs):\n    model.train()  # Set the model to training mode\n    running_loss = 0.0\n    \n    for inputs, labels in train_loader:\n        inputs, labels = inputs.to('cuda'), labels.to('cuda')\n        \n        # Zero the parameter gradients\n        optimizer.zero_grad()\n        \n        # Forward pass\n        outputs = model(inputs)\n        \n        # Compute loss\n        loss = criterion(outputs, labels)\n        \n        # Backward pass\n        loss.backward()\n        \n        # Update weights\n        optimizer.step()\n        \n        # Print statistics\n        running_loss += loss.item()\n    \n    train_loss = running_loss / len(train_loader)\n    train_losses.append(train_loss)\n    print(f'Epoch {epoch + 1}/{num_epochs}, Training Loss: {round(train_loss ,3)}')\n\n    # Evaluation loop\n    model.eval()  # Set the model to evaluation mode\n    correct = 0\n    total = 0\n    validation_loss = 0.0\n\n    with torch.no_grad():  # Disable gradient computation\n        for inputs, labels in validation_loader:\n            inputs, labels = inputs.to('cuda'), labels.to('cuda')\n            \n            # Forward pass\n            outputs = model(inputs)\n            \n            # Compute loss\n            loss = criterion(outputs, labels)\n            validation_loss += loss.item()\n            \n            # Get predictions\n            _, predicted = torch.max(outputs.data, 1)\n            \n            # Update total and correct predictions\n            total += labels.size(0)\n            correct += (predicted == labels).sum().item()\n\n    validation_loss /= len(validation_loader)\n    validation_losses.append(validation_loss)\n    accuracy = 100 * correct / total\n    print(f'Epoch {epoch + 1}/{num_epochs}, Validation Loss: {round(validation_loss ,3)}, Accuracy: {round(accuracy ,3)}%')\n    \n    epoch_time = time.time()\n    print(f'Epoch {epoch + 1} finished at: {round((epoch_time - start)/60 ,3)} minutes')\n    \n\n    # Early stopping check\n    if  validation_loss < best_loss:\n        best_loss = validation_loss\n        trigger_times = 0\n    else:\n        trigger_times += 1\n        print(f'Early stopping trigger times: {trigger_times}/{patience}')\n        \n        if trigger_times >= patience:\n            print('---- Early stopping! ----')\n            break\n\nend = time.time()\nprint(f'Finished Training in {round((end - start)/60 ,3)} minutes')","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:16:44.344855Z","iopub.execute_input":"2024-09-22T14:16:44.345642Z","iopub.status.idle":"2024-09-22T14:37:42.600641Z","shell.execute_reply.started":"2024-09-22T14:16:44.345596Z","shell.execute_reply":"2024-09-22T14:37:42.599535Z"},"trusted":true},"execution_count":28,"outputs":[{"name":"stdout","text":"Training started\nEpoch 1/10, Training Loss: 4.728\nEpoch 1/10, Validation Loss: 3.915, Accuracy: 2.1%\nEpoch 1 finished at: 3.707 minutes\nEpoch 2/10, Training Loss: 3.915\nEpoch 2/10, Validation Loss: 3.916, Accuracy: 2.067%\nEpoch 2 finished at: 7.232 minutes\nEarly stopping trigger times: 1/3\nEpoch 3/10, Training Loss: 3.915\nEpoch 3/10, Validation Loss: 3.915, Accuracy: 2.091%\nEpoch 3 finished at: 10.672 minutes\nEpoch 4/10, Training Loss: 3.915\nEpoch 4/10, Validation Loss: 3.916, Accuracy: 2.063%\nEpoch 4 finished at: 14.101 minutes\nEarly stopping trigger times: 1/3\nEpoch 5/10, Training Loss: 3.915\nEpoch 5/10, Validation Loss: 3.917, Accuracy: 1.993%\nEpoch 5 finished at: 17.526 minutes\nEarly stopping trigger times: 2/3\nEpoch 6/10, Training Loss: 3.915\nEpoch 6/10, Validation Loss: 3.915, Accuracy: 1.832%\nEpoch 6 finished at: 20.966 minutes\nEarly stopping trigger times: 3/3\n---- Early stopping! ----\nFinished Training in 20.966 minutes\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"markdown","source":"# **Checking the test score**","metadata":{}},{"cell_type":"code","source":"model.eval()  # Set the model to evaluation mode\ncorrect = 0\ntotal = 0\n\nwith torch.no_grad():  # Disable gradient computation\n    for inputs, labels in test_loader:\n        inputs, labels = inputs.to('cuda'), labels.to('cuda')\n        \n        # Forward pass\n        outputs = model(inputs)\n        \n        # Get predictions\n        _, predicted = torch.max(outputs.data, 1)\n        \n        # Update total and correct predictions\n        total += labels.size(0)\n        correct += (predicted == labels).sum().item()\n\naccuracy = 100 * correct / total\nprint(f'Overall Test Accuracy: {round(accuracy ,3)}%')\n","metadata":{"execution":{"iopub.status.busy":"2024-09-22T14:43:21.149627Z","iopub.execute_input":"2024-09-22T14:43:21.150731Z","iopub.status.idle":"2024-09-22T14:43:57.321906Z","shell.execute_reply.started":"2024-09-22T14:43:21.150672Z","shell.execute_reply":"2024-09-22T14:43:57.320742Z"},"trusted":true},"execution_count":33,"outputs":[{"name":"stdout","text":"Overall Test Accuracy: 1.979%\n","output_type":"stream"}]}]}