Update pages/SVM.py

pages/SVM.py

@@ -1,119 +1,137 @@
 import streamlit as st
 
-st.set_page_config(page_title="Support Vector Machine (SVM)", page_icon="🧠", layout="wide")
+st.set_page_config(page_title="Support Vector Machine", page_icon="🧠", layout="wide")
 
-# Header
-st.title("🧠 Support Vector Machine (SVM) - Classification")
+# Title
+st.markdown("<h1 style='color:#4CAF50;'>🧠 Support Vector Machine (SVM)</h1>", unsafe_allow_html=True)
 
+# Introduction
+st.markdown("### 📚 What is SVM?")
 st.markdown("""
-SVM is a powerful **supervised machine learning algorithm** used for **classification** and **regression**,  
-but it's mostly used for **classification** tasks.
+Support Vector Machine (SVM) is a powerful **supervised learning algorithm** used for both **classification** and **regression**, though it is mostly used for classification tasks.
+
+The core idea is to find the **optimal hyperplane** that best separates the data points of different classes by maximizing the **margin** between them.
 """)
 
-# Section 1 — Core Idea
-st.header("🎯 What is SVM?")
+# Use Cases
+st.markdown("### 🎯 Where is SVM Used?")
 st.markdown("""
-SVM aims to **find the best decision boundary** (called a **hyperplane**) that separates different classes.  
-It does this by **maximizing the margin** between the closest points of each class, known as **support vectors**.
+- Face Recognition  
+- Handwriting Recognition  
+- Bioinformatics (e.g., gene classification)  
+- Email Spam Detection  
+- Image Classification
 """)
 
-st.latex(r"f(x) = w^T x + b")
-st.markdown("- \\( w \\): weight vector  \n- \\( b \\): bias  \n- If \\( f(x) > 0 \\): class +1, else class -1")
-
-st.image("https://upload.wikimedia.org/wikipedia/commons/7/72/SVM_margin.png",
-         caption="SVM - Maximizing the Margin", use_column_width=True)
-
-# Section 2 — How it Works
-st.header("⚙️ How Does SVM Work?")
-col1, col2 = st.columns(2)
+# How It Works
+st.markdown("### ⚙️ How Does SVM Work?")
 
-with col1:
+with st.expander("🔹 Step 1: Find a Hyperplane"):
     st.markdown("""
-    - Find the **hyperplane** that best separates the classes  
-    - Support vectors are the **critical points** that define the boundary  
-    - Maximize the distance (margin) from support vectors to hyperplane
+    A **hyperplane** is a decision boundary that separates the data points of different classes.
+    SVM tries to find the hyperplane that **maximizes the margin** between classes.
     """)
 
-with col2:
-    st.markdown("### ✨ Objective Function")
-    st.latex(r"\min \frac{1}{2} ||w||^2 \quad \text{subject to: } y_i(w^T x_i + b) \geq 1")
-    st.markdown("We minimize weight norm to maximize margin")
-
-# Section 3 — Kernels
-st.header("🌀 Kernel Trick")
+with st.expander("🔹 Step 2: Identify Support Vectors"):
+    st.markdown("""
+    **Support vectors** are the data points that lie closest to the hyperplane.  
+    These points are critical in defining the position and orientation of the hyperplane.
+    """)
 
-st.markdown("""
-Sometimes, data isn't linearly separable.  
-**Kernel functions** help SVM project data into a higher-dimensional space.
+with st.expander("🔹 Step 3: Handle Non-Linearly Separable Data"):
+    st.markdown("""
+    When the data is not linearly separable, SVM uses the **kernel trick** to project it into a higher-dimensional space where it becomes separable.
+    """)
 
-Common kernels:
-- **Linear Kernel**: Works when data is linearly separable
-- **Polynomial Kernel**: Curved boundaries
-- **RBF (Gaussian)**: Handles complex boundaries
+# Kernel Functions
+st.markdown("### 🧪 Kernels in SVM")
 
-### 🧠 Kernel Formula (Example: RBF)
-""")
-st.latex(r"K(x, x') = \exp\left(-\frac{||x - x'||^2}{2\sigma^2}\right)")
+with st.expander("📌 Common Kernel Functions"):
+    st.markdown("""
+    - **Linear Kernel**: For linearly separable data  
+    - **Polynomial Kernel**: For curved decision boundaries  
+    - **RBF (Radial Basis Function)**: Most popular, handles complex data  
+    - **Sigmoid Kernel**: Similar to neural networks  
+    """)
 
-st.markdown("This allows SVM to classify non-linear data!")
+# Mathematical Intuition
+st.markdown("### 🧠 Mathematical Formulation")
 
-# Section 4 — Hard Margin vs Soft Margin
-st.header("🧱 Hard Margin vs Soft Margin")
-col1, col2 = st.columns(2)
+with st.expander("📌 Decision Function"):
+    st.latex(r"f(x) = w \cdot x + b")
 
