Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/image2image.png filter=lfs diff=lfs merge=lfs -text
+MidTerm_Report.pdf filter=lfs diff=lfs merge=lfs -text
+Model/data/data_batch_1 filter=lfs diff=lfs merge=lfs -text
+Model/data/data_batch_2 filter=lfs diff=lfs merge=lfs -text
+Model/data/data_batch_3 filter=lfs diff=lfs merge=lfs -text
+Model/data/data_batch_4 filter=lfs diff=lfs merge=lfs -text
+Model/data/data_batch_5 filter=lfs diff=lfs merge=lfs -text
+Model/data/test_batch filter=lfs diff=lfs merge=lfs -text

Experiments/Resnet50_classification.py

@@ -0,0 +1,128 @@
+import torchvision.datasets as datasets
+import matplotlib.pyplot as plt
+import tensorflow
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+import torchvision.models as models
+import torch
+from tqdm import tqdm
+import torch.nn as nn
+import torchvision.transforms as v2
+from torch.utils.data import DataLoader
+import torchvision.datasets as datasets
+from sklearn.metrics.pairwise import euclidean_distances
+from PIL import Image,ImageFilter
+import torchvision.transforms as transforms
+import pickle
+import os
+os.system("gdown --id 1qO2OLR7skDibo1LaMKD3CiOl_jaCTZ0h")
+
+
+IMAGE_SIZE = 224
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+def unpickle(file):
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+    
+class HiddenLayer(nn.Module):
+    def __init__(self, pretrained_model):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.new_layer = nn.Sequential(
+                nn.Linear(1000, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 256),
+                nn.LeakyReLU(),
+                nn.Linear(256, 10)
+                )
+
+    def forward(self, x):
+        out = self.premodel(x)
+        out_new_layer = self.new_layer(out)
+        return out_new_layer
+    
+
+def predict(features_path,image):
+    batch1 = unpickle(r"Model\data\data_batch_1")
+    batch2 = unpickle(r"Model\data\data_batch_2")
+    batch3 = unpickle(r"Model\data\data_batch_3")
+    batch4 = unpickle(r"Model\data\data_batch_4")
+    batch5 = unpickle(r"Model\data\data_batch_5")
+    test_batch = unpickle(r"Model\data\test_batch")
+    train_batch = [batch1,batch2,batch3,batch4,batch5]
+    train_y = []
+    train_x = []
+    for batch in train_batch:
+      y_data = batch[b'labels']
+      x_data = batch[b'data']
+      x_data = x_data.reshape(len(x_data),3,32,32).transpose(0,2,3,1)
+
+      for i in range(len(y_data)):
+        train_y.append(y_data[i])
+
+      for i in range(len(y_data)):
+        train_x.append(x_data[i])
+    
+    features = torch.load(features_path)
+    
+    resnet_train_data = []
+    for i in range(len(features)):
+      resnet_train_data.append((features[i],train_y[i]))
+                          
+    class_images_dict = {}
+    for batch_idx, (images, labels) in enumerate(resnet_train_data):
+        if labels not in class_images_dict:
+            class_images_dict[labels] = []
+        class_images_dict[labels].append(batch_idx)
+     
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean, std)
+    ])
+    pil_image = Image.fromarray(image)
+    image_tensor = transform(pil_image).unsqueeze(0) 
+    resnet = models.resnet50(pretrained=True)
+    model_check = HiddenLayer(resnet)
+    model_check.load_state_dict(torch.load("CIFAR_end_hll.pt"))
+    model_check.eval()
+    
+    with torch.no_grad():
+        z = model_check(image_tensor)
+        _, test_label = torch.max(z, 1)
+                          
+    return test_label,z,features,class_images_dict,train_x
+    
+    
+
+def retrieve(image,k,feature_path=r"Model\Resnet50_train_features.pt"):
+    print(image.shape)
+    test_label,z,features,class_images_dict,train_x = predict(feature_path,image)
+    class_indices = class_images_dict[test_label.item()]
+    class_features = [(features[idx], idx) for idx in class_indices]
+    test_features = z.cpu().detach().numpy()
+    distances = euclidean_distances(test_features, [f[0].cpu() for f in class_features])
+    sorted_indices = np.argsort(distances.flatten())[:k]
+    closest_indices = [class_features[idx][1] for idx in sorted_indices]
+    retrieved_images = []
+    for i, idx in enumerate(closest_indices):
+        closest_image = Image.fromarray(train_x[idx])
+        sharpened_closest_image = closest_image.filter(ImageFilter.SHARPEN)
+        retrieved_images.append(sharpened_closest_image)
+
+    return retrieved_images
+
+
+
+
+
+
+# test_image = Image.open("/kaggle/input/planes/download.jpeg")
+# retrieved_images = retrieve(test_image,3)

Experiments/__init__.py

@@ -0,0 +1 @@
+print("Initializing")

Experiments/ann_cifar.py

@@ -0,0 +1,91 @@
+import torchvision.datasets as datasets
+import matplotlib.pyplot as plt
+import tensorflow
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+import torchvision.models as models
+import torch
+from tqdm import tqdm
+import torch.nn as nn
+import torchvision.transforms as v2
+from torch.utils.data import DataLoader
+import torchvision.datasets as datasets
+from sklearn.metrics.pairwise import euclidean_distances
+from PIL import Image,ImageFilter
+import torchvision.transforms as transforms
+import pickle
+import os
+import cv2 
+
+
+def unpickle(file):
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+
+class ANN(nn.Module):
+    def __init__(self):
+        super(ANN, self).__init__()
+        self.layer_1 = nn.Linear(32 * 32 * 3, 512)  # Input size is 32x32x3
+        self.relu1 = nn.ReLU()
+        self.layer_2 = nn.Linear(512, 256)
+        self.relu2 = nn.ReLU()
+        self.layer_3 = nn.Linear(256, 10)  # Output size is 10 (number of classes)
+
+    def forward(self, x):
+        x = x.view(-1, 32 * 32 * 3)  # Flatten the input tensor
+        x=self.layer_1(x)
+        x=self.relu1(x)
+        x=self.layer_2(x)
+        x=self.relu2(x)
+        x=self.layer_3(x)
+        return x
+
+def retrieve(test_data,model,k_value=10):
+    test_data = cv2.resize(test_data,(32,32))
+    test_data = torch.tensor(test_data,dtype=torch.float32).unsqueeze(dim=0)
+    print(test_data.shape)
+    outputs = model(test_data)
+    _, predicted = torch.max(outputs.data, 1)
+    
+    batch1 = unpickle(r"Model\data\data_batch_1")
+    batch2 = unpickle(r"Model\data\data_batch_2")
+    batch3 = unpickle(r"Model\data\data_batch_3")
+    batch4 = unpickle(r"Model\data\data_batch_4")
+    batch5 = unpickle(r"Model\data\data_batch_5")
+    # test_batch = unpickle(r"Model\data\test_batch")
+    train_batch = [batch1,batch2,batch3,batch4,batch5]
+
+    train_data = []
+    for batch in train_batch:
+        y_data = batch[b'labels']
+        x_data = batch[b'data']
+        x_data = x_data.reshape(len(x_data),3,32,32).transpose(0,2,3,1)
+
+        for i in range(len(y_data)):
+            train_data.append((x_data[i],y_data[i]))
+
+    x_with_specific_y = [x for x, y in train_data if y-1 == predicted]
+    x_with_specific_y = np.array(x_with_specific_y)
+    test_data.squeeze().permute(1,2,0)
+    point = np.array(test_data.squeeze())
+
+    distance_with_label_and_index = []
+
+    for i,x_train in enumerate(x_with_specific_y):
+        train_point = np.array(x_train[1])
+        distance_with_label_and_index.append((i,np.linalg.norm(point-train_point)))
+
+    #sorting based on distance
+    distance_with_label_and_index_sorted=sorted(distance_with_label_and_index,key=lambda x: x[1])
+    k_nearest_points = distance_with_label_and_index_sorted[0:k_value]
+
+    retrived_images = []
+    #calculating accuracy
+    for i,(index,distance) in enumerate(k_nearest_points):
+        # print(np.array(train_data[index]).shape)
+        retrived_images.append(np.array(x_with_specific_y[index]))
+        
+    return retrived_images

Experiments/centroid_res18.py

