Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,194 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+# mushroom_app.py
 import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import requests
+from io import StringIO
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# -------------------------
+# Auto Download Mushroom Dataset
+# -------------------------
+@st.cache_data(show_spinner="Downloading Mushroom Dataset from UCI...")
+def load_mushroom_data():
+    url = "https://archive.ics.uci.edu/ml/machine-learning-databases/mushroom/agaricus-lepiota.data"
+    response = requests.get(url)
+    if response.status_code == 200:
+        # Column names as per UCI description
+        columns = [
+            'class', 'cap-shape', 'cap-surface', 'cap-color', 'bruises', 'odor',
+            'gill-attachment', 'gill-spacing', 'gill-size', 'gill-color',
+            'stalk-shape', 'stalk-root', 'stalk-surface-above-ring',
+            'stalk-surface-below-ring', 'stalk-color-above-ring',
+            'stalk-color-below-ring', 'veil-type', 'veil-color', 'ring-number',
+            'ring-type', 'spore-print-color', 'population', 'habitat'
+        ]
+        df = pd.read_csv(StringIO(response.text), header=None, names=columns)
+        return df
+    else:
+        st.error("Failed to download dataset.")
+        return None
+
+# Load data
+df = load_mushroom_data()
+if df is None:
+    st.stop()
+
+st.set_page_config(page_title="Mushroom Classification", layout="centered")
+st.title("Mushroom Classification")
+st.markdown("### Is it *Edible* or *Poisonous*?")
+st.success(f"Dataset loaded: {df.shape[0]:,} mushrooms | {df.shape[1]} features")
+
+# Show sample
+st.write("First 10 mushrooms:")
+st.dataframe(df.head(10), use_container_width=True)
+
+# Mapping
+class_map = {'e': 'Edible', 'p': 'Poisonous'}
+st.write("*Target Distribution:*")
+col1, col2 = st.columns(2)
+with col1:
+    st.metric("Edible (e)", df['class'].value_counts().get('e', 0))
+with col2:
+    st.metric("Poisonous (p)", df['class'].value_counts().get('p', 0))
+
+# Encode categorical features
+@st.cache_data
+def preprocess_data(df):
+    le_dict = {}
+    df_encoded = df.copy()
+    
+    for column in df.columns:
+        le = LabelEncoder()
+        df_encoded[column] = le.fit_transform(df[column])
+        le_dict[column] = le
+    
+    X = df_encoded.drop('class', axis=1)
+    y = df_encoded['class']
+    
+    return X, y, le_dict, df_encoded
+
+X, y, label_encoders, df_encoded = preprocess_data(df)
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
+
+# -------------------------
+# Train Model
+# -------------------------
+st.header("Train Random Forest Model (Best for this dataset)")
+if st.button("Train Model Now", type="primary"):
+    with st.spinner("Training Random Forest... (this dataset is 100% separable!)"):
+        model = RandomForestClassifier(n_estimators=100, random_state=42)
+        model.fit(X_train, y_train)
+        
+        y_pred = model.predict(X_test)
+        acc = accuracy_score(y_test, y_pred)
+        
+        st.success(f"Model Trained! Accuracy: {acc*100:.2f}%")
+        
+        if acc >= 0.999:
+            st.balloons()
+            st.markdown("### PERFECT CLASSIFICATION! (100% Accuracy)")
+
+        # Confusion Matrix
+        cm = confusion_matrix(y_test, y_pred)
+        fig, ax = plt.subplots(figsize=(6,5))
+        sns.heatmap(cm, annot=True, fmt='d', cmap="Greens", ax=ax,
+                    xticklabels=['Edible', 'Poisonous'],
+                    yticklabels=['Edible', 'Poisonous'])
+        ax.set_xlabel("Predicted")
+        ax.set_ylabel("Actual")
+        ax.set_title("Confusion Matrix")
+        st.pyplot(fig)
+
+        # Classification Report
+        report = classification_report(y_test, y_pred, target_names=['Edible', 'Poisonous'], output_dict=True)
+        report_df = pd.DataFrame(report).transpose()
+        st.write("### Classification Report")
+        st.dataframe(report_df.style.format("{:.3f}"))
+
+        # Save model
+        joblib.dump({
+            "model": model,
+            "label_encoders": label_encoders,
+            "features": X.columns.tolist()
+        }, "mushroom_model.pkl")
+        
+        with open("mushroom_model.pkl", "rb") as f:
+            st.download_button("Download Model (.pkl)", f, "mushroom_model.pkl")
+
+# -------------------------
+# Single Prediction (Perfect & Safe)
+# -------------------------
+st.header("Will You Eat This Mushroom?")
+st.markdown("Select features of a mushroom to predict if it's *safe to eat*")
+
+# Load model if trained
+model = None
+if 'model' in globals() or st.session_state.get("model_trained", False):
+    try:
+        loaded = joblib.load("mushroom_model.pkl")
+        model = loaded["model"]
+        label_encoders = loaded["label_encoders"]
+        st.session_state.model_trained = True
+    except:
+        pass
+
+if model is None:
+    st.info("Train the model above first to make predictions!")
+else:
+    cols = st.columns(3)
+    inputs = {}
+    
+    feature_descriptions = {
+        'cap-shape': ['bell', 'conical', 'flat', 'knobbed', 'sunken', 'convex'],
+        'cap-surface': ['fibrous', 'grooves', 'smooth', 'scaly'],
+        'cap-color': ['buff', 'cinnamon', 'red', 'gray', 'brown', 'pink', 'green', 'purple', 'white', 'yellow'],
+        'bruises': ['yes', 'no'],
+        'odor': ['almond', 'creosote', 'foul', 'anise', 'musty', 'none', 'pungent', 'spicy', 'fishy'],
+        'gill-color': ['buff', 'red', 'gray', 'chocolate', 'black', 'brown', 'orange', 'pink', 'green', 'purple', 'white', 'yellow'],
+        'stalk-shape': ['enlarging', 'tapering'],
+        'stalk-root': ['bulbous', 'club', 'equal', 'rooted', 'missing'],
+        'spore-print-color': ['black', 'brown', 'buff', 'chocolate', 'green', 'orange', 'purple', 'white', 'yellow'],
+        'population': ['abundant', 'clustered', 'numerous', 'scattered', 'several', 'solitary'],
+        'habitat': ['woods', 'grasses', 'leaves', 'meadows', 'paths', 'urban', 'waste']
+    }
+
+    selected = {}
+    for i, col in enumerate(X.columns):
+        with cols[i % 3]:
+            options = feature_descriptions.get(col, ['?'])
+            idx = st.selectbox(f"{col.replace('-', ' ').title()}", options, key=col)
+            # Map to encoded value
+            original_values = label_encoders[col].classes_
+            if idx in original_values:
+                encoded_val = label_encoders[col].transform([idx])[0]
+                selected[col] = encoded_val
+
+    if st.button("Predict Edible or Poisonous?", type="secondary"):
+        input_vec = [selected[f] for f in X.columns]
+        input_df = pd.DataFrame([input_vec], columns=X.columns)
+        
+        pred = model.predict(input_df)[0]
+        prob = model.predict_proba(input_df)[0]
+        
+        if pred == label_encoders['class'].transform(['e'])[0]:
+            st.success("EDIBLE & SAFE TO EAT!")
+            st.balloons()
+        else:
+            st.error("POISONOUS! DO NOT EAT!")
+            st.warning("This mushroom is highly toxic!")
+
+        col1, col2 = st.columns(2)
+        col1.metric("Edible Probability", f"{prob[0]:.1%}")
+        col2.metric("Poisonous Probability", f"{prob[1]:.1%}")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.markdown("---")
+st.caption("Mushroom Classification • UCI Dataset • 100% Accuracy Possible • Built with Streamlit")