model card

README.md

@@ -1,86 +1,72 @@
-# Maize Disease Detection Model
-
-This repository contains a TensorFlow model for detecting diseases in maize (corn) using camera images.
-
-## Model Description
-
-This model is designed to classify maize leaf images into four categories:
-
-0. Healthy
-1. Gray Leaf Spot
-2. Blight
-3. Common Rust
-
-The model uses computer vision techniques to analyze images of maize leaves and identify the presence of common diseases.
-
-## Usage
+---
+language:
+  - en
+thumbnail: "/assets/image.jpg"
+tags:
+  - image-classification
+  - computer-vision
+  - agriculture
+  - maize-diseases
+license: mit
+datasets:
+  - smaranjitghose/corn-or-maize-leaf-disease-dataset
+metrics:
+  - accuracy
+pipeline_tag: image-classification
+---
 
-To use this model for inference, follow these steps:
-
-1. Clone this repository:
-   ```
-   git clone https://huggingface.co/eligapris/maize-diseases-detection
-   cd maize-diseases-detection
-   ```
+# Maize Disease Detection Model
 
-2. Install the required dependencies (assuming you have Python and pip installed):
-   ```
-   pip install tensorflow pillow numpy
-   ```
+This model is designed to detect diseases in maize (corn) leaves using computer vision techniques.
 
-3. Use the `example.py` script as a reference for how to load and use the model. Here's a basic example:
+## Model description
 
-   ```python
-   import tensorflow as tf
-   from PIL import Image
-   import numpy as np
-   import json
+The Maize Disease Detection Model is a convolutional neural network (CNN) trained to classify images of maize leaves into four categories: Healthy, Gray Leaf Spot, Blight, and Common Rust. It aims to assist farmers and agricultural professionals in quickly identifying common maize diseases, potentially leading to earlier interventions and improved crop management.
 
-   # Load the model
-   model = tf.keras.models.load_model('saved_model.pb')
+### Intended uses & limitations
 
-   # Load and preprocess the image
-   img = Image.open('image.jpg')
-   img = img.resize((224, 224))  # Adjust size as needed
-   img_array = np.array(img) / 255.0  # Normalize pixel values
-   img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
+The model is intended for use as a diagnostic tool to assist in the identification of maize leaf diseases. It should be used in conjunction with expert knowledge and not as a sole means of diagnosis. The model's performance may vary depending on image quality, lighting conditions, and the presence of diseases or conditions not included in the training dataset.
 
-   # Make prediction
-   prediction = model.predict(img_array)
+**Limitations:**
+- The model is trained on a specific dataset and may not generalize well to significantly different growing conditions or maize varieties.
+- It is not designed to detect diseases other than the four categories it was trained on.
+- Performance on images with multiple diseases present has not been extensively tested.
+- The model should not be used as a replacement for professional agricultural advice.
 
-   # Load class names
-   with open('classes.json', 'r') as f:
-       class_names = json.load(f)
+### How to use
 
-   # Get the predicted class
-   predicted_class = class_names[str(np.argmax(prediction[0]))]
-   print(f"Predicted class: {predicted_class}")
-   ```
+Here's a basic example of how to use the model:
 
-   Make sure to replace 'image.jpg' with the path to your input image.
+```python
+import tensorflow as tf
+from PIL import Image
+import numpy as np
+import json
 
-## Model Architecture
+# Load the model
+model = tf.keras.models.load_model('saved_model.pb')
 
-The model architecture is based on a convolutional neural network (CNN) designed for image classification. The exact architecture details are not provided in the repository, but you can infer some information from the `saved_model.pb` file:
+# Load and preprocess the image
+img = Image.open('image.jpg')
+img = img.resize((224, 224))  # Adjust size as needed
+img_array = np.array(img) / 255.0  # Normalize pixel values
+img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
 
-- The model is saved in TensorFlow's SavedModel format, which preserves the entire tf.keras model, including its architecture and weights.
-- Input images are likely resized to a specific dimension (e.g., 224x224 pixels) before being fed into the network.
-- The output layer corresponds to the four classes defined in `classes.json`.
+# Make prediction
+prediction = model.predict(img_array)
 
-To get more detailed information about the model architecture, you can load the model and use TensorFlow's built-in summary function:
+# Load class names
+with open('classes.json', 'r') as f:
+    class_names = json.load(f)
 
-```python
-import tensorflow as tf
-
-model = tf.keras.models.load_model('saved_model.pb')
-model.summary()
+# Get the predicted class
+predicted_class = class_names[str(np.argmax(prediction[0]))]
+print(f"Predicted class: {predicted_class}")
 ```
 
-This will print out the layers and parameters of the model.
+### Training data
 
-## Training Data
-
-The model was trained on a dataset derived from the popular PlantVillage and PlantDoc datasets. The dataset consists of images of corn (maize) leaves in various health states:
+The model was trained on a dataset derived from the PlantVillage and PlantDoc datasets, specifically curated for maize leaf diseases. The dataset consists of:
 
 - Common Rust: 1306 images
 - Gray Leaf Spot: 574 images
@@ -91,41 +77,18 @@ Total images: 4188
 
 The original dataset can be found on Kaggle: [Corn or Maize Leaf Disease Dataset](https://www.kaggle.com/datasets/smaranjitghose/corn-or-maize-leaf-disease-dataset)
 
-Note: During the formation of this dataset, certain images from the original sources were removed if they were not found to be useful.
-
-## Performance
-
-[Include information about the model's performance, such as accuracy, precision, recall, or any other relevant metrics once available.]
-
-## Limitations
-
-- The model's performance may vary on images that significantly differ from the training dataset in terms of lighting conditions, camera angles, or image quality.
-- The model is trained to detect four specific conditions (Healthy, Gray Leaf Spot, Blight, and Common Rust). It may not accurately classify other maize diseases or conditions not included in these categories.
-- The model's performance on images with multiple diseases present has not been extensively tested.
-
-## License
-
-This model is released under the MIT License.
+## Ethical considerations
 
+- The model's predictions should not be used as the sole basis for agricultural decisions that may impact food security or farmers' livelihoods.
+- There may be biases in the training data that could lead to reduced performance for certain maize varieties or growing conditions not well-represented in the dataset.
+- Users should be made aware of the model's limitations and the importance of expert validation.
 
 Additionally, please credit the original authors of the PlantVillage and PlantDoc datasets, as this model's training data is derived from their work.
 
-## Contact
+## Model Card Authors
 
 Grey
-Eligapris
-
-## Acknowledgements
-
-- The dataset used for training this model is derived from the PlantVillage and PlantDoc datasets.
-- Special thanks to the creators and contributors of the [Corn or Maize Leaf Disease Dataset](https://www.kaggle.com/datasets/smaranjitghose/corn-or-maize-leaf-disease-dataset) on Kaggle.
 
-## File Structure
+## Model Card Contact
 
-- `assets/`: Contains additional resources for the model
-- `classes.json`: JSON file containing the mapping of class indices to disease names
-- `example.py`: Python script demonstrating how to use the model
-- `image.jpg`: Sample image for testing the model
-- `README.md`: This file, containing information about the model and how to use it
-- `saved_model.pb`: The saved TensorFlow model file
-- `variables/`: Directory containing model variables
+eligapris