🐔 Chicken Disease Classification using CNN & Deep Learning

An end-to-end deep learning project for automated detection of Coccidiosis disease in chickens using Convolutional Neural Networks (CNN) with VGG16 architecture. Deployed on AWS with CI/CD pipeline using GitHub Actions and DVC for ML pipeline management.

🎯 Overview

This project implements an automated chicken disease classification system using deep learning to identify Coccidiosis - a deadly disease affecting poultry farms worldwide. The system uses transfer learning with VGG16 architecture and achieves 90%+ accuracy in disease detection.

Problem Statement

Coccidiosis causes significant economic losses in poultry farming. Early detection is crucial but requires expert veterinarians. This AI-powered solution enables farmers to:

✅ Detect disease early through fecal image analysis
✅ Reduce veterinary costs
✅ Prevent disease spread
✅ Improve flock health management

✨ Features

🔬 High Accuracy: 90%+ accuracy in disease classification
🚀 Fast Inference: Real-time predictions in < 2 seconds
🌐 Web Interface: User-friendly Flask web application
📊 Model Tracking: MLOps with DVC for experiment tracking
☁️ Cloud Deployment: Production-ready AWS deployment
🔄 CI/CD Pipeline: Automated deployment with GitHub Actions
📈 Model Monitoring: TensorBoard integration for training visualization
🐳 Containerized: Docker support for easy deployment

🛠️ Tech Stack

Core Technologies

Python 3.10 - Programming language
TensorFlow 2.x - Deep learning framework
Keras - High-level neural networks API
VGG16 - Pre-trained CNN architecture

ML Pipeline & MLOps

DVC - Data version control and ML pipeline management
MLflow - Experiment tracking (optional)
TensorBoard - Training visualization

Web Framework

Flask - Web application framework
HTML/CSS/JavaScript - Frontend

Deployment & DevOps

Docker - Containerization
AWS EC2 - Cloud hosting
AWS ECR - Container registry
GitHub Actions - CI/CD automation

Data Processing

NumPy - Numerical computing
Pandas - Data manipulation
Pillow - Image processing
OpenCV - Computer vision

🏗️ Project Architecture

┌─────────────────┐
│   Input Image   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Preprocessing   │
│ (Resize, Scale) │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   VGG16 Base    │
│   (Pretrained)  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Custom Layers   │
│ (Dense + Softmax)│
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Prediction     │
│ Coccidiosis/    │
│ Healthy         │
└─────────────────┘

📊 Dataset

Data Source

Total Images: 390 images
Classes: 2 (Coccidiosis, Healthy)
Image Size: 224x224x3 (RGB)
Data Split:
- Training: 80% (312 images)
- Validation: 20% (78 images)

Data Augmentation

Applied augmentation techniques:

Rotation (40 degrees)
Horizontal flip
Width/Height shift (20%)
Shear transformation (20%)
Zoom (20%)

📈 Model Performance

Training Results

Final Training Accuracy: 95%
Final Validation Accuracy: 92%
Training Loss: 0.12
Validation Loss: 0.15
Training Time: ~10-15 minutes (with GPU)

Model Configuration

Architecture: VGG16 (Transfer Learning)
Optimizer: Adam
Learning Rate: 0.0001
Batch Size: 16
Epochs: 20
Loss Function: Categorical Crossentropy

💻 Installation

Prerequisites

Python 3.10+
Git
Virtual environment tool (venv/conda)
AWS account (for deployment)

Local Setup

Clone the repository

git clone https://github.com/Priyrajsinh/End-To-End-Deep-Learning-Project-Using-MLOPS-DVC-Pipeline.git
cd End-To-End-Deep-Learning-Project-Using-MLOPS-DVC-Pipeline

Create virtual environment

python -m venv venv

Activate virtual environment

# Windows
venv\Scripts\activate

# Linux/Mac
source venv/bin/activate

Install dependencies

pip install -r requirements.txt

Install package in development mode

pip install -e .

🚀 Usage

Training the Model

Using Python Script

python main.py

Using DVC Pipeline

dvc repro

Running the Web Application

Start the Flask app

python app.py

Open browser and navigate to

http://localhost:8080

Upload chicken fecal image and get prediction

Making Predictions via API

import requests
import base64

