foodvision

.gitattributes

@@ -33,3 +33,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
+model.pkl filter=lfs diff=lfs merge=lfs -text
+model_effecientnet_b2_weights.pth filter=lfs diff=lfs merge=lfs -text

Recipe/data_setup.py

@@ -0,0 +1,61 @@
+"""
+Contains functionality for creating PyTorch DataLoaders for 
+image classification data(Food101).
+"""
+import os
+
+from pathlib import Path
+
+import torchvision
+from torchvision import transforms
+from torch.utils.data import DataLoader
+
+num_workers = os.cpu_count()
+
+
+def create_dataloaders(transform: transforms.Compose,
+                       batch_size: int,
+                       num_workers: int = num_workers):
+    """Creates training and testing DataLoaders.
+
+    Takes in a transform them and download food 101 dataset 
+    and then into PyTorch DataLoaders.
+
+    Args:
+        transform: torchvision transforms to perform on training and testing data.
+        batch_size: Number of samples per batch in each of the DataLoaders.
+        num_workers: An integer for number of workers per DataLoader.
+
+    Returns:
+        A tuple of (train_dataloader, test_dataloader, class_names).
+        Where class_names is a list of the target classes.
+        Example usage:
+          train_dataloader, test_dataloader, class_names = \
+            = create_dataloaders(transform=some_transform,
+                                 batch_size=32,
+                                 num_workers=4)
+    """
+    # making dir for data
+    data_path = Path("data")
+    data_path.mkdir(parents=True, exist_ok=True)
+
+    # Dataset
+    train_data = torchvision.datasets.Food101(root=data_path,
+                                              split="train",
+                                              transform=transform,
+                                              download=True)
+    test_data = torchvision.datasets.Food101(root=data_path,
+                                             split="test",
+                                             transform=transform,
+                                             download=True)
+    # DataLoaders
+    train_dataloader = DataLoader(dataset=train_data,
+                                  batch_size=batch_size,
+                                  shuffle=True,
+                                  num_workers=num_workers)
+    test_dataloader = DataLoader(dataset=test_data,
+                                 batch_size=batch_size,
+                                 shuffle=False,
+                                 num_workers=num_workers)
+    class_names = train_data.classes
+    return train_dataloader, test_dataloader, class_names

Recipe/engine.py

