Upload 3 files

CUSTOMRESNET.py

@@ -1,6 +1,12 @@
-import torch.nn.functional as F
 import torch
 import torch.nn as nn
+from torch.nn import functional as F
+from torch import optim
+from pytorch_lightning import LightningModule
+from torchmetrics import Accuracy
+from utils.visualize import find_lr
+
+
 
 class MyModel(nn.Module):
     def __init__(self):
@@ -72,19 +78,89 @@ class MyModel(nn.Module):
         x=x+R2
 
         x = self.maxpool(x)
-        #x = x.randn(512, 1)
-
-# squeeze the tensor to size 512x
-        #x = x.squeeze(dim=[2, 3])
+       
         x = x.squeeze(dim=2)
         x = x.squeeze(dim=2)
-        #x = x.squeeze(dim=2).squeeze(dim=3)
-        #x = x.squeeze(dim=2)
-
-        #x = x.view(512, 10)
-
         x = self.fc(x)
-
         x = x.view(-1, 10)
-        x = F.log_softmax(x, dim=-1)
+        
         return x
+
+
+class Model(LightningModule):
+    def __init__(self, dataset,max_epochs=24):
+        super(Model, self).__init__()
+
+        self.dataset = dataset
+        self.network= MyModel()
+        self.criterion = nn.CrossEntropyLoss()
+        self.train_accuracy = Accuracy(task='multiclass', num_classes=10)
+        self.val_accuracy = Accuracy(task='multiclass', num_classes=10)
+
+        self.max_epochs = max_epochs
+
+    def forward(self, x):
+        return self.network(x)
+
+    def common_step(self, batch, mode):
+        x, y = batch
+        logits = self.forward(x)
+        loss = self.criterion(logits, y)
+
+        acc_metric = getattr(self, f'{mode}_accuracy')
+        acc_metric(logits, y)
+
+        return loss
+
+    def training_step(self, batch, batch_idx):
+        loss = self.common_step(batch, 'train')
+        self.log("train_loss", loss, on_epoch=True, prog_bar=True, logger=True)
+        self.log("train_acc", self.train_accuracy, on_epoch=True, prog_bar=True, logger=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        loss = self.common_step(batch, 'val')
+        self.log("val_loss", loss, on_epoch=True, prog_bar=True, logger=True)
+        self.log("val_acc", self.val_accuracy, on_epoch=True, prog_bar=True, logger=True)
+        return loss
+
+    def predict_step(self, batch, batch_idx, dataloader_idx=0):
+        if isinstance(batch, list):
+            x, _ = batch
+        else:
+            x = batch
+        return self.forward(x)
+
+    def configure_optimizers(self):
+        optimizer = optim.Adam(self.parameters(), lr=1e-7, weight_decay=1e-2)
+        best_lr = find_lr(self, self.train_dataloader(), optimizer, self.criterion)
+        scheduler = optim.lr_scheduler.OneCycleLR(
+            optimizer,
+            max_lr=best_lr,
+            steps_per_epoch=len(self.dataset.train_loader),
+            epochs=self.max_epochs,
+            pct_start=5/self.max_epochs,
+            div_factor=100,
+            three_phase=False,
+            final_div_factor=100,
+            anneal_strategy='linear'
+        )
+        return {
+            'optimizer': optimizer,
+            'lr_scheduler': {
+                "scheduler": scheduler,
+                "interval": "step",
+            }
+        }
+
+    def prepare_data(self):
+        self.dataset.download()
+
+    def train_dataloader(self):
+        return self.dataset.train_loader
+
+    def val_dataloader(self):
+        return self.dataset.test_loader
+
+    def predict_dataloader(self):
+        return self.val_dataloader()

incorrect_images.py

@@ -0,0 +1,65 @@
+import pandas as pd
+from collections import defaultdict
+
+from pytorch_lightning import Trainer
+from pytorch_lightning.callbacks import ModelSummary, LearningRateMonitor
+
+from .visualize import plot_examples, get_cam_visualisation, get_incorrect_preds
+
+
+class incorrect(object):
+    def __init__(self, model, max_epochs=None, precision="32-true"):
+        self.model = model
+        self.dataset = model.dataset
+        self.incorrect_preds = None
+        self.grad_cam = None
+        self.trainer = Trainer(callbacks=[ModelSummary(max_depth=10), LearningRateMonitor(logging_interval='step')],
+                               max_epochs=max_epochs or model.max_epochs, precision=precision)
+        self.incorrect_preds = None
+        self.incorrect_preds_pd = None
+        self.grad_cam = None
+
+    def execute(self):
+        self.trainer.fit(self.model)
+
+    def get_incorrect_preds(self):
+        self.incorrect_preds = defaultdict(list)
+        incorrect_images = list()
+        processed = 0
+        results = self.trainer.predict(self.model, self.model.predict_dataloader())
+        for (data, target), pred in zip(self.model.predict_dataloader(), results):
+            ind, pred_, truth = get_incorrect_preds(pred, target)
+            self.incorrect_preds["indices"] += [x + processed for x in ind]
+            incorrect_images += data[ind]
+            self.incorrect_preds["ground_truths"] += truth
+            self.incorrect_preds["predicted_vals"] += pred_
+            processed += len(data)
+        self.incorrect_preds_pd = pd.DataFrame(self.incorrect_preds)
+        self.incorrect_preds["images"] = incorrect_images
+
+    def show_incorrect(self, cams=False, target_layer=None):
+        if self.incorrect_preds is None:
+            self.get_incorrect_preds()
+
+        images = list()
+        labels = list()
+
+        for i in range(20):
+            image = self.incorrect_preds["images"][i]
+            pred = self.incorrect_preds["predicted_vals"][i]
+            truth = self.incorrect_preds["ground_truths"][i]
+
+            if cams:
+                image = get_cam_visualisation(self.model, self.dataset, image, pred, target_layer)
+            else:
+                image = self.dataset.show_transform(image).cpu()
+
+            if self.dataset.classes is not None:
+                pred = f'{pred}:{self.dataset.classes[pred]}'
+                truth = f'{truth}:{self.dataset.classes[truth]}'
+            label = f'{pred}/{truth}'
+
+            images.append(image)
+            labels.append(label)
+
+        plot_examples(images, labels, figsize=(10, 8))

visualize.py

@@ -0,0 +1,70 @@
+import torch
+import torchinfo
+from torch_lr_finder import LRFinder
+from matplotlib import pyplot as plt
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+SEED = 42
+DEVICE = None
+
+
+def get_device():
+    global DEVICE
+    if DEVICE is not None:
+        return DEVICE
+
+    if torch.cuda.is_available():
+        DEVICE = "cuda"
+    elif torch.backends.mps.is_available():
+        DEVICE = "mps"
+    else:
+        DEVICE = "cpu"
+    print("Device Selected:", DEVICE)
+    return DEVICE
+
+
+def seed(seed=SEED):
+    torch.manual_seed(seed)
+    if get_device() == 'cuda':
+        torch.cuda.manual_seed(seed)
+
+
+def plot_examples(images, labels, figsize=None, n=20):
+    _ = plt.figure(figsize=figsize)
+
+    for i in range(n):
+        plt.subplot(4, n//4, i + 1)
+        plt.tight_layout()
+        image = images[i]
+        plt.imshow(image, cmap='gray')
+        label = labels[i]
+        plt.title(str(label))
+        plt.xticks([])
+        plt.yticks([])
+
+
+def find_lr(model, data_loader, optimizer, criterion):
+    lr_finder = LRFinder(model, optimizer, criterion)
+    lr_finder.range_test(data_loader, end_lr=0.1, num_iter=200, step_mode='exp')
+    _, best_lr = lr_finder.plot()
+    lr_finder.reset()
+    return best_lr
+
+
+def get_incorrect_preds(prediction, labels):
+    prediction = prediction.argmax(dim=1)
+    indices = prediction.ne(labels).nonzero().reshape(-1).tolist()
+    return indices, prediction[indices].tolist(), labels[indices].tolist()
+
+
+def get_cam_visualisation(model, dataset, input_tensor, label, target_layer, use_cuda=False):
+    grad_cam = GradCAM(model=model, target_layers=[target_layer], use_cuda=use_cuda)
+    targets = [ClassifierOutputTarget(label)]
+    grayscale_cam = grad_cam(input_tensor=input_tensor.unsqueeze(0), targets=targets)
+    grayscale_cam = grayscale_cam[0, :]
+    output = show_cam_on_image(dataset.show_transform(input_tensor).cpu().numpy(), grayscale_cam,use_rgb=True)
+    return output
+
+