Create app.py

app.py

@@ -0,0 +1,466 @@
+"""
+🦋 Butterfly Species Classifier - Streamlit Web App
+Production-ready web interface for butterfly identification
+Features:
+- Upload butterfly images
+- Get instant predictions
+- View top-5 most likely species
+- Confidence visualization
+- Beautiful, user-friendly interface
+"""
+
+import streamlit as st
+import tensorflow as tf
+from tensorflow import keras
+import numpy as np
+from PIL import Image
+import json
+import os
+import plotly.graph_objects as go
+from datetime import datetime
+import warnings
+warnings.filterwarnings('ignore')
+
+# Page configuration
+st.set_page_config(
+    page_title="🦋 Butterfly Classifier",
+    page_icon="🦋",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: bold;
+        text-align: center;
+        color: #10b981;
+        margin-bottom: 0.5rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        text-align: center;
+        color: #6b7280;
+        margin-bottom: 2rem;
+    }
+    .prediction-card {
+        background-color: #f0fdf4;
+        padding: 1.5rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #10b981;
+        margin: 1rem 0;
+    }
+    .confidence-high {
+        color: #10b981;
+        font-weight: bold;
+    }
+    .confidence-medium {
+        color: #f59e0b;
+        font-weight: bold;
+    }
+    .confidence-low {
+        color: #ef4444;
+        font-weight: bold;
+    }
+    .stButton>button {
+        width: 100%;
+        background-color: #10b981;
+        color: white;
+        font-weight: bold;
+        padding: 0.75rem;
+        border-radius: 0.5rem;
+        border: none;
+        font-size: 1.1rem;
+    }
+    .stButton>button:hover {
+        background-color: #059669;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+@st.cache_resource
+def load_model_and_classes():
+    """Load the trained model and class indices with caching"""
+    try:
+        # Model path - using .keras format
+        model_path = 'butterfly_model_WORKING.keras'
+        
+        # Check if model exists
+        if not os.path.exists(model_path):
+            st.error(f"❌ Model not found at: {model_path}")
+            st.info("""
+            **Setup Instructions:**
+            1. Place `butterfly_model_best.keras` in `models/` directory
+            2. Place `class_indices.json` in the project root
+            3. Restart the Streamlit app
+            """)
+            return None, None, None
+        
+        st.info(f"📂 Loading model from: {model_path}")
+        
+        # Load model
+        model = None
+        try:
+            # Load with compile=False for faster loading
+            model = keras.models.load_model(model_path, compile=False)
+            
+            # Compile for predictions
+            model.compile(
+                optimizer='adam',
+                loss='categorical_crossentropy',
+                metrics=['accuracy']
+            )
+            
+            st.success("✅ Model loaded successfully!")
+            
+        except Exception as e:
+            st.error(f"❌ Failed to load model: {e}")
+            st.info("""
+            **Troubleshooting:**
+            1. Make sure you have the .keras file (not .h5)
+            2. File should be ~173 MB
+            3. Run: `ls -lh models/butterfly_model_best.keras`
+            """)
+            return None, None, None
+        
+        # Load class indices
+        class_indices_path = 'class_indices.json'
+        if not os.path.exists(class_indices_path):
+            st.error(f"❌ Class indices not found: {class_indices_path}")
+            st.info("Run: `python generate_json_files.py` to create it")
+            return None, None, None
+            
+        with open(class_indices_path, 'r') as f:
+            class_indices = json.load(f)
+        
+        # Create reverse mapping (index -> class name)
+        idx_to_class = {v: k for k, v in class_indices.items()}
+        
+        st.success(f"✅ Loaded {len(class_indices)} butterfly species")
+        
+        return model, class_indices, idx_to_class
+        
+    except Exception as e:
+        st.error(f"❌ Unexpected error: {e}")
+        import traceback
+        with st.expander("Show error details"):
+            st.code(traceback.format_exc())
+        return None, None, None
+
+
+def preprocess_image(image, target_size=(224, 224)):
+    """Preprocess image for model prediction"""
+    # Resize image
+    image = image.resize(target_size)
+    
+    # Convert to array and normalize to [0, 1]
+    img_array = np.array(image, dtype=np.float32) / 255.0
+    
+    # Add batch dimension
+    img_array = np.expand_dims(img_array, axis=0)
+    
+    return img_array
+
+
+def get_confidence_color(confidence):
+    """Return CSS class based on confidence level"""
+    if confidence >= 0.7:
+        return "confidence-high"
+    elif confidence >= 0.4:
+        return "confidence-medium"
+    else:
+        return "confidence-low"
+
+
+def get_confidence_interpretation(confidence):
+    """Return human-readable confidence interpretation"""
+    if confidence >= 0.9:
+        return "Very High Confidence"
+    elif confidence >= 0.7:
+        return "High Confidence"
+    elif confidence >= 0.5:
+        return "Medium Confidence"
+    elif confidence >= 0.3:
+        return "Low Confidence"
+    else:
+        return "Very Low Confidence"
+
+
+def create_confidence_gauge(confidence, species_name):
+    """Create a beautiful confidence gauge using Plotly"""
+    # Determine color based on confidence
+    if confidence >= 0.7:
+        bar_color = "#10b981"  # Green
+    elif confidence >= 0.4:
+        bar_color = "#f59e0b"  # Yellow
+    else:
+        bar_color = "#ef4444"  # Red
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=confidence * 100,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': f"Confidence", 'font': {'size': 20}},
+        number={'suffix': "%", 'font': {'size': 40}},
+        gauge={
+            'axis': {'range': [0, 100], 'tickwidth': 2, 'tickcolor': "darkgray"},
+            'bar': {'color': bar_color, 'thickness': 0.75},
+            'bgcolor': "white",
+            'borderwidth': 2,
+            'bordercolor': "gray",
+            'steps': [
+                {'range': [0, 40], 'color': '#fee2e2'},
+                {'range': [40, 70], 'color': '#fef3c7'},
+                {'range': [70, 100], 'color': '#d1fae5'}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 50
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        height=300,
+        margin=dict(l=20, r=20, t=60, b=20),
+        paper_bgcolor="rgba(0,0,0,0)",
+        font={'family': "Arial, sans-serif"}
+    )
+    
+    return fig
+
+
+def create_top_predictions_chart(predictions, idx_to_class, top_k=5):
+    """Create horizontal bar chart for top predictions"""
+    # Get top k predictions
+    top_indices = np.argsort(predictions[0])[-top_k:][::-1]
+    top_species = [idx_to_class[i] for i in top_indices]
+    top_confidences = predictions[0][top_indices] * 100
+    
+    # Create color scale based on confidence
+    colors = []
+    for c in top_confidences:
+        if c >= 70:
+            colors.append('#10b981')  # Green
+        elif c >= 40:
+            colors.append('#f59e0b')  # Yellow
+        else:
+            colors.append('#ef4444')  # Red
+    
+    fig = go.Figure(go.Bar(
+        x=top_confidences,
+        y=top_species,
+        orientation='h',
+        marker=dict(color=colors),
+        text=[f'{c:.1f}%' for c in top_confidences],
+        textposition='auto',
+        textfont=dict(size=14, color='white', family='Arial Black')
+    ))
+    
+    fig.update_layout(
+        title=f"Top {top_k} Most Likely Species",
+        xaxis_title="Confidence (%)",
+        yaxis_title="Species",
+        height=300,
+        margin=dict(l=20, r=20, t=60, b=20),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font={'family': "Arial, sans-serif", 'size': 12},
+        xaxis=dict(gridcolor='lightgray', range=[0, 100]),
+        yaxis=dict(autorange="reversed")
+    )
+    
+    return fig
+
+
+def main():
+    # Header
+    st.markdown('<p class="main-header">🦋 Butterfly Species Classifier</p>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Upload a butterfly image to identify its species using AI</p>', unsafe_allow_html=True)
+    
+    # Load model
+    with st.spinner("🔄 Loading AI model..."):
+        model, class_indices, idx_to_class = load_model_and_classes()
+    
+    # Check if model loaded
+    if model is None:
+        st.error("❌ Failed to load model. Please check the setup instructions above.")
+        st.stop()
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("ℹ️ About")
+        st.write(f"""
+        This AI-powered app can identify **{len(class_indices)} different butterfly species** with high accuracy!
+        
+        **How to use:**
+        1. Upload a clear butterfly image
+        2. Click 'Identify Species'
+        3. Get instant predictions!
+        
+        **Best results:**
+        - Clear, well-lit photos
+        - Butterfly in focus
+        - Minimal background clutter
+        """)
+        
+        st.divider()
+        
+        st.header("📊 Model Info")
+        if os.path.exists('model_info.json'):
+            try:
+                with open('model_info.json', 'r') as f:
+                    model_info = json.load(f)
+                st.write(f"**Model:** {model_info.get('best_model', 'MobileNetV2')}")
+                st.write(f"**Accuracy:** {model_info.get('best_model_metrics', {}).get('accuracy', 0.85)*100:.1f}%")
+                st.write(f"**Species:** {model_info.get('num_classes', len(class_indices))}")
+            except:
+                st.write(f"**Species:** {len(class_indices)}")
+        else:
+            st.write(f"**Architecture:** MobileNetV2")
+            st.write(f"**Species:** {len(class_indices)}")
+            st.write(f"**Format:** Keras 3.x (.keras)")
+        
+        st.divider()
+        
+        st.header("🎯 Tips")
+        st.write("""
+        - **High confidence (>70%)**: Very reliable
+        - **Medium (40-70%)**: Generally good
+        - **Low (<40%)**: May need verification
+        """)
+    
+    # Main content
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header("📤 Upload Image")
+        uploaded_file = st.file_uploader(
+            "Choose a butterfly image...",
+            type=['jpg', 'jpeg', 'png'],
+            help="Upload a clear image of a butterfly"
+        )
+        
+        if uploaded_file is not None:
+            # Display uploaded image
+            image = Image.open(uploaded_file).convert('RGB')
+            st.image(image, caption='Uploaded Image', use_container_width=True)
+            
+            # Show image info
+            st.info(f"📐 Image size: {image.size[0]} x {image.size[1]} pixels")
+            
+            # Predict button
+            if st.button("🔍 Identify Species", type="primary"):
+                with st.spinner("🤔 Analyzing butterfly..."):
+                    try:
+                        # Preprocess image
+                        processed_image = preprocess_image(image)
+                        
+                        # Make prediction
+                        predictions = model.predict(processed_image, verbose=0)
+                        
+                        # Get top prediction
+                        top_class_idx = np.argmax(predictions[0])
+                        top_species = idx_to_class[top_class_idx]
+                        top_confidence = float(predictions[0][top_class_idx])
+                        
+                        # Store in session state
+                        st.session_state['predictions'] = predictions
+                        st.session_state['top_species'] = top_species
+                        st.session_state['top_confidence'] = top_confidence
+                        st.session_state['prediction_time'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        
+                        st.success("✅ Prediction complete!")
+                        
+                    except Exception as e:
+                        st.error(f"❌ Prediction failed: {e}")
+                        st.info("Please try uploading a different image.")
+    
+    with col2:
+        st.header("🎯 Results")
+        
+        if 'predictions' in st.session_state:
+            predictions = st.session_state['predictions']
+            top_species = st.session_state['top_species']
+            top_confidence = st.session_state['top_confidence']
+            
+            # Main prediction card
+            confidence_class = get_confidence_color(top_confidence)
+            confidence_text = get_confidence_interpretation(top_confidence)
+            
+            st.markdown(f"""
+            <div class="prediction-card">
+                <h2 style="margin-top: 0; color: #10b981;">Predicted Species</h2>
+                <h1 style="margin: 0.5rem 0; color: #1f2937;">{top_species}</h1>
+                <p style="margin: 0; font-size: 1.5rem;" class="{confidence_class}">
+                    {top_confidence*100:.1f}% - {confidence_text}
+                </p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Confidence gauge
+            st.plotly_chart(
+                create_confidence_gauge(top_confidence, top_species),
+                use_container_width=True
+            )
+            
+            # Additional info
+            st.info(f"🕐 Predicted at: {st.session_state['prediction_time']}")
+        else:
+            st.info("👆 Upload an image and click 'Identify Species' to see results")
+    
+    # Top predictions chart (full width)
+    if 'predictions' in st.session_state:
+        st.divider()
+        st.header("📊 Top 5 Predictions")
+        
+        col_chart1, col_chart2 = st.columns([2, 1])
+        
+        with col_chart1:
+            st.plotly_chart(
+                create_top_predictions_chart(st.session_state['predictions'], idx_to_class, top_k=5),
+                use_container_width=True
+            )
+        
+        with col_chart2:
+            st.subheader("🔍 Interpretation")
+            top_conf = st.session_state['top_confidence']
+            
+            if top_conf >= 0.7:
+                st.success("✅ **High Confidence**")
+                st.write("The model is very sure about this prediction!")
+            elif top_conf >= 0.4:
+                st.warning("⚠️ **Medium Confidence**")
+                st.write("The prediction is likely correct, but consider the alternatives.")
+            else:
+                st.error("❌ **Low Confidence**")
+                st.write("The model is uncertain. This might not be in the training dataset.")
+            
+            st.write("**What to do:**")
+            if top_conf >= 0.7:
+                st.write("- ✅ Trust this prediction")
+                st.write("- 📚 Use for identification")
+            elif top_conf >= 0.4:
+                st.write("- 👀 Check top alternatives")
+                st.write("- 🔍 Verify with expert")
+            else:
+                st.write("- ⚠️ Image may be unclear")
+                st.write("- 🔄 Try a different photo")
+                st.write("- 👤 Consult an expert")
+    
+    # Footer
+    st.divider()
+    st.markdown(f"""
+    <div style="text-align: center; color: #6b7280; padding: 2rem 0;">
+        <p>🦋 <strong>Butterfly Species Classifier</strong> | Created by Arju</p>
+        <p style="font-size: 0.9rem;">Trained on {len(class_indices) if class_indices else 75} species | Built with TensorFlow & Streamlit</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()