S13 added.

README.md

@@ -10,4 +10,10 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+*Objective*: Get hands on woth hugging face and pytorch lightning, gradio.
+
+Here we have trained CIFAR10 dataset with custom resnet.
+We can visualize the results of classification using GradCAM and play around with them.
+We can upload our own images and get the top classification results.

app.py

@@ -0,0 +1,148 @@
+import torch, torchvision
+from torchvision import transforms
+import numpy as np
+import gradio as gr
+from PIL import Image
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from torch.utils.data import DataLoader
+import itertools
+import matplotlib.pyplot as plt
+import utils as utils
+from model import Net
+
+
+model = Net()
+model.load_state_dict(torch.load("model.pth", map_location=torch.device('cpu')), strict=False)
+model.eval()
+
+classes = ('plane', 'car', 'bird', 'cat', 'deer',
+           'dog', 'frog', 'horse', 'ship', 'truck')
+
+cifar_valid = utils.Cifar10SearchDataset('.', train=False, download=True, transform=utils.augmentation_custom_resnet())
+
+inv_normalize = transforms.Normalize(
+    mean=[-0.50/0.23, -0.50/0.23, -0.50/0.23],
+    std=[1/0.23, 1/0.23, 1/0.23]
+)
+
+def inference(wants_gradcam, n_gradcam, target_layer_number, transparency, wants_misclassified, n_misclassified, input_img = None, n_top_classes=10):
+    
+    if wants_gradcam: 
+      
+      outputs_inference_gc = []
+      cifar_valid_loader = DataLoader(cifar_valid, batch_size=1, shuffle = True)
+      count_gradcam = 1
+
+      for data, target in cifar_valid_loader:
+
+        data, target = data.to('cpu'), target.to('cpu')
+        if target_layer_number == '-2':
+            target_layers = [model.convblock31[0]]
+        elif target_layer_number == '-1':
+            target_layers = [model.convblock21[0]]
+
+        cam = GradCAM(model=model, target_layers=target_layers, use_cuda=False)
+        grayscale_cam = cam(input_tensor=data, targets=None)
+        grayscale_cam = grayscale_cam[0, :]
+
+        org_img = inv_normalize(data).squeeze(0).numpy()
+        org_img = np.transpose(org_img, (1, 2, 0))
+        visualization = np.array(show_cam_on_image(org_img, grayscale_cam, use_rgb=True, image_weight=transparency))
+        outputs_inference_gc.append(visualization)
+
+        count_gradcam += 1
+        if count_gradcam > n_gradcam:
+          break 
+    else:
+      outputs_inference_gc = None
+
+    if wants_misclassified: 
+      outputs_inference_mis = []
+
+      cifar_valid_loader = DataLoader(cifar_valid, batch_size=1, shuffle = True)
+      count_mis = 1
+
+      for data, target in cifar_valid_loader:
+
+        data, target = data.to('cpu'), target.to('cpu')
+
+        outputs = model(data)
+        softmax = torch.nn.Softmax(dim=0)
+        o = softmax(outputs.flatten())
+        confidences = {classes[i]: float(o[i]) for i in range(10)}
+        _, prediction = torch.max(outputs, 1)
+        
+        if target.numpy()[0] != prediction.numpy()[0]: 
+          
+            count_mis += 1
+
+            org_img = inv_normalize(data).squeeze(0).numpy()
+            org_img = np.transpose(org_img, (1, 2, 0))
+            
+            fig = plt.figure()
+            fig.add_subplot(111)
+
+            plt.imshow(org_img)
+            plt.title(f'Target: {classes[target.numpy()[0]]}\nPred: {classes[prediction.numpy()[0]]}')
+            plt.axis('off')
+            
+            fig.canvas.draw()
+
+            fig_img = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
+            fig_img = fig_img.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+
+            plt.close(fig)
+
+            outputs_inference_mis.append(fig_img)
+
+        if count_mis > n_misclassified:
+            break 
+
+    else:
+      outputs_inference_mis = None
+
+    if input_img is not None:
+        transform=utils.augmentation_custom_resnet('Valid')
+        org_img = input_img
+        input_img = transform(image=input_img)
+        input_img = input_img['image'].unsqueeze(0)
+        outputs = model(input_img)
+        softmax = torch.nn.Softmax(dim=0)
+        o = softmax(outputs.flatten())
+        confidences = {classes[i]: float(o[i]) for i in range(10)}
+        _, prediction = torch.max(outputs, 1)
+
+        confidences = {k: v for k, v in sorted(confidences.items(), key=lambda item: item[1], reverse=True)}
+        confidences = dict(itertools.islice(confidences.items(), n_top_classes))
+    else:
+      confidences = None
+    
+
+    return outputs_inference_gc, outputs_inference_mis, confidences
+
+    
+title = "CIFAR10 trained on Custom ResNet Model with GradCAM"
+description = "A Gradio interface to infer on Custom ResNet model, and to get GradCAM results"
+examples = [[None, None, None, None, None, None, 'examples/gr_'+str(i)+'.jpg', None] for i in range(10)]
+
+demo = gr.Interface(inference, 
+                    inputs = [gr.Checkbox(False, label='Do you want to see GradCAM outputs?'),
+                              gr.Slider(0, 10, value = 0, step=1, label="How many?"),
+                              gr.inputs.Dropdown([-2, -1], label="Which target layer?"), 
+                              gr.Slider(0, 1, value = 0, label="Opacity of GradCAM"), 
+                              gr.Checkbox(False, label='Do you want to see misclassified images?'),
+                              gr.Slider(0, 10, value = 0, step=1, label="How many?"),
+                              gr.Image(shape=(32, 32), label="Input image"), 
+                              gr.Slider(0, 10, value = 0, step=1, label="How many top classes you want to see?")
+                              ], 
+                    outputs = [
+                              gr.Gallery(label="GradCAM Outputs", show_label=True, elem_id="gallery").style(columns=[2], rows=[2], object_fit="contain", height="auto"), 
+                              gr.Gallery(label="Misclassified Images", show_label=True, elem_id="gallery").style(columns=[2], rows=[2], object_fit="contain", height="auto"), 
+                              gr.Label(num_top_classes=10, label = "Top classes")
+                              ],
+                    title = title, 
+                    description = description, 
+                    examples = examples
+                    )
+demo.launch()

