Initial Commit

.gitattributes

@@ -32,3 +32,5 @@ 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
+ResNet18_epoch-14.pth filter=lfs diff=lfs merge=lfs -text
+Experiments[[:space:]]Notebook/lemon_quality_classification.ipynb filter=lfs diff=lfs merge=lfs -text

Experiments Notebook/lemon_quality_classification.ipynb

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

Experiments Notebook/scripts/data_setup.py

@@ -0,0 +1,29 @@
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+import torchvision
+
+def make_dataloaders(train_ds,
+                     test_ds,
+                     batch_size: int):
+  """Creates dataloaders
+  Creates dataloaders by taking the directory in which train and test data are stored.
+
+  Args:
+  transforms(torchvision.transforms.Compose): Transform to apply to the dataset.
+
+  Returns:
+  tuple: train_dataloader, test_dataloader, class_names
+  """
+
+
+  train_dataloader = DataLoader(dataset = train_ds,
+                                batch_size = batch_size,
+                                num_workers = 1,
+                                shuffle = True)
+
+  test_dataloader = DataLoader(dataset = test_ds,
+                                batch_size = batch_size,
+                                num_workers = 1,
+                                shuffle = False)
+
+  return train_dataloader, test_dataloader

Experiments Notebook/scripts/engine.py

@@ -0,0 +1,110 @@
+
+import torch
+from torch import nn
+from tqdm.auto import tqdm
+
+def train_step(model: torch.nn.Module,
+               dataloader: torch.utils.data.DataLoader,
+               loss_fn: torch.nn.Module,
+               optimizer: torch.optim.Optimizer,
+               device: torch.device):
+  model.train()
+  train_loss, train_acc = 0, 0
+  for batch, (X, y) in enumerate(dataloader):
+    X, y = X.to(device), y.to(device)
+    y_pred = model(X)
+    y = y.unsqueeze(dim = 1).float()
+    loss = loss_fn(y_pred, y)
+    train_loss = train_loss + loss.item()
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    y_pred_class = torch.sigmoid(y_pred)
+    acc = (y_pred_class == y).sum().item() / len(y_pred)
+    train_acc = train_acc + acc
+  
+  train_loss = train_loss / len(dataloader)
+  train_acc = train_acc / len(dataloader)
+
+  return train_loss, train_acc
+
+def test_step(model: torch.nn.Module,
+              dataloader: torch.utils.data.DataLoader,
+              loss_fn: torch.nn.Module,
+              device: torch.device):
+  model.eval()
+  test_loss, test_acc = 0, 0
+
+  with torch.inference_mode():
+    for batch, (X, y) in enumerate(dataloader):
+      X, y = X.to(device), y.to(device)
+      y_pred = model(X)
+      y = y.unsqueeze(dim = 1).float()
+      loss = loss_fn(y_pred, y)
+      test_loss = test_loss + loss.item()
+
+      y_pred_class = y_pred.sigmoid()
+      acc = (y_pred_class == y).sum().item() / len(y_pred)
+      test_acc = test_acc + acc
+  test_loss = test_loss / len(dataloader)
+  test_acc = test_acc / len(dataloader)
+  return test_loss, test_acc
+def train(model: torch.nn.Module,
+          train_dataloader:  torch.utils.data.DataLoader,
+          test_dataloader:  torch.utils.data.DataLoader,
+          optimizer:  torch.optim.Optimizer,
+          loss_fn: torch.nn.Module,
+          epochs: int,
+          device: torch.device,
+          writer: torch.utils.tensorboard.SummaryWriter):
+  results = {"train_loss": [],
+             "train_acc": [],
+             "test_loss": [],
+             "test_acc": []}
+  model.to(device)
+  # loss_fn = nn.CrossEntropyLoss()
+  # optimizer = torch.optim.Adam(model.parameters(),lr = 0.01)
+  for epoch in tqdm(range(epochs)):
+    train_loss, train_acc = train_step(model = model,
+                                       dataloader = train_dataloader,
+                                       loss_fn = loss_fn,
+                                       optimizer = optimizer,
+                                       device = device)
+    test_loss, test_acc = test_step(model = model,
+                                    dataloader = test_dataloader,
+                                    loss_fn = loss_fn,
+                                    device = device)
+
+    print(
+        f"| Epoch: {epoch+1} | "
+        f"train_loss: {train_loss:.4f} | "
+        f"train_acc: {train_loss:.4f} | "
+        f"test_loss: {test_loss:.4f} | "
+        f"test_acc: {test_loss:.4f} |"
+    )
+
+    results['train_loss'].append(train_loss)
+    results['train_acc'].append(train_acc)
+    results['test_loss'].append(test_loss)
+    results['test_acc'].append(test_acc)
+
+    writer.add_scalars(main_tag="Loss", 
+                      tag_scalar_dict={"train_loss": train_loss,
+                                    "test_loss": test_loss},
+                      global_step=epoch)
+
+    # Add accuracy results to SummaryWriter
+    writer.add_scalars(main_tag="Accuracy", 
+                    tag_scalar_dict={"train_acc": train_acc,
+                                    "test_acc": test_acc}, 
+                    global_step=epoch)
+
+    # Track the PyTorch model architecture
+    writer.add_graph(model=model, 
+                  # Pass in an example input
+                  input_to_model=torch.randn(32, 3, 224, 224).to(device))
+
+    # Close the writer
+    writer.close()
+  return results

