Update app.py

app.py

@@ -1,160 +1,114 @@
 import streamlit as st
+import pandas as pd
+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
 
-# Set page configuration
-st.set_page_config(page_title="Decision Tree Theory", layout="wide")
+# Set up page
+st.set_page_config(page_title="Explore KNN Algorithm", layout="wide")
+st.title("📍 K-Nearest Neighbors (KNN): Explained with Iris Dataset")
 
-# Custom CSS styling
+# Intro Section
 st.markdown("""
-    <style>
-        .stApp {
-            background-color: #4A90E2;
-        }
-        h1, h2, h3 {
-            color: #003366;
-        }
-        .custom-font, p {
-            font-family: 'Arial', sans-serif;
-            font-size: 18px;
-            color: white;
-            line-height: 1.6;
-        }
-    </style>
-    """, unsafe_allow_html=True)
-
-# Title
-st.markdown("<h1 style='color: #003366;'>Understanding Decision Trees</h1>", unsafe_allow_html=True)
-
-# Introduction
-st.markdown("""
-    A **Decision Tree** is a versatile supervised learning algorithm used for both **classification** and **regression** tasks. It mimics human decision-making by using a tree-like model of decisions and their possible consequences.
-    
-    The basic structure includes:
-    - **Root Node**: Represents the complete dataset.
-    - **Internal Nodes**: Represent conditions on features.
-    - **Leaf Nodes**: Represent outcomes or predictions.
-    
-    Think of it as a flowchart where each internal node asks a question, and each branch represents the outcome, eventually leading to a final decision.
-""", unsafe_allow_html=True)
-
-# Entropy
-st.markdown("<h2 style='color: #003366;'>Entropy: Quantifying Uncertainty</h2>", unsafe_allow_html=True)
-st.markdown("""
-    **Entropy** measures the amount of randomness or disorder in the data. It’s commonly used in classification problems to decide how informative a feature is.
-    
-    Entropy formula:
-""")
-st.image("entropy-formula-2.jpg", width=300)
-st.markdown("""
-    Where:
-    - \( p(i) \) is the probability of class \( i \).
-    
-    **Example**:
-    - If \( P(Yes) = 0.5 \), \( P(No) = 0.5 \),
-    
-    Then:
-    $$ H(Y) = - (0.5 \cdot \log_2(0.5) + 0.5 \cdot \log_2(0.5)) = 1 $$
-    
-    This indicates maximum uncertainty (perfectly balanced classes).
-""", unsafe_allow_html=True)
-
-# Gini Impurity
-st.markdown("<h2 style='color: #003366;'>Gini Impurity: Measuring Impurity</h2>", unsafe_allow_html=True)
-st.markdown("""
-    **Gini Impurity** is another popular impurity measure. It calculates how often a randomly chosen element would be incorrectly labeled.
-    
-    Formula:
+## 🧠 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
+---
 """)
-st.image("gini.png", width=300)
-st.markdown("""
-    **Example**:
-    - \( P(Yes) = 0.5 \), \( P(No) = 0.5 \)
-    
-    Then:
-    $$ Gini(Y) = 1 - (0.5^2 + 0.5^2) = 0.5 $$
-    
-    A lower Gini value means purer splits.
-""", unsafe_allow_html=True)
-
-# Tree Construction
-st.markdown("<h2 style='color: #003366;'>Building the Decision Tree</h2>", unsafe_allow_html=True)
-st.markdown("""
-    Decision Trees are built **top-down**, starting from the root. At each node, the algorithm selects the feature that best splits the data using metrics like **Entropy** or **Gini**.
-    
-    Splitting stops when:
-    - The data is pure (contains one class), or
-    - A stopping condition is met (like maximum depth).
-""", unsafe_allow_html=True)
-
-# Iris Tree Visualization
-st.markdown("<h2 style='color: #003366;'>Visualizing: Iris Dataset Tree</h2>", unsafe_allow_html=True)
-st.markdown("""
-    Here's an example decision tree trained on the famous **Iris dataset**, which classifies flower species based on petal and sepal measurements.
-""", unsafe_allow_html=True)
-st.image("dt1 (1).jpg", caption="Decision Tree for Iris Dataset", use_container_width=True)
 