model.pth

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

model.py

@@ -0,0 +1,87 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(ResidualBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU()
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+
+
+    def forward(self, x):
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        return out
+    
+dropout_value = 0.01
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        # Prep Layer
+        self.convblock01 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=(3, 3), padding=1, bias=False),
+            nn.ReLU(),
+            nn.BatchNorm2d(64),
+            nn.Dropout(dropout_value))
+
+
+        # Layer 1
+        self.convblock11 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=(3, 3), padding=1,  bias=False),
+            nn.MaxPool2d((2,2)),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Dropout(dropout_value)
+            )
+
+        self.residual11 = ResidualBlock(in_channels = 128, out_channels = 128)
+
+
+        # Layer 2
+        self.convblock21 = nn.Sequential(
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=(3, 3), padding=1,  bias=False),
+            nn.MaxPool2d((2,2)),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Dropout(dropout_value)
+            )
+
+
+        # Layer 3
+        self.convblock31 = nn.Sequential(
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=(3, 3), padding=1,  bias=False),
+            nn.MaxPool2d((2,2)),
+            nn.BatchNorm2d(512),
+            nn.ReLU(),
+            nn.Dropout(dropout_value)
+            )
+
+        self.residual31 = ResidualBlock(in_channels = 512, out_channels = 512)
+
+        self.pool = nn.MaxPool2d((4,4))
+
+        ## Fully Connected Layer
+        self.fc = nn.Linear(512, 10)
+
+    def forward(self, x):
+        x1 = self.convblock01(x)
+        x2 = self.convblock11(x1)
+        x3 = x2 + self.residual11(x2)
+        x4 = self.convblock21(x3)
+        x5 = self.convblock31(x4)
+        x6 = x5 + self.residual31(x5)
+        x = self.pool(x6)
+        x = x.view(-1, 512)
+        x = self.fc(x)
+        return x

requirements.txt

@@ -0,0 +1,7 @@
+torch
+torchvision
+torch-lr-finder
+grad-cam
+pillow
+numpy
+albumentations

utils.py

@@ -0,0 +1,30 @@
+# utils file
+
+import matplotlib.pyplot as plt
+import torch
+from torchvision import transforms
+import torchvision
+import numpy as np 
+import albumentations as A
+from albumentations.pytorch.transforms import ToTensorV2
+
+class Cifar10SearchDataset(torchvision.datasets.CIFAR10):
+
+    def __init__(self, root="./data", train=True, download=True, transform=None):
+      super().__init__(root=root, train=train, download=download, transform=transform)
+
+    def __getitem__(self, index):
+      image, label = self.data[index], self.targets[index]
+      
+      if self.transform is not None:
+        transformed = self.transform(image=image)
+        image = transformed["image"]
+
+        return image, label
+        
+def augmentation_custom_resnet(mean=(0.4914, 0.4822, 0.4465), std=(0.2470, 0.2435, 0.2616), pad=4):
+ 
+    transform = A.Compose([A.Normalize(mean=mean, std=std),
+                           ToTensorV2()])
+
+    return transform