@@ -0,0 +1,85 @@
+import pickle
+import random
+import numpy as np
+import cv2
+from tensorflow.keras import models, layers
+
+# Load the trained model architecture
+def create_resnet18():
+    model = models.Sequential()
+    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
+    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
+    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Flatten())
+    model.add(layers.Dense(512, activation='relu'))
+    model.add(layers.Dense(10, activation='softmax'))
+    return model
+
+# Load the pretrained weights
+def load_pretrained_weights(model, weights_path):
+    model.load_weights(weights_path)
+
+# Function to unpickle a file
+def unpickle(file):
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+# Function to load images from the unpickled data batch file of a specific class
+def load_class_images(class_index, train_batches):
+    images = []
+    for batch in train_batches:
+        if b'data' in batch and b'labels' in batch:
+            data = batch[b'data']
+            labels = batch[b'labels']
+            for i, label in enumerate(labels):
+                if label == class_index:
+                    img = data[i].reshape(3, 32, 32).transpose(1, 2, 0)  # Reshape and transpose the image
+                    images.append(img)
+    return images
+
+# Function to calculate the distance of the mean embeddings with a query image
+def classify_query(query_image, model, mean_embeddings):
+    query_embedding = model.predict(np.expand_dims(query_image, axis=0))
+    distances = [np.linalg.norm(query_embedding.flatten() - mean_embedding) for mean_embedding in mean_embeddings]
+    predicted_class = np.argmin(distances)
+    return predicted_class
+
+from google.colab.patches import cv2_imshow
+
+def main():
+    model = create_resnet18()
+    load_pretrained_weights(model, 'pretrained_model_weights.h5')
+
+    mean_embeddings = pickle.load(open('mean_embeddings.pkl', 'rb'))
+
+    query_image_path = '/content/airplane_8925.png'
+    query_image = cv2.imread(query_image_path)
+    query_image = cv2.resize(query_image, (32, 32)) / 255.0  # Resize and normalize the image
+
+    predicted_class = classify_query(query_image, model, mean_embeddings)
+    print("Predicted Class:", predicted_class)
+
+    # Load random images of the predicted class
+    train_batches = [unpickle(f"/content/data_batch_{i}") for i in range(1,6)]
+    class_images = load_class_images(predicted_class+1, train_batches)
+    
+    if class_images:
+        random_images = random.sample(class_images, 3)  # Select 3 random images
+        for img in random_images:
+            if img is not None:
+                cv2_imshow(img)
+            else:
+                print("Random image is None.")
+    else:
+        print("No images found for the predicted class.")
+
+if __name__ == "__main__":
+    main()

Experiments/cifar_10_knn_resnet18_73_percent.ipynb

@@ -0,0 +1,197 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from scipy.spatial.distance import euclidean\n",
+    "from tensorflow.keras import datasets, layers, models\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()\n",
+    "\n",
+    "\n",
+    "train_images = train_images / 255.0\n",
+    "test_images = test_images / 255.0\n",
+    "\n",
+    "\n",
+    "def create_resnet18():\n",
+    "    model = models.Sequential()\n",
+    "    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))\n",
+    "    model.add(layers.MaxPooling2D((2, 2)))\n",
+    "    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))\n",
+    "    model.add(layers.MaxPooling2D((2, 2)))\n",
+    "    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))\n",
+    "    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))\n",
+    "    model.add(layers.MaxPooling2D((2, 2)))\n",
+    "    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))\n",
+    "    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))\n",
+    "    model.add(layers.MaxPooling2D((2, 2)))\n",
+    "    model.add(layers.Flatten())\n",
+    "    model.add(layers.Dense(512, activation='relu'))\n",
+    "    model.add(layers.Dense(10, activation='softmax'))\n",
+    "    return model\n",
+    "\n",
+    "\n",
+    "model = create_resnet18()\n",
+    "\n",
+    "\n",
+    "model.compile(optimizer='adam',\n",
+    "              loss='sparse_categorical_crossentropy',\n",
+    "              metrics=['accuracy'])\n",
+    "\n",
+    "\n",
+    "model.fit(train_images, train_labels, epochs=10, batch_size=64, validation_data=(test_images, test_labels))\n",
+    "\n",
+    "\n",
+    "train_embeddings = model.predict(train_images)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_embeddings = model.predict(test_images)\n",
+    "test_embeddings.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "resnet_train_data = []\n",
+    "for i in range(len(train_embeddings)):\n",
+    "  resnet_train_data.append((train_embeddings[i],train_labels[i]))\n",
+    "resnet_test_data = []\n",
+    "for i in range(len(test_embeddings)):\n",
+    "  resnet_test_data.append((test_embeddings[i],test_labels[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "def find_knn_and_plot_image(k_value:int =10,train_data=resnet_train_data,test_data=resnet_test_data[0]):\n",
+    "    correct = 0\n",
+    "    x_test,y_test = test_data\n",
+    "    point = np.array(x_test)\n",
+    "\n",
+    "    distance_with_label_and_index = []\n",
+    "\n",
+    "    for i,(x_train,y_train) in enumerate(train_data):\n",
+    "      train_point = np.array(x_train)\n",
+    "      distance_with_label_and_index.append(((y_train,i),np.linalg.norm(point-train_point)))\n",
+    "\n",
+    "    #sorting based on distance\n",
+    "    distance_with_label_and_index_sorted=sorted(distance_with_label_and_index,key=lambda x: x[1])\n",
+    "    k_nearest_points = distance_with_label_and_index_sorted[0:k_value]\n",
+    "\n",
+    "    \n",
+    "    #calculating accuracy\n",
+    "    fig, axes = plt.subplots(1, k_value, figsize=(15, 3))  # Adjust figsize as needed\n",
+    "    for i,((label,index),distance) in enumerate(k_nearest_points):\n",
+    "        if(label == y_test):\n",
+    "            correct+=1\n",
+    "        axes[i].imshow(train_images[index])\n",
+    "        axes[i].set_title(f\"Index: {index}\")\n",
+    "        axes[i].axis('off')\n",
+    "    plt.show()\n",
+    "    return correct/(k_value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "index =91\n",
+    "plt.imshow(test_images[index])\n",
+    "print(test_labels[index])\n",
+    "find_knn_and_plot_image(10,resnet_train_data,resnet_test_data[index])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_knn(k_value:int =10,train_data=resnet_train_data,test_data=resnet_test_data):\n",
+    "  results =[]\n",
+    "  correct = 0\n",
+    "  for idx, (x_test,y_test) in enumerate(tqdm(test_data)):\n",
+    "    point = np.array(x_test)\n",
+    "\n",
+    "    distance_with_label_and_index = []\n",
+    "\n",
+    "    for i,(x_train,y_train) in enumerate(train_data):\n",
+    "      train_point = np.array(x_train)\n",
+    "      distance_with_label_and_index.append(((y_train,i),np.linalg.norm(point-train_point)))\n",
+    "\n",
+    "    #sorting based on distance\n",
+    "    distance_with_label_and_index_sorted=sorted(distance_with_label_and_index,key=lambda x: x[1])\n",
+    "    k_nearest_points = distance_with_label_and_index_sorted[0:k_value]\n",
+    "\n",
+    "\n",
+    "    #calculating accuracy\n",
+    "    results.append([])\n",
+    "    for i,((label,index),distance) in enumerate(k_nearest_points):\n",
+    "      if(label == y_test):\n",
+    "        correct+=1\n",
+    "      results[idx].append((label,index))\n",
+    "  return results,correct/(k_value*len(test_data))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results,accuracy = find_knn(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "accuracy"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Experiments/cifar_10_res50_m.py

@@ -0,0 +1,37 @@
+import tensorflow as tf
+from tensorflow.keras import datasets, layers, models
+import numpy as np
+
+# Load CIFAR-10 dataset
+(train_images, train_labels), (_, _) = datasets.cifar10.load_data()
+
+# Normalize pixel values to be between 0 and 1
+train_images = train_images / 255.0
+
+# Load a pre-trained model (e.g., ResNet50)
+base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=(32, 32, 3))
+
+# Extract embeddings
+embeddings_model = models.Sequential([
+    base_model,
+    layers.GlobalAveragePooling2D(),  # Using GlobalAveragePooling2D to reduce spatial dimensions
+    layers.Dense(512, activation='relu')  # You can adjust the size of the dense layer according to your need
+])
+
+# Compute embeddings
+embeddings = embeddings_model.predict(train_images)
+
+# Initialize array to store mean embeddings for each class
+num_classes = 10
+mean_embeddings = np.zeros((num_classes, embeddings.shape[1]))
+
+# Calculate mean embeddings for each class
+for class_label in range(num_classes):
+    class_indices = np.where(train_labels == class_label)[0]
+    class_embeddings = embeddings[class_indices]
+    mean_embedding = np.mean(class_embeddings, axis=0)
+    mean_embeddings[class_label] = mean_embedding
+
+print("Mean embeddings for each class:")
+print(mean_embeddings)
+mean_embeddings.shape

Experiments/cnn-resnet34-cifar10.ipynb

