init commit

README.md

@@ -1,8 +1,8 @@
 ---
-title: ERABB
-emoji: 📚
-colorFrom: purple
-colorTo: gray
+title: Assignment
+emoji: 💻
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 4.27.0
 app_file: app.py

app.py

@@ -0,0 +1,89 @@
+import gradio as gr
+import torch, torchvision
+from torchvision import transforms
+from resnet import ResNet18
+from resnet import ResBlocks
+from PIL import Image
+import numpy as np
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pl_bolts.transforms.dataset_normalizations import cifar10_normalization
+
+model = ResNet18(0.00333)
+
+state_model = torch.load("save_model.pkl", map_location=torch.device('cpu'))
+state_dict = state_model.state_dict()
+
+model.load_state_dict(state_dict, strict=False)
+
+classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+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 resize_image_pil(image, new_width, new_height):
+
+    img = Image.fromarray(np.array(image))
+    
+    width, height = img.size
+
+    width_scale = new_width / width
+    height_scale = new_height / height 
+    scale = min(width_scale, height_scale)
+
+    resized = img.resize((int(width*scale), int(height*scale)), Image.NEAREST)
+    
+    resized = resized.crop((0, 0, new_width, new_height))
+    return np.array(resized)
+
+def inference(input_img, transparency = 0.5, target_layer_number = -1):
+
+    input_img = resize_image_pil(input_img, 32, 32)    
+    org_img = input_img
+
+    input_img = input_img.reshape((32, 32, 3))
+    transform = transforms.ToTensor()
+
+    input_img = transform(input_img)
+    # input_img = cifar10_normalization()(input_img)
+    input_img = input_img.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)
+
+    target_layers = [model.res_layers[2][target_layer_number]]
+    cam = GradCAM(model=model, target_layers=target_layers)
+    grayscale_cam = cam(input_tensor=input_img, targets=None)
+    grayscale_cam = grayscale_cam[0, :]
+
+    img = input_img.squeeze(0)
+    img = inv_normalize(img)
+    print(transparency)
+
+    visualization = show_cam_on_image(org_img/255, grayscale_cam, use_rgb=True, image_weight=transparency)
+    return classes[prediction[0].item()], visualization, confidences
+
+title = "CIFAR10 trained on ResNet18 Model with GradCAM"
+description = "A simple Gradio interface to infer on ResNet model, and get GradCAM results"
+
+iface = gr.Interface(
+    inference, 
+    inputs = [
+        gr.Image(width=256, height=256, label="Input Image"), 
+        gr.Slider(0, 1, value = 0.5, label="Overall Opacity of Image"), 
+        gr.Slider(-2, -1, value = -2, step=1, label="Which Layer?")
+        ], 
+    outputs = [
+        "text",
+        gr.Image(width=256, height=256, label="Output"),
+        gr.Label(num_top_classes=3)
+        ],
+    title = title,
+    description = description,
+)
+
+iface.launch()

requirements.txt

@@ -0,0 +1,8 @@
+torch==2.1.2
+torchvision
+torch-lr-finder
+grad-cam
+pillow
+numpy
+pytorch_lightning==1.9.5
+lightning-bolts

resnet.py

@@ -0,0 +1,143 @@
+import torch
+import torch.nn as nn
+from pytorch_lightning import LightningModule
+from torch.optim.lr_scheduler import OneCycleLR
+from torchmetrics import Accuracy
+import torch.nn.functional as F
+
+BATCH_SIZE = 256
+
+class ResBlocks(LightningModule):
+    
+    def __init__(self, inchannels, outchannels, stride):
+        super(ResBlocks, self).__init__()
+        
+        self.conv1 = self.make_conv(inchannels, outchannels, stride=stride)
+        self.conv2 = self.make_conv(outchannels, outchannels)
+    
+        if stride != 1 or inchannels != outchannels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(inchannels, outchannels, kernel_size=1, stride=stride)
+            )
+    
+    def make_conv(self, inchannels, outchannels, kernel=3, padding=1, stride=1):
+        
+        layers = []
+        
+        layers.append(nn.Conv2d(in_channels=inchannels, out_channels=outchannels, kernel_size=kernel, padding=padding, stride=stride))
+        layers.append(nn.BatchNorm2d(outchannels))
+        layers.append(nn.ReLU())
+        
+        return nn.Sequential(*layers)
+    
+    def forward(self, x):
+        
+        shortcut = self.shortcut(x) if hasattr(self, 'shortcut') else x
+        out = self.conv1(x)
+        out = self.conv2(out)
+        
+        return out + shortcut
+    
+class ResNet18(LightningModule):
+    def __init__(self, lr=0.05):
+        super(ResNet18, self).__init__()
+        
+        self.save_hyperparameters()
+        self.avgpool = nn.AvgPool2d(kernel_size=4)
+        self.fc =  self.make_FC()
+        self.accuracy = Accuracy(task="multiclass", num_classes=10)
+        self.in_layers = [64, 64, 128, 256]
+        self.out_layers = [64, 128, 256, 512]
+        self.strides = [1, 2, 2, 2]
+        self.num = [2, 2, 2, 2]
+        
+        self.convin = nn.Sequential(
+                nn.Conv2d(3, 64, 3, bias=False),
+                nn.BatchNorm2d(64),
+                nn.ReLU()   
+        )
+        self.res_layers = nn.ModuleList([self.make_res(self.in_layers[i], self.out_layers[i], self.num[i], self.strides[i]) for i in range(len(self.in_layers))])
+    
+    
+    def make_res(self, inchannels, outchannels, num, stride):
+        
+        strides = [stride] + [1] * (num-1)
+        layers = []
+        
+        for stride in strides:
+            layers.append(ResBlocks(inchannels=inchannels, outchannels=outchannels, stride=stride))
+            inchannels = outchannels
+        
+        return nn.Sequential(*layers)
+        
+    
+    def make_FC(self):
+        
+        layers = []
+        
+        layers.append(nn.Linear(512, 256))
+        layers.append(nn.GELU())
+        layers.append(nn.Linear(256, 10))
+        layers.append(nn.LogSoftmax(dim=1))
+        
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+
+        x = self.convin(x)
+        
+        for layer in self.res_layers:
+            x = layer(x)
+        
+        x = self.avgpool(x)
+        x = x.view(-1, 512)
+        x = self.fc(x)
+        
+        return x
+    
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        self.log("train_loss", loss)
+        return loss
+
+    def evaluate(self, batch, stage=None):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        preds = torch.argmax(logits, dim=1)
+        acc = self.accuracy(preds, y)
+
+        if stage:
+            self.log(f"{stage}_loss", loss, prog_bar=True)
+            self.log(f"{stage}_acc", acc, prog_bar=True)
+
+    def validation_step(self, batch, batch_idx):
+        self.evaluate(batch, "val")
+
+    def test_step(self, batch, batch_idx):
+        self.evaluate(batch, "test")
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(
+           self.parameters(),
+           lr=self.hparams.lr,
+            weight_decay=5e-4,
+        )
+        steps_per_epoch = 45000 // BATCH_SIZE
+        scheduler_dict = {
+            "scheduler": OneCycleLR(
+                optimizer, 
+                max_lr=1.26*1e-2,
+                steps_per_epoch=steps_per_epoch, 
+                epochs=20,
+                pct_start=0.2,
+                div_factor=10, 
+                three_phase=False,
+                final_div_factor=10,
+                anneal_strategy='linear'
+            ),
+            "interval": "step",
+        }
+        return {"optimizer": optimizer, "lr_scheduler": scheduler_dict}

save_model.pkl

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