@@ -0,0 +1,157 @@
+"""
+Contains functions for training and testing a PyTorch model.
+"""
+import torch
+
+from tqdm.auto import tqdm
+
+
+def train_step(model: torch.nn.Module,
+               train_dataloader: torch.utils.data.DataLoader,
+               loss_fn: torch.nn.Module,
+               optimizer: torch.optim.Optimizer,
+               device: torch.device):
+    """Trains a PyTorch model for a single epoch.
+
+    Turns a target PyTorch model to training mode and then
+    runs through all the required training steps (forward
+    pass, loss calculation, optimizer step).
+
+    Args:
+        model: A PyTorch model to be trained.
+        train_dataloader: A DataLoader instance for the model to be trained on.
+        loss_fn: A PyTorch loss function to minimize.
+        optimizer: A PyTorch optimizer to help minimize the loss function.
+        device: A target device to compute on (e.g. "cuda" or "cpu").
+
+    Returns:
+        A tuple of training loss and training accuracy metrics.
+        In the form (train_loss, train_accuracy). For example:
+
+        (0.1112, 0.8743)
+    """
+    # setting the model to train mode
+    total_loss, total_acc = 0, 0
+    for i, (X, y) in enumerate(train_dataloader):
+        # to device
+        X, y = X.to(device), y.to(device)
+        # forward pass
+        y_logits = model(X)
+        # loss calculate
+        loss = loss_fn(y_logits, y)
+        # zero the optimizer
+        optimizer.zero_grad()
+        # loss backward
+        loss.backward()
+        # optimizer step
+        optimizer.step()
+        total_acc += (torch.argmax(y_logits, dim=1) == y).sum() / len(y)
+        total_loss += loss
+    total_loss /= len(train_dataloader)
+    total_acc = total_acc / len(train_dataloader)
+    return total_loss, total_acc
+
+
+def test_step(model: torch.nn.Module,
+              test_dataloader: torch.utils.data.DataLoader,
+              loss_fn: torch.nn.Module,
+              device: torch.device):
+    """Tests a PyTorch model for a single epoch.
+
+    Turns a target PyTorch model to "eval" mode and then performs
+    a forward pass on a testing dataset.
+
+    Args:
+        model: A PyTorch model to be tested.
+        test_dataloader: A DataLoader instance for the model to be tested on.
+        loss_fn: A PyTorch loss function to calculate loss on the test data.
+        device: A target device to compute on (e.g. "cuda" or "cpu").
+
+    Returns:
+        A tuple of testing loss and testing accuracy metrics.
+        In the form (test_loss, test_accuracy). For example:
+
+        (0.0223, 0.8985)
+    """
+    # eval model
+    with torch.inference_mode():
+        test_loss, test_acc = 0, 0
+        for i, (X, y) in enumerate(test_dataloader):
+            X, y = X.to(device), y.to(device)
+            y_logits = model(X)
+            test_acc += (torch.argmax(y_logits, dim=1) == y).sum() / len(y)
+            test_loss += loss_fn(y_logits, y)
+        test_loss /= len(test_dataloader)
+        test_acc = test_acc / len(test_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):
+    """Trains and tests a PyTorch model.
+
+    Passes a target PyTorch models through train_step() and test_step()
+    functions for a number of epochs, training and testing the model
+    in the same epoch loop.
+
+    Calculates, prints and stores evaluation metrics throughout.
+
+    Args:
+        model: A PyTorch model to be trained and tested.
+        train_dataloader: A DataLoader instance for the model to be trained on.
+        test_dataloader: A DataLoader instance for the model to be tested on.
+        optimizer: A PyTorch optimizer to help minimize the loss function.
+        loss_fn: A PyTorch loss function to calculate loss on both datasets.
+        epochs: An integer indicating how many epochs to train for.
+        device: A target device to compute on (e.g. "cuda" or "cpu").
+
+    Returns:
+        A dictionary of training and testing loss as well as training and
+        testing accuracy metrics. Each metric has a value in a list for
+        each epoch.
+        In the form: {train_loss: [...],
+                  train_acc: [...],
+                  test_loss: [...],
+                  test_acc: [...]}
+        For example if training for epochs=2:
+                 {train_loss: [2.0616, 1.0537],
+                  train_acc: [0.3945, 0.3945],
+                  test_loss: [1.2641, 1.5706],
+                  test_acc: [0.3400, 0.2973]}
+                  
+    Remark : Can un-comment the below lines of code to also store the model weights 
+    """
+    results = {"train_loss": [],
+               "train_acc": [],
+               "test_loss": [],
+               "test_acc": []}
+    #     from pathlib import Path
+    #     save_path=Path("models")
+    #     save_path.mkdir(parents=True,exist_ok=True)
+    model.to(device)
+    for epoch in tqdm(range(epochs)):
+        model.train()
+        loss_train, acc_train = train_step(model,
+                                           train_dataloader=train_dataloader,
+                                           loss_fn=loss_fn,
+                                           optimizer=optimizer,
+                                           device=device)
+        results["train_loss"].append(loss_train)
+        results["train_acc"].append(acc_train)
+        model.eval()
+        loss_test, acc_test = test_step(model,
+                                        test_dataloader,
+                                        loss_fn,
+                                        device)
+        results["test_loss"].append(loss_test)
+        results["test_acc"].append(acc_test)
+        print(
+            f"epoch : {epoch + 1} | train_loss : {loss_train} | train_acc : {acc_train} | test_loss : {loss_test} | test_acc : {acc_test}")
+    #         model_path=save_path/f"model_efficient_b2_weights_{epoch}.pth"
+    #         torch.save(obj=model.state_dict(),f=model_path)
+    return results

Recipe/model_builder.py

@@ -0,0 +1,19 @@
+"""
+Build a EfficientNet B2 model from torchvision
+"""
+
+import torch
+import torchvision
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def model_build(device=device):
+    # getting the weights for EfficientNet B2 and then get the transforms
+    weights = torchvision.models.EfficientNet_B2_Weights.DEFAULT  # ".DEFAULT" = best available weights
+    # Transforms used in EfficientNet B2
+    transform = weights.transforms()
+    # Model
+    model = torchvision.models.efficientnet_b2(weights=weights).to(device)
+    # print(model)
+    return model

