first commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Jaffarbadi_sample.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,156 @@
+---
+license: apache-2.0
+tags:
+- cattle-breed-classification
+- buffalo-breed-classification
+- livestock-recognition
+- agriculture
+- computer-vision
+- onnx
+- resnet50
+pipeline_tag: image-classification
+base_model: microsoft/resnet-50
+---
+
+# 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
+
+```python
+import onnxruntime as ort
+import numpy as np
+from PIL import Image
+import json
+
+# Load model
+session = ort.InferenceSession('model.onnx')
+
+# Load breed prototypes
+with open('prototypes.json', 'r') as f:
+    prototypes = json.load(f)
+
+# Preprocess image
+def preprocess_image(image_path):
+    from torchvision import transforms
+    
+    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]
+        )
+    ])
+    
+    image = Image.open(image_path).convert('RGB')
+    tensor = transform(image).unsqueeze(0)
+    return tensor.numpy()
+
+# Predict breed
+def predict_breed(image_path):
+    # Get features
+    input_data = preprocess_image(image_path)
+    features = session.run(None, {'input': input_data})[0][0]
+    
+    # Calculate similarities
+    similarities = {}
+    for breed, prototype in prototypes['prototypes'].items():
+        similarity = np.dot(features, prototype)
+        similarities[breed] = float(similarity)
+    
+    # Get top prediction
+    predicted_breed = max(similarities, key=similarities.get)
+    confidence = similarities[predicted_breed]
+    
+    return predicted_breed, confidence, similarities
+
+# Example usage
+breed, confidence, all_scores = predict_breed('path/to/image.jpg')
+print(f"Predicted breed: {breed}")
+print(f"Confidence: {confidence:.4f}")
+```
+
+### Integration with Mobile Apps
+
+```javascript
+// 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.

config.json

@@ -0,0 +1,39 @@
+{
+  "architectures": ["CustomFeatureExtractor"],
+  "model_type": "custom",
+  "task": "image-classification",
+  "framework": "onnx",
+  "pipeline_tag": "image-classification",
+  "license": "apache-2.0",
+  "tags": [
+    "cattle-breed-classification",
+    "buffalo-breed-classification", 
+    "livestock-recognition",
+    "agriculture",
+    "computer-vision",
+    "onnx",
+    "resnet50"
+  ],
+  "base_model": "microsoft/resnet-50",
+  "num_classes": 10,
+  "breeds": [
+    "Bhadawari",
+    "Gir", 
+    "Jaffarbadi",
+    "Kankrej",
+    "Mehsana",
+    "Murrah",
+    "Ongole",
+    "Sahiwal",
+    "Surti",
+    "Tharparkar"
+  ],
+  "input_size": [224, 224],
+  "feature_dim": 2048,
+  "preprocessing": {
+    "image_mean": [0.485, 0.456, 0.406],
+    "image_std": [0.229, 0.224, 0.225],
+    "size": 256,
+    "crop_size": 224
+  }
+}

example_usage.py

@@ -0,0 +1,176 @@
+"""
+Hugging Face Model Hub Integration Example
+==========================================
+
+This script demonstrates how to use the cattle breed classification model
+from Hugging Face Model Hub.
+"""
+
+import onnxruntime as ort
+import numpy as np
+import json
+from PIL import Image
+from torchvision import transforms
+import requests
+from huggingface_hub import hf_hub_download
+import os
+
+class CattleBreedClassifier:
+    def __init__(self, model_name="your-username/cattle-breed-classifier"):
+        """
+        Initialize the classifier by downloading model files from Hugging Face
+        
+        Args:
+            model_name: HuggingFace model repository name
+        """
+        self.model_name = model_name
+        self.session = None
+        self.prototypes = None
+        self.metadata = None
+        
+        # Download and load model files
+        self._download_model_files()
+        self._load_model()
+        self._load_prototypes()
+        
+    def _download_model_files(self):
+        """Download model files from Hugging Face Hub"""
+        print("📥 Downloading model files from Hugging Face...")
+        
+        # Download ONNX model
+        self.model_path = hf_hub_download(
+            repo_id=self.model_name,
+            filename="model.onnx"
+        )
+        
+        # Download prototypes
+        self.prototypes_path = hf_hub_download(
+            repo_id=self.model_name,
+            filename="prototypes.json"
+        )
+        
+        # Download metadata
+        self.metadata_path = hf_hub_download(
+            repo_id=self.model_name,
+            filename="metadata.json"
+        )
+        
+        print("✅ Model files downloaded successfully!")
+        
+    def _load_model(self):
+        """Load the ONNX model"""
+        self.session = ort.InferenceSession(self.model_path)
+        print("✅ ONNX model loaded")
+        
+    def _load_prototypes(self):
+        """Load breed prototypes"""
+        with open(self.prototypes_path, 'r') as f:
+            self.prototypes = json.load(f)
+        
+        with open(self.metadata_path, 'r') as f:
+            self.metadata = json.load(f)
+            
+        print(f"✅ Loaded prototypes for {len(self.prototypes['prototypes'])} breeds")
+        
+    def preprocess_image(self, image_input):
+        """
+        Preprocess image for model inference
+        
+        Args:
+            image_input: PIL Image, numpy array, or file path
+            
+        Returns:
+            numpy.ndarray: Preprocessed image tensor
+        """
+        # Handle different input types
+        if isinstance(image_input, str):
+            image = Image.open(image_input).convert('RGB')
+        elif isinstance(image_input, np.ndarray):
+            image = Image.fromarray(image_input).convert('RGB')
+        else:
+            image = image_input.convert('RGB')
+            
+        # Apply preprocessing
+        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]
+            )
+        ])
+        
+        tensor = transform(image).unsqueeze(0)
+        return tensor.numpy()
+    
+    def predict(self, image_input, return_all_scores=False):
+        """
+        Predict cattle/buffalo breed from image
+        
+        Args:
+            image_input: Image input (PIL Image, numpy array, or file path)
+            return_all_scores: Whether to return scores for all breeds
+            
+        Returns:
+            dict: Prediction results
+        """
+        # Preprocess image
+        input_data = self.preprocess_image(image_input)
+        
+        # Run inference
+        features = self.session.run(None, {'input': input_data})[0][0]
+        
+        # Calculate similarities with all breed prototypes
+        similarities = {}
+        for breed, prototype in self.prototypes['prototypes'].items():
+            similarity = np.dot(features, np.array(prototype))
+            similarities[breed] = float(similarity)
+        
+        # Get top prediction
+        predicted_breed = max(similarities, key=similarities.get)
+        confidence = similarities[predicted_breed]
+        
+        # Determine animal type
+        buffalo_breeds = ['Bhadawari', 'Jaffarbadi', 'Mehsana', 'Murrah', 'Surti']
+        animal_type = 'Buffalo' if predicted_breed in buffalo_breeds else 'Cattle'
+        
+        result = {
+            'predicted_breed': predicted_breed,
+            'confidence': confidence,
+            'animal_type': animal_type
+        }
+        
+        if return_all_scores:
+            result['all_scores'] = similarities
+            
+        return result
+
+# Example usage
+def main():
+    # Initialize classifier (will download model from Hugging Face)
+    classifier = CattleBreedClassifier("your-username/cattle-breed-classifier")
+    
+    # Example 1: Predict from local image
+    image_path = "path/to/your/image.jpg"
+    if os.path.exists(image_path):
+        result = classifier.predict(image_path, return_all_scores=True)
+        
+        print(f"\n🐄 Prediction Results:")
+        print(f"Animal Type: {result['animal_type']}")
+        print(f"Predicted Breed: {result['predicted_breed']}")
+        print(f"Confidence: {result['confidence']:.4f}")
+        
+        print(f"\n📊 All Breed Scores:")
+        for breed, score in sorted(result['all_scores'].items(), 
+                                 key=lambda x: x[1], reverse=True):
+            print(f"  {breed}: {score:.4f}")
+    
+    # Example 2: Predict from PIL Image
+    from PIL import Image
+    image = Image.open(image_path)
+    result = classifier.predict(image)
+    print(f"\nDirect PIL prediction: {result['predicted_breed']} ({result['confidence']:.4f})")
+
+if __name__ == "__main__":
+    main()

metadata.json

@@ -0,0 +1,31 @@
+{
+  "model_name": "resnet50",
+  "feature_dim": 2048,
+  "input": {
+    "size": [3, 224, 224],
+    "mean": [0.485, 0.456, 0.406],
+    "std": [0.229, 0.224, 0.225]
+  },
+  "embedding_norm": "l2",
+  "similarity": "cosine",
+  "optimization_type": "maximum_10breed_near_perfect",
+  "breeds": [
+    "Bhadawari",
+    "Gir", 
+    "Jaffarbadi",
+    "Kankrej",
+    "Mehsana",
+    "Murrah",
+    "Ongole",
+    "Sahiwal",
+    "Surti",
+    "Tharparkar"
+  ],
+  "buffalo_breeds": ["Bhadawari", "Jaffarbadi", "Mehsana", "Murrah", "Surti"],
+  "cattle_breeds": ["Gir", "Kankrej", "Ongole", "Sahiwal", "Tharparkar"],
+  "total_breeds": 10,
+  "breed_types": {
+    "buffalo_count": 5,
+    "cattle_count": 5
+  }
+}

model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a39d75b315e0abfe9e8ab91c119207f4a649c8d0ddb20d92d5f9b5b77142d3af
+size 93957547