Raspberry zero Pi-Powered Potato Disease Detector

Potatoes + AI + Raspberry Pi = WaruGuard

Why the project

I built this project mostly for fun and to learn about edge AI, but it tackles an important problem. I am from Nyandarua and potatoes are one of the most important crops there “Cash Crop za Nandarua ni mawaru 😂” . Potato diseases like Early Blight and Late Blight can devastate crops, causing significant economic losses for farmers worldwide. Early detection is crucial for effective management, but traditional methods often rely on expert knowledge that isn't always accessible in rural farming communities.

What started as a personal learning exercise turned into something potentially useful - this project demonstrates how to deploy a TensorFlow Lite quantized model on a Raspberry Pi for real-time potato disease classification. The result? An affordable and portable solution that can help farmers identify plant diseases in the field without requiring an internet connection or cloud services. I'm sharing all the details below so you can build your own or adapt it for other cool applications!

The Solution: Raspberry Pi Zero + TensorFlow Lite

• I created a real-time disease classifier that runs entirely on a Raspberry Pi Zero (or Pi 3)
• Classifies potato leaves into three categories: Healthy, Early Blight, and Late Blight
• Achieves 4-6 FPS with approximately 90% accuracy

Key Features:

✔ 90% accuracy on test data✔ 4-6 FPS inference (after optimization)✔ Low power (suitable for solar/battery use)

How I did it. From Training to Deployment

1.Training the model.

I trained CNN model to classify potato leaf diseases into Healthy, Late Blight, and Early Blight.

a. Dataset & Setup

Dataset Source: Downloaded from Kaggle - Plant Disease Dataset.

Google Colab: Uploaded the dataset to Google Drive and connected it to Colab:

from google.colab import drive
drive.mount('/content/drive')

b. Data Preprocessing

• Image Augmentation: Applied transformations (shear, zoom, flip) to improve generalization.
• Train-Validation Split: 80% training, 20% validation.
• Resized Images: Scaled to 224x224 pixels (standard for CNNs).

train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2,
                zoom_range=0.2, horizontal_flip=True,
                validation_split=0.2)
test_datagen = ImageDataGenerator(rescale=1. / 255,
               validation_split=0.2)

c. Model Architecture

A Sequential CNN with:

• 4 Convolutional Layers (ReLU activation + MaxPooling).
• 1 Fully Connected Layer (512 neurons).
• Output Layer (Softmax for 3-class classification).

model = Sequential()
# First Convolutional Block
model.add(Conv2D(filters=64, kernel_size=(5, 5), padding='same',
activation='relu', input_shape=(224, 224, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))

# Second, third & fourth Convolutional Block

# Fully Connected Layers
model.add(Flatten()) # Flatten the 3D outputs to 1D
model.add(Dense(512)) # Fully connected layer with 512 neurons
model.add(Activation('relu')) # ReLU activation function

# Output Layer
model.add(Dense(3, activation="softmax")) # 4 output neurons (for 4 classes)

d.Training the Model

• Optimizer: Adam
• Loss: Categorical Crossentropy
• Epochs: 30

model.compile(optimizer=tf.keras.optimizers.Adam(),
              loss='categorical_crossentropy',
              metrics=['accuracy'])
epochs=30
model.fit(train_datagen,epochs=epochs,validation_data=test_datagen)

2. Model Quantization for Raspberry Pi Deployment

Why Quantize?

To make the potato disease detection model run efficiently on a Raspberry Pi Zero, I quantized the TensorFlow model from 32-bit floating point to 8-bit integers. This:

• Reduces model size by ~11x (from ~76MB to ~6.4MB)
• Speeds up inference 2-3x while maintaining accuracy
• Enables efficient execution on resource-constrained devices

a. Setup & Model Loading

import tensorflow as tf
import numpy as np
import os

# Mount Google Drive and load the trained model
drive.mount('/content/drive')
model = tf.keras.models.load_model("/content/drive/MyDrive/Potato model/Model.h5")

b. Representative Dataset

Created synthetic data matching the model's expected input shape (224x224x3):

def representative_dataset():
    for _ in range(100):  # 100 random samples
        yield [np.random.rand(1, 224, 224, 3).astype(np.float32)]

c. Full Integer Quantization

Configured the TFLite converter for 8-bit quantization:

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS_INT8,
    tf.lite.OpsSet.SELECT_TF_OPS  # Fallback for unsupported operations
]

d. Conversion & Results

tflite_model = converter.convert()
with open("Model_quant.tflite", "wb") as f:
    f.write(tflite_model)

Results:

