Update app.py

app.py

@@ -4,55 +4,67 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 from sklearn.datasets import load_iris
 from sklearn.model_selection import train_test_split
-from sklearn.neighbors import KNeighborsClassifier
 from sklearn.preprocessing import StandardScaler
 from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
+from sklearn.tree import DecisionTreeClassifier, plot_tree
+from sklearn.neighbors import KNeighborsClassifier
 
 # Set up page
-st.set_page_config(page_title="Explore KNN Algorithm", layout="wide")
-st.title("📍 K-Nearest Neighbors (KNN): Explained with Iris Dataset")
+st.set_page_config(page_title="ML Algorithms Explorer", layout="wide")
+st.title("🌸 ML Classifiers with Iris Dataset: KNN & Decision Tree")
 
-# Intro Section
-st.markdown("""
-## 🧠 What is K-Nearest Neighbors?
-**KNN** is a simple and intuitive machine learning algorithm that makes predictions based on the **majority class of the K closest data points** in the feature space.
-> 🧭 Think of it like asking your neighbors what they think — you take the majority opinion.
-
----
-## ⚙️ How KNN Works
-1. Choose the number of neighbors **K**.
-2. Calculate distance (usually **Euclidean**) between points.
-3. Pick the **K closest data points**.
-4. Predict the class that occurs most frequently among them.
-
-🔍 Distance Metrics:
-- Euclidean (default)
-- Manhattan
-- Minkowski
-
----
-### 📈 Pros and Cons
-✅ Simple to understand  
-✅ No training time (lazy learner)  
-✅ Works well with small datasets  
-⚠️ Slow on large datasets  
-⚠️ Needs feature scaling  
-⚠️ Sensitive to outliers and irrelevant features
----
-""")
-
-# Dataset and DataFrame
-st.subheader("🌼 Let's Explore the Iris Dataset")
+# Sidebar: Choose algorithm
+st.sidebar.header("⚙️ Algorithm Selection")
+model_choice = st.sidebar.selectbox("Choose a classifier", ["K-Nearest Neighbors (KNN)", "Decision Tree"])
+
+# Dataset
 iris = load_iris()
 df = pd.DataFrame(iris.data, columns=iris.feature_names)
 df["target"] = iris.target
 df["species"] = df["target"].apply(lambda x: iris.target_names[x])
 
-st.markdown("Here's a peek at the dataset 👇")
+# Intro Section
+if model_choice == "K-Nearest Neighbors (KNN)":
+    st.markdown("""
+    ## 📍 K-Nearest Neighbors (KNN)
+    **KNN** is a simple and intuitive algorithm that predicts based on the majority class of the K nearest data points.
+    > 🧭 It's like asking your closest neighbors for advice!
+
+    ---
+    ### ⚙️ How It Works:
+    1. Choose **K**.
+    2. Calculate distances.
+    3. Pick the **K closest**.
+    4. Predict the most frequent class.
+    """)
+    st.sidebar.subheader("KNN Settings")
+    n_neighbors = st.sidebar.slider("Number of Neighbors (K)", 1, 15, 5)
+    metric = st.sidebar.selectbox("Distance Metric", ["euclidean", "manhattan", "minkowski"])
+    model = KNeighborsClassifier(n_neighbors=n_neighbors, metric=metric)
+    
+else:
+    st.markdown("""
+    ## 🌳 Decision Tree Classifier
+    A **Decision Tree** splits data based on feature values to build a tree-like model for decision-making.
+    > 🧩 Think of it like playing "20 Questions" — each answer narrows things down!
+
+    ---
+    ### ⚙️ How It Works:
+    1. Pick the best feature to split.
+    2. Repeat until data is separated.
+    3. Result: A tree structure for classification.
+    """)
+    st.sidebar.subheader("Decision Tree Settings")
+    criterion = st.sidebar.radio("Splitting Criterion", ["gini", "entropy"])
+    max_depth = st.sidebar.slider("Max Depth", 1, 10, value=3)
+    model = DecisionTreeClassifier(criterion=criterion, max_depth=max_depth, random_state=42)
+
+# Show dataset
+st.subheader("🌼 Iris Dataset Preview")
 st.dataframe(df.head(), use_container_width=True)
 
-# Feature distribution visualization
-st.markdown("### 📊 Visualize Features")
+# Feature visualization
+st.markdown("### 📊 Feature Visualization")
 selected_features = st.multiselect("Pick features to visualize", iris.feature_names, default=iris.feature_names[:2])
 if len(selected_features) == 2:
     plt.figure(figsize=(8, 5))
@@ -60,26 +72,19 @@ if len(selected_features) == 2:
     st.pyplot(plt.gcf())
     plt.clf()
 
-# Sidebar controls
-st.sidebar.header("📍 KNN Model Settings")
-n_neighbors = st.sidebar.slider("Number of Neighbors (K)", 1, 15, value=5)
-metric = st.sidebar.selectbox("Distance Metric", ["euclidean", "manhattan", "minkowski"])
-
-# Prepare data
+# Prepare and scale data
 X = df[iris.feature_names]
 y = df["target"]
 
 scaler = StandardScaler()
 X_scaled = scaler.fit_transform(X)
-
 X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
 
 # Train model
-model = KNeighborsClassifier(n_neighbors=n_neighbors, metric=metric)
 model.fit(X_train, y_train)
 y_pred = model.predict(X_test)
 
-# Model performance
+# Accuracy
 acc = accuracy_score(y_test, y_pred)
 st.success(f"✅ Model Accuracy: {acc*100:.2f}%")
 
@@ -96,19 +101,31 @@ plt.xlabel("Predicted")
 plt.ylabel("Actual")
 st.pyplot(fig)
 
-# Final tips
-st.markdown("""
----
-## 💡 Key Takeaways
-- KNN is **non-parametric** and easy to implement.
-- It’s a **lazy learner** — no training, just prediction.
-- Sensitive to **scaling**, **K value**, and **irrelevant features**.
-## 📌 When to Use KNN?
-- When you want a **simple baseline model**.
-- For **small- to medium-sized** datasets.
-- When your features are properly scaled and meaningful.
-> 🎯 *Tip:* Use cross-validation to choose the optimal value of **K** and avoid overfitting!
----
-""")
+# Tree plot if applicable
+if model_choice == "Decision Tree":
+    st.markdown("### 🌳 Tree Visualization")
+    fig, ax = plt.subplots(figsize=(12, 6))
+    plot_tree(model, filled=True, feature_names=iris.feature_names, class_names=iris.target_names, fontsize=10)
+    st.pyplot(fig)
+
+# Key takeaways
+st.markdown("---")
+if model_choice == "K-Nearest Neighbors (KNN)":
+    st.markdown("""
+    ## 💡 KNN Takeaways
+    - No training phase — just prediction.
+    - Simple and powerful for small datasets.
+    - Needs **scaling** and is sensitive to **irrelevant features**.
+    > 🎯 Use GridSearchCV to find the best **K**!
+    """)
+else:
+    st.markdown("""
+    ## 💡 Decision Tree Takeaways
+    - Easy to interpret and visualize.
+    - Can overfit without depth control.
+    - Works on both numeric and categorical features.
+    > 🎯 Combine trees using **Random Forest** or **Boosting** for better performance!
+    """)
+