Upload 40 files

.gitignore

@@ -0,0 +1,249 @@
+.gap_gpu_env/
+saved_models/
+__pychache__/
+*.py[cod]
+
+
+# Created by https://www.toptal.com/developers/gitignore/api/venv,macos,python,visualstudiocode
+# Edit at https://www.toptal.com/developers/gitignore?templates=venv,macos,python,visualstudiocode
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### venv ###
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+[Ss]cripts
+pyvenv.cfg
+pip-selfcheck.json
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/venv,macos,python,visualstudiocode
+
+data/
+*.arrow

app.py

@@ -0,0 +1,41 @@
+import gradio as gr
+from utils.model_loader import load_model_and_config, load_ui_text
+from tabs.single_prediction import create_single_prediction_tab
+from tabs.batch_processing import create_batch_processing_tab
+
+# loadign model
+config = load_model_and_config()
+intro_md, about_md = load_ui_text()
+
+model = config['model']
+class_names = config['class_names']
+disease_db = config['disease_db']
+device = config['device']
+
+
+# Custom CSS
+custom_css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.output-class {
+    font-size: 16px;
+}
+"""
+
+# Create Gradio Interface
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown(intro_md)
+    
+    with gr.Tab("Single Image Prediction"):
+        create_single_prediction_tab(model, class_names, disease_db, device)
+    
+    with gr.Tab("Batch Processing"):
+        create_batch_processing_tab(model, class_names, device)
+    
+    with gr.Tab("About"):
+        gr.Markdown(about_md)
+
+if __name__ == "__main__":
+    demo.launch(share=False)

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/cache-4615ab977727fc47.arrow

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

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/cache-64f7f66e875a2297.arrow

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

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/cache-a711edc7192ef3fb.arrow

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

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/cache-f446c767d80f0d9a.arrow

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

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/dataset_info.json

@@ -0,0 +1 @@
+{"description": "", "citation": "", "homepage": "", "license": "", "features": {"image": {"_type": "Image"}, "label": {"names": ["Apple___Apple_scab", "Apple___Black_rot", "Apple___Cedar_apple_rust", "Apple___healthy", "Background_without_leaves", "Blueberry___healthy", "Cherry___Powdery_mildew", "Cherry___healthy", "Corn___Cercospora_leaf_spot Gray_leaf_spot", "Corn___Common_rust", "Corn___Northern_Leaf_Blight", "Corn___healthy", "Grape___Black_rot", "Grape___Esca_(Black_Measles)", "Grape___Leaf_blight_(Isariopsis_Leaf_Spot)", "Grape___healthy", "Orange___Haunglongbing_(Citrus_greening)", "Peach___Bacterial_spot", "Peach___healthy", "Pepper,_bell___Bacterial_spot", "Pepper,_bell___healthy", "Potato___Early_blight", "Potato___Late_blight", "Potato___healthy", "Raspberry___healthy", "Soybean___healthy", "Squash___Powdery_mildew", "Strawberry___Leaf_scorch", "Strawberry___healthy", "Tomato___Bacterial_spot", "Tomato___Early_blight", "Tomato___Late_blight", "Tomato___Leaf_Mold", "Tomato___Septoria_leaf_spot", "Tomato___Spider_mites Two-spotted_spider_mite", "Tomato___Target_Spot", "Tomato___Tomato_Yellow_Leaf_Curl_Virus", "Tomato___Tomato_mosaic_virus", "Tomato___healthy"], "_type": "ClassLabel"}}, "builder_name": "parquet", "dataset_name": "plant_village", "config_name": "default", "version": {"version_str": "0.0.0", "major": 0, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 863151201, "num_examples": 55447, "shard_lengths": [33224, 22223], "dataset_name": "plant_village"}}, "download_checksums": {"hf://datasets/DScomp380/plant_village@5ce680f815ea9fab7b6f8346ae4c71e7099696a5/data/train-00000-of-00002.parquet": {"num_bytes": 400759198, "checksum": null}, "hf://datasets/DScomp380/plant_village@5ce680f815ea9fab7b6f8346ae4c71e7099696a5/data/train-00001-of-00002.parquet": {"num_bytes": 459968278, "checksum": null}}, "download_size": 860727476, "dataset_size": 863151201, "size_in_bytes": 1723878677}

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/plant_village-train-00000-of-00002.arrow

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

data/plant_village/DScomp380___plant_village/default/0.0.0/5ce680f815ea9fab7b6f8346ae4c71e7099696a5/plant_village-train-00001-of-00002.arrow

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

models/model.py

@@ -0,0 +1,69 @@
+import torch
+import torch.nn as nn
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_channels:int, out_channels:int) :
+        super().__init__()
+        
+        # first convolutional layer
+        self.conv_1 = nn.Conv2d(in_channels, out_channels,
+                                 kernel_size=3, stride=1,
+                                 padding=1, bias=False)
+        self.batch_norm_1 = nn.BatchNorm2d(num_features=out_channels)
+        
+        # second convolutional layer
+        self.conv_2 = nn.Conv2d(out_channels, out_channels,
+                                kernel_size=3, stride=1,
+                                padding=1, bias=False)
+        self.batch_norm_2 = nn.BatchNorm2d(num_features=out_channels)
+        
+        self.activation = nn.ReLU(inplace=True)
+        
+    def forward(self, x):
+        # basic conv -> bn -> relu forward pass
+        output = self.activation(self.batch_norm_1(self.conv_1(x)))
+        output = self.activation(self.batch_norm_2(self.conv_2(output)))
+        return output
+                                 
+class PlantCNN(nn.Module):
+    def __init__(self, num_classes:int, channels, dropout: float):
+        super().__init__()
+        
+        # entry block to map RGB -> 64 channels
+        first_c = channels[0]
+        self.input_block = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=first_c, 
+                     kernel_size=3, stride=1,
+                     padding=1, bias=False),
+            nn.BatchNorm2d(num_features=first_c),
+            nn.ReLU(inplace=True)
+            )
+
+        self.stages = nn.ModuleList()
+        in_c = first_c
+        for c in channels:
+            stage = nn.Sequential(
+                ConvBlock(in_c,c),
+                ConvBlock(c,c),
+                nn.MaxPool2d(kernel_size=2)
+            )
+            self.stages.append(stage)
+            in_c = c
+            
+        # final pooling + classifer
+        self.pool = nn.AdaptiveAvgPool2d(1)
+        self.dropout = nn.Dropout(dropout)
+        self.fc = nn.Linear(channels[-1], num_classes) #change for app.py
+        
+    def forward(self, x):
+        output = self.input_block(x)
+        # pass through each stage in order
+        for stage in self.stages:
+            output = stage(output)
+        
+        # pool to (batch, 512) then flatten
+        output = torch.flatten(self.pool(output), 1)
+        output = self.fc(self.dropout(output))
+        return output
+        
+            

saved_models/plant_cnn.pt

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

tabs/batch_processing.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from utils.predictions import predict_batch_visual
+
+# this was written with the help of AI
+def create_batch_processing_tab(model, class_names, device):
+    """Create the batch processing tab"""
+    
+    def batch_predict_wrapper(files, progress=gr.Progress()):
+        if not files:
+            return None, " No files uploaded! Please select images to process."
+        
+        progress(0, desc="Starting batch processing...")
+        gallery, results = predict_batch_visual(files, model, class_names, device, progress)
+        return gallery, results
+    
+    gr.Markdown("""
+    ###  Upload multiple images for batch prediction
+    
+    Upload several plant leaf images at once to get predictions for all of them.
+    Results will show each image with its prediction and confidence score.
+    """)
+    
+    batch_input = gr.File(
+        file_count="multiple",
+        label="Upload Multiple Images",
+        file_types=["image"]
+    )
+    batch_btn = gr.Button("Process All Images", variant="primary", size="lg")
+    
+    with gr.Row():
+        batch_gallery = gr.Gallery(
+            label="Processed Images",
+            columns=3,
+            height="auto",
+            object_fit="contain"
+        )
+    
+    batch_output = gr.Markdown(label="Detailed Results")
+    
+    batch_btn.click(
+        fn=batch_predict_wrapper,
+        inputs=batch_input,
+        outputs=[batch_gallery, batch_output]
+    )
+    
+    return batch_input, batch_btn, batch_gallery, batch_output

tabs/single_prediction.py

@@ -0,0 +1,77 @@
+import gradio as gr
+from utils.predictions import predict_single_image, get_disease_info
+from utils.chart_vis import create_prediction_plot
+
+# this was written with the help of AI
+def create_single_prediction_tab(model, class_names, disease_db, device):
+    """Create the single image prediction tab"""
+    
+    def predict_with_visualization(image, show_top_n):
+        """Prediction function with all outputs"""
+        if image is None:
+            return None, "Please upload an image", None
+        
+        # Make prediction
+        top_preds = predict_single_image(image, model, class_names, device, show_top_n)
+        
+        # Create visualization
+        plot = create_prediction_plot(top_preds)
+        
+        # Get disease info
+        top_disease = top_preds[0][0]
+        confidence = top_preds[0][1]
+        
+        info_text = f"## Top Prediction: {top_disease}\n"
+        info_text += f"**Confidence:** {confidence:.2%}\n\n"
+        info_text += f"{get_disease_info(top_disease, disease_db)}\n\n"
+        
+        if confidence < 0.5:
+            info_text += "**Note:** Low confidence. Consider expert verification."
+        
+        # Results dictionary
+        results_dict = {label: round(float(prob), 4) for label, prob in top_preds}
+        
+        return plot, info_text, results_dict
+    
+    examples = [
+        ["ui_text/examples/Apple___Apple_scab.jpg"],
+        ["ui_text/examples/Tomato___healthy.jpg"],
+        ["ui_text/examples/Tomato___Bacterial_spot.jpg"],
+        ["ui_text/examples/Tomato___Tomato_Yellow_Leaf_Curl_Virus.jpg"],
+        ["ui_text/examples/Tomato___Septoria_leaf_spot.jpg"],
+        ["ui_text/examples/Soybean___healthy.jpg"]
+    ]
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(type="pil", label="Upload Plant Leaf Image")
+            top_n_slider = gr.Slider(
+                minimum=3, 
+                maximum=15, 
+                value=10, 
+                step=1, 
+                label="Number of top predictions to show"
+            )
+            predict_btn = gr.Button("Analyze Disease", variant="primary")
+            
+            gr.Markdown("### Example Images")
+            gr.Examples(
+                examples=examples,
+                inputs=input_image,
+                label="Click an example to try it out",
+                cache_examples=False
+            )
+        
+        with gr.Column(scale=1):
+            output_plot = gr.Plot(label="Prediction Confidence Chart")
+            output_info = gr.Markdown(label="Disease Information")
+            output_label = gr.Label(label="Detailed Predictions", num_top_classes=10)
+    
+    # Connect button
+    predict_btn.click(
+        fn=predict_with_visualization,
+        inputs=[input_image, top_n_slider],
+        outputs=[output_plot, output_info, output_label]
+    )
+    
+    return input_image, top_n_slider, predict_btn

ui_text/about.md

@@ -0,0 +1,25 @@
+
+            ##  Model Information
+            
+            **Architecture:** Custom PlantCNN
+            - **Channels:** [96, 192, 384, 768]
+            - **Number of Classes:** 39
+            - **Input Size:** 224x224 pixels
+            - **Framework:** PyTorch
+            
+            ##  Features
+            
+            -  Real-time disease detection
+            -  Confidence visualization with histogram
+            -  Top-N predictions customization
+            -  Batch processing support
+            -  Pre-loaded example gallery
+            -  Disease information and treatment suggestions
+            
+            ##  How to Use
+            
+            1. Upload a clear image of a plant leaf
+            2. Adjust the number of predictions if needed
+            3. Click "Analyze Disease" to get results
+            4. Review the confidence chart and recommendations
+            

ui_text/class_names.json

@@ -0,0 +1,41 @@
+[
+  "Apple___Apple_scab",
+  "Apple___Black_rot",
+  "Apple___Cedar_apple_rust",
+  "Apple___healthy",
+  "Background_without_leaves",
+  "Blueberry___healthy",
+  "Cherry___Powdery_mildew",
+  "Cherry___healthy",
+  "Corn___Cercospora_leaf_spot_Gray_leaf_spot",
+  "Corn___Common_rust",
+  "Corn___Northern_Leaf_Blight",
+  "Corn___healthy",
+  "Grape___Black_rot",
+  "Grape___Esca_(Black_Measles)",
+  "Grape___Leaf_blight_(Isariopsis_Leaf_Spot)",
+  "Grape___healthy",
+  "Orange___Haunglongbing_(Citrus_greening)",
+  "Peach___Bacterial_spot",
+  "Peach___healthy",
+  "Pepper,_bell___Bacterial_spot",
+  "Pepper,_bell___healthy",
+  "Potato___Early_blight",
+  "Potato___Late_blight",
+  "Potato___healthy",
+  "Raspberry___healthy",
+  "Soybean___healthy",
+  "Squash___Powdery_mildew",
+  "Strawberry___Leaf_scorch",
+  "Strawberry___healthy",
+  "Tomato___Bacterial_spot",
+  "Tomato___Early_blight",
+  "Tomato___Late_blight",
+  "Tomato___Leaf_Mold",
+  "Tomato___Septoria_leaf_spot",
+  "Tomato___Spider_mites_Two-spotted_spider_mite",
+  "Tomato___Target_Spot",
+  "Tomato___Tomato_Yellow_Leaf_Curl_Virus",
+  "Tomato___Tomato_mosaic_virus",
+  "Tomato___healthy"
+]

ui_text/disease_info.json

@@ -0,0 +1,9 @@
+{
+  "healthy": "✅ No disease detected! The plant appears healthy.",
+  "scab": "Apple Scab: A fungal disease causing dark, scabby lesions. Treatment: Apply fungicides and remove infected leaves.",
+  "rust": "Rust: Fungal infection with orange/brown pustules. Treatment: Use fungicides and improve air circulation.",
+  "spot": "Leaf Spot: Bacterial or fungal spots on leaves. Treatment: Remove infected parts and apply appropriate treatment.",
+  "blight": "Blight: A severe disease causing rapid plant death. Treatment: Remove infected plants and use resistant varieties.",
+  "mold": "Mold: Fungal growth on leaves. Treatment: Improve ventilation and reduce humidity.",
+  "virus": "Viral disease: Transmitted by insects. Treatment: Remove infected plants and control insect vectors."
+}

ui_text/intro.md

@@ -0,0 +1,5 @@
+
+        #  Plant Disease Detection System
+        
+        Upload an image of a plant leaf to detect diseases using our trained CNN model.
+        The model can identify **39 different plant diseases and healthy conditions**.

utils/chart_vis.py

@@ -0,0 +1,31 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def create_prediction_plot(top_preds):
+    """Create a horizontal bar chart of predictions"""
+    labels = [label for label, _ in top_preds]
+    probs = [prob for _, prob in top_preds]
+    
+    # figure
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    # horizontal bar chart
+    y_pos = np.arange(len(labels))
+    colors = plt.cm.RdYlGn(np.array(probs))  # Color based on confidence AI idea
+    
+    ax.barh(y_pos, probs, color=colors, alpha=0.8)
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(labels)
+    ax.invert_yaxis()  # Top prediction at the top
+    ax.set_xlabel('Confidence Score', fontsize=12)
+    ax.set_title('Top Disease Predictions', fontsize=14, fontweight='bold')
+    ax.set_xlim([0, 1])
+    
+    # Add value labels on bars
+    for i, (label, prob) in enumerate(zip(labels, probs)):
+        ax.text(prob + 0.01, i, f'{prob:.3f}', 
+                va='center', fontsize=10)
+    
+    plt.tight_layout()
+    return fig
+

utils/config.py

@@ -0,0 +1,6 @@
+import yaml
+
+# helper function to load configs from yaml file
+def load_config(path="config.yaml"):
+    with open(path, "r") as f:
+        return yaml.safe_load(f)

utils/model_loader.py

@@ -0,0 +1,51 @@
+import torch
+import json
+import os
+from models.model import PlantCNN
+
+def load_model_and_config():
+    """Load the trained model and all configuration files"""
+    
+    # Paths
+    MODEL_PATH = "saved_models/plant_cnn.pt"
+    CLASS_NAMES_PATH = "ui_text/class_names.json"
+    
+    # Config
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    CHANNELS = [96, 192, 384, 768]
+    DROPOUT = 0.4
+    NUM_CLASSES = 39
+    
+    # Load class names
+    with open(CLASS_NAMES_PATH, "r") as f:
+        class_names = json.load(f)
+    
+    # Load disease info
+    with open("ui_text/disease_info.json", "r", encoding="utf-8") as f:
+        disease_db = json.load(f)
+    
+    # Load model
+    model = PlantCNN(num_classes=NUM_CLASSES, channels=CHANNELS, dropout=DROPOUT).to(DEVICE)
+    if os.path.exists(MODEL_PATH):
+        print("Loading trained model weights...")
+        model.load_state_dict(torch.load(MODEL_PATH, map_location=DEVICE))
+        model.eval()
+    else:
+        exit()
+    
+    return {
+        'model': model,
+        'class_names': class_names,
+        'disease_db': disease_db,
+        'device': DEVICE
+    }
+
+def load_ui_text():
+    """Load intro and about markdown files"""
+    with open("ui_text/intro.md", "r", encoding="utf-8") as f:
+        intro_md = f.read()
+    
+    with open("ui_text/about.md", "r", encoding="utf-8") as f:
+        about_md = f.read()
+    
+    return intro_md, about_md

utils/predictions.py

@@ -0,0 +1,58 @@
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import os
+
+# this was written with the help of AI
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+def get_disease_info(disease_name, disease_db):
+    """Get information about a detected disease"""
+    disease_lower = disease_name.lower()
+    for key, info in disease_db.items():
+        if key in disease_lower:
+            return info
+    return " Disease information not available for this classification."
+
+def predict_single_image(image, model, class_names, device, show_top_n=10):
+    """Make prediction on a single image"""
+    if image is None:
+        return None
+    
+    # Transform and predict
+    image_tensor = transform(image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        outputs = model(image_tensor)
+        probs = torch.nn.functional.softmax(outputs, dim=1).cpu().squeeze().numpy()
+    
+    # Get top predictions
+    all_preds = sorted(zip(class_names, probs), key=lambda x: x[1], reverse=True)
+    top_preds = all_preds[:show_top_n]
+    
+    return top_preds
+
+def predict_batch(files, model, class_names, device):
+    """Process multiple images at once"""
+    if not files:
+        return "No files uploaded"
+    
+    results = []
+    for file in files:
+        image = Image.open(file.name).convert('RGB')
+        image_tensor = transform(image).unsqueeze(0).to(device)
+        
+        with torch.no_grad():
+            outputs = model(image_tensor)
+            probs = torch.nn.functional.softmax(outputs, dim=1).cpu().squeeze().numpy()
+        
+        top_pred = class_names[probs.argmax()]
+        confidence = probs.max()
+        
+        results.append(f"**{os.path.basename(file.name)}**: {top_pred} ({confidence:.2%})")
+    
+    return "\n\n".join(results)
+

utils/vis.py

@@ -0,0 +1,100 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+import torch
+
+def to_display_image(img_tensor, mean, std):
+    img = img_tensor.cpu().numpy()
+    for c in range(3):
+        img[c] = img[c]*std[c]+mean[c]
+    img = np.clip(img, 0.0, 1.0)
+    img = np.transpose(img, (1,2,0))
+    return img
+
+def visualize_preds(images, labels, preds, logger, class_names, mean, std, num_images):
+    num_images = min(num_images, len(images))
+    rows = int(np.ceil(num_images/4))
+    fig, axs = plt.subplots(rows, 4, figsize=(24, 6*rows))
+    axs = axs.flatten()
+    
+    for i, ax in enumerate(axs):
+        ax.axis("off")
+        if i >= len(images):
+            continue
+        
+        img = to_display_image(images[i], mean, std)
+        lbl = labels[i]
+        pr = preds[i]
+        
+        ax.imshow(img)
+        title = f"Label: {class_names[lbl]}\nPrediction: {class_names[pr]}"
+        colour = "green" if lbl == pr else "red"
+        ax.set_title(title, fontsize=16, color=colour)
+    
+    fig.tight_layout()
+    logger.report_matplotlib_figure("sample_predictions", "test", fig, iteration=0)
+    plt.close(fig)
+    
+def plot_cfm(labels, preds, logger, class_names, num_classes):
+    cfm = confusion_matrix(labels, preds, labels=list(range(num_classes)))
+    cfm_norm = cfm/cfm.sum(axis=1, keepdims=True)
+    cfm_norm = np.nan_to_num(cfm_norm)
+    
+    fig, ax = plt.subplots(figsize=(16, 16))
+    im = ax.imshow(cfm_norm, interpolation="nearest", cmap="Blues")
+    cbar = fig.colorbar(im, ax)
+    cbar.ax.set_ylabel("Fraction of sample", rotation=90)
+    fig.colorbar(im, ax)
+    ax.set_xticks(range(num_classes))
+    ax.set_yticks(range(num_classes))
+    ax.set_xticklabels(class_names, rotation=90, fontsize=8)
+    ax.set_yticklabels(class_names, fontsize=8)
+    ax.set_xlabel("Predicted")
+    ax.set_ylabel("Ground Truth")
+    ax.set_title("Confusion matrix (Normalized)")
+    
+    threshold = cfm_norm.max() / 2.0  
+    for i in range(num_classes):
+        for j in range(num_classes):
+            value = cfm_norm[i, j]
+            if value == 0:
+                    continue  
+            ax.text(j, i, f"{value:.2f}", ha="center", va="center",
+                fontsize=5, color="white" if value > threshold else "black")
+    
+    fig.tight_layout()
+    logger.report_matplotlib_figure(title="normalized_confusion_matrix", series="test", figure=fig, iteration=0)
+    plt.close(fig)
+    
+    cfm_errors = cfm.copy()
+    np.fill_diagonal(cfm_errors, 0)
+    if cfm_errors.max() > 0:
+        fig_err, ax_err = plt.subplots(figsize=(18, 18))
+        im_err = ax_err.imshow(cfm_errors, interpolation="nearest", cmap=plt.cm.Blues)
+        cbar_err = fig_err.colorbar(im_err, ax=ax_err)
+        cbar_err.ax.set_ylabel("Number of misclassified samples", rotation=90)
+        ax_err.set_title("Confusion matrix (errors only)")
+        ax_err.set_xlabel("Predicted")
+        ax_err.set_ylabel("Ground Truth")
+        ax_err.set_xticks(np.arange(len(class_names)))
+        ax_err.set_yticks(np.arange(len(class_names)))
+        ax_err.set_xticklabels(class_names, rotation=90, fontsize=8)
+        ax_err.set_yticklabels(class_names, fontsize=8)
+        
+        threshold = cfm_errors.max() / 2.0
+        for i in range(num_classes):
+            for j in range(num_classes):
+                value = cfm_errors[i, j]
+                if value == 0:
+                    continue  
+                ax_err.text(j, i, str(value), ha="center", va="center",
+                    fontsize=5, color="white" if value > threshold else "black")
+
+        fig_err.tight_layout()
+        logger.report_matplotlib_figure(title="errors_only_confusion_matrix", series="test", figure=fig_err, iteration=0)
+        plt.close(fig_err)
+    else:
+        print("No misclassifications")
+    
+            
+