Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ 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
+models/mobileNet_1.keras filter=lfs diff=lfs merge=lfs -text
+models/mobileNet_10.keras filter=lfs diff=lfs merge=lfs -text

.github/workflows/dockerhub_push.yml

@@ -0,0 +1,40 @@
+name: CI/CD - DockerHub
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  build-test-deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.11"
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pytest
+
+    - name: Login to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+    - name: Build and push Docker image
+      run: |
+        docker build -t ${{ secrets.DOCKERHUB_USERNAME }}/plants-diseases-lite:latest .
+        docker push ${{ secrets.DOCKERHUB_USERNAME }}/plants-diseases-lite:latest
+
+

.github/workflows/hf_deploy.yml

@@ -0,0 +1,60 @@
+name: CI/CD - Hugging Face Spaces & Models
+
+on:
+  push:
+    branches: ["main"]
+  workflow_dispatch:
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install huggingface_hub
+
+    - name: Upload Model to Hugging Face Hub
+      env:
+        HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      run: |
+        from huggingface_hub import HfApi
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj="models/mobilenet_int8.tflite",
+            path_in_repo="mobilenet_int8.tflite",
+            repo_id="${{ secrets.HF_USERNAME }}/plants-diseases-lite-model",
+            repo_type="model",
+            token="${{ secrets.HF_TOKEN }}"
+        )
+        api.upload_file(
+            path_or_fileobj="class_names.txt",
+            path_in_repo="class_names.txt",
+            repo_id="${{ secrets.HF_USERNAME }}/plants-diseases-lite-model",
+            repo_type="model",
+            token="${{ secrets.HF_TOKEN }}"
+        )
+      shell: python
+
+    - name: Deploy to Hugging Face Space
+      env:
+        HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      run: |
+        from huggingface_hub import HfApi
+        api = HfApi()
+        api.upload_folder(
+            folder_path=".",
+            repo_id="${{ secrets.HF_USERNAME }}/plants-diseases-detection",
+            repo_type="space",
+            token="${{ secrets.HF_TOKEN }}"
+        )
+      shell: python

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY ./models/mobilenet_int8.tflite /app/models/mobilenet_int8.tflite
+COPY ./src/app.py /app/app.py
+COPY ./class_names.txt /app/class_names.txt
+
+RUN pip install --no-cache-dir streamlit ai-edge-litert pillow numpy
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

class_names.py

@@ -0,0 +1,19 @@
+import tensorflow as tf
+
+from keras.utils import image_dataset_from_directory
+
+train_dir="/media/data/plants_diseases_dataset/train"
+
+img_size=(224,224)
+batch_size=32
+
+train_ds=image_dataset_from_directory(train_dir,
+                                    image_size=img_size,
+                                    batch_size=batch_size,
+                                    label_mode="categorical")
+
+class_names=train_ds.class_names
+print(class_names)
+with open("class_names.txt","w") as f:
+    for c in class_names:
+        f.write(c+"\n")

class_names.txt

@@ -0,0 +1,38 @@
+Apple___Apple_scab
+Apple___Black_rot
+Apple___Cedar_apple_rust
+Apple___healthy
+Blueberry___healthy
+Cherry_(including_sour)___Powdery_mildew
+Cherry_(including_sour)___healthy
+Corn_(maize)___Cercospora_leaf_spot Gray_leaf_spot
+Corn_(maize)___Common_rust_
+Corn_(maize)___Northern_Leaf_Blight
+Corn_(maize)___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

models/mobileNet_1.keras

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

models/mobileNet_10.keras

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

models/mobilenet_int8.tflite

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

requirements.txt

@@ -0,0 +1,7 @@
+tensorflow
+streamlit
+keras
+ai-edge-litert
+matplotlib
+scikit-learn
+seaborn

src/app.py

