Plant Disease Detection in Agriculture

Project Overview

• The project is designed to detect plant leaf diseases using deep learning techniques.
• Uses deep convolutional neural networks (CNNs) implemented with the TensorFlow framework.
• Analyzes high-resolution images of plant leaves.
• Aims to accurately identify and classify various diseases affecting crop plants.
• TensorFlow enhances CNN model training and optimization.
• A web application using FastAPI provides a user-friendly interface.
• The application offers farmers and stakeholders in Indian agriculture convenient access to the disease detection system.
• Helps farmers diagnose plant leaf diseases early and take timely preventive measures to minimize crop losses.
• Combines deep learning techniques with TensorFlow and FastAPI to address real-world agricultural challenges.

Motivation

• The project addresses the growing need for efficient and accurate disease diagnosis methods in agriculture.
• Addresses the increasing demand for food production and the threat of plant diseases.
• Explores the potential of deep learning to revolutionize image analysis for plant disease detection.
• Aims to develop sustainable and efficient food production methods through combining AI and agriculture.

Objectives

• To collect an image dataset of plant leaves, representing both healthy and diseased leaves.
• To preprocess and augment the image dataset, improving model performance and reducing overfitting.
• To implement and evaluate several plant leaf disease detection deep learning models., incuding Convolutional Neural Networks (CNNs) and transfer learning-based approaches.
• To analyze the deep learning models’ performance using accuracy, precision, recall, and F1 score metrics.
• To identify the best-performing plant leaf disease detection model by comparing the performance of different models.
• To visualize and interpret the model predictions in order to gain insight into the features and patterns that distinguish diseased leaves from healthy ones.
• To address the the limitations and future perspective for the suggested course of action, including possible uses in practical circumstances around the world.

Project Scope

• To develop a deep learning-based system using a dataset of plant leaf images that represent both healthy leaves and leaves with common plant diseases.
• Implement and evaluate a number of learning models from the field of deep learning, incorporating both Convolutional Neural Networks (CNNs) and strategies grounded in transfer learning.

Project Limitations

• Training data diversity and quality and labeled data availability for rare diseases can impact deep learning models' performance.
• Environmental factors like lighting and background conditions can affect models' performance.
• Early-stage disease detection or detection when symptoms are not visible may be problematic.
• Specialized hardware, software, and technical expertise may limit accessibility for some farmers and agricultural stakeholders.

Project Organization

• Chapter 1 introduces the project.
• Chapter 2 provides a literature survey of the project.
• Chapter 3 explains materials and methodologies required to complete the project.
• Chapter 4 provides analysis of the project.
• Chapter 5 provides the design phase of the project.
• Chapter 6 provides implementation of the project.
• Chapter 7 provides results of the project
• Chapter 8 gives the conclusion of the task.
• Chapter 9 provides future work.
• Chapter 10 provides social impacts.

CNN - Convolutional Neural Network

• CNN's neurons' connectivity patterns are like the animal visual cortex.
• The local receptive field focuses on hidden neurons that process data inside the mentioned field.
• Convolutional, ReLU, pooling, and fully connected layers form CNNs.
• The goal is for the computer recognize the input signal looking like previous images it has seen before.
• The resulting signal is passed on to then next layer.
• Some neurons fire when exposed to vertex, horizontal, or diagonal edges.
• Spatial correlations existing with the input data are utilized.
• Each concurrent layer connects some input neurons called a local receptive field.

Materials and Method

• A plant leaf image dataset representing common and healthy leaves collected from various sources, such as online repositories.
• i5 processor and sufficient memory and storage capacity was used in the hardware for training.
• Python, TensorFlow, and Keras were used in the software.
• Preprocessing the plant leaf image dataset for consistency by resizing, normalizing, and augmenting techniques (rotation, flipping, shearing).
• The preprocessed dataset was split in the ratios of 54:18:8 into training, validation, and testing sets.
• VGG16, InceptionV3, and ResNet50 models were implemented and evaluated for plant leaf disease detection.
• Accuracy, precision, recall, and F1 score were used to evaluate the model's performance.