Recipe/prediction.py

@@ -0,0 +1,78 @@
+"""
+Utility functions to make predictions.
+"""
+import torch
+import torchvision
+from torchvision import transforms
+import matplotlib.pyplot as plt
+
+from typing import List, Tuple
+
+from PIL import Image
+
+# Set device
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# Predict on a target image with a target model
+def pred_and_plot_image(
+        model: torch.nn.Module,
+        class_names: List[str],
+        image_path: str,
+        image_size: Tuple[int, int] = (288, 288),
+        transform: torchvision.transforms = None,
+        device: torch.device = device):
+    """Predicts on a target image with a target model.
+
+    Args:
+        model (torch.nn.Module): A trained (or untrained) PyTorch model to predict on an image.
+        class_names (List[str]): A list of target classes to map predictions to.
+        image_path (str): Filepath to target image to predict on.
+        image_size (Tuple[int, int], optional): Size to transform target image to. Defaults to (224, 224).
+        transform (torchvision.transforms, optional): Transform to perform on image. Defaults to None which uses ImageNet normalization.
+        device (torch.device, optional): Target device to perform prediction on. Defaults to device.
+    """
+
+    # Open image
+    img = Image.open(image_path)
+
+    # Create transformation for image (if one doesn't exist)
+    if transform is not None:
+        image_transform = transform
+    else:
+        image_transform = transforms.Compose([
+            transforms.Resize(image_size),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+
+    ### Predict on image ###
+
+    # Make sure the model is on the target device
+    model.to(device)
+
+    # Turn on model evaluation mode and inference mode
+    model.eval()
+    with torch.inference_mode():
+        # Transform and add an extra dimension to image (model requires samples in [batch_size, color_channels,
+        # height, width])
+        transformed_image = image_transform(img).unsqueeze(dim=0)
+
+        # Make a prediction on image with an extra dimension and send it to the target device
+        target_image_pred = model(transformed_image.to(device))
+
+    # Convert logits -> prediction probabilities (using torch.softmax() for multi-class classification)
+    target_image_pred_probs = torch.softmax(target_image_pred, dim=1)
+
+    # Convert prediction probabilities -> prediction labels
+    target_image_pred_label = torch.argmax(target_image_pred_probs, dim=1)
+
+    # Plot image with predicted label and probability
+    plt.figure()
+    plt.imshow(img)
+    plt.title(
+        f"Pred: {class_names[target_image_pred_label]} | Prob: {target_image_pred_probs.max():.3f}"
+    )
+    plt.axis(False)
+    plt.show()

Recipe/train.py

@@ -0,0 +1,114 @@
+"""
+Trains a PyTorch image classification model using device-agnostic code.
+"""
+
+import torch
+import torchvision
+from torch import nn
+import data_setup
+import engine
+import model_builder
+import utils
+
+# Setup hyperparameters 
+NUM_EPOCHS = [7, 4, 3]  # [feature Extraction, Fine Tuning Part 1, Fine Tuning Part 2]
+BATCH_SIZE = 32
+LEARNING_RATE = [0.001, 0.0001, 0.00001]  # [feature Extraction, Fine Tuning Part 1, Fine Tuning Part 2]
+
+# Setup target device
+device = "cuda" if torch.cuda.is_available() else "cpu"
+# Create transforms
+data_transform = torchvision.models.EfficientNet_B2_Weights.DEFAULT.transforms()
+# ------------------------------------------ DataLoaders ----------------------------------------------------------------------#
+# Create DataLoaders with help from data_setup.py
+train_dataloader, test_dataloader, class_names = data_setup.create_dataloaders(
+    transform=data_transform,
+    batch_size=BATCH_SIZE)
+print("dataloaders created")
+
+# ------------------------------------------ Model ----------------------------------------------------------------------------#
+# Create model with help from model_builder.py
+model = model_builder.model_build(device=device)
+print("model created")
+
+# ------------------------------------------ Feature Extraction ---------------------------------------------------------------#
+# Setting all parameters to not-trainable
+for params in model.parameters():
+    params.requires_grad = False
+
+# Changing Classification layer
+model.classifier = nn.Sequential(
+    nn.Dropout(p=0.3, inplace=True),
+    nn.Linear(in_features=1408, out_features=len(class_names)))
+# model.classifier
+
+# Set loss and optimizer
+loss_fn = torch.nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(),
+                             lr=LEARNING_RATE[0])
+
+# Start training with help from engine.py
+feature_extraction_results=engine.train(model=model,
+             train_dataloader=train_dataloader,
+             test_dataloader=test_dataloader,
+             loss_fn=loss_fn,
+             optimizer=optimizer,
+             epochs=NUM_EPOCHS[0],
+             device=device)
+print(feature_extraction_results)
+
+# ------------------------------------------ Fine Tuning Part 1 ---------------------------------------------------------------#
+# Setting models upper layer un froze
+for params in model.features[5:].parameters():
+    params.requires_grad = True
+
+for m in model.modules():  # Making the BatchNorm2d froze
+    if isinstance(m, nn.BatchNorm2d):
+        m.track_running_stats = False
+        m.eval()
+
+# Set loss and optimizer
+loss_fn = torch.nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(),
+                             lr=LEARNING_RATE[1])
+
+# Start training with help from engine.py
+fine_tuning_p1_results=engine.train(model=model,
+             train_dataloader=train_dataloader,
+             test_dataloader=test_dataloader,
+             loss_fn=loss_fn,
+             optimizer=optimizer,
+             epochs=NUM_EPOCHS[1],
+             device=device)
+print(fine_tuning_p1_results)
+
+# ------------------------------------------ Fine Tuning Part 2 ---------------------------------------------------------------#
+# Setting models upper layer un froze
+for params in model.features.parameters():
+    params.requires_grad = True
+
+for m in model.modules():  # Making the BatchNorm2d froze
+    if isinstance(m, nn.BatchNorm2d):
+        m.track_running_stats = False
+        m.eval()
+
+# Set loss and optimizer
+loss_fn = torch.nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(),
+                             lr=LEARNING_RATE[2])
+
+# Start training with help from engine.py
+fine_tuning_p2_results=engine.train(model=model,
+             train_dataloader=train_dataloader,
+             test_dataloader=test_dataloader,
+             loss_fn=loss_fn,
+             optimizer=optimizer,
+             epochs=NUM_EPOCHS[2],
+             device=device)
+print(fine_tuning_p2_results)
+
+# ------------------------------------------ Save model -----------------------------------------------------------------------#
+# Save the model with help from utils.py
+utils.save_model(model=model,
+                 target_dir="models",
+                 model_name="Image_Classification_EfficientNet_B2.pth")

