Update pages/4Logistic_Regression.py

pages/4Logistic_Regression.py

@@ -1,201 +1,194 @@
 import streamlit as st
 
-# Configure the Streamlit page
 st.set_page_config(page_title="Logistic Regression", page_icon="🤖", layout="wide")
 
-# Custom CSS for styling
+# Updated CSS styling
 st.markdown("""
     <style>
         .stApp {
-            background-color: #4A90E2; /* Light blue background */
+            background-color: #f2f6fa;
         }
         h1, h2, h3 {
-            color: #003366; /* Dark blue headers */
+            color: #1a237e;
         }
         .custom-font, p {
             font-family: 'Arial', sans-serif;
             font-size: 18px;
-            color: white;
+            color: #212121;
             line-height: 1.6;
         }
+        code {
+            background-color: #e3eaf5;
+            color: #1a237e;
+            padding: 4px 6px;
+            border-radius: 6px;
+            font-size: 16px;
+        }
+        pre {
+            background-color: #e3eaf5 !important;
+            color: #1a237e;
+            padding: 10px;
+            border-radius: 10px;
+            overflow-x: auto;
+        }
     </style>
 """, unsafe_allow_html=True)
 
-# Title
-st.markdown("<h1 style='color:#003366;'>Logistic Regression</h1>", unsafe_allow_html=True)
+# App Content
+st.markdown("<h1>Logistic Regression</h1>", unsafe_allow_html=True)
 
-# Introduction
 st.write("""
-Logistic Regression is a supervised machine learning method primarily used for classification tasks. While it's ideal for binary classification, it can be extended to handle multiple classes using appropriate techniques. Its main objective is to find the best linear separator—line, plane, or hyperplane—that effectively divides different classes. It assumes that the classes can be linearly separated to perform optimally.
+Logistic Regression is a supervised machine learning algorithm used for classification only. It is mainly used for binary classification, but with some extensions, it can handle multi-class labels as well.
+The main task of logistic regression is to find the best line, plane, or hyperplane that separates the classes linearly. It assumes the data should be (almost) linearly separable for good performance.
 """)
 
-# Step Function
-st.markdown("<h2 style='color:#003366;'>1. Logistic Regression with Step Function</h2>", unsafe_allow_html=True)
+st.markdown("<h2>1. Logistic Regression with Step Function</h2>", unsafe_allow_html=True)
 st.write("""
-The step function outputs either 0 or 1 based on a defined threshold. However, it comes with limitations:
-- Not differentiable, making it unsuitable for gradient-based optimization.
-- Cannot represent probabilities.
-- Unresponsive to small changes in input.
+The step function assigns an output of either 0 or 1 based on a threshold value. However, it has the following disadvantages:
+- Not differentiable, which makes optimization hard.
+- Cannot measure the probability of class membership.
+- Small input changes don’t change the output smoothly.
 
-To address these drawbacks, the sigmoid function is used.
+To solve this, we use the Sigmoid function.
 """)
 
-# Sigmoid Function
-st.markdown("<h2 style='color:#003366;'>2. Logistic Regression with Sigmoid Function</h2>", unsafe_allow_html=True)
-st.write(r'''
+st.markdown("<h2>2. Logistic Regression with Sigmoid Function</h2>", unsafe_allow_html=True)
+st.write(r"""
 The sigmoid function is defined as:
 
 \[
-sigmoid(z) = \frac{1}{1 + e^{-z}}\
+sigmoid(z) = \frac{1}{1 + e^{-z}}
 \]
 
 where \( z = WX + b \).
 
-**Advantages:**
-- Smooth and continuous
-- Outputs values between 0 and 1 (interpretable as probabilities)
-- Differentiable and suitable for optimization
-''')
+**Advantages**:
+- Smooth and differentiable
+- Outputs probability between 0 and 1
+- Great for binary classification
+""")
 
-# Loss Function
-st.markdown("<h2 style='color:#003366;'>1. Loss Function in Logistic Regression</h2>", unsafe_allow_html=True)
-st.write(r'''
-Logistic Regression uses the cross-entropy (log) loss:
+st.markdown("<h2>Loss used in Logistic Regression</h2>", unsafe_allow_html=True)
+st.write(r"""
+Logistic Regression uses **cross-entropy loss**:
 
 \[
-L = -\sum_{i=1}^{N} [y_i \log P(y_i) + (1 - y_i) \log(1 - P(y_i))]
+L = -\sum_{i=1}^{N} \left[y_i \log P(y_i) + (1 - y_i) \log (1 - P(y_i)) \right]
 \]
