Create app.py

app.py

@@ -0,0 +1,241 @@
+import streamlit as st
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import pandas as pd
+import matplotlib.pyplot as plt
+import plotly.express as px
+
+# Configure page
+st.set_page_config(
+    page_title="ML Model Demo",
+    page_icon="🤖",
+    layout="wide"
+)
+
+@st.cache_resource
+def load_model():
+    """Load your model (cached to avoid reloading)"""
+    try:
+        # Replace this with your actual model loading
+        # Example: model = tf.keras.models.load_model('path/to/your/model.h5')
+        
+        # For demonstration, we'll create a simple model
+        model = tf.keras.Sequential([
+            tf.keras.layers.Dense(64, activation='relu', input_shape=(4,)),
+            tf.keras.layers.Dense(32, activation='relu'),
+            tf.keras.layers.Dense(3, activation='softmax')
+        ])
+        
+        st.success("✅ Model loaded successfully!")
+        return model
+        
+    except Exception as e:
+        st.error(f"❌ Error loading model: {str(e)}")
+        return None
+
+def preprocess_image(image):
+    """Preprocess image for model input"""
+    # Resize image to expected dimensions
+    image = image.resize((224, 224))
+    # Convert to array and normalize
+    image_array = np.array(image) / 255.0
+    # Add batch dimension
+    return np.expand_dims(image_array, axis=0)
+
+def make_prediction(model, input_data, input_type):
+    """Make prediction with the model"""
+    if model is None:
+        return "❌ Model not available"
+    
+    try:
+        if input_type == "image":
+            # Process image prediction
+            processed_input = preprocess_image(input_data)
+            # Mock prediction for demo
+            prediction = np.random.rand(1, 3)
+            classes = ['Class A', 'Class B', 'Class C']
+            predicted_class = classes[np.argmax(prediction)]
+            confidence = np.max(prediction) * 100
+            
+            return {
+                'predicted_class': predicted_class,
+                'confidence': confidence,
+                'all_predictions': dict(zip(classes, prediction[0]))
+            }
+            
+        elif input_type == "numeric":
+            # Process numeric prediction
+            prediction = model.predict(input_data.reshape(1, -1))
+            predicted_class = f"Class {np.argmax(prediction[0])}"
+            confidence = np.max(prediction[0]) * 100
+            
+            return {
+                'predicted_class': predicted_class,
+                'confidence': confidence,
+                'raw_output': prediction[0].tolist()
+            }
+            
+        elif input_type == "text":
+            # Mock text processing
+            return {
+                'sentiment': 'Positive',
+                'confidence': 85.6,
+                'keywords': ['example', 'text', 'analysis']
+            }
+            
+    except Exception as e:
+        return f"❌ Prediction error: {str(e)}"
+
+def main():
+    # Header
+    st.title("🤖 Machine Learning Model Demo")
+    st.markdown("---")
+    
+    # Sidebar
+    st.sidebar.header("🎛️ Model Controls")
+    
+    # Load model
+    with st.spinner("Loading model..."):
+        model = load_model()
+    
+    # Model selection
+    model_type = st.sidebar.selectbox(
+        "Select Model Type:",
+        ["Image Classification", "Numeric Prediction", "Text Analysis"]
+    )
+    
+    # Main content area
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        if model_type == "Image Classification":
+            st.subheader("📸 Image Classification")
+            
+            uploaded_file = st.file_uploader(
+                "Upload an image:",
+                type=['jpg', 'jpeg', 'png', 'bmp'],
+                help="Supported formats: JPG, JPEG, PNG, BMP"
+            )
+            
+            if uploaded_file is not None:
+                # Display uploaded image
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+                
+                # Prediction button
+                if st.button("🔍 Classify Image", type="primary"):
+                    with st.spinner("Analyzing image..."):
+                        result = make_prediction(model, image, "image")
+                    
+                    if isinstance(result, dict):
+                        st.success(f"**Prediction:** {result['predicted_class']}")
+                        st.info(f"**Confidence:** {result['confidence']:.1f}%")
+                        
+                        # Show all predictions
+                        st.subheader("All Predictions:")
+                        for class_name, prob in result['all_predictions'].items():
+                            st.write(f"• {class_name}: {prob*100:.1f}%")
+                    else:
+                        st.error(result)
+        
+        elif model_type == "Numeric Prediction":
+            st.subheader("🔢 Numeric Prediction")
+            
+            # Input parameters
+            col_a, col_b = st.columns(2)
+            
+            with col_a:
+                param1 = st.number_input("Parameter 1:", value=5.0, step=0.1)
+                param2 = st.number_input("Parameter 2:", value=3.2, step=0.1)
+            
+            with col_b:
+                param3 = st.number_input("Parameter 3:", value=1.4, step=0.1)
+                param4 = st.number_input("Parameter 4:", value=0.2, step=0.1)
+            
+            # Create input array
+            input_array = np.array([param1, param2, param3, param4])
+            
+            if st.button("🚀 Make Prediction", type="primary"):
+                with st.spinner("Computing prediction..."):
+                    result = make_prediction(model, input_array, "numeric")
+                
+                if isinstance(result, dict):
+                    st.success(f"**Prediction:** {result['predicted_class']}")
+                    st.info(f"**Confidence:** {result['confidence']:.1f}%")
+                    
+                    # Visualization
+                    fig, ax = plt.subplots()
+                    ax.bar(range(len(result['raw_output'])), result['raw_output'])
+                    ax.set_xlabel('Class')
+                    ax.set_ylabel('Probability')
+                    ax.set_title('Prediction Probabilities')
+                    st.pyplot(fig)
+                else:
+                    st.error(result)
+        
+        elif model_type == "Text Analysis":
+            st.subheader("📝 Text Analysis")
+            
+            text_input = st.text_area(
+                "Enter your text:",
+                placeholder="Type your text here for analysis...",
+                height=150
+            )
+            
+            if st.button("📊 Analyze Text", type="primary") and text_input.strip():
+                with st.spinner("Analyzing text..."):
+                    result = make_prediction(model, text_input, "text")
+                
+                if isinstance(result, dict):
+                    st.success(f"**Sentiment:** {result['sentiment']}")
+                    st.info(f"**Confidence:** {result['confidence']:.1f}%")
+                    
+                    st.subheader("Keywords:")
+                    for keyword in result['keywords']:
+                        st.write(f"• {keyword}")
+                else:
+                    st.error(result)
+    
+    with col2:
+        st.subheader("📊 Model Info")
+        
+        # Model statistics (mock data)
+        metrics = {
+            'Accuracy': 94.2,
+            'Precision': 91.8,
+            'Recall': 93.5,
+            'F1-Score': 92.6
+        }
+        
+        for metric, value in metrics.items():
+            st.metric(metric, f"{value}%")
+        
+        # Additional info
+        st.markdown("---")
+        st.subheader("ℹ️ About")
+        st.info("""
+        **Model Details:**
+        - Framework: TensorFlow 2.13
+        - Architecture: Deep Neural Network
+        - Training Data: Custom dataset
+        - Last Updated: July 2025
+        """)
+        
+        # Usage stats (mock)
+        st.markdown("---")
+        st.subheader("📈 Usage Stats")
+        usage_data = pd.DataFrame({
+            'Day': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
+            'Predictions': [45, 52, 38, 61, 49]
+        })
+        
+        fig = px.bar(usage_data, x='Day', y='Predictions', title='Daily Predictions')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("Built with ❤️ using Streamlit and TensorFlow")
+
+if __name__ == "__main__":
+    main()