@@ -0,0 +1,749 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "MkoGLH_Tj5wn"
+   },
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     }
+    },
+    "colab_type": "code",
+    "id": "ORj09gnrj5wp"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "\n",
+    "\n",
+    "if torch.cuda.is_available():\n",
+    "    torch.backends.cudnn.deterministic = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "I6hghKPxj5w0"
+   },
+   "source": [
+    "## Model Settings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     },
+     "base_uri": "https://localhost:8080/",
+     "height": 85
+    },
+    "colab_type": "code",
+    "executionInfo": {
+     "elapsed": 23936,
+     "status": "ok",
+     "timestamp": 1524974497505,
+     "user": {
+      "displayName": "Sebastian Raschka",
+      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
+      "userId": "118404394130788869227"
+     },
+     "user_tz": 240
+    },
+    "id": "NnT0sZIwj5wu",
+    "outputId": "55aed925-d17e-4c6a-8c71-0d9b3bde5637"
+   },
+   "outputs": [],
+   "source": [
+    "##########################\n",
+    "### SETTINGS\n",
+    "##########################\n",
+    "\n",
+    "# Hyperparameters\n",
+    "RANDOM_SEED = 1\n",
+    "LEARNING_RATE = 0.001\n",
+    "BATCH_SIZE = 256\n",
+    "NUM_EPOCHS = 10\n",
+    "\n",
+    "# Architecture\n",
+    "NUM_FEATURES = 28*28\n",
+    "NUM_CLASSES = 10\n",
+    "\n",
+    "# Other\n",
+    "DEVICE = \"cuda:1\"\n",
+    "GRAYSCALE = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##########################\n",
+    "### MODEL\n",
+    "##########################\n",
+    "\n",
+    "\n",
+    "def conv3x3(in_planes, out_planes, stride=1):\n",
+    "    \"\"\"3x3 convolution with padding\"\"\"\n",
+    "    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n",
+    "                     padding=1, bias=False)\n",
+    "\n",
+    "\n",
+    "class BasicBlock(nn.Module):\n",
+    "    expansion = 1\n",
+    "\n",
+    "    def __init__(self, inplanes, planes, stride=1, downsample=None):\n",
+    "        super(BasicBlock, self).__init__()\n",
+    "        self.conv1 = conv3x3(inplanes, planes, stride)\n",
+    "        self.bn1 = nn.BatchNorm2d(planes)\n",
+    "        self.relu = nn.ReLU(inplace=True)\n",
+    "        self.conv2 = conv3x3(planes, planes)\n",
+    "        self.bn2 = nn.BatchNorm2d(planes)\n",
+    "        self.downsample = downsample\n",
+    "        self.stride = stride\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        residual = x\n",
+    "\n",
+    "        out = self.conv1(x)\n",
+    "        out = self.bn1(out)\n",
+    "        out = self.relu(out)\n",
+    "\n",
+    "        out = self.conv2(out)\n",
+    "        out = self.bn2(out)\n",
+    "\n",
+    "        if self.downsample is not None:\n",
+    "            residual = self.downsample(x)\n",
+    "\n",
+    "        out += residual\n",
+    "        out = self.relu(out)\n",
+    "\n",
+    "        return out\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "class ResNet(nn.Module):\n",
+    "\n",
+    "    def __init__(self, block, layers, num_classes, grayscale):\n",
+    "        self.inplanes = 64\n",
+    "        if grayscale:\n",
+    "            in_dim = 1\n",
+    "        else:\n",
+    "            in_dim = 3\n",
+    "        super(ResNet, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3,\n",
+    "                               bias=False)\n",
+    "        self.bn1 = nn.BatchNorm2d(64)\n",
+    "        self.relu = nn.ReLU(inplace=True)\n",
+    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
+    "        self.layer1 = self._make_layer(block, 64, layers[0])\n",
+    "        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)\n",
+    "        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)\n",
+    "        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)\n",
+    "        self.avgpool = nn.AvgPool2d(7, stride=1)\n",
+    "        self.fc = nn.Linear(512 * block.expansion, num_classes)\n",
+    "\n",
+    "        for m in self.modules():\n",
+    "            if isinstance(m, nn.Conv2d):\n",
+    "                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
+    "                m.weight.data.normal_(0, (2. / n)**.5)\n",
+    "            elif isinstance(m, nn.BatchNorm2d):\n",
+    "                m.weight.data.fill_(1)\n",
+    "                m.bias.data.zero_()\n",
+    "\n",
+    "    def _make_layer(self, block, planes, blocks, stride=1):\n",
+    "        downsample = None\n",
+    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
+    "            downsample = nn.Sequential(\n",
+    "                nn.Conv2d(self.inplanes, planes * block.expansion,\n",
+    "                          kernel_size=1, stride=stride, bias=False),\n",
+    "                nn.BatchNorm2d(planes * block.expansion),\n",
+    "            )\n",
+    "\n",
+    "        layers = []\n",
+    "        layers.append(block(self.inplanes, planes, stride, downsample))\n",
+    "        self.inplanes = planes * block.expansion\n",
+    "        for i in range(1, blocks):\n",
+    "            layers.append(block(self.inplanes, planes))\n",
+    "\n",
+    "        return nn.Sequential(*layers)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.bn1(x)\n",
+    "        x = self.relu(x)\n",
+    "        x = self.maxpool(x)\n",
+    "\n",
+    "        x = self.layer1(x)\n",
+    "        x = self.layer2(x)\n",
+    "        x = self.layer3(x)\n",
+    "        x = self.layer4(x)\n",
+    "        \n",
+    "        x = x.view(x.size(0), -1)\n",
+    "        logits = self.fc(x)\n",
+    "        probas = F.softmax(logits, dim=1)\n",
+    "        return logits, probas\n",
+    "\n",
+    "\n",
+    "\n",
+    "def resnet34(num_classes):\n",
+    "    \"\"\"Constructs a ResNet-34 model.\"\"\"\n",
+    "    model = ResNet(block=BasicBlock, \n",
+    "                   layers=[3, 4, 6, 3],\n",
+    "                   num_classes=NUM_CLASSES,\n",
+    "                   grayscale=GRAYSCALE)\n",
+    "    return model\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "RAodboScj5w6"
+   },
+   "source": [
+    "## Training without Pinned Memory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files already downloaded and verified\n",
+      "Image batch dimensions: torch.Size([256, 3, 32, 32])\n",
+      "Image label dimensions: torch.Size([256])\n",
+      "Image batch dimensions: torch.Size([256, 3, 32, 32])\n",
+      "Image label dimensions: torch.Size([256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "##########################\n",
+    "### CIFAR-10 Dataset\n",
+    "##########################\n",
+    "\n",
+    "\n",
+    "# Note transforms.ToTensor() scales input images\n",
+    "# to 0-1 range\n",
+    "train_dataset = datasets.CIFAR10(root='data', \n",
+    "                                 train=True, \n",
+    "                                 transform=transforms.ToTensor(),\n",
+    "                                 download=True)\n",
+    "\n",
+    "test_dataset = datasets.CIFAR10(root='data', \n",
+    "                                train=False, \n",
+    "                                transform=transforms.ToTensor())\n",
+    "\n",
+    "\n",
+    "train_loader = DataLoader(dataset=train_dataset, \n",
+    "                          batch_size=BATCH_SIZE, \n",
+    "                          num_workers=8,\n",
+    "                          shuffle=True)\n",
+    "\n",
+    "test_loader = DataLoader(dataset=test_dataset, \n",
+    "                         batch_size=BATCH_SIZE,\n",
+    "                         num_workers=8,\n",
+    "                         shuffle=False)\n",
+    "\n",
+    "# Checking the dataset\n",
+    "for images, labels in train_loader:  \n",
+    "    print('Image batch dimensions:', images.shape)\n",
+    "    print('Image label dimensions:', labels.shape)\n",
+    "    break\n",
+    "\n",
+    "# Checking the dataset\n",
+    "for images, labels in train_loader:  \n",
+    "    print('Image batch dimensions:', images.shape)\n",
+    "    print('Image label dimensions:', labels.shape)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     }
+    },
+    "colab_type": "code",
+    "id": "_lza9t_uj5w1"
+   },
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(RANDOM_SEED)\n",
+    "\n",
+    "model = resnet34(NUM_CLASSES)\n",
+    "model.to(DEVICE)\n",
+    "\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     },
+     "base_uri": "https://localhost:8080/",
+     "height": 1547
+    },
+    "colab_type": "code",
+    "executionInfo": {
+     "elapsed": 2384585,
+     "status": "ok",
+     "timestamp": 1524976888520,
+     "user": {
+      "displayName": "Sebastian Raschka",
+      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
+      "userId": "118404394130788869227"
+     },
+     "user_tz": 240
+    },
+    "id": "Dzh3ROmRj5w7",
+    "outputId": "5f8fd8c9-b076-403a-b0b7-fd2d498b48d7",
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 001/010 | Batch 0000/0196 | Cost: 2.6021\n",
+      "Epoch: 001/010 | Batch 0150/0196 | Cost: 1.3961\n",
+      "Epoch: 001/010 | Train: 45.084%\n",
+      "Time elapsed: 0.26 min\n",
+      "Epoch: 002/010 | Batch 0000/0196 | Cost: 1.1228\n",
+      "Epoch: 002/010 | Batch 0150/0196 | Cost: 1.0426\n",
+      "Epoch: 002/010 | Train: 56.166%\n",
+      "Time elapsed: 0.52 min\n",
+      "Epoch: 003/010 | Batch 0000/0196 | Cost: 0.9980\n",
+      "Epoch: 003/010 | Batch 0150/0196 | Cost: 0.8279\n",
+      "Epoch: 003/010 | Train: 66.702%\n",
+      "Time elapsed: 0.80 min\n",
+      "Epoch: 004/010 | Batch 0000/0196 | Cost: 0.6384\n",
+      "Epoch: 004/010 | Batch 0150/0196 | Cost: 0.7103\n",
+      "Epoch: 004/010 | Train: 65.330%\n",
+      "Time elapsed: 1.08 min\n",
+      "Epoch: 005/010 | Batch 0000/0196 | Cost: 0.6308\n",
+      "Epoch: 005/010 | Batch 0150/0196 | Cost: 0.5913\n",
+      "Epoch: 005/010 | Train: 79.636%\n",
+      "Time elapsed: 1.36 min\n",
+      "Epoch: 006/010 | Batch 0000/0196 | Cost: 0.4409\n",
+      "Epoch: 006/010 | Batch 0150/0196 | Cost: 0.5557\n",
+      "Epoch: 006/010 | Train: 76.456%\n",
+      "Time elapsed: 1.62 min\n",
+      "Epoch: 007/010 | Batch 0000/0196 | Cost: 0.4778\n",
+      "Epoch: 007/010 | Batch 0150/0196 | Cost: 0.4815\n",
+      "Epoch: 007/010 | Train: 65.890%\n",
+      "Time elapsed: 1.89 min\n",
+      "Epoch: 008/010 | Batch 0000/0196 | Cost: 0.3782\n",
+      "Epoch: 008/010 | Batch 0150/0196 | Cost: 0.4339\n",
+      "Epoch: 008/010 | Train: 85.200%\n",
+      "Time elapsed: 2.16 min\n",
+      "Epoch: 009/010 | Batch 0000/0196 | Cost: 0.3083\n",
+      "Epoch: 009/010 | Batch 0150/0196 | Cost: 0.3290\n",
+      "Epoch: 009/010 | Train: 78.108%\n",
+      "Time elapsed: 2.42 min\n",
+      "Epoch: 010/010 | Batch 0000/0196 | Cost: 0.2229\n",
+      "Epoch: 010/010 | Batch 0150/0196 | Cost: 0.1945\n",
+      "Epoch: 010/010 | Train: 87.384%\n",
+      "Time elapsed: 2.70 min\n",
+      "Total Training Time: 2.70 min\n",
+      "Test accuracy: 70.67%\n",
+      "Total Time: 2.71 min\n"
+     ]
+    }
+   ],
+   "source": [
+    "def compute_accuracy(model, data_loader, device):\n",
+    "    correct_pred, num_examples = 0, 0\n",
+    "    for i, (features, targets) in enumerate(data_loader):\n",
+    "            \n",
+    "        features = features.to(device)\n",
+    "        targets = targets.to(device)\n",
+    "\n",
+    "        logits, probas = model(features)\n",
+    "        _, predicted_labels = torch.max(probas, 1)\n",
+    "        num_examples += targets.size(0)\n",
+    "        correct_pred += (predicted_labels == targets).sum()\n",
+    "    return correct_pred.float()/num_examples * 100\n",
+    "    \n",
+    "\n",
+    "start_time = time.time()\n",
+    "for epoch in range(NUM_EPOCHS):\n",
+    "    \n",
+    "    model.train()\n",
+    "    for batch_idx, (features, targets) in enumerate(train_loader):\n",
+    "        \n",
+    "        features = features.to(DEVICE)\n",
+    "        targets = targets.to(DEVICE)\n",
+    "            \n",
+    "        ### FORWARD AND BACK PROP\n",
+    "        logits, probas = model(features)\n",
+    "        cost = F.cross_entropy(logits, targets)\n",
+    "        optimizer.zero_grad()\n",
+    "        \n",
+    "        cost.backward()\n",
+    "        \n",
+    "        ### UPDATE MODEL PARAMETERS\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        ### LOGGING\n",
+    "        if not batch_idx % 150:\n",
+    "            print ('Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f' \n",
+    "                   %(epoch+1, NUM_EPOCHS, batch_idx, \n",
+    "                     len(train_loader), cost))\n",
+    "\n",
+    "        \n",
+    "\n",
+    "    model.eval()\n",
+    "    with torch.set_grad_enabled(False): # save memory during inference\n",
+    "        print('Epoch: %03d/%03d | Train: %.3f%%' % (\n",
+    "              epoch+1, NUM_EPOCHS, \n",
+    "              compute_accuracy(model, train_loader, device=DEVICE)))\n",
+    "        \n",
+    "    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))\n",
+    "    \n",
+    "print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))\n",
+    "\n",
+    "\n",
+    "with torch.set_grad_enabled(False): # save memory during inference\n",
+    "    print('Test accuracy: %.2f%%' % (compute_accuracy(model, test_loader, device=DEVICE)))\n",
+    "    \n",
+    "print('Total Time: %.2f min' % ((time.time() - start_time)/60))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training with Pinned Memory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files already downloaded and verified\n",
+      "Image batch dimensions: torch.Size([256, 3, 32, 32])\n",
+      "Image label dimensions: torch.Size([256])\n",
+      "Image batch dimensions: torch.Size([256, 3, 32, 32])\n",
+      "Image label dimensions: torch.Size([256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "##########################\n",
+    "### CIFAR-10 Dataset\n",
+    "##########################\n",
+    "\n",
+    "\n",
+    "# Note transforms.ToTensor() scales input images\n",
+    "# to 0-1 range\n",
+    "train_dataset = datasets.CIFAR10(root='data', \n",
+    "                                 train=True, \n",
+    "                                 transform=transforms.ToTensor(),\n",
+    "                                 download=True)\n",
+    "\n",
+    "test_dataset = datasets.CIFAR10(root='data', \n",
+    "                                train=False, \n",
+    "                                transform=transforms.ToTensor())\n",
+    "\n",
+    "\n",
+    "train_loader = DataLoader(dataset=train_dataset, \n",
+    "                          batch_size=BATCH_SIZE, \n",
+    "                          pin_memory=True,\n",
+    "                          shuffle=True)\n",
+    "\n",
+    "test_loader = DataLoader(dataset=test_dataset, \n",
+    "                         batch_size=BATCH_SIZE,\n",
+    "                         pin_memory=True,\n",
+    "                         shuffle=False)\n",
+    "\n",
+    "# Checking the dataset\n",
+    "for images, labels in train_loader:  \n",
+    "    print('Image batch dimensions:', images.shape)\n",
+    "    print('Image label dimensions:', labels.shape)\n",
+    "    break\n",
+    "\n",
+    "# Checking the dataset\n",
+    "for images, labels in train_loader:  \n",
+    "    print('Image batch dimensions:', images.shape)\n",
+    "    print('Image label dimensions:', labels.shape)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     }
+    },
+    "colab_type": "code",
+    "id": "_lza9t_uj5w1"
+   },
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(RANDOM_SEED)\n",
+    "\n",
+    "model = resnet34(NUM_CLASSES)\n",
+    "model.to(DEVICE)\n",
+    "\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "autoexec": {
+      "startup": false,
+      "wait_interval": 0
+     },
+     "base_uri": "https://localhost:8080/",
+     "height": 1547
+    },
+    "colab_type": "code",
+    "executionInfo": {
+     "elapsed": 2384585,
+     "status": "ok",
+     "timestamp": 1524976888520,
+     "user": {
+      "displayName": "Sebastian Raschka",
+      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
+      "userId": "118404394130788869227"
+     },
+     "user_tz": 240
+    },
+    "id": "Dzh3ROmRj5w7",
+    "outputId": "5f8fd8c9-b076-403a-b0b7-fd2d498b48d7",
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 001/010 | Batch 0000/0196 | Cost: 2.6021\n",
+      "Epoch: 001/010 | Batch 0150/0196 | Cost: 1.3961\n",
+      "Epoch: 001/010 | Train: 45.084%\n",
+      "Time elapsed: 0.39 min\n",
+      "Epoch: 002/010 | Batch 0000/0196 | Cost: 1.1228\n",
+      "Epoch: 002/010 | Batch 0150/0196 | Cost: 1.0426\n",
+      "Epoch: 002/010 | Train: 56.166%\n",
+      "Time elapsed: 0.77 min\n",
+      "Epoch: 003/010 | Batch 0000/0196 | Cost: 0.9980\n",
+      "Epoch: 003/010 | Batch 0150/0196 | Cost: 0.8279\n",
+      "Epoch: 003/010 | Train: 66.702%\n",
+      "Time elapsed: 1.16 min\n",
+      "Epoch: 004/010 | Batch 0000/0196 | Cost: 0.6384\n",
+      "Epoch: 004/010 | Batch 0150/0196 | Cost: 0.7103\n",
+      "Epoch: 004/010 | Train: 65.330%\n",
+      "Time elapsed: 1.55 min\n",
+      "Epoch: 005/010 | Batch 0000/0196 | Cost: 0.6308\n",
+      "Epoch: 005/010 | Batch 0150/0196 | Cost: 0.5913\n",
+      "Epoch: 005/010 | Train: 79.636%\n",
+      "Time elapsed: 1.94 min\n",
+      "Epoch: 006/010 | Batch 0000/0196 | Cost: 0.4409\n",
+      "Epoch: 006/010 | Batch 0150/0196 | Cost: 0.5557\n",
+      "Epoch: 006/010 | Train: 76.456%\n",
+      "Time elapsed: 2.33 min\n",
+      "Epoch: 007/010 | Batch 0000/0196 | Cost: 0.4778\n",
+      "Epoch: 007/010 | Batch 0150/0196 | Cost: 0.4815\n",
+      "Epoch: 007/010 | Train: 65.890%\n",
+      "Time elapsed: 2.71 min\n",
+      "Epoch: 008/010 | Batch 0000/0196 | Cost: 0.3782\n",
+      "Epoch: 008/010 | Batch 0150/0196 | Cost: 0.4339\n",
+      "Epoch: 008/010 | Train: 85.200%\n",
+      "Time elapsed: 3.10 min\n",
+      "Epoch: 009/010 | Batch 0000/0196 | Cost: 0.3083\n",
+      "Epoch: 009/010 | Batch 0150/0196 | Cost: 0.3290\n",
+      "Epoch: 009/010 | Train: 78.108%\n",
+      "Time elapsed: 3.49 min\n",
+      "Epoch: 010/010 | Batch 0000/0196 | Cost: 0.2229\n",
+      "Epoch: 010/010 | Batch 0150/0196 | Cost: 0.1945\n",
+      "Epoch: 010/010 | Train: 87.384%\n",
+      "Time elapsed: 3.88 min\n",
+      "Total Training Time: 3.88 min\n",
+      "Test accuracy: 70.67%\n",
+      "Total Time: 3.91 min\n"
+     ]
+    }
+   ],
+   "source": [
+    "def compute_accuracy(model, data_loader, device):\n",
+    "    correct_pred, num_examples = 0, 0\n",
+    "    for i, (features, targets) in enumerate(data_loader):\n",
+    "            \n",
+    "        features = features.to(device)\n",
+    "        targets = targets.to(device)\n",
+    "\n",
+    "        logits, probas = model(features)\n",
+    "        _, predicted_labels = torch.max(probas, 1)\n",
+    "        num_examples += targets.size(0)\n",
+    "        correct_pred += (predicted_labels == targets).sum()\n",
+    "    return correct_pred.float()/num_examples * 100\n",
+    "    \n",
+    "\n",
+    "start_time = time.time()\n",
+    "for epoch in range(NUM_EPOCHS):\n",
+    "    \n",
+    "    model.train()\n",
+    "    for batch_idx, (features, targets) in enumerate(train_loader):\n",
+    "        \n",
+    "        features = features.to(DEVICE)\n",
+    "        targets = targets.to(DEVICE)\n",
+    "            \n",
+    "        ### FORWARD AND BACK PROP\n",
+    "        logits, probas = model(features)\n",
+    "        cost = F.cross_entropy(logits, targets)\n",
+    "        optimizer.zero_grad()\n",
+    "        \n",
+    "        cost.backward()\n",
+    "        \n",
+    "        ### UPDATE MODEL PARAMETERS\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        ### LOGGING\n",
+    "        if not batch_idx % 150:\n",
+    "            print ('Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f' \n",
+    "                   %(epoch+1, NUM_EPOCHS, batch_idx, \n",
+    "                     len(train_loader), cost))\n",
+    "\n",
+    "        \n",
+    "\n",
+    "    model.eval()\n",
+    "    with torch.set_grad_enabled(False): # save memory during inference\n",
+    "        print('Epoch: %03d/%03d | Train: %.3f%%' % (\n",
+    "              epoch+1, NUM_EPOCHS, \n",
+    "              compute_accuracy(model, train_loader, device=DEVICE)))\n",
+    "        \n",
+    "    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))\n",
+    "    \n",
+    "print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))\n",
+    "\n",
+    "\n",
+    "with torch.set_grad_enabled(False): # save memory during inference\n",
+    "    print('Test accuracy: %.2f%%' % (compute_accuracy(model, test_loader, device=DEVICE)))\n",
+    "    \n",
+    "print('Total Time: %.2f min' % ((time.time() - start_time)/60))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Based on the training time without and with `pin_memory=True`, there doesn't seem to be a speed-up when using page-locked (or \"pinned\") memory -- in fact, pinning the memory even slowed down the training. (I reran the code in the opposite order, i.e., `pin_memory=True` first, and got the same results.) This could be due to the relatively small dataset size, batch size.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "default_view": {},
+   "name": "convnet-vgg16.ipynb",
+   "provenance": [],
+   "version": "0.3.2",
+   "views": {}
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.1"
+  },
+  "toc": {
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": true,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "371px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Experiments/quicknet_cifar10_centroid.ipynb

@@ -0,0 +1,698 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5aR8PYXi684E",
+        "outputId": "a6b59bdf-41f5-4b86-e7b1-47ceb6fb6893"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
+            "170498071/170498071 [==============================] - 5s 0us/step\n",
+            "Epoch 1/10\n",
+            "782/782 [==============================] - 14s 10ms/step - loss: 1.6260 - accuracy: 0.3923 - val_loss: 1.2804 - val_accuracy: 0.5374\n",
+            "Epoch 2/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 1.1254 - accuracy: 0.5914 - val_loss: 1.0466 - val_accuracy: 0.6335\n",
+            "Epoch 3/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.9187 - accuracy: 0.6723 - val_loss: 0.9976 - val_accuracy: 0.6503\n",
+            "Epoch 4/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.7763 - accuracy: 0.7259 - val_loss: 0.8091 - val_accuracy: 0.7194\n",
+            "Epoch 5/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.6660 - accuracy: 0.7670 - val_loss: 0.7875 - val_accuracy: 0.7268\n",
+            "Epoch 6/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.5799 - accuracy: 0.7962 - val_loss: 0.8075 - val_accuracy: 0.7319\n",
+            "Epoch 7/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.5006 - accuracy: 0.8232 - val_loss: 0.8128 - val_accuracy: 0.7300\n",
+            "Epoch 8/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.4253 - accuracy: 0.8497 - val_loss: 0.8981 - val_accuracy: 0.7261\n",
+            "Epoch 9/10\n",
+            "782/782 [==============================] - 6s 8ms/step - loss: 0.3633 - accuracy: 0.8707 - val_loss: 0.8523 - val_accuracy: 0.7377\n",
+            "Epoch 10/10\n",
+            "782/782 [==============================] - 7s 9ms/step - loss: 0.3099 - accuracy: 0.8887 - val_loss: 0.8689 - val_accuracy: 0.7499\n",
+            "1563/1563 [==============================] - 4s 2ms/step\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([[8.79073262e-01, 2.84781260e-03, 3.16492580e-02, 9.60051734e-03,\n",
+              "        8.88401456e-03, 4.04336443e-03, 1.89202465e-03, 2.60451157e-03,\n",
+              "        4.94241416e-02, 9.98295005e-03],\n",
+              "       [5.34512708e-03, 9.61387515e-01, 1.82328641e-03, 1.49091403e-03,\n",
+              "        3.62021121e-04, 2.36713630e-03, 9.99960001e-04, 3.58641875e-04,\n",
+              "        8.00825842e-03, 1.78600885e-02],\n",
+              "       [1.93752628e-02, 5.49300632e-04, 8.71673167e-01, 3.62917222e-02,\n",
+              "        2.81240512e-02, 1.94428060e-02, 1.17484620e-02, 7.90499710e-03,\n",
+              "        3.91457370e-03, 9.77586606e-04],\n",
+              "       [3.43155907e-03, 3.87360866e-04, 3.25083360e-02, 8.04273427e-01,\n",
+              "        2.26426423e-02, 1.00013100e-01, 1.48316240e-02, 1.55726429e-02,\n",
+              "        3.46732978e-03, 2.87183723e-03],\n",
+              "       [4.50019445e-03, 3.07688024e-04, 3.81155163e-02, 3.81957851e-02,\n",
+              "        8.43278885e-01, 2.98470370e-02, 1.07433125e-02, 3.15311365e-02,\n",
+              "        2.45781220e-03, 1.02343888e-03],\n",
+              "       [8.63184629e-04, 2.92542420e-04, 2.77942196e-02, 1.26914889e-01,\n",
+              "        1.68064609e-02, 7.96062946e-01, 6.89344807e-03, 2.19228752e-02,\n",
+              "        1.45196577e-03, 9.96942166e-04],\n",
+              "       [2.25282880e-03, 1.00196269e-03, 4.27705161e-02, 4.95258309e-02,\n",
+              "        1.27582047e-02, 1.77529752e-02, 8.66206527e-01, 2.50199367e-03,\n",
+              "        2.86106160e-03, 2.37041595e-03],\n",
+              "       [1.76379981e-03, 2.93744437e-04, 8.86812247e-03, 1.57593563e-02,\n",
+              "        1.64906941e-02, 2.32193433e-02, 5.39854867e-04, 9.30097342e-01,\n",
+              "        8.36823776e-04, 2.13308516e-03],\n",
+              "       [1.30738802e-02, 4.98946663e-03, 2.41551897e-03, 5.38546871e-03,\n",
+              "        1.31231989e-03, 1.98870571e-03, 1.08822726e-03, 5.06214972e-04,\n",
+              "        9.64531541e-01, 4.71282937e-03],\n",
+              "       [1.20871738e-02, 2.48907283e-02, 2.02297443e-03, 6.83936710e-03,\n",
+              "        1.44265452e-03, 4.34162840e-03, 1.16528722e-03, 2.80632032e-03,\n",
+              "        1.10650901e-02, 9.33342278e-01]])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 1
+        }
+      ],
+      "source": [
+        "from scipy.spatial.distance import euclidean\n",
+        "import tensorflow as tf\n",
+        "from tensorflow.keras import datasets, layers, models\n",
+        "import numpy as np\n",
+        "\n",
+        "\n",
+        "(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()\n",
+        "\n",
+        "\n",
+        "train_images = train_images / 255.0\n",
+        "test_images = test_images / 255.0\n",
+        "\n",
+        "\n",
+        "def create_resnet18():\n",
+        "    model = models.Sequential()\n",
+        "    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))\n",
+        "    model.add(layers.MaxPooling2D((2, 2)))\n",
+        "    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))\n",
+        "    model.add(layers.MaxPooling2D((2, 2)))\n",
+        "    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))\n",
+        "    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))\n",
+        "    model.add(layers.MaxPooling2D((2, 2)))\n",
+        "    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))\n",
+        "    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))\n",
+        "    model.add(layers.MaxPooling2D((2, 2)))\n",
+        "    model.add(layers.Flatten())\n",
+        "    model.add(layers.Dense(512, activation='relu'))\n",
+        "    model.add(layers.Dense(10, activation='softmax'))\n",
+        "    return model\n",
+        "\n",
+        "\n",
+        "model = create_resnet18()\n",
+        "\n",
+        "\n",
+        "model.compile(optimizer='adam',\n",
+        "              loss='sparse_categorical_crossentropy',\n",
+        "              metrics=['accuracy'])\n",
+        "\n",
+        "\n",
+        "model.fit(train_images, train_labels, epochs=10, batch_size=64, validation_data=(test_images, test_labels))\n",
+        "\n",
+        "\n",
+        "train_embeddings = model.predict(train_images)\n",
+        "\n",
+        "num_classes = 10\n",
+        "mean_embeddings = np.zeros((num_classes, train_embeddings.shape[1]))\n",
+        "\n",
+        "\n",
+        "for class_label in range(num_classes):\n",
+        "    class_indices = np.where(train_labels.flatten() == class_label)[0]\n",
+        "    class_embeddings = train_embeddings[class_indices]\n",
+        "    mean_embedding = np.mean(class_embeddings, axis=0)\n",
+        "    mean_embeddings[class_label] = mean_embedding\n",
+        "\n",
+        "\n",
+        "def classify_query(query_image):\n",
+        "    query_embedding = model.predict(np.expand_dims(query_image, axis=0))\n",
+        "    distances = [euclidean(query_embedding.flatten(), mean_embedding) for mean_embedding in mean_embeddings]\n",
+        "    predicted_class = np.argmin(distances)\n",
+        "    return predicted_class\n",
+        "\n",
+        "mean_embeddings\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calculate accuracy\n",
+        "correct_predictions = 0\n",
+        "total_predictions = 500\n",
+        "\n",
+        "for i in range(500):\n",
+        "    predicted_class = classify_query(test_images[i])\n",
+        "    if predicted_class == test_labels[i]:\n",
+        "        correct_predictions += 1\n",
+        "\n",
+        "accuracy = correct_predictions / total_predictions\n",
+        "print(\"Accuracy:\", accuracy)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "1-b_E44RrxuV",
+        "outputId": "125e4835-b44a-48bf-ff43-1103c2b1b6f4"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1/1 [==============================] - 0s 388ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 23ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 48ms/step\n",
+            "1/1 [==============================] - 0s 32ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 35ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 32ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 34ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 35ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 23ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 22ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 22ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 23ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 21ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 23ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 20ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 38ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 24ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 30ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 26ms/step\n",
+            "1/1 [==============================] - 0s 36ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 31ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 29ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 28ms/step\n",
+            "1/1 [==============================] - 0s 27ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 22ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 18ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 17ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 16ms/step\n",
+            "1/1 [==============================] - 0s 19ms/step\n",
+            "1/1 [==============================] - 0s 25ms/step\n",
+            "Accuracy: 0.744\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

Experiments/quicknet_knn.py

@@ -0,0 +1,37 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pickle
+
+def find_knn_and_plot_image(test_data,model,k_value:int =10):
+    x_test = test_data
+    point = np.array(x_test)
+    point = np.expand_dims(point, axis=0)
+    
+    test_embedding = model.predict(point)
+    
+    with open(r'Model\data\train_embeddings_resnet18.pkl', 'rb') as f:
+        data = pickle.load(f)
+
+    # Convert data to NumPy array
+    train_data = np.array(data)
+
+    # Convert NumPy array to TensorFlow tensor
+#     data_tensor = tf.convert_to_tensor(data_array, dtype=tf.float32)
+
+    distance_with_label_and_index = []
+    print(train_data)
+    for i,(x_train) in enumerate(train_data):
+      train_point = np.array(x_train)
+      distance_with_label_and_index.append((i,np.linalg.norm(test_embedding-train_point)))
+
+    #sorting based on distance
+    distance_with_label_and_index_sorted=sorted(distance_with_label_and_index,key=lambda x: x[1])
+    k_nearest_points = distance_with_label_and_index_sorted[0:k_value]
+
+    
+    #calculating accuracy
+    result =[]
+    for i,(index,distance) in enumerate(k_nearest_points):
+        print(index)
+        result.append(train_image[index])
+    return result

Experiments/train_resnet50_3hll.py

@@ -0,0 +1,163 @@
+import torch
+from tqdm import tqdm
+import wandb
+import torch.nn as nn
+import torchvision.transforms as v2
+from torch.utils.data import DataLoader
+import torchvision.datasets as datasets
+
+wandb.login()
+
+wandb.init(project="CIFAR", entity="gjyotin305")
+mps_device = torch.device("cuda")
+
+
+IMAGE_SIZE = 224
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+wandb.init()
+transform_test = v2.Compose(
+    [v2.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+    v2.ToTensor(),
+     v2.Normalize(mean, std)])
+
+transform_train = v2.Compose(
+    [v2.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+        v2.RandomRotation(20),
+        v2.RandomHorizontalFlip(0.1),
+        v2.ColorJitter(brightness = 0.1, contrast=0.1, saturation=0.1),
+        v2.RandomAdjustSharpness(sharpness_factor=2, p=0.1),
+        v2.ToTensor(),
+        v2.Normalize(mean, std),
+        v2.RandomErasing(p=0.75, scale=(0.02, 0.1), value=1.0, inplace=False)])
+
+cifar_trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
+cifar_testset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
+
+batch_size=64
+
+trainLoader = DataLoader(cifar_trainset, batch_size=batch_size, shuffle=True, num_workers=8)
+testLoader = DataLoader(cifar_testset, batch_size=batch_size, shuffle=True, num_workers=8)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+print(next(iter(trainLoader))[0].shape)
+
+
+import torchvision.datasets as datasets
+import torchvision.models as models
+
+resnet = models.resnet50(pretrained=True)
+
+
+class JHARMNet(nn.Module):
+    def __init__(self, pretrained_model, num_classes):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.premodel.fc = nn.Linear(2048, num_classes)
+        nn.init.xavier_uniform_(self.premodel.fc.weight)
+    
+    def forward(self, x):
+        out = self.premodel(x)
+        return out
+
+class HiddenLayer(nn.Module):
+    def __init__(self, pretrained_model):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.new_layer = nn.Sequential(
+                nn.Linear(1000, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 256),
+                nn.LeakyReLU(),
+                nn.Linear(256, 10)
+                )
+
+    def forward(self, x):
+        out = self.premodel(x)
+        out_new_layer = self.new_layer(out)
+        return out_new_layer
+
+model_check = HiddenLayer(resnet)
+criterion = nn.CrossEntropyLoss()
+learning_rate=0.001
+
+optimizer = torch.optim.SGD(model_check.parameters(),lr=learning_rate, momentum=0.2)
+
+# scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+
+def train_model(model, train_loader, validation_loader, optimizer, n_epochs = 20):
+    
+    # Global variable
+    N_test = len(cifar_testset)
+    accuracy_list = []
+    train_loss_list = []
+    model = model.to(mps_device)
+    train_cost_list = []
+    val_cost_list = []
+    
+    for epoch in range(n_epochs):
+        train_COST = 0
+        print(f"Training Epoch: {epoch+1}")
+        for x,y in tqdm(train_loader):
+            x = x.to(mps_device)
+            y = y.to(mps_device)
+            model.train()
+            optimizer.zero_grad()
+            z = model(x)
+            loss = criterion(z,y)
+            loss.backward()
+            wandb.log({"train_loss": loss.item()})
+            optimizer.step()
+            train_COST+=loss.item()
+            
+        train_COST = train_COST/len(train_loader)
+        train_cost_list.append(train_COST)
+        correct = 0
+        print(f"Validation Loop") 
+        # Perform the prediction on the validation data
+        val_COST = 0
+        for x_test, y_test in tqdm(validation_loader):
+            model.eval()
+            x_test = x_test.to(mps_device)
+            y_test = y_test.to(mps_device)
+            z = model(x_test)
+            val_loss = criterion(z, y_test)
+            # scheduler.step(val_loss)
+            wandb.log({"val_loss": val_loss})
+            _, yhat = torch.max(z.data, 1)
+            correct += (yhat==y_test).sum().item()
+            val_COST+=val_loss.item()
+        
+        val_COST = val_COST/ len(validation_loader)
+        val_cost_list.append(val_COST)
+        accuracy = correct / N_test
+        accuracy_list.append(accuracy)
+        wandb.log({"val_acc": accuracy}) 
+        if (epoch+1)%5 == 0:
+            torch.save(model.state_dict(), f"/root/test_cifar/log_model/CIFAR_{epoch+1}_end_hll.pt")
+            print(f"Saved Model as CIFAR_{epoch+1}_end_hll.pt")
+
+        print("--> Epoch Number : {}".format(epoch + 1),
+              " | Training Loss : {}".format(round(train_COST,4)),
+              " | Validation Loss : {}".format(round(val_COST,4)),
+              " | Validation Accuracy : {}%".format(round(accuracy * 100, 2)))
+        
+    return accuracy_list, train_cost_list, val_cost_list, model
+
+
+
+accuracy_list_normalv5, train_cost_listv5, val_cost_listv5, model_to_save=train_model(model=model_check, 
+                                                                       n_epochs=100, 
+                                                                       train_loader=trainLoader, 
+                                                                       validation_loader=testLoader, 
+                                                                       optimizer=optimizer)
+
+torch.save(model_to_save.state_dict(), "CIFAR_end_hll.pt")
+model = torch.load("CIFAR_end_hll.pt")
+model.eval()
+
+pred = model(next(iter(testLoader))[0])
+print(pred[0][0], next(iter(testLoader))[1][0])

Experiments/train_resnet50_iter_1.py

@@ -0,0 +1,156 @@
+import torchvision.models as models
+import torch
+from tqdm import tqdm
+import torch.nn as nn
+import torchvision.transforms as v2
+from torch.utils.data import DataLoader
+import torchvision.datasets as datasets
+
+
+mps_device = torch.device("cuda")
+
+IMAGE_SIZE = 224
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+
+transform_test = v2.Compose(
+    [v2.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+     v2.ToTensor(),
+     v2.Normalize(mean, std)])
+
+transform_train = v2.Compose(
+    [v2.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+        v2.RandomRotation(20),
+        v2.RandomHorizontalFlip(0.1),
+        v2.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1),
+        v2.RandomAdjustSharpness(sharpness_factor=2, p=0.1),
+        v2.ToTensor(),
+        v2.Normalize(mean, std),
+        v2.RandomErasing(p=0.75, scale=(0.02, 0.1), value=1.0, inplace=False)])
+
+cifar_trainset = datasets.CIFAR10(
+    root='./data',
+    train=True,
+    download=True,
+    transform=transform_train)
+cifar_testset = datasets.CIFAR10(
+    root='./data',
+    train=False,
+    download=True,
+    transform=transform_test)
+
+batch_size = 64
+
+trainLoader = DataLoader(
+    cifar_trainset,
+    batch_size=batch_size,
+    shuffle=True,
+    num_workers=8)
+testLoader = DataLoader(
+    cifar_testset,
+    batch_size=batch_size,
+    shuffle=True,
+    num_workers=8)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+print(next(iter(trainLoader))[0].shape)
+
+
+resnet = models.resnet50(pretrained=True)
+# print(resnet)
+# print(resnet.fc)
+
+
+class JHARMNet(nn.Module):
+    def __init__(self, pretrained_model, num_classes):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.premodel.fc = nn.Linear(2048, num_classes)
+        nn.init.xavier_uniform_(self.premodel.fc.weight)
+
+    def forward(self, x):
+        out = self.premodel(x)
+        return out
+
+
+model_check = JHARMNet(resnet, 10)
+criterion = nn.CrossEntropyLoss()
+learning_rate = 0.1
+
+optimizer = torch.optim.SGD(
+    model_check.parameters(),
+    lr=learning_rate,
+    momentum=0.2)
+
+scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
+
+
+def train_model(
+        model,
+        train_loader,
+        validation_loader,
+        optimizer,
+        n_epochs=20):
+
+    # Global variable
+    N_test = len(cifar_testset)
+    accuracy_list = []
+    train_loss_list = []
+    model = model.to(mps_device)
+    train_cost_list = []
+    val_cost_list = []
+
+    for epoch in range(n_epochs):
+        train_COST = 0
+        print(f"Training Epoch: {epoch}")
+        for x, y in tqdm(train_loader):
+            x = x.to(mps_device)
+            y = y.to(mps_device)
+            model.train()
+            optimizer.zero_grad()
+            z = model(x)
+            loss = criterion(z, y)
+            loss.backward()
+            optimizer.step()
+            train_COST += loss.item()
+
+        train_COST = train_COST / len(train_loader)
+        train_cost_list.append(train_COST)
+        correct = 0
+        print(f"Validation Loop")
+        # Perform the prediction on the validation data
+        val_COST = 0
+        for x_test, y_test in tqdm(validation_loader):
+            model.eval()
+            x_test = x_test.to(mps_device)
+            y_test = y_test.to(mps_device)
+            z = model(x_test)
+            val_loss = criterion(z, y_test)
+            scheduler.step(val_loss)
+            _, yhat = torch.max(z.data, 1)
+            correct += (yhat == y_test).sum().item()
+            val_COST += val_loss.item()
+
+        val_COST = val_COST / len(validation_loader)
+        val_cost_list.append(val_COST)
+        accuracy = correct / N_test
+        accuracy_list.append(accuracy)
+
+        print("--> Epoch Number : {}".format(epoch + 1),
+              " | Training Loss : {}".format(round(train_COST, 4)),
+              " | Validation Loss : {}".format(round(val_COST, 4)),
+              " | Validation Accuracy : {}%".format(round(accuracy * 100, 2)))
+
+    return accuracy_list, train_cost_list, val_cost_list, model
+
+
+accuracy_list_normalv5, train_cost_listv5, val_cost_listv5, model_to_save = train_model(
+    model=model_check, n_epochs=100, train_loader=trainLoader, validation_loader=testLoader, optimizer=optimizer)
+
+torch.save(model_to_save.state_dict(), "CIFAR.pt")
+model = torch.load("CIFAR.pt")
+model.eval()
+
+pred = model(next(iter(testLoader))[0])
+print(pred[0][0], next(iter(testLoader))[1][0])

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jyotin Goel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MidTerm_Report.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e171b9314127b3662ce813589398106b1c1dbabd996bc36aadc475cfda02ed8d
+size 1110513