-with col1:
-    st.markdown("### Hard Margin SVM")
+with st.expander("📌 Classification Rule"):
     st.markdown("""
-    - No misclassification allowed  
-    - Only works if data is perfectly separable
+    - If \\( f(x) > 0 \\): Predict **Class 1**  
+    - If \\( f(x) < 0 \\): Predict **Class 0**  
     """)
 
-with col2:
-    st.markdown("### Soft Margin SVM")
+with st.expander("📌 Optimization Objective"):
+    st.latex(r"\text{Maximize Margin} = \frac{2}{\|w\|}")
+    st.markdown("We want to maximize the margin between support vectors and the hyperplane.")
+
+with st.expander("📌 Soft Margin & C Parameter"):
+    st.latex(r" \min \frac{1}{2} \|w\|^2 + C \sum \xi_i ")
     st.markdown("""
-    - Allows misclassifications  
-    - Adds penalty to error via regularization term (\\( C \\))  
-    - Better generalization on noisy data
+    - The **C parameter** balances margin maximization vs classification error.
+    - A **small C** allows for a wider margin but more errors.
+    - A **large C** aims for perfect classification but might overfit.
     """)
 
-st.latex(r"\min \frac{1}{2} ||w||^2 + C \sum \xi_i")
-
-# Section 5 — Evaluation Metrics
-st.header("📏 Evaluation Metrics for Classification")
+# Evaluation Metrics
+st.markdown("### 📏 Evaluation Metrics")
 
-col1, col2, col3 = st.columns(3)
+st.markdown("#### ✅ Accuracy")
+st.latex(r"Accuracy = \frac{TP + TN}{TP + TN + FP + FN}")
+st.markdown("The percentage of correct predictions.")
 
-with col1:
-    st.subheader("✔️ Accuracy")
-    st.latex(r"Accuracy = \frac{TP + TN}{TP + TN + FP + FN}")
+st.markdown("#### 🎯 Precision")
+st.latex(r"Precision = \frac{TP}{TP + FP}")
+st.markdown("Out of all predicted positives, how many are actually positive?")
 
-with col2:
-    st.subheader("🎯 Precision")
-    st.latex(r"Precision = \frac{TP}{TP + FP}")
+st.markdown("#### 📣 Recall (Sensitivity)")
+st.latex(r"Recall = \frac{TP}{TP + FN}")
+st.markdown("Out of all actual positives, how many did we correctly predict?")
 
-with col3:
-    st.subheader("🔍 Recall")
-    st.latex(r"Recall = \frac{TP}{TP + FN}")
+st.markdown("#### ⚖️ F1 Score")
+st.latex(r"F1 = 2 \cdot \frac{Precision \cdot Recall}{Precision + Recall}")
+st.markdown("Balances precision and recall — especially useful in imbalanced datasets.")
 
-col4, col5 = st.columns(2)
-
-with col4:
-    st.subheader("📊 F1-Score")
-    st.latex(r"F1 = 2 \cdot \frac{Precision \cdot Recall}{Precision + Recall}")
-
-with col5:
-    st.subheader("🧠 ROC-AUC")
-    st.markdown("Area under ROC curve (TPR vs FPR)")
+st.markdown("#### 📈 ROC-AUC")
+st.markdown("""
+- Plots True Positive Rate (TPR) vs False Positive Rate (FPR).  
+- **AUC (Area Under Curve)** closer to 1 indicates a better model.
+""")
 
-# Section 6 — Summary
-st.header("🧾 Summary & Key Takeaways")
+# Pros and Cons
+st.markdown("### ✅ Advantages of SVM")
+st.markdown("""
+- Effective in high-dimensional spaces  
+- Works well even when features > samples  
+- Memory efficient (uses support vectors)  
+- Handles non-linearity with kernels  
+""")
 
+st.markdown("### ❌ Limitations of SVM")
 st.markdown("""
-- SVM aims to **maximize the margin** between classes  
-- Works with **linear and non-linear** data using **kernels**  
-- **Support vectors** are the most critical data points  
-- Use **soft margin + kernels** for real-world problems  
-- Evaluate using **Accuracy, Precision, Recall, F1, ROC-AUC**
+- Not ideal for large datasets (computationally expensive)  
+- Requires careful parameter tuning (C, kernel)  
+- Hard to interpret compared to decision trees  
 """)
 
-st.success("✅ Use SVM when you have clean, medium-sized datasets and need robust classification!")
+# Summary
+st.markdown("### 🔚 Summary")
+st.markdown("""
+Support Vector Machine is a **robust**, **flexible**, and **accurate** classification algorithm.  
+Great for:
+- Text data
+- Image recognition
+- Biomedical data
+
+Make sure to:
+- Scale your features  
+- Use kernel wisely  
+- Tune the **C** and **gamma** parameters
+
+✅ Powerful for **both linear and non-linear** decision boundaries!
+""")