Data Augmentation

• Aims to increase dataset size and improve the CNN model's generalization.
• Images are flipped horizontally and vertically with a 0.5 probability.
• Images randomly rotate in a -10 to 10 degree range.
• Randomly zoom in on images by a factor of 0.8 to 1.2.
• Keras ImageDataGenerator class performs augmentation during training.
• New images are generated on-the-fly, storing them on disk.
• A batch size of 32 images were used during training.
• For each original image in the dataset, ten enhanced images were created.

Neural Networks - CNN Training

• A CNN (Convolutional Neural Network) was used to sort potato plant leaves into three categories: Late Blight, Early Blight and Healthly.
• Consisted of 4 Convolutional layers, followed by two fully connected layers and final output layer
• Total 33,248,707 parameters
• Adam Optimizer with a 0.0001 learning rate.
• Batch size of 32
• Used categorical cross-entropy as loss function, and accuracy as evaluation metric.
• Trained our CNN model on a GPU for 50 epochs.
• Watched the validation dataset perform 20%
• Achieve 94% accuracy.
• Data augmentation helps to improve the model's performance..

Use Case - CNN

• The Data was divided and 24,500 images used for training and the remaining 500 used for testing
• Images where resized to 50 x50 Pixels and then converted to greyscale
• Adam was used as a Optimizer and learning rate set to 0.00
• Training and building different types of dog breeds
• Jupyter Notebook was used in the Python coding by implementing NumPy and Pandas

CNN Architectures

• Used to process grid-like topology data.
• Has a spatial or temporal relationship to the process data.
• Is similar to other neural networks.
• Uses a series of convolutional layers.
• Convolutional layers uses a set of filters (kernels) applied to the input image, making a feature map.
• Pooling layers reduce the spatial size of the input which requires less momory, make processing easier and reduce number of parameters and makes training faster. Max or average pooling is used.
• Max pooling is used between convolutional layers to reduce spatial size of images helping prevent overfitting and allows CNNs to train more effectively.
• Fully connected layers every neuron connected to every other neuron in the previous layers. Can classify image of dog, cat, or bird.
• CNNs mostly used for image recognition and classification tasks, and used for complex tasks.
• Can be used for identifying image objects, or used with series data, such as audio or text data.

Implementation Strategy - Jupyter Notebook

• Used for building and training deep learning model.
• An open source web application that allows create and share live code documents, equations, visualizations, and text.
• Prototyping of different models and hyperparameters can quickly happen using its interactive development environment.
• TensorFlow, an open-source software library, built the deep learning model as a flexible and scalable platform for building and training.
• FastAPI deploys the model by building APIs with Python.
• It can create a RESTful API that exposed our model.
• Validated individual components and worked together as expected, as well as ensured it met the project's requirements.

Hardware and Software

• The project used a desktop with an Intel Core i5 processor and 8 GB of RAM, as well as acer and HP latops
• Training is done using Jupyter Notebook
• Used Python 3.11, VS Code, IntelliJ, TensorFlow

Results

• 99% overal accuracy achieved in plant leaf disease detections
• 95-100% accurancy range achieved
• Identifying early blight - 98% accuracy achieved
• Used confusion matrixes and f1-score methods to evaluate performance of the model

Social Impact

• Sustainable agriculture practices can be implemented to help with plant leaf detection
• Early detections can help prevent spreading of diseaseses by farmers
• The usage of chemicals/pesticides can be reduced, while farmers access to expert agricultural advice can be provided.
• Reducing the amount of harmful pesticides, which leeds to less contamination of water and soil
• Can contribute to reduce deforestation
• Increase efficiency, productivity and income

This project focuses on the prompt and accurate detection of plant diseases using CNNs and TensorFlow. FastAPI provides a robust API for disease identification, benefiting farmers through early identification of diseased plants. The technology analyzes plant leaves, impacting disease management in Indian agriculture.