Upload 17 files

.gitattributes

@@ -33,3 +33,4 @@ 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
+test_images/mosaic_1.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,51 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import image
+plt.style.use("fivethirtyeight")
+import PIL
+from PIL import Image
+from PIL import ImageFile
+from matplotlib import image
+
+import os, shutil, tqdm
+from tqdm.auto import tqdm, trange
+import gradio as gr
+
+import torch, torchvision
+import torch.nn as nn
+from torchvision.transforms import v2 as v2
+import lightning.pytorch as pl
+from lightning.pytorch import LightningModule, LightningDataModule
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+import utils
+from utils.utils import prepare_image, make_preds_return_class_class_confidence_dict, load_model
+
+def run_gradio_app():
+    def return_class_x_label_conf_dict(img_path_):
+        lightning_model = load_model()
+        image = prepare_image(img_path = img_path_)
+        class_, label_conf_dict = make_preds_return_class_class_confidence_dict(img = image, model = lightning_model)
+        return f"Predicted class: {class_}", label_conf_dict
+    
+    title = "Tomato Leaf Disease Classification with Prediction Confidence Visualization"
+    description = "This intuitive interface simplifies the process of diagnosing diseases in tomato plants using leaf imagery. \
+                   By uploading a clear image of a tomato leaf, the application leverages a trained deep learning classifier to \
+                   identify the most likely disease affecting the plant. The system returns the top predicted class, along with a \
+                   ranked list of the top 5 possible diseases and their associated confidence scores. This layered feedback ensures \
+                   users not only receive a diagnosis but also understand the certainty of each prediction.\n \
+                    - Please ensure that uploaded images are of individual leaves with minimal background clutter for optimal accuracy.\n \
+                    - The model was trained on a curated dataset of common tomato leaf diseases and performs best on clear, close-up images."
+
+    demo = gr.Interface(fn = return_class_x_label_conf_dict, inputs = [gr.Image(type = "pil", label = "Upload Image of Tomato Leaf here:")],
+                        outputs=[gr.Textbox(label = "Predicted Disease Class"), gr.Label(label = "Top 5 Predicted Class Probability distribution")],
+                        title = title,
+                        description=description,
+                        theme = gr.themes.Ocean())
+    demo.launch(share = False)
+
+
+if __name__ == "__main__":
+    run_gradio_app()

checkpoints/epoch=12-step=10504.ckpt

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

checkpoints/epoch=14-step=12120.ckpt

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

requirements.txt

@@ -0,0 +1,7 @@
+torch
+matplotlib
+gradio
+numpy
+pandas
+lightning
+pillow

utils/utils.py

@@ -0,0 +1,117 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import image
+plt.style.use("fivethirtyeight")
+import PIL
+from PIL import Image
+from PIL import ImageFile
+from matplotlib import image
+
+import os, shutil, tqdm
+from tqdm.auto import tqdm, trange
+import pathlib
+from pathlib import Path
+
+import torch, torchvision, torchmetrics
+import torch.nn as nn
+from torchvision.transforms import v2 as v2
+import lightning.pytorch as pl
+from lightning.pytorch import LightningModule, LightningDataModule
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+current_file = Path(__file__).resolve()
+checkpoint_path = current_file.parent.parent / "checkpoints" / "epoch=14-step=12120.ckpt"
+
+transform = v2.Compose(
+        [
+            v2.Resize(size = (224, 224)),
+            v2.ToImage(),
+            v2.ToDtype(dtype = torch.float32, scale = True),
+            v2.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ]
+    )
+idx_to_class = {0: 'Leaf mold',
+                1: 'Tomato mosaic virus',
+                2: 'Powdery mildew',
+                3: 'Spider mites',
+                4: 'Bacterial spot',
+                5: 'Early blight',
+                6: 'Healthy',
+                7: 'Late blight',
+                8: 'Tomato yellow leaf curl virus',
+                9: 'Septoria leaf spot',
+                10: 'Target spot'}
+
+def prepare_image(img_path):
+    image_ = transform(img_path).unsqueeze(0)
+    return image_
+
+
+def make_preds_return_class_class_confidence_dict(img, model):
+    model.eval()
+    with torch.inference_mode():
+        logits = model(img)
+
+    pred_probs = torch.softmax(logits, dim = 1)
+    pred_probs_df = pd.DataFrame(data = torch.softmax(logits, dim = 1).numpy(), columns = idx_to_class.values())
+    class_ = idx_to_class[torch.argmax(pred_probs, axis = 1).item()]
+    pred_probs_df = pred_probs_df.T
+    pred_probs_df.columns = ["confidence"]
+    pred_probs_df = pred_probs_df.sort_values("confidence", ascending = False).head(5)
+    label_dict = dict()
+    for disease, confidence in zip(pred_probs_df.index, pred_probs_df["confidence"].values):
+        label_dict[disease] = confidence
+    return class_, label_dict
+
+
+def load_model():
+    class myLightningModel(pl.LightningModule):
+        def __init__(self, model, lr):
+            super().__init__()
+            self.model = model
+            self.lr = lr
+            self.loss_fn = nn.CrossEntropyLoss()
+            self.metric_fn = torchmetrics.classification.MulticlassAccuracy(num_classes = 11)
+            self.save_hyperparameters(ignore = ["model"])
+
+        def forward(self, x):
+            return self.model(x)
+
+        def training_step(self, batch, batch_idx):
+            self.model.train()
+            X, y = batch
+            logits = self.model(X)
+            loss = self.loss_fn(logits, y)
+            acc = self.metric_fn(torch.flatten(torch.argmax(torch.softmax(logits, dim = 1), axis = 1)), y)
+            self.log("Train accuracy", acc, prog_bar = True, on_epoch = True, on_step = False)
+            self.log("Train logloss", loss, prog_bar = True, on_epoch = True, on_step = False)
+            return {"Train Accuracy": acc, "loss": loss}
+
+        def validation_step(self, batch, batch_idx):
+            self.model.eval()
+            X, y = batch
+            logits = self.model(X)
+            val_loss = self.loss_fn(logits, y)
+            val_acc = self.metric_fn(torch.flatten(torch.argmax(torch.softmax(logits, dim = 1), axis = 1)), y)
+            self.log("Val accuracy", val_acc, prog_bar = True, on_epoch = True, on_step = False)
+            self.log("Val logloss", val_loss, prog_bar = True, on_epoch = True, on_step = False)
+            return {"Val Accuracy": val_acc, "Val loss": val_loss}
+
+        def configure_optimizers(self):
+            optimizer = torch.optim.Adam(params = self.model.parameters(), lr = self.lr, weight_decay = 1e-4)
+            return optimizer
+    
+    model = torchvision.models.efficientnet.efficientnet_b0(progress = True, weights = torchvision.models.efficientnet.EfficientNet_B0_Weights.DEFAULT)
+    model.classifier = nn.Sequential(
+    nn.Dropout(p=0.2, inplace=True),
+    nn.Linear(in_features=1280, out_features=11, bias=True)
+    )
+    lightning_model = myLightningModel.load_from_checkpoint(checkpoint_path = checkpoint_path, map_location = device, model = model, lr = 1e-3)
+    return lightning_model