BPA

🏗️ Project Structure

Breed-Recognizer/
├── README.md                      # Project documentation
├── ACCURACY_IMPROVEMENTS.md       # Detailed accuracy enhancements
├── classifier.py                  # Inference/prediction module
├── nn.py                         # Neural network training module
├── example_inference.py          # Example usage scripts
├── best.py                       # Best model utilities
├── new.py                        # Additional utilities
├── lin.py                        # Linear utilities
├── evaluate_confusion_matrix.py  # Script to compute confusion matrix
└── main.py                       # Main entry point

🚀 Quick Start

Installation

1. Clone the repository:

git clone https://github.com/Vishu200672/Breed-Recognizer.git
cd Breed-Recognizer

2. Install dependencies:

pip install torch torchvision timm pillow numpy matplotlib seaborn scikit-learn

Basic Usage

from classifier import BreedPredictor

# Initialize the predictor
predictor = BreedPredictor(
    model_path="best_breed_model.pth",
    num_classes=26,
    class_names=["Gir", "Sahiwal", "Kankrej", "Breed4", ...]
)

# Make a prediction with TTA
result = predictor.predict(
    image_path="cattle_image.jpg",
    use_tta=True,
    confidence_threshold=0.3
)

print(f"Breed: {result['breed']}")
print(f"Confidence: {result['confidence']}")

💡 Usage Examples

1. High Accuracy Prediction with TTA

result = predictor.predict(
    image_path="test_cattle.jpg",
    use_tta=True,  # Enable test-time augmentation
    confidence_threshold=0.3
)

print(f"🐄 Predicted Breed: {result['breed']}")
print(f"📊 Confidence: {result['confidence']}")
print(f"🔄 TTA Enabled: {result['tta_enabled']}")

2. Fast Single Prediction

result = predictor.predict(
    image_path="test_cattle.jpg",
    use_tta=False  # Disable TTA for speed
)

print(f"⚡ Fast Prediction: {result['breed']}")

3. Top-K Predictions

top_k_results = predictor.predict_top_k(
    image_path="test_cattle.jpg",
    k=3,
    use_tta=True
)

for rank, pred in enumerate(top_k_results, 1):
    print(f"{rank}. {pred['breed']:<15} - {pred['confidence']}")

4. Batch Processing

from pathlib import Path

image_files = list(Path(".").glob("*.jpg"))

for image_path in image_files:
    result = predictor.predict(
        image_path=str(image_path),
        use_tta=True,
        confidence_threshold=0.5
    )
    
    if result['breed'] != "UNCERTAIN":
        print(f"✅ {image_path.name}: {result['breed']}")
    else:
        print(f"⚠️ {image_path.name}: {result['message']}")

📊 Model Architecture

ConvNeXt-based Classifier

• Base Model: ConvNeXt (pretrained ImageNet weights)
• Architecture: Modern convolutional neural network
• Output: Softmax classification over N cattle breeds
• Input Size: 224x224 images (normalized ImageNet stats)

Improvements Over Previous Version

1. Stronger Architecture - ConvNeXt with enhanced design
2. Enhanced Augmentation - More aggressive training transforms
3. Label Smoothing - Prevents overconfidence (factor: 0.1)
4. Test-Time Augmentation - 4 augmented views ensembled
5. Confidence Calibration - Better confidence scores
6. Extended Training - 50 epochs with early stopping

🎯 Performance Metrics

🧪 Confusion Matrix (Reproducibility)

If you've generated a confusion matrix using the included evaluation script, it will be displayed here. To produce the confusion matrix image and an exact accuracy number, run the evaluation script:

Confusion matrix

Reproduce the figure and accuracy with:

python evaluate_confusion_matrix.py \
  --model-path best_breed_model.pth \
  --test-dir ./test \
  --class-names-file class_names.txt \
  --output confusion_matrix.png

Notes:

• The script prints the overall accuracy and saves confusion_matrix.png. Commit that image to the repo to make it visible in this README.
• Ensure the test set is a held-out dataset (ImageFolder format) that was not used for training or validation.

🔧 Configuration

In classifier.py:

use_tta = True                    # Enable/disable TTA
confidence_threshold = 0.3        # Minimum confidence (0-1)
k = 3                            # Number of top predictions

In nn.py (Training):

BATCH_SIZE = 32          # Adjust based on GPU VRAM
EPOCHS = 50              # Number of training epochs
LR = 1e-4               # Learning rate
LABEL_SMOOTHING = 0.1   # Regularization (0-1)

📝 Training

To retrain the model with your own data:

python nn.py

Requirements:

• Training dataset organized by breed folders
• Each image in breed_name/ subdirectory
• Image formats: .jpg, .png, etc.

Training Parameters:

• Cosine annealing learning rate schedule
• Mixed precision training for stability
• Early stopping with 10-epoch patience
• Automatic best model checkpointing

🐛 Troubleshooting

Model is Making Incorrect Predictions

# Check top predictions
results = predictor.predict_top_k(image_path, k=5)
for pred in results:
    print(f"{pred['breed']}: {pred['confidence']}")

Solutions:

• Use predict_top_k() to see alternatives
• Increase confidence_threshold to filter uncertain cases
• Check image quality - blurry/low-quality images reduce accuracy
• Retrain with more epochs and higher quality data

Model Is Too Slow

• Disable TTA: use_tta=False (10x faster, slightly less accurate)
• Use batch processing for multiple images

Model Is Overfitting

• Increase LABEL_SMOOTHING to 0.15-0.2
• Increase data augmentation strength
• Use more training data
• Add L2 regularization

Out of Memory (OOM) Errors

• Reduce BATCH_SIZE in nn.py
• Disable mixed precision training
• Use smaller input images (192x192 instead of 224x224)

🔗 Dependencies

• PyTorch - Deep learning framework
• torchvision - Image processing utilities
• timm - PyTorch Image Models
• Pillow - Image I/O
• NumPy - Numerical computing

📚 References

• ConvNeXt: A RegNet-like model (Liu et al., 2022)
• Label Smoothing: Rethinking the Inception Architecture (Szegedy et al., 2016)
• Test-Time Augmentation: Standard ensemble technique for robustness
• Timm Models: PyTorch Image Models

💻 System Requirements

Minimum:

• Python 3.7+
• 4GB RAM
• CPU inference (~2-5 seconds per image)

Recommended:

• Python 3.8+
• 8GB+ RAM
• NVIDIA GPU with CUDA support
• GPU inference (~0.2-0.5 seconds per image)

📖 Additional Documentation

For detailed information about accuracy improvements and enhancements, see ACCURACY_IMPROVEMENTS.md

📄 License

This project is open source and available under the MIT License.

🤝 Contributing

Contributions are welcome! Please feel free to submit pull requests or open issues for bugs and feature requests.

✉️ Contact & Support

For questions, suggestions, or issues:

• GitHub Issues: Breed-Recognizer Issues
• Author: Vishu200672

🎉 Acknowledgments

• Built with PyTorch and the timm library
• Inspired by modern deep learning practices
• Thanks to the open-source community

Happy cattle breed recognizing! 🐄✨