Upload 12 files

.gitignore

@@ -0,0 +1,9 @@
+*.pyc
+__pycache__/
+
+model/efficientnetb1_plant_final.weights.h5
+model/efficientnetb1_plant_model.h5
+
+assets/Pepper__bell___healthy.jpg
+assets/Potato___Early_blight.jpg
+assets/Potato___healthy.jpg

README.md

@@ -1,13 +1,149 @@
 ---
-title: EfficientNetB1
-emoji: 🏢
-colorFrom: pink
-colorTo: gray
+title: Plant-Disease-Detection-EfficientNetB1
+emoji: 🌿
+colorFrom: green
+colorTo: purple
 sdk: gradio
-sdk_version: 6.3.0
 app_file: app.py
-pinned: false
-license: apache-2.0
+pinned: true
+license: mit
+tags:
+  - plant-disease
+  - image-classification
+  - efficientnet
+  - tensorflow
+  - gradio
+  - computer-vision
+  - huggingface-spaces
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+[![HF Spaces](https://img.shields.io/badge/🤗%20HuggingFace-Space-blue?logo=huggingface&style=flat-square)](https://huggingface.co/spaces/McKlay/Plant-Disease-Detection-EfficientNetB1)
+[![Gradio](https://img.shields.io/badge/Built%20with-Gradio-orange?logo=gradio&style=flat-square)](https://www.gradio.app/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+![GitHub last commit](https://img.shields.io/github/last-commit/McKlay/plant-disease-type-EfficientNetB1)
+![GitHub stars](https://img.shields.io/github/stars/McKlay/plant-disease-type-EfficientNetB1?style=social)
+![GitHub forks](https://img.shields.io/github/forks/McKlay/plant-disease-type-EfficientNetB1?style=social)
+![MIT License](https://img.shields.io/github/license/McKlay/plant-disease-type-EfficientNetB1)
+![Visitors](https://visitor-badge.laobi.icu/badge?page_id=McKlay.plant-disease-type-EfficientNetB1)
+
+# 🌿 Plant Disease Detection with EfficientNetB1
+
+**Plant-Disease-Detection-EfficientNetB1** is a deep learning-powered app that identifies 15 types of plant diseases from leaf images using a fine-tuned **EfficientNetB1** model trained on the PlantVillage dataset.
+
+> 📸 Upload an image, paste from clipboard, or use **webcam input**  
+> Get instant predictions on plant disease type — with confidence score and class label.
+
+---
+
+## 🌐 Demo
+
+Deployed on Hugging Face Spaces:  
+[![Open in Spaces](https://huggingface.co/datasets/huggingface/badges/raw/main/open-in-hf-spaces-sm.svg)](https://huggingface.co/spaces/McKlay/Plant-Disease-Detection-EfficientNetB1)
+
+---
+
+## 🧠 Model Details
+
+- **Model:** EfficientNetB1 (Keras, Sequential API)
+- **Classes:** 15 plant disease types
+- **Input Size:** 240×240  
+- **Preprocessing:** Normalization (0–1), real-time data augmentation
+- **Training:**
+  - Phase 1: Freeze base, train classification head
+  - Phase 2: Unfreeze all, fine-tune at low learning rate (`1e-5`)
+- **Validation Accuracy:** ~97%
+
+---
+
+## 📓 Training Notebook (Kaggle)
+
+The model was trained using TensorFlow and Keras on Kaggle.  
+[🔗 fine-tuning-efficientnetb1-plantdiseasedetection](https://www.kaggle.com/code/claymarksarte/fine-tuning-efficientnetb1-plantdiseasedetection/notebook)  
+Includes:
+- Stratified 80/20 data split using `ImageDataGenerator`
+- Real-time augmentations
+- Early stopping and checkpointing (best weights only)
+- Final `.h5` weights file exported
+
+---
+
+## Features
+
+- Classifies **15 plant diseases**
+- Supports **upload**, **webcam**, and **clipboard paste**
+- Outputs **predicted class name** and **confidence score**
+- Lightweight & fast inference — powered by Gradio
+
+---
+
+## ⚠️ Grad-CAM Note
+
+Grad-CAM is **disabled** in this version due to using `Sequential()` with `load_weights()`  
+To enable Grad-CAM, re-train with `Functional API` and access the last convolutional layer output.
+
+---
+
+## 📁 Folder Structure
+
+```bash
+12_PlantDiseaseDetection-HF/
+├── app.py                   # Gradio interface
+├── inference_utils.py       # Model loading + prediction
+├── model/
+│   ├── efficientnetb1_plant_final.weights.h5
+│   └── class_names.json
+├── assets/                  # Demo/test images
+├── requirements.txt
+└── README.md
+````
+
+---
+
+## Example Output
+
+| Input Image                                                                                                  | Prediction                       |
+| ------------------------------------------------------------------------------------------------------------ | -------------------------------- |
+| ![sample](https://huggingface.co/datasets/McKlay/documentation-images/resolve/main/plant-disease-detect-EfficientNetB1/Tomato_Early_blight.jpg) | 🍅 Tomato - Early Blight (99%) |
+
+---
+
+## Installation
+
+To run locally:
+
+```bash
+git clone https://github.com/McKlay/plant-disease-type-EfficientNetB1
+cd plant-disease-type-EfficientNetB1
+pip install -r requirements.txt
+python app.py
+```
+
+---
+
+## Requirements
+
+```txt
+tensorflow
+gradio
+opencv-python
+numpy
+Pillow
+```
+
+---
+
+## 👨‍💻 Author
+
+Developed by [Clay Mark Sarte](https://github.com/McKlay)  
+Built with TensorFlow + Gradio  
+Deployed to Hugging Face Spaces
+
+---
+
+## ⚠️ Disclaimer
+
+> **This tool is for educational use only.**
+> Not intended for use in real-world agricultural decisions or medical treatment.
+
+---

app.py

@@ -0,0 +1,30 @@
+import gradio as gr
+from inference_utils import predict_plant_disease
+
+title = "🌿 Plant Disease Classifier (EfficientNetB1)"
+description = """
+Upload a plant leaf image, use your webcam, or paste an image from your clipboard.  
+The model will predict the **plant + disease** and display the confidence.
+"""
+
+examples = [
+    "assets/Pepper__bell___Bacterial_spot.jpg",
+    "assets/Pepper__bell___healthy.jpg",
+    "assets/Potato___Early_blight.jpg",
+    "assets/Potato___healthy.jpg"
+]
+
+iface = gr.Interface(
+    fn=predict_plant_disease,
+    inputs=gr.Image(type="filepath", label="Input Leaf Image"),
+    outputs=gr.Label(label="Prediction & Confidence"),
+    title=title,
+    description=description,
+    examples=examples,
+    flagging_mode="never",
+    theme="default",
+    live=False,
+    cache_examples=False,
+)
+
+iface.launch()

inference_utils.py

@@ -0,0 +1,98 @@
+import tensorflow as tf
+import numpy as np
+import cv2
+from PIL import Image
+import json
+
+# Constants
+IMG_SIZE = 240
+MODEL_PATH = "model/efficientnetb1_plant_final.weights.h5"
+CLASS_NAMES_PATH = "model/class_names.json"
+
+# Load CLASS_NAMES
+with open(CLASS_NAMES_PATH, "r") as f:
+    CLASS_NAMES = json.load(f)
+
+# Build model EXACTLY like in training
+base_model = tf.keras.applications.EfficientNetB1(
+    include_top=False,
+    weights="imagenet",
+    input_shape=(IMG_SIZE, IMG_SIZE, 3)
+)
+base_model.trainable = True
+
+model = tf.keras.Sequential([
+    base_model,
+    tf.keras.layers.GlobalAveragePooling2D(),
+    tf.keras.layers.Dropout(0.2),
+    tf.keras.layers.Dense(len(CLASS_NAMES), activation='softmax')
+])
+
+# Load weights
+model.load_weights(MODEL_PATH)
+
+# Preprocess image
+def preprocess_image(image_path):
+    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(IMG_SIZE, IMG_SIZE))
+    img_array = tf.keras.preprocessing.image.img_to_array(img) / 255.0
+    return np.expand_dims(img_array, axis=0)
+
+# Grad-CAM
+def generate_gradcam(img_path, model, class_index, layer_name="efficientnetb1"):
+    img_array = preprocess_image(img_path)
+
+    grad_model = tf.keras.models.Model(
+        [model.inputs],
+        [model.get_layer(layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        conv_outputs, predictions = grad_model(img_array)
+        loss = predictions[:, class_index]
+
+    grads = tape.gradient(loss, conv_outputs)[0]
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1))
+
+    conv_outputs = conv_outputs[0]
+    heatmap = tf.reduce_sum(conv_outputs * pooled_grads, axis=-1)
+
+    heatmap = np.maximum(heatmap, 0)
+    heatmap /= tf.math.reduce_max(heatmap) + 1e-6
+    heatmap = heatmap.numpy()
+
+    # Overlay heatmap
+    img = cv2.imread(img_path)
+    img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
+    heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    superimposed_img = heatmap * 0.4 + img
+    result_img = Image.fromarray(np.uint8(superimposed_img))
+
+    return result_img
+
+# Inference
+def predict_plant_disease(image_path):
+    img_array = preprocess_image(image_path)
+    preds = model.predict(img_array)[0]
+
+    class_index = int(np.argmax(preds))
+    confidence = float(preds[class_index])
+    label = CLASS_NAMES[class_index]
+
+    return {label: confidence}
+
+
+''' gradcam_img = generate_gradcam(image_path, model, class_index)
+    we will disable gradcam for now, we need to rebuild the model in kaggle using functional API to for this to work'''
+    
+''' def build_model(num_classes=15):
+    inputs = tf.keras.Input(shape=(240, 240, 3))
+    base_model = tf.keras.applications.EfficientNetB1(include_top=False, weights='imagenet', input_tensor=inputs)
+    x = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
+    x = tf.keras.layers.Dropout(0.2)(x)
+    outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
+    return tf.keras.Model(inputs=inputs, outputs=outputs)
+    
+    model = build_model()
+    model.load_weights("model/efficientnetb1_plant_final.weights.h5")'''

model/README.md

@@ -0,0 +1,7 @@
+# Model Links
+
+## Hugging Face Space
+- 🌐 Live Demo: [Click here to open the Hugging Face Space](https://huggingface.co/spaces/McKlay/Plant-Disease-Detection-EfficientNetB1)
+
+## Other Resources
+- 📄 Kaggle Notebook: [Download the output file](https://www.kaggle.com/code/claymarksarte/fine-tuning-efficientnetb1-plantdiseasedetection/output)

model/class_names.json

@@ -0,0 +1,17 @@
+[
+  "Pepper__bell___Bacterial_spot",
+  "Pepper__bell___healthy",
+  "Potato___Early_blight",
+  "Potato___Late_blight",
+  "Potato___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_YellowLeaf__Curl_Virus",
+  "Tomato__Tomato_mosaic_virus",
+  "Tomato_healthy"
+]

model/efficientnetb1_plant_final.weights.h5

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

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow
+gradio
+opencv-python
+numpy
+Pillow