Create app.py

app.py

@@ -0,0 +1,171 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+import plotly.express as px
+import plotly.graph_objects as go
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+class IrisPredictor:
+    def __init__(self):
+        self.iris = load_iris()
+        self.df = pd.DataFrame(data=np.c_[self.iris['data'], self.iris['target']], 
+                             columns=self.iris['feature_names'] + ['target'])
+        self.models = {
+            'Logistic Regression': LogisticRegression(),
+            'Decision Tree': DecisionTreeClassifier(),
+            'Random Forest': RandomForestClassifier()
+        }
+        self.X = self.df.drop('target', axis=1)
+        self.y = self.df['target']
+        self.scaler = StandardScaler()
+        
+    def preprocess_data(self):
+        # Split the data
+        X_train, X_test, y_train, y_test = train_test_split(
+            self.X, self.y, test_size=0.2, random_state=42
+        )
+        
+        # Scale the features
+        X_train_scaled = self.scaler.fit_transform(X_train)
+        X_test_scaled = self.scaler.transform(X_test)
+        
+        return X_train_scaled, X_test_scaled, y_train, y_test
+    
+    def train_model(self, model_name):
+        X_train_scaled, X_test_scaled, y_train, y_test = self.preprocess_data()
+        
+        # Train model
+        model = self.models[model_name]
+        model.fit(X_train_scaled, y_train)
+        
+        # Make predictions
+        y_pred = model.predict(X_test_scaled)
+        
+        # Calculate metrics
+        accuracy = accuracy_score(y_test, y_pred)
+        conf_matrix = confusion_matrix(y_test, y_pred)
+        class_report = classification_report(y_test, y_pred)
+        
+        return {
+            'model': model,
+            'accuracy': accuracy,
+            'confusion_matrix': conf_matrix,
+            'classification_report': class_report,
+            'X_test': X_test_scaled,
+            'y_test': y_test,
+            'y_pred': y_pred
+        }
+    
+    def plot_confusion_matrix(self, conf_matrix):
+        fig = px.imshow(conf_matrix,
+                       labels=dict(x="Predicted", y="Actual"),
+                       x=['Setosa', 'Versicolor', 'Virginica'],
+                       y=['Setosa', 'Versicolor', 'Virginica'],
+                       title="Confusion Matrix")
+        return fig
+    
+    def plot_feature_importance(self, model_name, model):
+        if model_name == 'Logistic Regression':
+            importance = abs(model.coef_[0])
+        else:
+            importance = model.feature_importances_
+            
+        fig = px.bar(x=self.X.columns, y=importance,
+                    title=f"Feature Importance - {model_name}",
+                    labels={'x': 'Features', 'y': 'Importance'})
+        return fig
+    
+    def predict_single_sample(self, model, features):
+        # Scale features
+        scaled_features = self.scaler.transform([features])
+        # Make prediction
+        prediction = model.predict(scaled_features)
+        probabilities = model.predict_proba(scaled_features)
+        return prediction[0], probabilities[0]
+
+def main():
+    st.title("🌸 Iris Flower Prediction App")
+    st.write("""
+    This app predicts the Iris flower type based on its features.
+    Choose a model and see how it performs!
+    """)
+    
+    # Initialize predictor
+    predictor = IrisPredictor()
+    
+    # Model selection
+    st.sidebar.header("Model Selection")
+    model_name = st.sidebar.selectbox(
+        "Choose a model",
+        list(predictor.models.keys())
+    )
+    
+    # Train model and show results
+    if st.sidebar.button("Train Model"):
+        with st.spinner("Training model..."):
+            results = predictor.train_model(model_name)
+            
+            # Display metrics
+            st.header("Model Performance")
+            st.metric("Accuracy", f"{results['accuracy']:.2%}")
+            
+            # Display confusion matrix
+            st.subheader("Confusion Matrix")
+            conf_matrix_fig = predictor.plot_confusion_matrix(results['confusion_matrix'])
+            st.plotly_chart(conf_matrix_fig)
+            
+            # Display feature importance
+            st.subheader("Feature Importance")
+            importance_fig = predictor.plot_feature_importance(model_name, results['model'])
+            st.plotly_chart(importance_fig)
+            
+            # Display classification report
+            st.subheader("Classification Report")
+            st.text(results['classification_report'])
+            
+            # Store the trained model in session state
+            st.session_state['trained_model'] = results['model']
+    
+    # Make predictions
+    st.header("Make Predictions")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        sepal_length = st.slider("Sepal Length", 4.0, 8.0, 5.4)
+        sepal_width = st.slider("Sepal Width", 2.0, 4.5, 3.4)
+    
+    with col2:
+        petal_length = st.slider("Petal Length", 1.0, 7.0, 4.7)
+        petal_width = st.slider("Petal Width", 0.1, 2.5, 1.4)
+    
+    if st.button("Predict"):
+        if 'trained_model' in st.session_state:
+            features = [sepal_length, sepal_width, petal_length, petal_width]
+            prediction, probabilities = predictor.predict_single_sample(
+                st.session_state['trained_model'], features
+            )
+            
+            # Display prediction
+            iris_types = ['Setosa', 'Versicolor', 'Virginica']
+            st.success(f"Predicted Iris Type: {iris_types[int(prediction)]}")
+            
+            # Display probability distribution
+            st.subheader("Prediction Probabilities")
+            prob_fig = px.bar(x=iris_types, y=probabilities,
+                            title="Prediction Probability Distribution",
+                            labels={'x': 'Iris Type', 'y': 'Probability'})
+            st.plotly_chart(prob_fig)
+        else:
+            st.warning("Please train a model first!")
+
+if __name__ == "__main__":
+    main()