@@ -0,0 +1,65 @@
+import streamlit as st
+import numpy as np
+from PIL import Image
+from ai_edge_litert.interpreter import Interpreter
+import time
+
+
+st.title("🌿 MobileNet TFLite Image Classifier")
+st.write("Upload an image to test your quantized MobileNet model.")
+
+
+def load_labels(path):
+    try:
+        with open(path, "r") as f:
+            return [line.strip() for line in f.readlines()]
+    except FileNotFoundError:
+        return None
+
+labels = load_labels("class_names.txt")
+
+def preprocess(image_array: np.ndarray) -> np.ndarray:
+    """Replicate keras.applications.mobilenet_v3.preprocess_input"""
+    image_array = image_array.astype(np.float32)
+    image_array = image_array / 127.5 - 1.0  # scale to [-1, 1]
+    return image_array
+
+@st.cache_resource
+def load_tflite_model():
+    interpreter = Interpreter(model_path="models/mobilenet_int8.tflite")
+    interpreter.allocate_tensors()
+    return interpreter
+interpreter = load_tflite_model()
+input_details = interpreter.get_input_details()
+output_details = interpreter.get_output_details()
+
+
+uploaded_file = st.file_uploader("📸 Choose an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file).convert("RGB")
+    st.image(image, caption="Uploaded Image", width="stretch")
+
+    img = image.resize((224, 224))
+    img = np.array(img)
+    input_data = preprocess(img)
+    input_data = np.expand_dims(img, axis=0).astype(np.float32)
+    
+
+    start = time.time()
+    interpreter.set_tensor(input_details[0]['index'], input_data)
+    interpreter.invoke()
+    preds = interpreter.get_tensor(output_details[0]['index'])[0]
+    inference_time = (time.time() - start) * 1000
+
+
+    top_k = preds.argsort()[-2:][::-1]
+    st.markdown("### 🔍 Predictions:")
+    for i in top_k:
+        label = labels[i] if labels else f"Class {i}"
+        st.write(f"**{label}** — {preds[i]*100:.2f}%")
+        if preds[i]==1:
+            break
+            
+
+    st.write(f" Inference Time: {inference_time:.2f} ms")

src/convert.py

@@ -0,0 +1,78 @@
+import tensorflow as tf
+import numpy as np
+import time
+import os
+from keras.utils import image_dataset_from_directory
+
+val_dir="/media/data/plants_diseases_dataset/valid"
+path="/media/data/plants_diseases_dataset/"
+img_size=(224,224)
+batch_size=32
+INPUT_SHAPE = (224, 224, 3)
+
+keras_model = tf.keras.models.load_model("models/mobileNet_10.keras")
+
+
+converter = tf.lite.TFLiteConverter.from_keras_model(keras_model)
+converter.optimizations = [tf.lite.Optimize.DEFAULT]
+tflite_model = converter.convert()
+with open("models/mobilenet_int8.tflite", "wb") as f:
+    f.write(tflite_model)
+
+
+def evaluate_models(keras_model, tflite_model_path, dataset):
+    """Compare size, speed, and accuracy of Keras vs TFLite model."""
+    keras_size = os.path.getsize("models/mobileNet_10.keras") / 1024**2
+    tflite_size = os.path.getsize(tflite_model_path) / 1024**2
+
+
+
+    interpreter = tf.lite.Interpreter(model_path=tflite_model_path)
+    interpreter.allocate_tensors()
+    input_details = interpreter.get_input_details()
+    output_details = interpreter.get_output_details()
+
+    correct = 0
+    total = 0
+    times = []
+
+    for batch_images, batch_labels in dataset.take(50):  
+        batch_images = batch_images.numpy()
+        batch_labels = tf.argmax(batch_labels, axis=1).numpy()
+
+        for i in range(len(batch_images)):
+            input_data = np.expand_dims(batch_images[i], axis=0).astype(np.float32)
+            start = time.time()
+            interpreter.set_tensor(input_details[0]['index'], input_data)
+            interpreter.invoke()
+            output = interpreter.get_tensor(output_details[0]['index'])
+            times.append(time.time() - start)
+
+            pred = np.argmax(output)
+            if pred == batch_labels[i]:
+                correct += 1
+            total += 1
+
+    tflite_acc = correct / total
+    avg_time = np.mean(times) * 1000  
+    print(f"\nModel sizes:")
+    print(f" - Keras: {keras_size:.2f} MB")
+    print(f" - TFLite INT8: {tflite_size:.2f} MB")
+    print("---------------------------------------------")
+    _, keras_acc = keras_model.evaluate(dataset, verbose=0)
+    print(f"\n Keras Model Accuracy: {keras_acc*100:.2f}%")
+
+    print(f" TFLite Model Accuracy: {tflite_acc*100:.2f}%")
+    print(f" Avg Inference Time (1 image): {avg_time:.2f} ms")
+
+    print("\n Summary:")
+    print(f" - Size reduction: {(1 - tflite_size/keras_size)*100:.1f}%")
+    print(f" - Accuracy drop: {(keras_acc - tflite_acc)*100:.2f}%")
+
+
+
+val_ds=image_dataset_from_directory(val_dir,
+                                    image_size=img_size,
+                                    batch_size=batch_size,
+                                    label_mode="categorical")
+evaluate_models(keras_model, "models/mobilenet_int8.tflite", val_ds)

src/eval.py

@@ -0,0 +1,63 @@
+import numpy as np
+from sklearn.metrics import classification_report, confusion_matrix
+import seaborn as sns
+import matplotlib.pyplot as plt
+from keras.utils import image_dataset_from_directory
+
+train_dir="/media/data/plants_diseases_dataset/train"
+val_dir="/media/data/plants_diseases_dataset/valid"
+img_size=(224,224)
+batch_size=32
+
+train_ds=image_dataset_from_directory(train_dir,
+                                      image_size=img_size,
+                                      batch_size=batch_size,
+                                      label_mode="categorical")
+
+val_ds=image_dataset_from_directory(val_dir,
+                                      image_size=img_size,
+                                      batch_size=batch_size,
+                                      label_mode="categorical")
+def evaluate_model(model, dataset, class_names):
+    """
+    Evaluate a trained Keras model on a dataset.
+
+    Args:
+        model: Trained Keras model
+        dataset: tf.data.Dataset (e.g. val_ds)
+        class_names: list of class names
+    """
+
+    # Get predictions and true labels
+    y_true = []
+    y_pred = []
+
+    for batch in dataset:
+        images, labels = batch
+        preds = model.predict(images)
+        y_true.extend(np.argmax(labels.numpy(), axis=1))
+        y_pred.extend(np.argmax(preds, axis=1))
+
+    # Classification report
+    print("\n--- Classification Report ---")
+    print(classification_report(y_true, y_pred, target_names=class_names))
+
+    # Confusion matrix
+    cm = confusion_matrix(y_true, y_pred)
+    plt.figure(figsize=(10, 8))
+    sns.heatmap(cm, annot=False, cmap="Blues", xticklabels=class_names, yticklabels=class_names)
+    plt.title("Confusion Matrix")
+    plt.xlabel("Predicted")
+    plt.ylabel("True")
+    plt.show()
+
+    # Overall accuracy
+    acc = np.mean(np.array(y_true) == np.array(y_pred))
+    print(f"\n Accuracy: {acc*100:.2f}%")
+
+from keras.models import load_model
+from keras.applications import mobilenet_v3
+
+
+model = load_model("models/mobileNet_1.keras")
+evaluate_model(model, val_ds, class_names=train_ds.class_names)

src/train.py

@@ -0,0 +1,96 @@
+import tensorflow as tf
+import keras
+from keras.applications import MobileNetV3Small, mobilenet_v3
+from keras import layers,models
+from keras.utils import image_dataset_from_directory
+import matplotlib.pyplot as plt
+
+
+def preprocess(x):
+    return mobilenet_v3.preprocess_input(x)
+train_dir="/media/data/plants_diseases_dataset/train"
+val_dir="/media/data/plants_diseases_dataset/valid"
+path="/media/data/plants_diseases_dataset/"
+img_size=(224,224)
+batch_size=32
+INPUT_SHAPE = (224, 224, 3)
+num_epochs=10
+print(INPUT_SHAPE)
+def get_datasets(path):
+    train_dir=path+"/train"
+    val_dir=path+"/valid"
+    train_ds=image_dataset_from_directory(train_dir,
+                                        image_size=img_size,
+                                        batch_size=batch_size,
+                                        label_mode="categorical")
+
+    val_ds=image_dataset_from_directory(val_dir,
+                                        image_size=img_size,
+                                        batch_size=batch_size,
+                                        label_mode="categorical")
+    num_classes=len(train_ds.class_names)
+    train_ds=train_ds.map(lambda x, y: (mobilenet_v3.preprocess_input(x), y))
+    val_ds=val_ds.map(lambda x, y: (mobilenet_v3.preprocess_input(x), y))
+
+    AUTOTUNE=tf.data.AUTOTUNE
+    train_ds=train_ds.prefetch(buffer_size=AUTOTUNE)
+    val_ds=val_ds.prefetch(buffer_size=AUTOTUNE)
+    return train_ds, val_ds, num_classes
+
+
+
+
+def create_MobileNet(INPUT_SHAPE,NUM_CLASSES):
+    base_model=MobileNetV3Small(input_shape=INPUT_SHAPE,
+                                include_top=False,
+                                weights='imagenet')
+
+    model=models.Sequential([
+        keras.Input(shape=INPUT_SHAPE),
+        base_model,
+        layers.GlobalAveragePooling2D(),
+        layers.Dropout(0.5),
+        layers.Dense(NUM_CLASSES,activation='softmax')
+    ])
+
+    model.compile(
+        optimizer=keras.optimizers.Adam(0.001),
+        loss="categorical_crossentropy",
+        metrics=["accuracy"]
+    )
+
+    return model
+
+
+def plot_hist(history):
+    plt.figure(figsize=(12, 5))
+    plt.subplot(1, 2, 1)
+    plt.plot(history.history["loss"], label="Train Loss")
+    plt.plot(history.history["val_loss"], label="Val Loss")
+    plt.title("Training and Validation Loss")
+    plt.xlabel("Epochs")
+    plt.ylabel("Loss")
+    plt.legend()
+
+
+    plt.subplot(1, 2, 2)
+    plt.plot(history.history["accuracy"], label="Train Accuracy")
+    plt.plot(history.history["val_accuracy"], label="Val Accuracy")
+    plt.title("Training and Validation Accuracy")
+    plt.xlabel("Epochs")
+    plt.ylabel("Accuracy")
+    plt.legend()
+
+    plt.tight_layout()
+    plt.show()
+
+def main():
+
+    train_ds,val_ds,num_classes=get_datasets(path)
+    model=create_MobileNet(INPUT_SHAPE,num_classes)
+    history=model.fit(train_ds,validation_data=val_ds,epochs=num_epochs)
+    model.save(f"models/mobileNet_{num_epochs}.keras")
+    plot_hist(history)
+
+if __name__=="__main__":
+    main()