Model/CIFAR.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fc375fa01813882af9e2a88654b765fb58bd8cd2f48731963ffa56fb1652434
+size 94418218

Model/Resnet50_train_features.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50516ceab17cd7ca8eaa2738b30e201fad30a89972a256cc370a56236a70c427
+size 2001185

Model/ann.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6375c0313b719e85a904bc2d733ee741f084599b3f5671b8dd4b978a5a4101b1
+size 6832736

Model/centroid_app.py

@@ -0,0 +1,80 @@
+
+import pickle
+import random
+import numpy as np
+import cv2
+from tensorflow.keras import models, layers
+
+# Load the trained model architecture
+def create_resnet18():
+    model = models.Sequential()
+    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
+    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
+    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
+    model.add(layers.MaxPooling2D((2, 2)))
+    model.add(layers.Flatten())
+    model.add(layers.Dense(512, activation='relu'))
+    model.add(layers.Dense(10, activation='softmax'))
+    return model
+
+# Load the pretrained weights
+def load_pretrained_weights(model, weights_path):
+    model.load_weights(weights_path)
+
+# Function to unpickle a file
+def unpickle(file):
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+# Function to load images from the unpickled data batch file of a specific class
+def load_class_images(class_index, train_batches):
+    images = []
+    for batch in train_batches:
+        if b'data' in batch and b'labels' in batch:
+            data = batch[b'data']
+            labels = batch[b'labels']
+            for i, label in enumerate(labels):
+                if label == class_index:
+                    img = data[i].reshape(3, 32, 32).transpose(1, 2, 0)  # Reshape and transpose the image
+                    images.append(img)
+    return images
+
+# Function to calculate the distance of the mean embeddings with a query image
+def classify_query(query_image, model, mean_embeddings):
+    query_embedding = model.predict(np.expand_dims(query_image, axis=0))
+    distances = [np.linalg.norm(query_embedding.flatten() - mean_embedding) for mean_embedding in mean_embeddings]
+    predicted_class = np.argmin(distances)
+    return predicted_class
+
+
+def retrieve(query_image,k=3):
+    model = create_resnet18()
+    load_pretrained_weights(model, 'Model\pretrained_model_weights.h5')
+
+    mean_embeddings = pickle.load(open('Model\data\mean_embeddings.pkl', 'rb'))
+
+    # query_image_path = '/content/airplane_8925.png'
+    # query_image = cv2.imread(query_image_path)
+    query_image = cv2.resize(query_image, (32, 32)) / 255.0  # Resize and normalize the image
+
+    predicted_class = classify_query(query_image, model, mean_embeddings)
+    # print("Predicted Class:", predicted_class)
+
+    # Load random images of the predicted class
+    train_batches = [unpickle(rf"Model\data\data_batch_{i}") for i in range(1,6)]
+    class_images = load_class_images(predicted_class, train_batches)
+    
+    if class_images:
+        random_images = random.sample(class_images, k)  # Select 3 random images
+        return random_images
+    else:
+        print("No images found for the predicted class.")
+
+

