📌 Overview

PestReKNet-X is a novel deep learning framework for crop pest and disease classification that combines a ResNet18 backbone with a custom Kolmogorov–Arnold Network (KAN) layer for enhanced feature learning.

The framework integrates Explainable AI (XAI) techniques — Grad-CAM and LIME — alongside Monte Carlo Dropout for uncertainty estimation and model calibration.

Key Features

• 🎯 High Accuracy: Achieves 95.09% testing accuracy
• 🔍 Explainable AI: Built-in Grad-CAM and LIME visualizations
• 📊 Uncertainty Quantification: Monte Carlo Dropout implementation
• ⚖️ Model Calibration: Reliability diagrams and ECE metrics
• 🚀 Easy Deployment: Pre-trained weights and inference scripts

---

📊 Key Results

---

📂 Repository Structure

The following code notebooks are available in this repository:

• Resnet18_with_KAN_9393_Training.ipynb
• Resnet18_with_KAN_9393_Testing.ipynb
• Classwise_Accuracy_Test.ipynb
• t_SNE_Visualization.ipynb
• gradcam-cropest.ipynb
• limeonresnet18kan.ipynb

---

⚙️ Installation

Prerequisites

• Python 3.8+
• CUDA-compatible GPU (recommended)
• 8GB+ RAM

Setup Instructions

# Create and activate a virtual environment
python3 -m venv pestreknet_env
source pestreknet_env/bin/activate  # Linux/Mac
# pestreknet_env\Scripts\activate    # Windows

# Install dependencies
pip install -r requirements.txt

# Verify installation
python -c "import torch; print(f'PyTorch: {torch.__version__}')"

---

🚀 Quick Start

1. Model Training

# Open and run the training notebook (achieves 93.93% validation accuracy)
jupyter notebook notebooks/resnet18withkan9393.ipynb

2. Model Testing

# Evaluate the trained model
jupyter notebook notebooks/Resnet18_with_KAN_9393_Testing.ipynb

3. Class-wise Performance Analysis

# Analyze performance per class
jupyter notebook notebooks/Classwise_Accuracy_Test.ipynb

4. Feature Visualization

# Visualize learned features with t-SNE
jupyter notebook notebooks/t_SNE_Visualization.ipynb

5. Inference Example

import torch
import torchvision.transforms as transforms
from torchvision import models
from KANLinear import KANLinear  # Import your KAN implementation

# Load pre-trained model
model = models.resnet18(pretrained=False)
model.fc = KANLinear(in_features=512, out_features=22)
model.load_state_dict(torch.load('models/PestReKNet-X_Model.pth'))
model.eval()

# Define preprocessing transforms
val_transforms = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# Predict on a new image
def predict_image(image_path, model, transforms, device='cuda'):
    from PIL import Image
    
    image = Image.open(image_path).convert('RGB')
    image_tensor = transforms(image).unsqueeze(0).to(device)
    
    with torch.no_grad():
        outputs = model(image_tensor)
        probabilities = torch.nn.functional.softmax(outputs, dim=1)
        confidence, predicted = torch.max(probabilities, 1)
    
    return predicted.item(), confidence.item()

# Usage
image_path = 'path/to/your/image.jpg'
class_idx, confidence = predict_image(image_path, model, val_transforms)
print(f"Predicted class: {class_idx} (confidence: {confidence:.4f})")

---

📈 Dataset Information

CCMT Dataset

We used the CCMT: Dataset for crop pest and disease detection

📥 Download: Mendeley Data Repository

Dataset Statistics

Supported Classes

The model can classify the following categories:
🐛 Pest Detection

Cashew: Leaf Miner

Cassava: Green Mite

Maize: Fall Armyworm, Grasshopper, Leaf Beetle

🦠 Disease Classification

Cashew: Anthracnose, Gummosis, Red Rust

Cassava: Bacterial Blight, Brown Spot, Mosaic

Maize: Leaf Blight, Leaf Spot, Streak Virus

Tomato: Leaf Blight, Leaf Curl, Septoria Leaf Spot, Verticillium Wilt

🌱 Healthy Crops

Cashew: Healthy

Cassava: Healthy

Maize: Healthy

Tomato: Healthy

🍂 Senescence Detection

Biotic stress-induced senescence signs across crops, particularly visible in aging or diseased leaves (e.g., Yellowing in Late-Stage Blight or Wilt).

---

🧠 Model Architecture

Architecture Components

• Backbone: ResNet18 (pre-trained on ImageNet)
• Custom Final Layer: KANLinear layer replacing the standard fully connected layer
  • in_features: 512 (from ResNet18 feature extractor)
  • out_features: 22 (number of pest/disease classes)
  • grid_size: 10
  • spline_order: 4
  • base_activation: ReLU
• Mixed Precision Training: GradScaler for efficient GPU utilization
• Regularization: Built-in KAN regularization with activation and entropy terms
• Output: Softmax classification for 22 classes

Key Innovations

1. KAN Integration: Kolmogorov–Arnold Networks for enhanced feature learning
2. Explainable AI: Grad-CAM and LIME for model interpretability
3. Uncertainty Quantification: Monte Carlo Dropout for confidence estimation
4. Model Calibration: Temperature scaling and reliability diagrams

Training Configuration

# Training hyperparameters (from actual implementation)
BATCH_SIZE = 256
IMG_HEIGHT, IMG_WIDTH = 224, 224
EPOCHS = 40  # Early stopping at epoch 39
LEARNING_RATE = 1e-4
OPTIMIZER = 'Adam'
NUM_CLASSES = 22
DEVICE = 'cuda' if available else 'cpu'
PATIENCE = 7  # Early stopping patience

# Data Augmentation
TRAIN_TRANSFORMS = [
    'Resize(224, 224)',
    'RandomHorizontalFlip()',
    'RandomRotation(20)',
    'ToTensor()',
    'Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])'
]

# Mixed Precision Training with GradScaler
# KAN Layer Configuration: grid_size=10, spline_order=4

---

🔍 Explainable AI Features

Grad-CAM Visualizations

from src.explainability import generate_gradcam

# Generate Grad-CAM heatmap
heatmap = generate_gradcam(model, image, target_class)

LIME Explanations

from src.explainability import generate_lime_explanation

# Generate LIME explanation
explanation = generate_lime_explanation(model, image)
explanation.show_in_notebook()

---