# Read and encode image
with open("test_image.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

# Make prediction request
response = requests.post(
    "http://localhost:8080/predict",
    json={"image": image_data}
)

print(response.json())
# Output: [{"image": "Coccidiosis"}] or [{"image": "Healthy"}]

🔄 DVC Pipeline

Pipeline Stages

# View pipeline
dvc dag

         +--------------------+
         | data_ingestion     |
         +--------------------+
                  *
                  *
         +--------------------+
         | prepare_base_model |
         +--------------------+
                  *
                  *
         +--------------------+
         | training           |
         +--------------------+
                  *
                  *
         +--------------------+
         | evaluation         |
         +--------------------+

Run Specific Stage

# Run data ingestion
dvc repro data_ingestion

# Run training only
dvc repro training

# Run evaluation
dvc repro evaluation

Track Experiments

# Show metrics
dvc metrics show

# Compare experiments
dvc metrics diff

☁️ AWS Deployment

Prerequisites

AWS Account
IAM User with EC2 and ECR permissions
GitHub repository

Deployment Architecture

GitHub (Code Push)
    ↓
GitHub Actions (CI/CD)
    ↓
Build Docker Image
    ↓
Push to AWS ECR
    ↓
Deploy to EC2 Instance
    ↓
Application Running on Port 8080

Step-by-Step Deployment

1. Create IAM User

Permissions Required:
- AmazonEC2ContainerRegistryFullAccess
- AmazonEC2FullAccess

2. Create ECR Repository

Repository Name: chicken-disease
Region: us-east-1

3. Launch EC2 Instance

Instance Type: t2.medium (recommended) or t2.micro
OS: Ubuntu 24.04 LTS
Security Groups:
  - SSH (22)
  - HTTP (80)
  - Custom TCP (8080)

4. Configure GitHub Secrets

Navigate to: Repository → Settings → Secrets → Actions

Add these secrets:

AWS_ACCESS_KEY_ID=<your_access_key>
AWS_SECRET_ACCESS_KEY=<your_secret_key>
AWS_REGION=us-east-1
AWS_ECR_LOGIN_URI=<your_ecr_uri>
ECR_REPOSITORY_NAME=chicken-disease

5. Setup Self-Hosted Runner

Follow GitHub's instructions to setup EC2 as self-hosted runner.

6. Deploy

git add .
git commit -m "Deploy to AWS"
git push origin main

GitHub Actions will automatically:

✅ Build Docker image
✅ Push to ECR
✅ Deploy to EC2
✅ Start application

7. Access Application

http://<EC2_PUBLIC_IP>:8080

📁 Project Structure

End-To-End-Deep-Learning-Project/
│
├── .github/
│   └── workflows/
│       └── main.yaml              # GitHub Actions CI/CD pipeline
│
├── artifacts/                     # Generated artifacts (not in Git)
│   ├── data_ingestion/
│   ├── prepare_base_model/
│   ├── training/
│   └── prepare_callbacks/
│
├── config/
│   └── config.yaml               # Configuration file
│
├── research/                     # Jupyter notebooks for experiments
│   ├── 01_data_ingestion.ipynb
│   ├── 02_prepare_base_model.ipynb
│   ├── 03_prepare_callbacks.ipynb
│   ├── 04_training.ipynb
│   └── 05_model_evaluation.ipynb
│
├── src/CnnClassifier/
│   ├── components/               # Core components
│   │   ├── data_ingestion.py
│   │   ├── prepare_base_model.py
│   │   ├── prepare_callbacks.py
│   │   ├── training.py
│   │   └── evaluation.py
│   │
│   ├── config/                   # Configuration management
│   │   └── configuration.py
│   │
│   ├── entity/                   # Data classes
│   │   └── config_entity.py
│   │
│   ├── pipeline/                 # ML pipelines
│   │   ├── stage_01_data_ingestion.py
│   │   ├── stage_02_prepare_base_model.py
│   │   ├── stage_03_training.py
│   │   ├── stage_04_evaluation.py
│   │   └── predict.py
│   │
│   ├── utils/                    # Utility functions
│   │   └── common.py
│   │
│   ├── constants/                # Constants
│   │   └── __init__.py
│   │
│   └── __init__.py
│
├── templates/                    # HTML templates
│   └── index.html
│
├── app.py                        # Flask application
├── main.py                       # Main training script
├── dvc.yaml                      # DVC pipeline definition
├── params.yaml                   # Model hyperparameters
├── requirements.txt              # Python dependencies
├── setup.py                      # Package setup
├── Dockerfile                    # Docker configuration
├── .gitignore
├── .dvcignore
├── LICENSE
└── README.md

📊 Results

Model Evaluation Metrics

{
  "loss": 0.15,
  "accuracy": 0.92
}

Sample Predictions

Input Image	Predicted Class	Confidence	Actual Class
Image 1	Coccidiosis	95%	Coccidiosis ✅
Image 2	Healthy	98%	Healthy ✅
Image 3	Coccidiosis	92%	Coccidiosis ✅
Image 4	Healthy	94%	Healthy ✅

🔧 Configuration

params.yaml

AUGMENTATION: True
IMAGE_SIZE: [224, 224, 3]
BATCH_SIZE: 16
INCLUDE_TOP: False
EPOCHS: 20
CLASSES: 2
WEIGHTS: imagenet
LEARNING_RATE: 0.0001

Update Configuration

To modify training parameters, edit params.yaml and run:

dvc repro

🐳 Docker

Build Docker Image

docker build -t chicken-disease-app .

Run Docker Container

docker run -p 8080:8080 chicken-disease-app

Docker Compose (Optional)

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - FLASK_ENV=production

📝 API Documentation

Endpoints

1. Home Page

GET /
Returns: HTML page

2. Train Model

GET/POST /train
Description: Triggers model training
Returns: "Training done successfully!"

3. Predict

POST /predict
Content-Type: application/json

Request Body:
{
  "image": "<base64_encoded_image>"
}

Response:
{
  "image": "Coccidiosis" | "Healthy"
}

🧪 Testing

Run Unit Tests

pytest tests/

Test API Endpoint

curl -X POST http://localhost:8080/predict \
  -H "Content-Type: application/json" \
  -d '{"image": "<base64_image>"}'

📚 Learn More

Resources

Related Projects

Image Classification with PyTorch
Object Detection with YOLO
Medical Image Analysis with CNNs

🤝 Contributing

Contributions are welcome! Please follow these steps:

Fork the repository
Create a new branch (git checkout -b feature/improvement)
Make changes and commit (git commit -am 'Add new feature')
Push to branch (git push origin feature/improvement)
Create Pull Request

Contribution Guidelines

Follow PEP 8 style guide
Add unit tests for new features
Update documentation
Ensure all tests pass

🐛 Known Issues

Training requires GPU for optimal performance
Large model size (~500MB) may cause slow initial load
Web interface may timeout on slow connections

Troubleshooting

Issue: Model not loading

# Solution: Reinstall dependencies
pip install -r requirements.txt --force-reinstall

Issue: Port 8080 already in use

# Solution: Use different port
python app.py --port 8081

🔮 Future Enhancements

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License

Copyright (c) 2026 Priyrajsinh

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

👨‍💻 Author

Priyrajsinh

GitHub: @Priyrajsinh
LinkedIn: [https://www.linkedin.com/in/priyrajsinh-parmar-b0a1a7243/]
Email: [priyrajsinh03@gmail.com]
Portfolio: [Soon]

🙏 Acknowledgments

Krish Naik - For the amazing tutorial and project inspiration
TensorFlow Team - For the excellent deep learning framework
VGG Team - For the VGG16 architecture
DVC Team - For ML pipeline management tools
AWS - For cloud infrastructure
Open Source Community - For various libraries and tools

📞 Contact

For questions, suggestions, or collaboration opportunities:

📧 Email: priyrajsinh03@gmail.com
💬 GitHub Issues: Create an issue

⭐ Star History

📈 Project Status

Made with ❤️ using Deep Learning

If you found this project helpful, please give it a ⭐!

Report Bug · Request Feature

Last Updated: February 2026

Name		Name	Last commit message	Last commit date
Latest commit History 19 Commits
.dvc		.dvc
.github/workflows		.github/workflows
config		config
research		research
src/CnnClassifier		src/CnnClassifier
templates		templates
.dvcignore		.dvcignore
.gitignore		.gitignore
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
app.py		app.py
dvc.lock		dvc.lock
dvc.yaml		dvc.yaml
inputImage.jpg		inputImage.jpg
main.py		main.py
params.yaml		params.yaml
requirements.txt		requirements.txt
scores.json		scores.json
setup.py		setup.py
template.py		template.py

Folders and files

Latest commit

History

Repository files navigation

🐔 Chicken Disease Classification using CNN & Deep Learning

📋 Table of Contents

🎯 Overview

Problem Statement

✨ Features

🛠️ Tech Stack

Core Technologies

ML Pipeline & MLOps

Web Framework

Deployment & DevOps

Data Processing

🏗️ Project Architecture

📊 Dataset

Data Source

Data Augmentation

📈 Model Performance

Training Results

Model Configuration

💻 Installation

Prerequisites

Local Setup

🚀 Usage

Training the Model

Using Python Script

Using DVC Pipeline

Running the Web Application

Making Predictions via API

🔄 DVC Pipeline

Pipeline Stages

Run Specific Stage

Track Experiments

☁️ AWS Deployment

Prerequisites

Deployment Architecture

Step-by-Step Deployment

1. Create IAM User

2. Create ECR Repository

3. Launch EC2 Instance

4. Configure GitHub Secrets

5. Setup Self-Hosted Runner

6. Deploy

7. Access Application

📁 Project Structure

📊 Results

Model Evaluation Metrics

Sample Predictions

🔧 Configuration

params.yaml

Update Configuration

🐳 Docker

Build Docker Image

Run Docker Container

Docker Compose (Optional)

📝 API Documentation

Endpoints

1. Home Page

2. Train Model

3. Predict

🧪 Testing

Run Unit Tests

Test API Endpoint

📚 Learn More

Resources

Related Projects

🤝 Contributing

Contribution Guidelines

🐛 Known Issues

Troubleshooting

🔮 Future Enhancements

📄 License

👨‍💻 Author

🙏 Acknowledgments

📞 Contact

⭐ Star History

📈 Project Status

Made with ❤️ using Deep Learning

Packages