Model/data/data_batch_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54636561a3ce25bd3e19253c6b0d8538147b0ae398331ac4a2d86c6d987368cd
+size 31035704

Model/data/data_batch_2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:766b2cef9fbc745cf056b3152224f7cf77163b330ea9a15f9392beb8b89bc5a8
+size 31035320

Model/data/data_batch_3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f00d98ebfb30b3ec0ad19f9756dc2630b89003e10525f5e148445e82aa6a1f9
+size 31035999

Model/data/data_batch_4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f7bb240661948b8f4d53e36ec720d8306f5668bd0071dcb4e6c947f78e9682b
+size 31035696

Model/data/data_batch_5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d91802434d8376bbaeeadf58a737e3a1b12ac839077e931237e0dcd43adcb154
+size 31035623

Model/data/mean_embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:272f9a5f5bd64519f68c8ac5397a6d98a920175d15ad67e19af110f54ac9dfaf
+size 952

Model/data/test_batch

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f53d8d457504f7cff4ea9e021afcf0e0ad8e24a91f3fc42091b8adef61157831
+size 31035526

Model/data/train_embeddings_resnet18.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8238e4c8fb43aa0175def221191fe3c9f7e137683746e1f33086681488a266f4
+size 2000162

Model/pretrained_model_weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c60f7cc223c7256a4a3de446b2820d5cd05b552dcbe4a60fcea2f83465f1538
+size 6735320

