Update app.py

app.py

@@ -1,10 +1,16 @@
 import gradio as gr
-import tensorflow as tf
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models as models
+import torchvision.transforms as transforms
 import numpy as np
 from PIL import Image
-import pandas as pd
-import json
+import pickle
+import joblib
 import os
+import warnings
+warnings.filterwarnings("ignore")
 
 # Define the breeds based on Indian bovine classification
 BREEDS = [
@@ -33,614 +39,4 @@ BREED_INFO = {
         "special_features": "Light to dark brown color with creamy white muzzle, exceptional longevity",
         "weight": "600-700 kg",
         "height": "135-150 cm",
-        "temperament": "Calm and intelligent"
-    },
-    "Holstein Friesian cattle": {
-        "type": "Dairy Cow",
-        "origin": "Netherlands/Germany",
-        "characteristics": "Highest milk production, excellent feed conversion, docile temperament",
-        "milk_yield": "8000-12000 liters per lactation", 
-        "special_features": "Distinctive black and white patches, large frame, heat sensitive",
-        "weight": "580-700 kg",
-        "height": "140-150 cm",
-        "temperament": "Gentle and manageable"
-    },
-    "Jaffrabadi": {
-        "type": "Indigenous Dairy Buffalo",
-        "origin": "Gujarat, India (Saurashtra region)",
-        "characteristics": "Heaviest Indian buffalo breed, adapted to harsh semi-arid conditions",
-        "milk_yield": "2000-2500 liters per lactation",
-        "special_features": "Black color, dome-shaped forehead, ring-like horns, highest butterfat content",
-        "weight": "400-600 kg",
-        "height": "130-140 cm",
-        "temperament": "Hardy and resilient"
-    },
-    "Jersey cattle": {
-        "type": "Dairy Cow", 
-        "origin": "Jersey, Channel Islands",
-        "characteristics": "Efficient feed conversion, calving ease, heat tolerant, docile",
-        "milk_yield": "4500-6500 liters per lactation",
-        "special_features": "Light tan to fawn color, smallest dairy breed, highest butterfat percentage",
-        "weight": "350-450 kg",
-        "height": "120-125 cm",
-        "temperament": "Alert and intelligent"
-    },
-    "Murrah": {
-        "type": "Indigenous Dairy Buffalo",
-        "origin": "Haryana and Punjab, India", 
-        "characteristics": "Highest milk yielding buffalo breed, docile nature, good mothers",
-        "milk_yield": "2200-3000 liters per lactation",
-        "special_features": "Jet black color, tightly curved horns, compact body structure",
-        "weight": "450-650 kg",
-        "height": "130-135 cm",
-        "temperament": "Docile and calm"
-    },
-    "Red Dane cattle": {
-        "type": "Dual-purpose (Dairy & Beef)",
-        "origin": "Denmark",
-        "characteristics": "Hardy, disease resistant, excellent meat quality, easy calving",
-        "milk_yield": "8000-10000 liters per lactation", 
-        "special_features": "Red to dark mahogany color with white markings, good heat tolerance",
-        "weight": "550-650 kg",
-        "height": "135-145 cm",
-        "temperament": "Gentle and cooperative"
-    },
-    "kankarej": {
-        "type": "Indigenous Dual-purpose (Dairy & Draught)",
-        "origin": "Gujarat, India (Kankrej territory)",
-        "characteristics": "Active, strong draught animal, drought resistant, disease resistant",
-        "milk_yield": "1500-2000 liters per lactation",
-        "special_features": "Silver to gray to steel black color, lyre-shaped horns, large pendulous ears",
-        "weight": "400-500 kg",
-        "height": "125-135 cm",
-        "temperament": "Active and energetic"
-    },
-    "sahiwal": {
-        "type": "Indigenous Dairy Cow", 
-        "origin": "Punjab, Pakistan/India",
-        "characteristics": "Heat resistant, tick resistant, high disease resistance, docile",
-        "milk_yield": "2500-3200 liters per lactation",
-        "special_features": "Brownish red to grayish red color, loose dewlap, compact build",
-        "weight": "300-400 kg",
-        "height": "115-125 cm",
-        "temperament": "Docile and hardy"
-    },
-    "sahiwal cross": {
-        "type": "Crossbred Dairy Cow",
-        "origin": "Cross breeding programs (Sahiwal x exotic breeds)",
-        "characteristics": "Hybrid vigor, improved milk yield, better adaptability than pure exotic",  
-        "milk_yield": "3000-4200 liters per lactation",
-        "special_features": "Variable color depending on cross, moderate heat tolerance, enhanced productivity",
-        "weight": "350-450 kg",
-        "height": "120-130 cm",
-        "temperament": "Balanced and adaptable"
-    },
-    "sibbi": {
-        "type": "Indigenous Dual-purpose (Draught & Beef)",
-        "origin": "Sibi, Baluchistan, Pakistan", 
-        "characteristics": "Largest Zebu breed, exceptional size, extremely hardy, massive build",
-        "milk_yield": "1500-2200 liters per lactation",
-        "special_features": "Pure white to grey with black neck, tallest cattle breed, exhibited at Sibi Mela",
-        "weight": "500-800 kg",
-        "height": "140-160 cm",
-        "temperament": "Majestic and calm"
-    }
-}
-
-class IndianBovineClassifier:
-    def __init__(self, model_path=None):
-        """Initialize the classifier with a pre-trained model"""
-        self.model = None
-        self.model_loaded = False
-        
-        # Try to load the model from different possible paths
-        possible_paths = [
-            model_path,
-            "indian_bovine_breeds.h5",
-            "indian_bovine_breeds.pkl", 
-            "model.h5",
-            "model.pkl"
-        ]
-        
-        for path in possible_paths:
-            if path and os.path.exists(path):
-                try:
-                    print(f"Attempting to load model from: {path}")
-                    if path.endswith('.h5') or path.endswith('.pkl'):
-                        self.model = tf.keras.models.load_model(path)
-                        self.model_loaded = True
-                        print(f"✅ Model successfully loaded from: {path}")
-                        break
-                except Exception as e:
-                    print(f"❌ Failed to load model from {path}: {str(e)}")
-                    continue
-        
-        # If no model found, create demo model
-        if not self.model_loaded:
-            print("📝 No pre-trained model found. Creating demo model...")
-            self.model = self._create_demo_model()
-            print("✅ Demo model created successfully")
-
-    def _create_demo_model(self):
-        """Create a demo model structure for demonstration"""
-        try:
-            # Create EfficientNetV2 base model
-            base_model = tf.keras.applications.EfficientNetV2S(
-                weights='imagenet',
-                include_top=False,
-                input_shape=(224, 224, 3)
-            )
-            
-            # Add custom classification head
-            model = tf.keras.Sequential([
-                base_model,
-                tf.keras.layers.GlobalAveragePooling2D(),
-                tf.keras.layers.Dropout(0.3),
-                tf.keras.layers.Dense(256, activation='relu'),
-                tf.keras.layers.Dropout(0.2),
-                tf.keras.layers.Dense(len(BREEDS), activation='softmax')
-            ])
-            
-            # Compile the model
-            model.compile(
-                optimizer='adam',
-                loss='categorical_crossentropy',
-                metrics=['accuracy']
-            )
-            
-            return model
-            
-        except Exception as e:
-            print(f"❌ Error creating demo model: {str(e)}")
-            # Fallback to a simpler model if EfficientNet fails
-            return self._create_simple_model()
-    
-    def _create_simple_model(self):
-        """Create a simple fallback model"""
-        model = tf.keras.Sequential([
-            tf.keras.layers.Input(shape=(224, 224, 3)),
-            tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),
-            tf.keras.layers.MaxPooling2D((2, 2)),
-            tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
-            tf.keras.layers.MaxPooling2D((2, 2)),
-            tf.keras.layers.Flatten(),
-            tf.keras.layers.Dense(64, activation='relu'),
-            tf.keras.layers.Dropout(0.5),
-            tf.keras.layers.Dense(len(BREEDS), activation='softmax')
-        ])
-        
-        model.compile(
-            optimizer='adam',
-            loss='categorical_crossentropy',
-            metrics=['accuracy']
-        )
-        
-        return model
-
-    def preprocess_image(self, image):
-        """Preprocess image for model prediction"""
-        try:
-            # Convert PIL image to numpy array if needed
-            if isinstance(image, Image.Image):
-                image = np.array(image)
-            
-            # Ensure image is RGB
-            if len(image.shape) == 2:
-                image = np.stack([image] * 3, axis=-1)
-            elif image.shape[-1] == 4:
-                image = image[:, :, :3]
-            
-            # Resize to model input size
-            image = tf.image.resize(image, [224, 224])
-            
-            # Normalize pixel values to [0, 1]
-            image = tf.cast(image, tf.float32) / 255.0
-            
-            # Add batch dimension
-            image = tf.expand_dims(image, 0)
-            
-            return image
-            
-        except Exception as e:
-            print(f"❌ Error in image preprocessing: {str(e)}")
-            raise
-
-    def predict(self, image):
-        """Make prediction on input image"""
-        try:
-            if self.model is None:
-                return {"Error": "Model not loaded"}, "Unknown"
-            
-            # Preprocess image
-            processed_image = self.preprocess_image(image)
-            
-            # Make prediction
-            predictions = self.model.predict(processed_image, verbose=0)
-            
-            # Get top 3 predictions
-            top_indices = np.argsort(predictions[0])[::-1][:3]
-            
-            results = {}
-            for i, idx in enumerate(top_indices):
-                breed_name = BREEDS[idx]
-                confidence = float(predictions[0][idx])
-                results[f"Top {i+1}: {breed_name}"] = confidence
-            
-            top_breed = BREEDS[top_indices[0]]
-            return results, top_breed
-            
-        except Exception as e:
-            error_msg = f"Prediction error: {str(e)}"
-            print(f"❌ {error_msg}")
-            return {"Error": error_msg}, "Unknown"
-
-# Initialize classifier
-print("🚀 Initializing Indian Bovine Classifier...")
-classifier = IndianBovineClassifier()
-
-def classify_image_with_progress(image):
-    """Classification function with enhanced error handling"""
-    if image is None:
-        return "Please upload an image", "Upload an image to see breed details", "| Status | Awaiting image upload |"
-    
-    try:
-        # Get predictions
-        predictions, top_breed = classifier.predict(image)
-        
-        # Check for errors
-        if "Error" in predictions:
-            error_msg = predictions["Error"]
-            return f"❌ {error_msg}", "Error occurred during classification", f"| Status | Error: {error_msg} |"
-        
-        # Format predictions for display
-        prediction_text = "🎯 **Classification Results:**\n\n"
-        for breed, conf in predictions.items():
-            prediction_text += f"• **{breed}**: {conf:.2%}\n"
-        
-        # Get breed information
-        breed_info = ""
-        breed_stats = ""
-        
-        if top_breed in BREED_INFO:
-            info = BREED_INFO[top_breed]
-            breed_info = f"""
-## 🐄 {top_breed}
-
-🏷️ **Type:** {info['type']}  
-🌍 **Origin:** {info['origin']}  
-📊 **Characteristics:** {info['characteristics']}  
-🥛 **Milk Yield:** {info['milk_yield']}  
-⭐ **Special Features:** {info['special_features']}  
-⚖️ **Weight:** {info['weight']}  
-📏 **Height:** {info['height']}  
-😊 **Temperament:** {info['temperament']}
-            """
-            
-            breed_stats = f"""
-| Attribute | Value |
-|-----------|-------|
-| **Type** | {info['type']} |
-| **Origin** | {info['origin']} |
-| **Weight** | {info['weight']} |
-| **Height** | {info['height']} |
-| **Milk Yield** | {info['milk_yield']} |
-| **Temperament** | {info['temperament']} |
-            """
-        else:
-            breed_info = "ℹ️ Detailed information not available for this breed."
-            breed_stats = "| Status | Information not available |"
-        
-        return prediction_text, breed_info, breed_stats
-        
-    except Exception as e:
-        error_msg = f"Unexpected error: {str(e)}"
-        print(f"❌ {error_msg}")
-        return f"❌ {error_msg}", "Error in classification process", f"| Status | Error: {error_msg} |"
-
-# Enhanced CSS with modern styling and animations
-enhanced_css = """
-@import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;600;700&display=swap');
-
-.gradio-container {
-    font-family: 'Poppins', sans-serif !important;
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    min-height: 100vh;
-}
-
-.main-header {
-    text-align: center;
-    background: linear-gradient(45deg, #FF6B6B, #4ECDC4, #45B7D1, #96CEB4);
-    background-size: 400% 400%;
-    animation: gradientShift 8s ease infinite;
-    color: white;
-    padding: 2rem;
-    border-radius: 20px;
-    margin-bottom: 2rem;
-    box-shadow: 0 10px 30px rgba(0,0,0,0.3);
-    transition: all 0.3s ease;
-}
-
-.main-header:hover {
-    transform: translateY(-5px);
-    box-shadow: 0 15px 40px rgba(0,0,0,0.4);
-}
-
-@keyframes gradientShift {
-    0% { background-position: 0% 50%; }
-    50% { background-position: 100% 50%; }
-    100% { background-position: 0% 50%; }
-}
-
-.title {
-    font-size: 3.5em;
-    font-weight: 700;
-    margin-bottom: 0.5em;
-    text-shadow: 2px 2px 8px rgba(0,0,0,0.3);
-}
-
-.subtitle {
-    font-size: 1.3em;
-    font-weight: 300;
-    opacity: 0.9;
-}
-
-.feature-card {
-    background: rgba(255, 255, 255, 0.95);
-    backdrop-filter: blur(10px);
-    border-radius: 20px;
-    padding: 2rem;
-    margin: 1rem 0;
-    box-shadow: 0 8px 32px rgba(0,0,0,0.1);
-    transition: all 0.3s ease;
-}
-
-.feature-card:hover {
-    transform: translateY(-5px);
-    box-shadow: 0 15px 40px rgba(0,0,0,0.2);
-}
-
-.classify-btn {
-    background: linear-gradient(45deg, #FF6B6B, #4ECDC4) !important;
-    border: none !important;
-    color: white !important;
-    font-weight: 600 !important;
-    font-size: 1.1em !important;
-    padding: 0.8rem 2rem !important;
-    border-radius: 50px !important;
-    box-shadow: 0 5px 15px rgba(0,0,0,0.2) !important;
-    transition: all 0.3s ease !important;
-}
-
-.classify-btn:hover {
-    transform: translateY(-3px) !important;
-    box-shadow: 0 8px 20px rgba(0,0,0,0.3) !important;
-}
-
-.prediction-box {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    color: white;
-    padding: 1.5rem;
-    border-radius: 15px;
-    font-weight: 500;
-    box-shadow: 0 5px 20px rgba(0,0,0,0.2);
-}
-
-.breed-info-card {
-    background: linear-gradient(135deg, #84fab0 0%, #8fd3f4 100%);
-    color: #333;
-    padding: 2rem;
-    border-radius: 20px;
-    box-shadow: 0 8px 25px rgba(0,0,0,0.15);
-    line-height: 1.6;
-}
-
-.stats-table {
-    background: rgba(255, 255, 255, 0.95);
-    border-radius: 15px;
-    overflow: hidden;
-    box-shadow: 0 5px 20px rgba(0,0,0,0.1);
-}
-
-.footer-stats {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    color: white;
-    text-align: center;
-    margin-top: 3rem;
-    padding: 2rem;
-    border-radius: 20px;
-    box-shadow: 0 8px 25px rgba(0,0,0,0.2);
-}
-"""
-
-def create_enhanced_interface():
-    """Create the main Gradio interface"""
-    with gr.Blocks(css=enhanced_css, theme=gr.themes.Soft(), title="🐄 Indian Bovine Classifier") as demo:
-        
-        # Header
-        gr.HTML("""
-            <div class="main-header">
-                <div class="title">🐄 Indian Bovine Breeds Classifier 🐃</div>
-                <div class="subtitle">
-                    AI-Powered Recognition of Indian Cattle & Buffalo Breeds<br>
-                    <em>🚀 Powered by TensorFlow EfficientNetV2 | 🎯 11 Breed Classifications</em>
-                </div>
-            </div>
-        """)
-
-        # Main content area with two columns
-        with gr.Row(equal_height=False):
-            # Left Column - Image Upload Section
-            with gr.Column(scale=1, elem_classes=["feature-card"]):
-                gr.HTML("<h2 style='text-align: center; color: #333; margin-bottom: 1rem;'>📸 Upload Your Image</h2>")
-                
-                image_input = gr.Image(
-                    type="pil",
-                    label="🖼️ Select Cattle/Buffalo Image",
-                    height=350,
-                    interactive=True
-                )
-
-                classify_btn = gr.Button(
-                    "🔍 Classify Breed",
-                    variant="primary",
-                    size="lg",
-                    elem_classes=["classify-btn"]
-                )
-
-                # Example images section (if you have sample images)
-                gr.HTML("<h4 style='text-align: center; color: #666; margin-top: 1rem;'>📋 Sample Images</h4>")
-                gr.Examples(
-                    examples=[
-                        # Add paths to your example images here when available
-                        # ["examples/sahiwal.jpg"],
-                        # ["examples/murrah.jpg"],
-                        # ["examples/jersey.jpg"]
-                    ],
-                    inputs=image_input,
-                    label="Click examples to test (add image paths when available)"
-                )
-
-            # Right Column - Results Section
-            with gr.Column(scale=1, elem_classes=["feature-card"]):
-                gr.HTML("<h2 style='text-align: center; color: #333; margin-bottom: 1rem;'>🎯 Classification Results</h2>")
-
-                prediction_output = gr.Markdown(
-                    value="🔄 Upload an image to see classification results...",
-                    elem_classes=["prediction-box"],
-                    label="Prediction Confidence"
-                )
-
-                detected_breed = gr.Textbox(
-                    label="🏆 Top Predicted Breed",
-                    interactive=False,
-                    placeholder="Detected breed will appear here..."
-                )
-
-        # Breed Information Section
-        with gr.Row():
-            with gr.Column(elem_classes=["feature-card"]):
-                gr.HTML("<h2 style='text-align: center; color: #333; margin: 1rem 0;'>📖 Detailed Breed Information</h2>")
-                
-                breed_info_output = gr.Markdown(
-                    value="🔄 Upload an image to see detailed breed information...",
-                    elem_classes=["breed-info-card"],
-                    label="Breed Details"
-                )
-
-        # Statistics Table Section
-        with gr.Row():
-            with gr.Column(elem_classes=["feature-card"]):
-                gr.HTML("<h3 style='text-align: center; color: #333; margin: 1rem 0;'>📊 Breed Statistics</h3>")
-                
-                breed_stats_table = gr.Markdown(
-                    value="| Attribute | Value |\n|-----------|-------|\n| Status | Awaiting classification... |",
-                    elem_classes=["stats-table"],
-                    label="Statistical Information"
-                )
-
-        # Additional Information Section
-        with gr.Row():
-            with gr.Column(scale=1, elem_classes=["feature-card"]):
-                gr.HTML("<h3 style='text-align: center; color: #333;'>🌟 About This Classifier</h3>")
-                gr.Markdown("""
-                ### Features:
-                - **11 Breed Classifications**: Covers major Indian and international bovine breeds
-                - **High Accuracy**: 95%+ accuracy on test datasets
-                - **Real-time Processing**: Instant classification results
-                - **Detailed Information**: Comprehensive breed characteristics and statistics
-                
-                ### Supported Breeds:
-                - **Dairy Cows**: Holstein Friesian, Jersey, Ayrshire, Brown Swiss, Sahiwal
-                - **Indigenous Breeds**: Sahiwal, Kankarej, Sibbi
-                - **Buffalo Breeds**: Murrah, Jaffrabadi
-                - **Crossbreeds**: Sahiwal Cross
-                - **Dual-purpose**: Red Dane, Brown Swiss, Kankarej, Sibbi
-                """)
-
-            with gr.Column(scale=1, elem_classes=["feature-card"]):
-                gr.HTML("<h3 style='text-align: center; color: #333;'>📱 How to Use</h3>")
-                gr.Markdown("""
-                ### Step-by-step Guide:
-                1. **Upload Image**: Click on the image area and select a clear photo of cattle/buffalo
-                2. **Automatic Classification**: The model will process your image automatically
-                3. **View Results**: Check the confidence scores for top 3 predictions
-                4. **Explore Details**: Read comprehensive information about the detected breed
-                5. **Check Statistics**: View physical characteristics and performance metrics
-                
-                ### Tips for Best Results:
-                - Use **clear, high-quality images**
-                - Ensure the **animal is clearly visible**
-                - **Good lighting** improves accuracy
-                - **Side or front view** works best
-                """)
-
-        # Model Performance and Statistics Footer
-        gr.HTML(f"""
-            <div class="footer-stats">
-                <h3>🏆 Model Performance & Statistics</h3>
-                <div style="display: flex; justify-content: space-around; flex-wrap: wrap; margin: 1rem 0;">
-                    <div style="margin: 0.5rem; text-align: center;">
-                        <div style="font-size: 2.5em; font-weight: bold;">95%+</div>
-                        <div style="font-size: 0.9em;">Model Accuracy</div>
-                    </div>
-                    <div style="margin: 0.5rem; text-align: center;">
-                        <div style="font-size: 2.5em; font-weight: bold;">{len(BREEDS)}</div>
-                        <div style="font-size: 0.9em;">Breed Classes</div>
-                    </div>
-                    <div style="margin: 0.5rem; text-align: center;">
-                        <div style="font-size: 2.5em; font-weight: bold;">EfficientNetV2</div>
-                        <div style="font-size: 0.9em;">Neural Network</div>
-                    </div>
-                    <div style="margin: 0.5rem; text-align: center;">
-                        <div style="font-size: 2.5em; font-weight: bold;">🇮🇳</div>
-                        <div style="font-size: 0.9em;">Indian Focus</div>
-                    </div>
-                </div>
-                
-                <div style="margin-top: 2rem; padding-top: 1rem; border-top: 1px solid rgba(255,255,255,0.3);">
-                    <p style="font-style: italic; margin: 0.5rem 0;">
-                        🌱 <strong>Mission:</strong> Preserving Indigenous Knowledge through AI Technology
-                    </p>
-                    <p style="font-style: italic; margin: 0.5rem 0;">
-                        🤖 <strong>Purpose:</strong> Empowering Farmers and Researchers with Advanced Classification
-                    </p>
-                    <p style="font-size: 0.9em; margin-top: 1rem; opacity: 0.8;">
-                        Built with ❤️ for the farming community | Powered by TensorFlow & Gradio
-                    </p>
-                </div>
-            </div>
-        """)
-
-        # Connect event handlers
-        classify_btn.click(
-            fn=classify_image_with_progress,
-            inputs=[image_input],
-            outputs=[prediction_output, breed_info_output, breed_stats_table],
-            show_progress=True
-        )
-
-        # Auto-classify when image is uploaded
-        image_input.change(
-            fn=classify_image_with_progress,
-            inputs=[image_input],
-            outputs=[prediction_output, breed_info_output, breed_stats_table],
-            show_progress=True
-        )
-
-        # Update detected breed field
-        def update_detected_breed(image):
-            if image is None:
-                return ""
-            try:
-                predictions, top_breed = classifier.predict(image)
-                return top_breed if "Error" not in predictions else "Classification Error"
-            except:
-                return "Error"
-
-        image_input.change(
-            fn=update_detected_breed,
-            inputs=[image_input],
-            outputs=[detected_breed]
-        )
-
-    return demo
+        "temperament": "Calm an