HF Changes

.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+service/static/PlantDiseaseClassificationModel/best.ckpt filter=lfs diff=lfs merge=lfs -text
+service/static/PlantDiseaseOODModel filter=lfs diff=lfs merge=lfs -text
+service/static/PlantDiseaseOODModel/best.ckpt filter=lfs diff=lfs merge=lfs -text
+service/static/PlantDiseaseClassificationModel filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,15 @@
+.venv
+ml/input
+.DS_Store
+logs
+
+.env
+lightning_logs
+input/*
+!input/.gitkeep
+logs/*
+*.pyc
+venv
+.venv
+
+__pycache__

README.md

@@ -0,0 +1,95 @@
+---
+title: CDIApp
+emoji: 🏆
+colorFrom: red
+colorTo: black
+sdk: gradio
+sdk_version: 5.4.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# Plant Disease Classification
+## Generated by Claude v3
+
+This is a deep learning project for classifying plant diseases from images. It uses a convolutional neural network trained on a dataset of plant disease images.
+
+## Features
+
+- Train a disease classification model on your own dataset
+- Evaluate model performance on a test set
+- Run inference on new images through a web interface
+
+## Installation
+
+1. Clone the repository:
+
+```
+git clone https://github.com/username/plant-disease-classifier.git
+```
+
+2. Install dependencies:
+
+```
+cd plant-disease-classifier
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Data Preparation
+
+Organize your image data into folders for each disease class, for example:
+
+```
+data/
+  healthy/
+    image1.jpg
+    image2.jpg
+    ...
+  disease_a/
+    image1.jpg
+    image2.jpg
+    ...
+  disease_b/
+    ...
+```
+
+### Training
+
+To train the model, run:
+
+```
+python train_classifier.py --data_dir data/
+```
+
+This will save the trained model to the `models/` directory.
+
+### Evaluation
+
+Evaluate the model on a test set:
+
+```
+python evaluate.py --data_dir data/test/ --model models/classifier.pth
+```
+
+This will print the classification metrics.
+
+### Inference
+
+To launch the web interface for running inference on new images:
+
+```
+python app.py
+```
+
+Then open `http://localhost:5000` in your web browser. You can upload images and see the predicted disease class.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

acfg/appconfig.py

@@ -0,0 +1,112 @@
+from dataclasses import dataclass
+
+import torch
+
+from acfg.modelconfig import ModelConfig
+from ml.app.anomaly import DiseaseOODModule
+from ml.app.models.classification import DiseaseClassificationModel
+from ml.app.models.ood import Autoencoder
+
+
+def get_device():
+    """Gets the appropriate device for PyTorch operations.
+
+    Checks for CUDA GPU availability first, then Apple M1/M2 MPS, falling back to CPU.
+
+    Returns:
+        tuple: A tuple containing two strings:
+            - First string indicates the device type ('cuda', 'mps', or 'cpu')
+            - Second string indicates the specific device ('cuda:0', 'mps', or 'cpu')
+    """
+    if torch.cuda.is_available():
+        return "cuda", "cuda:0"
+    elif torch.backends.mps.is_available():
+        return "mps", "mps"
+    else:
+        return "cpu", "cpu"
+
+
+@dataclass
+class ServiceConfig:
+    LLM_MODEL_KEY = "gemini"
+    OOD_THRESHOLD = 0.034
+    ID2LABEL = (
+        "Apple scab",
+        "Apple Black rot",
+        "Apple Cedar rust",
+        "Apple healthy",
+        "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 Yellow Leaf Curl Virus",
+        "Tomato mosaic virus",
+        "Tomato healthy",
+    )
+
+
+def load_my_model(checkpoint_path, model):
+    """Loads a PyTorch model from a checkpoint file with state dict key remapping.
+
+    Args:
+        checkpoint_path (str): Path to the checkpoint file containing model weights
+        model (torch.nn.Module): PyTorch model instance to load the weights into
+
+    Returns:
+        torch.nn.Module: Model with loaded weights
+
+    Notes:
+        - Loads checkpoint using appropriate device (CUDA/MPS/CPU)
+        - Remaps state dict keys by removing 'model.model.' prefix
+        - Only keeps state dict entries that start with 'model.model.'
+    """
+    checkpoint = torch.load(checkpoint_path, map_location=torch.device(get_device()[1]))
+    state_dict = checkpoint["state_dict"]
+
+    # Create a new state dict with the correct keys
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        if k.startswith("model.model."):
+            new_key = k.replace("model.model.", "model.")
+            new_state_dict[new_key] = v
+
+    # Load the new state dict
+    model.load_state_dict(new_state_dict)
+    return model
+
+
+CLF_MODEL = DiseaseClassificationModel(model_name=ModelConfig.PRETRAINED_MODEL_NAME)
+CLF_MODEL = load_my_model(ModelConfig.CLASSIFY_MODEL_CHECKPOINT, CLF_MODEL).to(
+    get_device()[1]
+)
+
+OOD_MODEL = DiseaseOODModule.load_from_checkpoint(
+    ModelConfig.OOD_MODEL_CHECKPOINT
+).model.to(get_device()[1])

acfg/modelconfig.py

@@ -0,0 +1,22 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelConfig:
+    TRAIN_DATA_PATH: str = "ml/input/PlantDiseaseClassificationDataset/train"
+    VAL_DATA_PATH: str = "ml/input/PlantDiseaseClassificationDataset/valid"
+    TEST_DATA_PATH: str = "ml/input/PlantDiseaseClassificationDataset/test"
+    N_INPUT_CHANNELS = 3
+    IMG_SIZE: int = 224
+    BATCH_SIZE: int = 128
+    NUM_OUTPUT_CLASSES: int = 38
+    NUM_WORKERS: int = os.cpu_count() // 2
+    IMG_STD: tuple = (0.485, 0.456, 0.406)
+    IMG_MEAN: tuple = (0.229, 0.224, 0.225)
+    VAL_LOSS: str = "VL"
+    PRETRAINED_MODEL_NAME: str = "mobilenet_v3_small"
+    CLASSIFY_MODEL_CHECKPOINT: str = (
+        "service/static/PlantDiseaseClassificationModel/best.ckpt"
+    )
+    OOD_MODEL_CHECKPOINT: str = "service/static/PlantDiseaseOODModel/best.ckpt"

app.py

@@ -0,0 +1,29 @@
+import gradio as gr
+
+from service.predict import workflow
+
+
+def process_image(image):
+    disease_name, remedy = workflow(image)
+    return disease_name, remedy
+
+
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=process_image,
+    inputs=gr.Image(
+        image_mode="RGB",
+        sources="upload",
+        label="Upload Plant Disease Image",
+        show_download_button=True,
+        type="pil",
+    ),
+    outputs=[
+        gr.Textbox(label="Prediction", placeholder="Disease Prediction"),
+        gr.Markdown(label="Remedy"),
+    ],
+    title="Classify Plant Diseases and Get Remedies",
+)
+
+if __name__ == "__main__":
+    iface.launch()

ml/.gitignore

@@ -0,0 +1,6 @@
+input/*
+!input/.gitkeep
+logs/*
+*.pyc
+venv
+.venv

ml/README.md

@@ -0,0 +1 @@
+# Model training

ml/app/anomaly.py

@@ -0,0 +1,36 @@
+from typing import Tuple
+
+import torch
+from lightning import LightningModule
+from torch.nn import functional as F
+
+from ml.app.models.ood import Autoencoder
+
+
+class DiseaseOODModule(LightningModule):
+    def __init__(self) -> None:
+        super().__init__()
+        self.model = Autoencoder(in_channels=3, out_channels=3)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)
+
+    def training_step(self, batch: Tuple[torch.Tensor, ...], batch_idx: int) -> torch.Tensor:
+        loss = self._loss(batch)
+        self.log("TL", loss, prog_bar=True)
+        return loss
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
+        return optimizer
+
+    def validation_step(self, batch: Tuple[torch.Tensor, ...], batch_idx: int):
+        loss = self._loss(batch)
+        self.log("VL", loss, prog_bar=True)
+        return loss
+
+    def _loss(self, batch):
+        images, _ = batch
+        outputs = self(images)
+        loss = F.mse_loss(outputs, images)
+        return loss

ml/app/data.py

@@ -0,0 +1,91 @@
+from lightning import LightningDataModule
+from torch.utils.data import DataLoader
+from torchvision import transforms as T
+from torchvision.datasets import ImageFolder
+
+from acfg.modelconfig import ModelConfig
+
+
+class ImageDataModule(LightningDataModule):
+    def __init__(
+        self,
+        train_path: str,
+        val_path: str,
+        test_path: str,
+        batch_size: int,
+        img_size: int,
+    ):
+        super().__init__()
+        self.train_path = train_path
+        self.val_path = val_path
+        self.test_path = test_path
+        self.batch_size = batch_size
+        self.img_size = img_size
+        self.train_transforms = self._get_train_transforms()
+        self.val_transforms = self._get_val_transforms()
+        self.test_transforms = self._get_test_transforms()
+
+    def _get_train_transforms(self):
+        return T.Compose(
+            [
+                T.Resize(self.img_size),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomVerticalFlip(p=0.5),
+                T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
+                T.ToTensor(),
+                T.Normalize(mean=ModelConfig.IMG_MEAN, std=ModelConfig.IMG_STD),
+            ]
+        )
+
+    def _get_val_transforms(self):
+        return T.Compose(
+            [
+                T.Resize(self.img_size),
+                T.ToTensor(),
+                T.Normalize(mean=ModelConfig.IMG_MEAN, std=ModelConfig.IMG_STD),
+            ]
+        )
+
+    def _get_test_transforms(self):
+        return T.Compose(
+            [
+                T.Resize(self.img_size),
+                T.ToTensor(),
+                T.Normalize(mean=ModelConfig.IMG_MEAN, std=ModelConfig.IMG_STD),
+            ]
+        )
+
+    def setup(self, stage=None):
+        if stage == "fit" or stage is None:
+            self.train_data = ImageFolder(root=self.train_path, transform=self.train_transforms)
+            self.val_data = ImageFolder(root=self.val_path, transform=self.val_transforms)
+        if stage == "test" or stage is None:
+            self.test_data = ImageFolder(root=self.test_path, transform=self.test_transforms)
+
+    def train_dataloader(self):
+        return DataLoader(
+            self.train_data,
+            batch_size=self.batch_size,
+            shuffle=True,
+            persistent_workers=True,
+            pin_memory=True,
+            num_workers=ModelConfig.NUM_WORKERS,
+        )
+
+    def val_dataloader(self):
+        return DataLoader(
+            self.val_data,
+            batch_size=self.batch_size,
+            persistent_workers=True,
+            pin_memory=True,
+            num_workers=ModelConfig.NUM_WORKERS,
+        )
+
+    def test_dataloader(self):
+        return DataLoader(
+            self.test_data,
+            batch_size=self.batch_size,
+            persistent_workers=True,
+            pin_memory=True,
+            num_workers=ModelConfig.NUM_WORKERS,
+        )

ml/app/lm.py

@@ -0,0 +1,54 @@
+from typing import Tuple, Any
+
+import torch
+from lightning import LightningModule
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torch.optim import AdamW
+
+
+class ClassificationModule(LightningModule):
+    def __init__(
+        self,
+        model: nn.Module,
+        num_classes: int,
+    ) -> None:
+        super().__init__()
+        self.model = model
+        self.num_classes = num_classes
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)
+
+    def configure_optimizers(self):
+        # Low lr as we would be fine tuning a backbone
+        optimizer = AdamW(self.parameters(), lr=1e-5)
+        return optimizer
+
+    def training_step(self, batch: Tuple[torch.Tensor, ...], batch_idx: int) -> torch.Tensor:
+        images, labels = batch
+        outputs = self(images)
+        loss = F.cross_entropy(outputs, labels)
+        self.log("TL", loss, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch: Tuple[torch.Tensor, ...], batch_idx: int) -> dict[str, Tensor | float | Any]:
+        images, labels = batch
+        outputs = self(images)
+        loss = F.cross_entropy(outputs, labels)
+        acc = self._accuracy(labels, outputs)
+        self.log("VL", loss, prog_bar=True)
+        self.log("VA", acc, prog_bar=True)
+        return {"VL": loss, "VA": acc}
+
+    @staticmethod
+    def _accuracy(labels, outputs):
+        preds = torch.argmax(outputs, dim=1)
+        acc = torch.sum(preds == labels).float() / len(labels)
+        return acc
+
+    def test_step(self, batch: Tuple[torch.Tensor, ...], batch_idx: int) -> None:
+        images, labels = batch
+        outputs = self(images)
+        loss = F.cross_entropy(outputs, labels)
+        self.log("TL", loss)

ml/app/models/classification.py

@@ -0,0 +1,90 @@
+import torch
+import torchvision
+from torch import nn
+from torchvision.models import EfficientNet_B0_Weights, ResNet50_Weights, MobileNet_V3_Small_Weights
+
+from acfg.modelconfig import ModelConfig
+
+
+# TODO: Uncomment if needed
+# Pytorch fix for hash mismatch
+# def get_state_dict(self, *args, **kwargs):
+#     kwargs.pop("check_hash")
+#     return load_state_dict_from_url(self.url, *args, **kwargs)
+
+
+# WeightsEnum.get_state_dict = get_state_dict
+
+
+class MLPHead(nn.Module):
+    def __init__(self, in_features: int, num_output_classes: int) -> None:
+        super().__init__()
+        self.classifier = nn.Sequential(
+            nn.Linear(in_features, 2048),
+            nn.GELU(),
+            nn.Dropout(p=0.5),
+            nn.Linear(2048, num_output_classes),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.classifier(x)
+
+
+class PretrainedModelFactory:
+    @staticmethod
+    def _freeze_pretrained_weights(model):
+        for param in model.parameters():
+            param.requires_grad = False
+
+    @staticmethod
+    def _efficientnet_b0():
+        model = torchvision.models.efficientnet_b0(weights=EfficientNet_B0_Weights.DEFAULT)
+        model.classifier = MLPHead(
+            in_features=model.classifier[1].in_features,
+            num_output_classes=ModelConfig.NUM_OUTPUT_CLASSES,
+        )
+        return model
+
+    @staticmethod
+    def _resnet_50():
+        model = torchvision.models.resnet50(weights=ResNet50_Weights.DEFAULT)
+        model.fc = MLPHead(
+            in_features=model.fc.in_features,
+            num_output_classes=ModelConfig.NUM_OUTPUT_CLASSES,
+        )
+        return model
+
+    @staticmethod
+    def _mobilenet_v3_small():
+        model = torchvision.models.mobilenet_v3_small(weights=MobileNet_V3_Small_Weights.DEFAULT)
+        model.classifier = MLPHead(
+            in_features=model.classifier[0].in_features,
+            num_output_classes=ModelConfig.NUM_OUTPUT_CLASSES,
+        )
+        return model
+    @staticmethod
+    def _vit_b_16():
+        raise NotImplementedError
+
+    def __init__(self):
+        self.available_models = {
+            "efficientnet_b0": self._efficientnet_b0,
+            "resnet_50": self._resnet_50,
+            "vit_b_16": self._vit_b_16,
+            "mobilenet_v3_small": self._mobilenet_v3_small,
+        }
+
+    def get_model(self, model_name: str) -> nn.Module:
+        if model_name not in self.available_models:
+            raise ValueError(f"Model '{model_name}' not available. Choose from {self.available_models.keys()}")
+        return self.available_models[model_name]()
+
+
+class DiseaseClassificationModel(nn.Module):
+    def __init__(self, model_name: str) -> None:
+        super().__init__()
+        factory = PretrainedModelFactory()
+        self.model = factory.get_model(model_name)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)

ml/app/models/ood.py

@@ -0,0 +1,79 @@
+import torch
+from torch import nn
+
+
+class ConvADN(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel=2,
+        stride=2,
+        dilation=1,
+        padding=0,
+        p_drop=0.2,
+        is_transpose: bool = False,
+    ):
+        super().__init__()
+        self.model = nn.Sequential(
+            (nn.Conv2d if not is_transpose else nn.ConvTranspose2d)(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=kernel,
+                stride=stride,
+                dilation=dilation,
+                padding=padding,
+            ),
+            nn.GELU(),
+            nn.Dropout(p_drop),
+            nn.InstanceNorm3d(num_features=out_channels),
+        )
+
+    def forward(self, x):
+        return self.model(x)
+
+
+class Encoder(nn.Module):
+    def __init__(self, in_channels: int = 3):
+        super().__init__()
+        self.model = nn.Sequential(
+            ConvADN(in_channels, 32, kernel=2, stride=2, padding=0),
+            ConvADN(32, 64, kernel=2, stride=2, padding=0),
+            ConvADN(64, 128, kernel=2, stride=2, padding=0),
+            ConvADN(128, 256, kernel=2, stride=2, padding=0),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)
+
+
+class Decoder(nn.Module):
+    def __init__(self, out_channels: int = 3):
+        super().__init__()
+        self.model = nn.Sequential(
+            ConvADN(256, 128, kernel=2, stride=2, padding=0, is_transpose=True),
+            ConvADN(128, 64, kernel=2, stride=2, padding=0, is_transpose=True),
+            ConvADN(64, 32, kernel=2, stride=2, padding=0, is_transpose=True),
+            ConvADN(32, out_channels, kernel=2, stride=2, padding=0, is_transpose=True),
+        )
+        self.output = nn.Conv2d(out_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.model(x)
+        return self.output(x)
+
+
+class Autoencoder(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+    ) -> None:
+        super().__init__()
+        self.encoder = Encoder(in_channels)
+        self.decoder = Decoder(out_channels)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.encoder(x)
+        x = self.decoder(x)
+        return x

ml/pyproject.toml

@@ -0,0 +1,2 @@
+[tool.black]
+line-length = 120

requirements.txt

@@ -0,0 +1,69 @@
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.3
+aiohttp==3.10.10
+aiosignal==1.3.1
+annotated-types==0.7.0
+anyio==4.6.2.post1
+attrs==24.2.0
+certifi==2024.8.30
+charset-normalizer==3.4.0
+click==8.1.7
+fastapi==0.115.4
+ffmpy==0.4.0
+filelock==3.16.1
+frozenlist==1.5.0
+fsspec==2024.10.0
+gradio==5.4.0
+gradio_client==1.4.2
+h11==0.14.0
+httpcore==1.0.6
+httpx==0.27.2
+huggingface-hub==0.26.2
+idna==3.10
+Jinja2==3.1.4
+lightning==2.4.0
+lightning-utilities==0.11.8
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.1.0
+networkx==3.4.2
+numpy==1.26.4
+orjson==3.10.11
+packaging==24.1
+pandas==2.2.3
+pillow==11.0.0
+propcache==0.2.0
+pydantic==2.9.2
+pydantic_core==2.23.4
+pydub==0.25.1
+Pygments==2.18.0
+python-dateutil==2.9.0.post0
+python-multipart==0.0.12
+pytorch-lightning==2.4.0
+pytz==2024.2
+PyYAML==6.0.2
+requests==2.32.3
+rich==13.9.4
+ruff==0.7.2
+safehttpx==0.1.1
+semantic-version==2.10.0
+setuptools==75.3.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+starlette==0.41.2
+sympy==1.13.1
+tomlkit==0.12.0
+torch==2.5.1
+torchmetrics==1.5.1
+torchvision==0.20.1
+tqdm==4.66.6
+typer==0.12.5
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.2.3
+uvicorn==0.32.0
+websockets==12.0
+yarl==1.17.1

service/.gitignore

@@ -0,0 +1,264 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python,jetbrains+all
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,jetbrains+all
+
+### JetBrains+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### JetBrains+all Patch ###
+# Ignore everything but code style settings and run configurations
+# that are supposed to be shared within teams.
+
+.idea/*
+
+!.idea/codeStyles
+!.idea/runConfigurations
+
+### 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
+
+# End of https://www.toptal.com/developers/gitignore/api/python,jetbrains+all

service/README.md

@@ -0,0 +1 @@
+# Crop Disease Prediction Backend

service/external.py

@@ -0,0 +1,29 @@
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+load_dotenv()
+
+SYS_INSTR = "You are a plant disease expert. You will be given queries regarding plant diseases. Always respond in Markdown"
+TXT_PROMPT = "Suggest remedy for the disease in bullet points"
+IMG_TXT_PROMPT = "Based on the given image, suggest the possible disease the plant is suffering from, along with the remedy in 150 words"
+
+
+def llm_strategy(llm_name, disease_name, image_file=None):
+    if llm_name.lower() == "gemini":
+        return get_response_from_gemini(disease_name, image_file)
+    else:
+        raise ValueError(f"LLM {llm_name} not supported")
+
+
+def get_response_from_gemini(disease_name, image_file=None) -> str:
+    genai.configure(api_key=os.environ["GEMINI_API_KEY"])
+    model = genai.GenerativeModel("gemini-1.5-flash", system_instruction=SYS_INSTR)
+
+    generation_config = genai.GenerationConfig(max_output_tokens=300)
+
+    prompt = [TXT_PROMPT, disease_name]
+    if image_file:
+        prompt = [IMG_TXT_PROMPT, image_file]
+    response = model.generate_content(prompt, generation_config=generation_config)
+    return response.text

service/predict.py

@@ -0,0 +1,71 @@
+import PIL
+import numpy as np
+import torch
+from acfg.modelconfig import ModelConfig
+import torchvision.transforms.functional as F
+from torch.nn import functional as Fx
+
+
+from acfg.appconfig import CLF_MODEL, OOD_MODEL, ServiceConfig, get_device
+from service.external import llm_strategy
+
+
+def transform_for_prediction(img: PIL.Image):
+    """Transforms a PIL image for model prediction.
+
+    This function applies a series of transformations to prepare an image for model inference:
+    1. Resizes the image to the model's expected input size
+    2. Converts the image to a tensor
+    3. Normalizes the tensor using preconfigured mean and std values
+
+    Args:
+        img (PIL.Image): Input image to transform
+
+    Returns:
+        torch.Tensor: Transformed image tensor ready for model inference
+    """
+    z = img
+    z = F.resize(img, [ModelConfig.IMG_SIZE, ModelConfig.IMG_SIZE])
+    z = F.to_tensor(z)
+    z = F.normalize(z, mean=ModelConfig.IMG_MEAN, std=ModelConfig.IMG_STD)
+    return z.to(get_device()[1])
+
+
+def classify_disease(image):
+    image_tensor = transform_for_prediction(image).unsqueeze(0)
+
+    with torch.no_grad():
+        outputs = CLF_MODEL(image_tensor)
+        _, predicted = torch.max(outputs, 1)
+        prediction = predicted.item()
+
+    return ServiceConfig.ID2LABEL[prediction]
+
+
+def img_in_distribution(image):
+    image_tensor = transform_for_prediction(image).unsqueeze(0)
+
+    with torch.no_grad():
+        output = OOD_MODEL(image_tensor)
+        mse_loss_value = Fx.mse_loss(output, image_tensor)
+        print("MSE", mse_loss_value)
+        
+    return mse_loss_value < ServiceConfig.OOD_THRESHOLD
+
+
+def workflow(image: np.array):
+    if not img_in_distribution(image):
+        disease_name = "Unknown"
+        remedy = "We do not know the remedy to this one. Sorry!"
+    else:
+        disease_name = classify_disease(image)
+        remedy = "No remedy needed. Plant is Healthy"
+        print(disease_name)
+
+        if "healthy" in disease_name:
+            return disease_name, remedy
+
+        else:
+            remedy = llm_strategy(ServiceConfig.LLM_MODEL_KEY, disease_name)
+
+    return disease_name, remedy

service/static/PlantDiseaseClassificationModel/best.ckpt

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

service/static/PlantDiseaseOODModel/best.ckpt

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

train_classifier.py

@@ -0,0 +1,47 @@
+from lightning import Trainer, seed_everything
+from lightning.pytorch.callbacks import ModelCheckpoint, TQDMProgressBar
+
+from acfg.modelconfig import ModelConfig
+from ml.app.data import ImageDataModule
+from ml.app.lm import ClassificationModule
+from ml.app.models.classification import DiseaseClassificationModel
+
+
+ckpt_callback = ModelCheckpoint(
+    filename="classification" + "_{epoch:02d}_{VA:.2f}",
+    save_top_k=1,
+    mode="min",
+    monitor=ModelConfig.VAL_LOSS,
+)
+
+tqdm_callback = TQDMProgressBar(refresh_rate=10)
+
+
+model = DiseaseClassificationModel(ModelConfig.PRETRAINED_MODEL_NAME)
+
+datamodule = ImageDataModule(
+    train_path=ModelConfig.TRAIN_DATA_PATH,
+    val_path=ModelConfig.VAL_DATA_PATH,
+    test_path=ModelConfig.TEST_DATA_PATH,
+    batch_size=ModelConfig.BATCH_SIZE,
+    img_size=ModelConfig.IMG_SIZE,
+)
+
+l_module = ClassificationModule(
+    model=model,
+    num_classes=ModelConfig.NUM_OUTPUT_CLASSES,
+)
+
+seed_everything(42)
+trainer = Trainer(
+    max_epochs=25,
+    callbacks=[ckpt_callback, tqdm_callback],
+    num_sanity_val_steps=2,
+)
+
+
+if __name__ == "__main__":
+    trainer.fit(
+        model=l_module,
+        datamodule=datamodule,
+    )

train_ood.py

@@ -0,0 +1,39 @@
+from lightning import Trainer, seed_everything
+from lightning.pytorch.callbacks import ModelCheckpoint, TQDMProgressBar
+
+from acfg.modelconfig import ModelConfig
+from ml.app.anomaly import DiseaseOODModule
+from ml.app.data import ImageDataModule
+
+
+
+ckpt_callback = ModelCheckpoint(
+    filename="ood" + "_{epoch:02d}_{VL:.2f}",
+    save_top_k=1,
+    mode="min",
+    monitor=ModelConfig.VAL_LOSS,
+)
+
+tqdm_callback = TQDMProgressBar(refresh_rate=10)
+
+datamodule = ImageDataModule(
+    train_path=ModelConfig.TRAIN_DATA_PATH,
+    val_path=ModelConfig.VAL_DATA_PATH,
+    test_path=ModelConfig.TEST_DATA_PATH,
+    batch_size=ModelConfig.BATCH_SIZE,
+    img_size=ModelConfig.IMG_SIZE,
+)
+
+l_module = DiseaseOODModule()
+
+seed_everything(42)
+
+trainer = Trainer(
+    max_epochs=100,
+    callbacks=[ckpt_callback, tqdm_callback],
+    num_sanity_val_steps=2,
+)
+
+
+if __name__ == "__main__":
+    trainer.fit(model=l_module, datamodule=datamodule)