Model/resnet18.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8415a29fcbd661a67bc004b26e9bcccc7a2133bffa99cd1dc1811c8d1a37dd5
+size 20154704

Model/test.py

@@ -0,0 +1,49 @@
+import torch
+import os
+import torch.nn as nn
+import torchvision.datasets as datasets
+import torchvision.transforms as transforms
+import torchvision.models as models
+
+os.system("gdown --id 1qO2OLR7skDibo1LaMKD3CiOl_jaCTZ0h")
+
+class JHARMNet(nn.Module):
+    def __init__(self, pretrained_model, num_classes):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.premodel.fc = nn.Linear(2048, num_classes)
+        nn.init.xavier_uniform_(self.premodel.fc.weight)
+
+    def forward(self, x):
+        out = self.premodel(x)
+        return out
+
+class HiddenLayer(nn.Module):
+    def __init__(self, pretrained_model):
+        super().__init__()
+        self.premodel = pretrained_model
+        self.new_layer = nn.Sequential(
+                nn.Linear(1000, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 512),
+                nn.LeakyReLU(),
+                nn.Linear(512, 256),
+                nn.LeakyReLU(),
+                nn.Linear(256, 10)
+                )
+
+    def forward(self, x):
+        out = self.premodel(x)
+        out_new_layer = self.new_layer(out)
+        return out_new_layer
+
+
+resnet = models.resnet50(pretrained=True)
+
+x = torch.randn((2, 3, 32, 32))
+
+print(x.shape)
+model_check = HiddenLayer(resnet)
+model_check.load_state_dict(torch.load("CIFAR_end_hll.pt"))
+model_check.eval()
+print(model_check.forward(x).shape)