Recipe/utils.py

@@ -0,0 +1,37 @@
+"""
+Contains various utility functions for PyTorch model training and saving.
+"""
+
+import torch
+from pathlib import Path
+
+
+def save_model(model: torch.nn.Module,
+               target_dir: str,
+               model_name: str):
+    """Saves a PyTorch model to a target directory.
+
+    Args:
+    model: A target PyTorch model to save.
+    target_dir: A directory for saving the model to.
+    model_name: A filename for the saved model. Should include
+      either ".pth" or ".pt" as the file extension.
+
+    Example usage:
+    save_model(model=model,
+               target_dir="models",
+               model_name="model_name.pth")
+    """
+    # Create target directory
+    target_dir_path = Path(target_dir)
+    target_dir_path.mkdir(parents=True,
+                          exist_ok=True)
+
+    # Create model save path
+    assert model_name.endswith(".pth") or model_name.endswith(".pt"), "model_name should end with '.pt' or '.pth'"
+    model_save_path = target_dir_path / model_name
+
+    # Save the model state_dict()
+    print(f"[INFO] Saving model to: {model_save_path}")
+    torch.save(obj=model.state_dict(),
+               f=model_save_path)

app.py

@@ -0,0 +1,66 @@
+import torch
+import torchvision
+import pickle
+import gradio as gr
+from timeit import default_timer as timer
+
+# device-agnostic code
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Create the model 
+model = pickle.load(open("model.pkl", "rb"))
+model.to(device)
+model.eval()
+next(iter(model.parameters())).to(device)
+# Transform for prediction
+transform = torchvision.models.EfficientNet_B2_Weights.DEFAULT.transforms()
+# class_names
+# Open Food101 class names file and read each line into a list
+with open("class_names.txt", "r") as f:
+    class_names = [food.strip() for food in f.readlines()]
+
+# example_list
+example_list = [["example/pizza.jpg"],
+                ["example/ice_cream.jpg"],
+                ["example/pancakes.jpg"],
+                ["example/steak.jpg"],
+                ["example/hot_dog.jpg"]]
+
+
+def predict(img):
+    """Predict the class of image
+    
+    Args:
+        img: input image vector
+    Results:
+        a tuple of dictionary and float
+    Predictions,Prediction_time=predict(img=img_vector) 
+    """
+    start_time = timer()
+    with torch.inference_mode():
+        t_img = transform(img).unsqueeze(0).to(device)
+        # print(t_img)
+        probs = torch.softmax(model(t_img), dim=1).to("cpu")
+    end_time = timer()
+    label_and_prob = {class_names[i]: float(probs[0][i]) for i in range(len(class_names))}
+    # print(probs)
+    return label_and_prob, round(end_time - start_time, 4)
+
+
+# Create title, description strings
+title = "FoodVision 🍕🥩🍣"
+description = "An EfficientNetB2 fine tuning computer vision model to classify 101 different food images."
+
+# Create the Gradio demo
+demo = gr.Interface(fn=predict,  # mapping function from input to output
+                    inputs=gr.Image(type="pil"),  # what are the inputs?
+                    outputs=[gr.Label(num_top_classes=3, label="Predictions"),  # what are the outputs?
+                             gr.Number(label="Prediction time(s)")],
+                    # our fn has two outputs, therefore we have two outputs
+                    examples=example_list,
+                    title=title,
+                    description=description)
+# article=article)
+
+demo.launch(debug=False,  # print errors locally?
+            share=True)  # generate a publicly shareable URL?