-# Training & Testing - Classification
-st.markdown("<h2 style='color: #003366;'>Training & Testing (Classification)</h2>", unsafe_allow_html=True)
-st.markdown("""
-    **Training**:
-    - Select features and split based on impurity reduction.
-    - Recursively grow the tree until stopping criteria are met.
-    
-    **Testing**:
-    - Traverse the tree with new data.
-    - Follow the decision rules until you reach a leaf node (prediction).
-    
-    💡 *Example: For Iris, classify the flower as Setosa, Versicolor, or Virginica based on petal dimensions.*
-""", unsafe_allow_html=True)
-
-# Training & Testing - Regression
-st.markdown("<h2 style='color: #003366;'>Training & Testing (Regression)</h2>", unsafe_allow_html=True)
-st.markdown("""
-    **Training**:
-    - Split data to minimize **Mean Squared Error (MSE)**.
-    
-    **Testing**:
-    - Output the mean value in the corresponding leaf.
-    
-    💡 *Example: Predict house price using features like size, location, and number of rooms.*
-""", unsafe_allow_html=True)
-
-# Pre-Pruning
-st.markdown("<h2 style='color: #003366;'>Pre-Pruning: Control Overfitting Early</h2>", unsafe_allow_html=True)
-st.markdown("""
-    Pre-pruning stops the tree from growing too deep and complex. Common techniques include:
-    
-    - **Max Depth**
-    - **Min Samples Split**
-    - **Min Samples Leaf**
-    - **Max Features**
-    
-    These help in generalizing better and reducing noise.
-""", unsafe_allow_html=True)
-
-# Post-Pruning
-st.markdown("<h2 style='color: #003366;'>Post-Pruning: Simplify After Growth</h2>", unsafe_allow_html=True)
-st.markdown("""
-    In **post-pruning**, we allow the tree to grow fully, then trim unnecessary branches:
-    
-    - **Cost Complexity Pruning**
-    - **Validation-based Pruning**
-    
-    This helps reduce overfitting and improves model simplicity.
-""", unsafe_allow_html=True)
-
-# Feature Importance
-st.markdown("<h2 style='color: #003366;'>Feature Selection with Decision Trees</h2>", unsafe_allow_html=True)
+# Dataset and DataFrame
+st.subheader("🌼 Let's Explore the Iris 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 👇")
+st.dataframe(df.head(), use_container_width=True)
+
+# Feature distribution visualization
+st.markdown("### 📊 Visualize Features")
+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))
+    sns.scatterplot(data=df, x=selected_features[0], y=selected_features[1], hue="species", palette="Set2", s=80)
+    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
+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
+acc = accuracy_score(y_test, y_pred)
+st.success(f"✅ Model Accuracy: {acc*100:.2f}%")
+
+# Classification report
+st.markdown("### 🧾 Classification Report")
+st.text(classification_report(y_test, y_pred, target_names=iris.target_names))
+
+# Confusion matrix
+st.markdown("### 🔍 Confusion Matrix")
+cm = confusion_matrix(y_test, y_pred)
+fig, ax = plt.subplots()
+sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=iris.target_names, yticklabels=iris.target_names)
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+st.pyplot(fig)
+
+# Final tips
 st.markdown("""
-    Decision Trees provide insight into which features are most important based on how often and how effectively they split data.
+---
+## 💡 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!
+---
 """)
-st.image("feature.png", width=500)
-st.markdown("""
-    💡 *Higher importance → More influential in decision making.*
-""", unsafe_allow_html=True)
-
-# Notebook Link
-st.markdown("<h2 style='color: #003366;'>Explore Hands-On Implementation</h2>", unsafe_allow_html=True)
-st.markdown(
-    "<a href='https://colab.research.google.com/drive/1SqZ5I5h7ivS6SJDwlOZQ-V4IAOg90RE7?usp=sharing' target='_blank' style='font-size: 16px; color: #003366;'>🔗 Open Jupyter Notebook on Google Colab</a>",
-    unsafe_allow_html=True
-)
+
+