Preprocessing/k_means.py

@@ -0,0 +1,46 @@
+from sklearn.cluster import KMeans
+from sklearn.utils import shuffle
+from sklearn.metrics import pairwise_distances_argmin
+from PIL import Image
+import numpy as np
+import matplotlib.image as mpimg
+import matplotlib.pyplot as plt
+import random
+
+def kmeans_image_compression(image, n_colors=8):
+
+    # Convert image to numpy array
+    image_np = np.array(image)
+
+    # Reshape the image to a 2D array of pixels
+    image_reshaped = image_np.reshape(-1, 3)
+    # print(image_reshaped.shape)
+
+    # Shuffle the pixels
+    image_reshaped_sample = shuffle(image_reshaped, random_state=0)[:image_reshaped.shape[0]]
+
+    # Apply KMeans clustering using sklearn Library
+    kmeans = KMeans(n_clusters=n_colors, random_state=0,n_init=10).fit(image_reshaped_sample)
+    labels = kmeans.predict(image_reshaped)
+    centroids = kmeans.cluster_centers_
+
+    # Replace each pixel with its corresponding centroid color
+    compressed_image = centroids[labels]
+
+    # Reshape the compressed image back to its original shape
+    compressed_image = compressed_image.reshape(image_np.shape)
+
+    # Convert the compressed image array to uint8 data type
+    compressed_image = compressed_image.astype(np.uint8)
+    return compressed_image
+
+
+compressed_train_data =[]
+for x,y in train_data:
+  compressed_x=kmeans_image_compression(x,6)
+  compressed_train_data.append((compressed_x,y))
+
+compressed_test_data = []
+for x,y in test_data:
+  compressed_x=kmeans_image_compression(x,6)
+  compressed_test_data.append((compressed_x,y))