class_names.txt

@@ -0,0 +1,101 @@
+apple_pie
+baby_back_ribs
+baklava
+beef_carpaccio
+beef_tartare
+beet_salad
+beignets
+bibimbap
+bread_pudding
+breakfast_burrito
+bruschetta
+caesar_salad
+cannoli
+caprese_salad
+carrot_cake
+ceviche
+cheese_plate
+cheesecake
+chicken_curry
+chicken_quesadilla
+chicken_wings
+chocolate_cake
+chocolate_mousse
+churros
+clam_chowder
+club_sandwich
+crab_cakes
+creme_brulee
+croque_madame
+cup_cakes
+deviled_eggs
+donuts
+dumplings
+edamame
+eggs_benedict
+escargots
+falafel
+filet_mignon
+fish_and_chips
+foie_gras
+french_fries
+french_onion_soup
+french_toast
+fried_calamari
+fried_rice
+frozen_yogurt
+garlic_bread
+gnocchi
+greek_salad
+grilled_cheese_sandwich
+grilled_salmon
+guacamole
+gyoza
+hamburger
+hot_and_sour_soup
+hot_dog
+huevos_rancheros
+hummus
+ice_cream
+lasagna
+lobster_bisque
+lobster_roll_sandwich
+macaroni_and_cheese
+macarons
+miso_soup
+mussels
+nachos
+omelette
+onion_rings
+oysters
+pad_thai
+paella
+pancakes
+panna_cotta
+peking_duck
+pho
+pizza
+pork_chop
+poutine
+prime_rib
+pulled_pork_sandwich
+ramen
+ravioli
+red_velvet_cake
+risotto
+samosa
+sashimi
+scallops
+seaweed_salad
+shrimp_and_grits
+spaghetti_bolognese
+spaghetti_carbonara
+spring_rolls
+steak
+strawberry_shortcake
+sushi
+tacos
+takoyaki
+tiramisu
+tuna_tartare
+waffles

model.pkl

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

model_effecientnet_b2_weights.pth

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

requirements.txt

@@ -0,0 +1,4 @@
+python==3.10.6
+torch==2.0.0
+torchvision==0.15.2
+gradio==3.38.0