vishnuamar/cattle-breed-classifier

Cattle & Buffalo Breed Classification Model

This model classifies cattle and buffalo breeds using computer vision. It's based on ResNet-50 architecture and trained to recognize 10 different breeds.

Model Description

• Model Type: Feature extraction + similarity matching
• Architecture: ResNet-50 backbone with L2 normalization
• Format: ONNX (89.6MB)
• Input: RGB images (224x224)
• Output: 2048-dimensional feature vectors
• Classification: Cosine similarity with breed prototypes

Supported Breeds

Buffalo Breeds (5)

• Bhadawari
• Jaffarbadi
• Mehsana
• Murrah
• Surti

Cattle Breeds (5)

• Gir
• Kankrej
• Ongole
• Sahiwal
• Tharparkar

Usage

Using ONNX Runtime

from huggingface_hub import hf_hub_download
import onnxruntime as ort
import numpy as np
import json
from PIL import Image
from torchvision import transforms

def setup_model():
    print("📥 Downloading model from Hugging Face...")
    model_path = hf_hub_download("vishnuamar/cattle-breed-classifier", "model.onnx")
    prototypes_path = hf_hub_download("vishnuamar/cattle-breed-classifier", "prototypes.json")
    session = ort.InferenceSession(model_path)
    with open(prototypes_path, 'r') as f:
        prototypes = json.load(f)
    print("✅ Model ready!")
    return session, prototypes

def predict_breed(session, prototypes, image_path):
    image = Image.open(image_path).convert('RGB')
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    input_data = transform(image).unsqueeze(0).numpy()
    features = session.run(None, {'input': input_data})[0][0]
    similarities = {}
    for breed, prototype in prototypes['prototypes'].items():
        similarity = np.dot(features, np.array(prototype))
        similarities[breed] = float(similarity)
    predicted_breed = max(similarities, key=similarities.get)
    confidence = similarities[predicted_breed]
    buffalo_breeds = ['Bhadawari', 'Jaffarbadi', 'Mehsana', 'Murrah', 'Surti']
    animal_type = 'Buffalo' if predicted_breed in buffalo_breeds else 'Cattle'
    return {
        'breed': predicted_breed,
        'confidence': confidence,
        'animal_type': animal_type,
        'all_scores': similarities
    }

if __name__ == "__main__":
    session, prototypes = setup_model()
    image_path = "path/to/your/image.jpg"  # Change this to your test image
    result = predict_breed(session, prototypes, image_path)
    print(f"\n🐄 Animal: {result['animal_type']}")
    print(f"Breed: {result['breed']}")
    print(f"Confidence: {result['confidence']:.4f}")

Integration with Mobile Apps

// React Native example
import { ONNX } from 'onnxjs-react-native';

const model = new ONNX.InferenceSession();
await model.loadModel('path/to/model.onnx');

const prediction = await model.run([preprocessedImageTensor]);
// Process with prototypes for final classification

Model Performance

• Inference Time: ~45-50ms (CPU)
• Model Size: 89.6MB
• Accuracy: Optimized for livestock breed recognition
• Platforms: Cross-platform (ONNX Runtime support)

Files Included

• model.onnx: The trained ONNX model
• prototypes.json: Breed prototype vectors for classification
• config.json: Model configuration and metadata
• sample_images/: Example images for testing

Technical Details

• Feature Extraction: ResNet-50 backbone → 2048-dim features
• Normalization: L2 normalization applied to features
• Classification: Cosine similarity with pre-computed breed prototypes
• Preprocessing: ImageNet-style normalization (mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

License

Apache 2.0

Citation

If you use this model, please cite:

@misc{cattle-breed-classifier,
  title={Cattle and Buffalo Breed Classification Model},
  author={Your Name},
  year={2025},
  publisher={Hugging Face},
  url={https://huggingface.co/your-username/cattle-breed-classifier}
}

Contact

For questions or issues, please open an issue in the model repository.