Preprocessing/utils.py

@@ -0,0 +1,29 @@
+from sklearn.decomposition import PCA
+import numpy as np
+
+
+def pca_for_rgb(img, n_components):
+    red = img[:, :, 0]
+    green = img[:, :, 1]
+    blue = img[:, :, 2]
+
+    try:
+        pca = PCA(n_components=n_components)
+
+        red_transformed = pca.fit_transform(red)
+        red_inverted = pca.inverse_transform(red_transformed)
+
+        green_transformed = pca.fit_transform(green)
+        green_inverted = pca.inverse_transform(green_transformed)
+
+        blue_transformed = pca.fit_transform(blue)
+        blue_inverted = pca.inverse_transform(blue_transformed)
+        img_compressed = (
+            np.dstack(
+                (red_inverted,
+                 green_inverted,
+                 blue_inverted))).astype(
+            np.uint8)
+        return img_compressed
+    except BaseException:
+        print("Kindly put valid number of components")

README.md

@@ -1,12 +1,44 @@
----
-title: Deep Image Search System
-emoji: 👀
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 4.37.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Deep_Image_Search_System
+app_file: ui_gradio.py
+sdk: gradio
+sdk_version: 4.36.1
+---
+# CSL2050 CourseProject
+
+## TOPIC : Image Retrieval
+
+## Team Members:
+  - Akshat Jain (B22CS096)
+  - Harshiv Shah (B22CS098)
+  - Mehta Jay Kamalkumar (B22CS034)
+  - Jyotin Goel (B22AI063)
+  - Rhythm Baghel (B22CS042)
+
+## Repository Structure 
+
+```bash
+├── Experiments
+│   ├── cifar_10_knn.ipynb
+│   ├── cifar_10_pca_knn.ipynb
+│   ├── cnn-resnet34-cifar10.ipynb
+│   ├── cifar_10_mean.ipynb
+│   ├── cifar_10_centroid.ipynb
+│   ├── HOG+KNN.ipynb
+│   ├── Logs
+│   │   └── RESNET50_CIFAR.out
+│   ├── PCA+HOG+KNN.ipynb
+│   └── train.py
+├── LICENSE
+├── MidTerm_Report.pdf
+├── Model
+│   ├── CIFAR.pt
+│   └── test.py
+├──Gradio_Interface
+│   ├── ui_gradio.py
+├── Preprocessing
+│   ├── cifar_eda.ipynb
+│   ├── k_means.py
+│   └── utils.py
+└── README.md
+```

__init__.py

@@ -0,0 +1 @@
+print("Check")

flagged/log.csv

@@ -0,0 +1,2 @@
+Query Image,Retrieved Images,flag,username,timestamp
+flagged\Query Image\184c0788f490a0624d75\Screenshot 2024-04-20 153136.png,"[{""image"": ""flagged\\Retrieved Images\\6efd8d4fa439705c4bec\\image.webp"", ""caption"": null}, {""image"": ""flagged\\Retrieved Images\\911f2dbf15da7790c9f6\\image.webp"", ""caption"": null}, {""image"": ""flagged\\Retrieved Images\\d194d62692564b86e213\\image.webp"", ""caption"": null}]",,,2024-04-20 15:56:52.109627