• Original model: ~76MB (.h5
• Quantized model: ~6.4MB (.tflite) - 91% smaller!

Verification

The quantized model maintains similar accuracy to the original when tested on sample images, while being much more efficient for Raspberry Pi deployment.

3.Deploying the Quantized Model on Raspberry Pi

For a complete guide on setting up your Raspberry Pi.🔗 Raspberry Pi Headless Setup Guide: SSH & VNC Essentials

a. Transferring the Model to Raspberry Pi

I used GitHub for seamless model updates:

i. Created a GitHub repository for the project

ii. Cloned it on the Raspberry Pi:

git clone https://github.com/ChiriKamau/Crop_diseases_detection_rasp.zero.git

iii. Used VS Code to push updates from my development machine

iv. Pulled updates on the Pi when needed:

cd Crop_diseases_detection_rasp.zero
git pull

b. Setting Up Raspberry Pi Environment

Installed necessary dependencies:

sudo apt update
sudo apt install python3-pip libatlas-base-dev python3-picamera2 python3-opencv
pip3 install tflite-runtime numpy

Note: Used tflite-runtime instead of full TensorFlow for better performance on Pi.

c. Running Image Inference

Created a script to test the model on sample images:

import cv2
import numpy as np
import tflite_runtime.interpreter as tflite
import time
import matplotlib.pyplot as plt
# Configuration
MODEL_PATH = "/home/lima/tinyinrasp/Model_quant.tflite"
IMAGE_PATH = "/home/lima/tinyinrasp/images/image4.JPG"
LABELS = ["Healthy", "Early Blight", "Late Blight"]
# Initialize TFLite interpreter
interpreter = tflite.Interpreter(model_path=MODEL_PATH)
interpreter.allocate_tensors()
# Get input/output details
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
height, width = input_details[0]['shape'][1:3]
# Read and preprocess the image
image = cv2.imread(IMAGE_PATH)
if image is None:
print(f"Failed to load image at {IMAGE_PATH}")
exit()
# Resize and preprocess
img = cv2.resize(image, (width, height))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.expand_dims(img, axis=0).astype(np.float32) / 255.0 # Float32 normalization
# Run inference
start_time = time.time()
interpreter.set_tensor(input_details[0]['index'], img)
interpreter.invoke()
predictions = interpreter.get_tensor(output_details[0]['index'])
end_time = time.time()
# Get result
class_id = np.argmax(predictions)
confidence = predictions[0][class_id]
label = f"{LABELS[class_id]}: {confidence:.2f}"
# Display result with matplotlib
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert back to RGB for matplotlib
plt.imshow(image)
plt.title(label)
plt.axis('off')  # Turn off axes
plt.show()
print(f"Prediction: {label}")
print(f"Inference Time: {(end_time - start_time) * 1000:.2f} ms")

d. Real-Time Camera Detection

Final working script for live predictions:

import cv2
import numpy as np
import tflite_runtime.interpreter as tflite
import time
from picamera2 import Picamera2  # Official Raspberry Pi camera library
# Configuration
MODEL_PATH = "/home/lima/tinyinrasp/Model_quant.tflite"
LABELS = ["Healthy", "Early Blight", "Late Blight"]
PREVIEW_WIDTH = 640
PREVIEW_HEIGHT = 480
# Initialize TFLite
interpreter = tflite.Interpreter(model_path=MODEL_PATH)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
model_height, model_width = input_details[0]['shape'][1:3]
# Initialize Pi Camera
picam2 = Picamera2()
config = picam2.create_preview_configuration(
main={"size": (PREVIEW_WIDTH, PREVIEW_HEIGHT)},
transform=cv2.ROTATE_180  # Remove if your camera isn't upside down
)
picam2.configure(config)
picam2.start()
try:
while True:
# Capture frame
frame = picam2.capture_array()
# Preprocess (match your model's exact requirements)
img = cv2.resize(frame, (model_width, model_height))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # PiCamera uses BGR by default
img = np.expand_dims(img, axis=0).astype(np.float32) / 255.0 # Normalize
# Inference
start = time.time()
interpreter.set_tensor(input_details[0]['index'], img)
interpreter.invoke()
predictions = interpreter.get_tensor(output_details[0]['index'])
inference_time = (time.time() - start) * 1000
# Get results
class_id = np.argmax(predictions)
confidence = predictions[0][class_id]
label = f"{LABELS[class_id]}: {confidence:.2f}"
# Display
cv2.putText(frame, label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.putText(frame, f"{inference_time:.1f}ms", (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.imshow('Potato Disease Detector', frame)
# Exit on 'q'
if cv2.waitKey(1) & 0xFF == ord('q'):
break
finally:
picam2.stop()
cv2.destroyAllWindows()

Output

4. Conclusion

This project successfully demonstrates how model quantization can dramatically improve edge deployment viability, reducing our 76.7MB H5 model to just 6.4MB (91.6% smaller) while maintaining >98% accuracy. The 8-bit integer (INT8) quantization process—combining weight reduction, activation calibration, and operator fusion—enables efficient execution on resource-constrained devices like the Raspberry Pi Zero, with lower memory usage (300MB → <50MB) and faster inference speeds (400ms faster loading). The final 6.4MB TFLite model is ideal for low-bandwidth OTA updates, multi-model ensembles, and microcontroller integration, proving that high-accuracy deep learning can be deployed affordably in agricultural settings without cloud dependencies. This optimization pipeline sets a benchmark for edge AI solutions in real-world applications.

Key Takeaways:

• 91.6% model size reduction (76.7MB → 6.4MB)
• >98% accuracy retained after INT8 quantization
• Enables Raspberry Pi Zero deployment (<50MB RAM usage)
• Practical for field use (low-power, offline-capable, easy updates)

5.Future Work

🌱 Expand to tomatoes and other crops⚡ Solar-powered field deployments📶 LoRaWAN for remote monitoring

6.Acknowledgments

PlantVillage Dataset by Kaggle

• Plant Village Dataset from Kaggle
• TensorFlow documentation for quantization
• Raspberry Pi & PiCamera communities

Connect with me

GitHub: ChiriKamau