+""")
 
-where \( y_i \) is the true label and \( P(y_i) \) is the predicted probability.
-''')
-
-# Gradient Descent
-st.markdown("<h2 style='color:#003366;'>2. Gradient Descent</h2>", unsafe_allow_html=True)
-st.write(r'''
-Gradient Descent is used to optimize the weights by minimizing the loss:
+st.markdown("<h2>Gradient Descent</h2>", unsafe_allow_html=True)
+st.write(r"""
+Gradient Descent is used to minimize the loss function:
 
 \[
 W = W - \alpha \frac{\partial L}{\partial W}
 \]
 
-Here, \( \alpha \) is the learning rate.
-''')
+Where \( \alpha \) is the learning rate.
+""")
 
-# Learning Rate
-st.markdown("<h2 style='color:#003366;'>3. Learning Rate in Gradient Descent</h2>", unsafe_allow_html=True)
+st.markdown("<h2>Learning Rate in Gradient Descent</h2>", unsafe_allow_html=True)
 st.write("""
-- A high learning rate may overshoot the minimum and cause instability.
-- A low learning rate slows down convergence.
-- A balanced rate (e.g., 0.01 or 0.1) is commonly used.
-- Fixed learning rates may cause oscillations if not tuned properly.
+- High learning rate → faster but unstable
+- Low learning rate → stable but slow
+- Too low → may never converge
+- Typically used: 0.1 or 0.01
 """)
 
-# Types of Gradient Descent
-st.markdown("<h2 style='color:#003366;'>4. Types of Gradient Descent</h2>", unsafe_allow_html=True)
+st.markdown("<h2>Types of Gradient Descent</h2>", unsafe_allow_html=True)
 st.write("""
-- **Batch Gradient Descent**: Uses the entire dataset per update. Fewer epochs, more computation per epoch.
-- **Stochastic Gradient Descent (SGD)**: Updates weights after each sample. Faster updates but noisier convergence.
-- **Mini-batch Gradient Descent**: Uses batches of samples. A balance between batch and SGD—widely used in practice.
+- **Batch GD**: Full dataset per update — few epochs, slow
+- **Stochastic GD (SGD)**: One sample per update — fast per epoch, more epochs
+- **Mini-batch GD**: Small batch updates — balanced and commonly used
 """)
 
-# Softmax Regression
-st.markdown("<h2 style='color:#003366;'>Multiclass Logistic Regression</h2>", unsafe_allow_html=True)
+st.markdown("<h2>Multiclass Logistic Regression</h2>", unsafe_allow_html=True)
 st.subheader("1. Softmax Regression")
-st.write(r'''
-Softmax Regression extends logistic regression to multiclass classification:
+st.write(r"""
+Softmax regression generalizes logistic regression for multi-class problems.
 
 \[
 P(y = j | X) = \frac{e^{Z_j}}{\sum_{k=1}^{K} e^{Z_k}}
 \]
 
-### Softmax Regression Steps:
+**Steps**:
 1. Compute scores: \( Z = WX + b \)
-2. Apply softmax to get probabilities
+2. Apply softmax
 3. Use cross-entropy loss
-4. Optimize with gradient descent
-5. Choose the class with the highest probability
-''')
+4. Update with gradient descent
 
-# Example table for softmax
-st.write("""**Example:**
-If the model predicts probabilities for classes 0 to 9 as follows:
+**Example**:
+If class probabilities are:
 
 | Class | Probability |
 |-------|-------------|
 | 0     | 0.02        |
 | 1     | 0.05        |
-| 2     | 0.07        |
-| 3     | 0.10        |
-| 4     | 0.08        |
-| 5     | 0.12        |
-| 6     | 0.10        |
 | 7     | 0.30        |
-| 8     | 0.05        |
 | 9     | 0.11        |
 
-The model predicts class **7** because it has the highest probability.
+Prediction = **7**
 """)
 
-# One-vs-Rest
-st.markdown("<h2 style='color:#003366;'>2. One-vs-Rest (OvR) Classification</h2>", unsafe_allow_html=True)
+st.markdown("<h2>2. One-vs-Rest (OvR) Classification</h2>", unsafe_allow_html=True)
 st.write("""
-OvR decomposes a multiclass problem into several binary problems:
-
-### OvR Steps:
-1. Train one classifier per class
-2. Each predicts whether a sample belongs to its class
-3. Choose the class with the highest score
-
-**Example:** Classify 🍎 🍌 🍊
-- Classifiers: Apple vs Others, Banana vs Others, Orange vs Others
-- Predict based on the highest confidence
+OvR breaks a multi-class problem into many binary ones.
+
+**Steps**:
+1. Train N binary classifiers (one per class)
+2. Each says: "Is this class or not?"
+3. Pick the one with the highest score
+
+**Example**:
+For 🍎 🍌 🍊, you train:
+- Apple vs Not Apple
+- Banana vs Not Banana
+- Orange vs Not Orange
 """)
 
-# Regularization
-st.markdown("<h2 style='color:#003366;'>Regularization in Logistic Regression</h2>", unsafe_allow_html=True)
-st.write("""
-Regularization helps reduce overfitting by penalizing large weights:
+st.markdown("<h2>Regularization in Logistic Regression</h2>", unsafe_allow_html=True)
+st.write(r"""
+Regularization adds a penalty to reduce overfitting:
 
-- **L1 (Lasso)**: \( \lambda \sum |w| \), encourages sparsity
-- **L2 (Ridge)**: \( \lambda \sum w^2 \), smooths the weights
-- **ElasticNet**: Combines both L1 and L2 penalties
+- **L1 (Lasso)**: \( \lambda \sum |w| \)
+- **L2 (Ridge)**: \( \lambda \sum w^2 \)
+- **ElasticNet**: Combination of both
 
-Regularization leads to simpler, more generalizable models.
+**Why?**
+- Reduces model complexity
+- Encourages generalization
 """)
 
-# Multicollinearity
-st.markdown("<h2 style='color:#003366;'>Detecting Multicollinearity</h2>", unsafe_allow_html=True)
-st.write(r'''
-High correlation among features can affect performance.
-
-### Variance Inflation Factor (VIF):
+st.markdown("<h2>Detecting Multicollinearity</h2>", unsafe_allow_html=True)
+st.write(r"""
+**Variance Inflation Factor (VIF)**:
 
 \[
 VIF_i = \frac{1}{1 - R^2_i}
 \]
 
-- VIF > 10 indicates multicollinearity
-- Lower VIF is preferred
-''')
+- VIF > 10 = high multicollinearity
+""")
 
-# Hyperparameters
-st.markdown("<h2 style='color:#003366;'>Hyperparameters in Logistic Regression</h2>", unsafe_allow_html=True)
+st.markdown("<h2>Hyperparameters in Logistic Regression</h2>", unsafe_allow_html=True)
 st.table([
+    ["Hyperparameter", "Description"],
     ["penalty", "Regularization type ('l1', 'l2', 'elasticnet', None)"],
     ["dual", "Use dual formulation (for 'l2' with 'liblinear')"],
-    ["tol", "Stopping tolerance"],
+    ["tol", "Tolerance for stopping"],
     ["C", "Inverse of regularization strength"],
     ["fit_intercept", "Add intercept term or not"],
-    ["intercept_scaling", "Scaling of intercept (liblinear only)"],
-    ["class_weight", "Class weights ('balanced' or dict)"],
-    ["random_state", "Random seed"],
-    ["solver", "Optimization algorithm ('lbfgs', etc.)"],
-    ["max_iter", "Max iterations"],
-    ["multi_class", "'ovr' or 'multinomial'"],
-    ["verbose", "Verbosity"],
+    ["intercept_scaling", "Intercept scaling (for 'liblinear')"],
+    ["class_weight", "Weights for classes ('balanced' or dict)"],
+    ["random_state", "Seed for reproducibility"],
+    ["solver", "Optimization algorithm (e.g., 'lbfgs', 'saga')"],
+    ["max_iter", "Max number of iterations"],
+    ["multi_class", "Strategy ('ovr' or 'multinomial')"],
+    ["verbose", "Level of output verbosity"],
     ["warm_start", "Reuse previous solution"],
-    ["n_jobs", "CPU cores used"],
-    ["l1_ratio", "Ratio for ElasticNet"]
+    ["n_jobs", "Cores used for training"],
+    ["l1_ratio", "Mix ratio (for 'elasticnet')"],
 ])
 
-st.write("This interactive guide helps you understand logistic regression from basics to advanced concepts! 🚀")
+st.write("🚀 This app helps you understand **Logistic Regression** step by step!")