Experiments Notebook/scripts/utils.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+import torch
+def save_model(model: torch.nn.Module,
+               model_name: str,
+               target_dir: str):
+  target_dir_path = Path(target_dir)
+  target_dir_path.mkdir(parents = True,
+                        exist_ok = True)
+  assert model_name.endswith(".pth") or model_name.endswith(".pt"), "Model name should end with .pth or .pt"
+  model_save_path = target_dir_path / model_name
+  torch.save(obj = model.state_dict(),
+             f = model_save_path)

ResNet18_epoch-14.pth

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

app.py

@@ -0,0 +1,53 @@
+import torch
+from model import create_resnet
+import numpy as np
+import gradio as gr
+import os 
+from timeit import default_timer as timer
+from typing import Tuple, Dict
+
+model = create_resnet()
+model.load_state_dict(torch.load(f="ResNet18_epoch-14.pth",
+                                    map_location=torch.device("cpu")))
+
+from torchvision import datasets, transforms
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+def predict(img):
+  start_time = timer()
+  transformed_image = transform(img)
+  transformed_image = transformed_image.unsqueeze(0)
+  model.eval()
+
+  with torch.no_grad():
+    output = model(transformed_image)
+    predicted_label = int(torch.sigmoid(output).item())
+
+  end_time = timer()
+  pred_time = round(end_time - start_time, 4)
+  output = "Good" if predicted_label == 1 else "Bad"
+
+  return output, pred_time
+
+# Gradio Interface
+title = "🍋 Lemon Quality Classifier 🍋"
+description = "A [ResNet18](https://pytorch.org/vision/main/models/generated/torchvision.models.resnet18.html) computer vision model to classify lemons as good or bad in quality."
+article = "Created for practice and learning."
+
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+demo = gr.Interface(fn=predict,
+                    inputs=gr.Image(type="pil"),
+                    outputs=[gr.Label(num_top_classes=1, label="Prediction"),
+                             gr.Number(label="Prediction time (s)")],
+                    examples=example_list,
+                    title=title,
+                    description=description,
+                    article=article)
+
+demo.launch() 

model.py

@@ -0,0 +1,13 @@
+import torch
+import torchvision
+from torch import nn
+
+# Function for ResNet18.
+def create_resnet():
+  weights = torchvision.models.ResNet18_Weights.DEFAULT
+  transforms = weights.transforms()
+  model = torchvision.models.resnet18(weights = weights)
+  for param in model.parameters():
+    param.requires_grad = False
+  model.fc = nn.Linear(in_features=512, out_features=1, bias=True)
+  return model

requirements.txt

@@ -0,0 +1,3 @@
+torch==2.0.0
+torchvision==0.15.1
+gradio==3.1.4