Please enter a valid number for hours studied.
'; + outputDiv.classList.remove('hidden'); + } +}); + +// Function to handle canvas resizing and redraw the graph +function resizeCanvas() { + // Get the device pixel ratio for sharper rendering on high-DPI screens + const dpi = window.devicePixelRatio; + // Get the actual rendered size of the canvas element from its CSS styles + const rect = canvas.getBoundingClientRect(); + + // Set the internal drawing buffer size of the canvas + canvas.width = rect.width * dpi; + canvas.height = rect.height * dpi; + + // Scale the drawing context to match the DPI, ensuring crisp lines and text + ctx.scale(dpi, dpi); + + // Re-setup scaling for data to canvas coordinates and redraw + setupScaling(); + drawGraph(); +} + +// Initial setup and draw when the window loads +window.addEventListener('load', () => { + resizeCanvas(); // Set initial canvas size and draw + // Also trigger an initial prediction for the default value in the input field + const initialHours = parseFloat(document.getElementById('hoursInput').value); + if (!isNaN(initialHours)) { + predictedHours = initialHours; + predictedScore = slope * initialHours + intercept; + document.getElementById('predictedScore').textContent = predictedScore.toFixed(2); + document.getElementById('predictionOutput').classList.remove('hidden'); + setupScaling(); + drawGraph(); + } +}); + +// Redraw the graph whenever the window is resized +window.addEventListener('resize', resizeCanvas); + +// Optional: Allow clicking on canvas to set hours input (for quick testing) +canvas.addEventListener('click', (event) => { + // Get mouse click coordinates relative to the canvas + const rect = canvas.getBoundingClientRect(); + const mouseX = (event.clientX - rect.left) / (canvas.width / canvas.getBoundingClientRect().width); + const mouseY = (event.clientY - rect.top) / (canvas.height / canvas.getBoundingClientRect().height); // Corrected this line + + // Convert canvas X coordinate back to data X (hours studied) + const clickedHours = xMin + (mouseX - padding) / xScale; + // Update the input field with the clicked hours + document.getElementById('hoursInput').value = clickedHours.toFixed(1); + // Trigger the prediction immediately + document.getElementById('predictBtn').click(); +}); diff --git a/Static/js/poly.js b/Static/js/poly.js new file mode 100644 index 0000000000000000000000000000000000000000..9fad29d6c8a6ca9110f44fb7515ac46df8e52652 --- /dev/null +++ b/Static/js/poly.js @@ -0,0 +1,85 @@ +const canvas = document.getElementById("polyCanvas"); +const ctx = canvas.getContext("2d"); + +const X_data = [1, 2, 3, 4, 5]; +const y_data = [3, 8, 15, 24, 35]; + +function toCanvasX(x, xScale, padding) { + return padding + x * xScale; +} + +function toCanvasY(y, yScale, padding, canvasHeight) { + return canvasHeight - padding - y * yScale; +} + +function setupAndDraw(predX = null, predY = null) { + const padding = 50; + const canvasWidth = canvas.width = canvas.clientWidth; + const canvasHeight = canvas.height = canvas.clientHeight; + + const xMax = 6; + const yMax = 40; + + const xScale = (canvasWidth - 2 * padding) / xMax; + const yScale = (canvasHeight - 2 * padding) / yMax; + + // Clear + ctx.clearRect(0, 0, canvasWidth, canvasHeight); + + // Axes + ctx.beginPath(); + ctx.moveTo(padding, toCanvasY(0, yScale, padding, canvasHeight)); + ctx.lineTo(canvasWidth - padding, toCanvasY(0, yScale, padding, canvasHeight)); + ctx.moveTo(toCanvasX(0, xScale, padding), padding); + ctx.lineTo(toCanvasX(0, xScale, padding), canvasHeight - padding); + ctx.strokeStyle = "#475569"; + ctx.stroke(); + + // Points + ctx.fillStyle = "#3b82f6"; + X_data.forEach((x, i) => { + ctx.beginPath(); + ctx.arc(toCanvasX(x, xScale, padding), toCanvasY(y_data[i], yScale, padding, canvasHeight), 5, 0, 2 * Math.PI); + ctx.fill(); + }); + + // Curve + ctx.beginPath(); + ctx.moveTo(toCanvasX(0, xScale, padding), toCanvasY(0, yScale, padding, canvasHeight)); + for (let x = 0; x <= xMax; x += 0.1) { + const y = x * x + 2 * x; // match your data (x^2 + 2x) + ctx.lineTo(toCanvasX(x, xScale, padding), toCanvasY(y, yScale, padding, canvasHeight)); + } + ctx.strokeStyle = "#ef4444"; + ctx.lineWidth = 2; + ctx.stroke(); + + // Predicted point + if (predX !== null && predY !== null) { + ctx.fillStyle = "#22c55e"; + ctx.beginPath(); + ctx.arc(toCanvasX(predX, xScale, padding), toCanvasY(predY, yScale, padding, canvasHeight), 6, 0, 2 * Math.PI); + ctx.fill(); + } +} + +// Prediction handler +function predict() { + const hours = parseFloat(document.getElementById("hoursInput").value); + fetch("/predict_poly", { + method: "POST", + body: JSON.stringify({ hours }), + headers: { + "Content-Type": "application/json" + } + }) + .then(res => res.json()) + .then(data => { + const score = data.prediction; + document.getElementById("predictedScore").textContent = score; + document.getElementById("predictionOutput").classList.remove("hidden"); + setupAndDraw(hours, score); + }); +} + +window.onload = () => setupAndDraw(); diff --git a/Static/knn.js b/Static/knn.js new file mode 100644 index 0000000000000000000000000000000000000000..05d871b00be6c85c065877c1029f791367941467 --- /dev/null +++ b/Static/knn.js @@ -0,0 +1,71 @@ +let points = [ + [2, 3, 0], [3, 4, 0], [1, 1, 0], + [7, 8, 1], [6, 9, 1], [8, 7, 1] +]; // (x, y, label) +let testPoint = [4.5, 5.5]; + +const ctx = document.getElementById('knnChart').getContext('2d'); +const colors = ['#1f77b4', '#ff7f0e', '#2ca02c']; + +let chart = new Chart(ctx, { + type: 'scatter', + data: { + datasets: [ + { + label: 'Class 0', + data: points.filter(p => p[2] === 0).map(p => ({ x: p[0], y: p[1] })), + backgroundColor: colors[0] + }, + { + label: 'Class 1', + data: points.filter(p => p[2] === 1).map(p => ({ x: p[0], y: p[1] })), + backgroundColor: colors[1] + }, + { + label: 'Test Point', + data: [{ x: testPoint[0], y: testPoint[1] }], + backgroundColor: 'black', + pointStyle: 'triangle', + radius: 7 + } + ] + }, + options: { + responsive: true, + plugins: { + legend: { position: 'top' }, + title: { display: true, text: 'KNN Classification Plot' } + }, + scales: { + x: { type: 'linear', position: 'bottom' }, + y: { type: 'linear' } + } + } +}); + +async function sendToServer() { + const k = document.getElementById('k-value').value; + + const response = await fetch('/knn_visual_predict', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ points, test_point: testPoint, k }) + }); + + const result = await response.json(); + + document.getElementById('output').innerHTML = + `Prediction: Class ${result.prediction}`; + + // Highlight neighbors + const neighborLayer = { + label: 'Nearest Neighbors', + data: result.neighbors.map(p => ({ x: p[0], y: p[1] })), + backgroundColor: '#d62728', + pointStyle: 'rect', + radius: 6 + }; + + chart.data.datasets = chart.data.datasets.slice(0, 3).concat([neighborLayer]); + chart.update(); +} \ No newline at end of file diff --git a/Static/svr_linear.png b/Static/svr_linear.png new file mode 100644 index 0000000000000000000000000000000000000000..fc45bd001e812fd36710618f14aaf9bb8564893f Binary files /dev/null and b/Static/svr_linear.png differ diff --git a/Static/svr_poly.png b/Static/svr_poly.png new file mode 100644 index 0000000000000000000000000000000000000000..e6f8e5140ce1740498889e4f78a0c5f0e2ed6f2f Binary files /dev/null and b/Static/svr_poly.png differ diff --git a/Static/svr_rbf.png b/Static/svr_rbf.png new file mode 100644 index 0000000000000000000000000000000000000000..4e8c10970323503afff5961485f8947bc178d006 Binary files /dev/null and b/Static/svr_rbf.png differ diff --git a/Static/uploads/Figure_1.png b/Static/uploads/Figure_1.png new file mode 100644 index 0000000000000000000000000000000000000000..d28d7c2040d32a342c45002a5c61d160809c28dc Binary files /dev/null and b/Static/uploads/Figure_1.png differ diff --git a/Static/uploads/compressed_clean.jpg b/Static/uploads/compressed_clean.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83c29b8410f4c79e3340bf986f72c3b16968b798 Binary files /dev/null and b/Static/uploads/compressed_clean.jpg differ diff --git a/Static/uploads/digit_0.png b/Static/uploads/digit_0.png new file mode 100644 index 0000000000000000000000000000000000000000..b6d83e2532cf8600c113d87f7235809feada5261 Binary files /dev/null and b/Static/uploads/digit_0.png differ diff --git a/Static/uploads/digit_4.png b/Static/uploads/digit_4.png new file mode 100644 index 0000000000000000000000000000000000000000..cc6a668b2dbca47f95564049bac912587861baed Binary files /dev/null and b/Static/uploads/digit_4.png differ diff --git a/Static/uploads/download.jpg b/Static/uploads/download.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1d841d232b82936e30214276abc355c216566d97 Binary files /dev/null and b/Static/uploads/download.jpg differ diff --git a/Static/uploads/download.png b/Static/uploads/download.png new file mode 100644 index 0000000000000000000000000000000000000000..72884c4f6a7334db4247da7f83a72c917aff6179 Binary files /dev/null and b/Static/uploads/download.png differ diff --git a/Static/uploads/download_1.jpg b/Static/uploads/download_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4268a9f07c74cb50dad1be9690dbe29b5c1d8467 Binary files /dev/null and b/Static/uploads/download_1.jpg differ diff --git a/Static/uploads/download_2.jpg b/Static/uploads/download_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb7e5a2c7943f3756ed2f75d6cb4658e0650b757 Binary files /dev/null and b/Static/uploads/download_2.jpg differ diff --git a/Static/uploads/input.jpg b/Static/uploads/input.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8dba2828491ffd79ebc3cef45f42aca4158de43 Binary files /dev/null and b/Static/uploads/input.jpg differ diff --git a/Static/uploads/kmeans.png b/Static/uploads/kmeans.png new file mode 100644 index 0000000000000000000000000000000000000000..8bc454d4a69b5e791b2de5d7f305c1147eac6053 Binary files /dev/null and b/Static/uploads/kmeans.png differ diff --git a/Static/uploads/test_digit.png b/Static/uploads/test_digit.png new file mode 100644 index 0000000000000000000000000000000000000000..c0239664ca898de966ef32440cc2f8fa6e4c007c Binary files /dev/null and b/Static/uploads/test_digit.png differ diff --git a/Static/uploads/test_digit_8.png b/Static/uploads/test_digit_8.png new file mode 100644 index 0000000000000000000000000000000000000000..65fd4e1bfb8201f82699ce08797014425b41b627 Binary files /dev/null and b/Static/uploads/test_digit_8.png differ diff --git a/Static/uploads/test_digit_8_1.png b/Static/uploads/test_digit_8_1.png new file mode 100644 index 0000000000000000000000000000000000000000..ab7b29556adb894692bbe53059d78646b3a2c896 Binary files /dev/null and b/Static/uploads/test_digit_8_1.png differ diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..df8ef478037bc681b860ed1f7cadb76b5b867bb4 --- /dev/null +++ b/app.py @@ -0,0 +1,2373 @@ +from flask import Flask, render_template, request, jsonify +import numpy as np +import pandas as pd +import joblib +import os +from sklearn.svm import SVR +from sklearn.model_selection import train_test_split +from sklearn.metrics import mean_squared_error, r2_score +from sklearn.neighbors import KNeighborsClassifier +from sklearn.preprocessing import StandardScaler +from sklearn.ensemble import RandomForestClassifier +from sklearn.tree import DecisionTreeClassifier +from sklearn import svm +from sklearn.naive_bayes import GaussianNB # <--- Add this import +from sklearn.feature_extraction.text import CountVectorizer +from textblob import TextBlob +import traceback +from flask_cors import CORS +from werkzeug.utils import secure_filename # For secure file names +import io # To read CSV from memory +import re +from sklearn.cluster import KMeans, DBSCAN +from PIL import Image +import matplotlib.pyplot as plt +from joblib import load # ✅ This is the missing line +import traceback +import pickle +from sklearn.svm import SVC +from sklearn.datasets import make_classification +import plotly.graph_objs as go +import json +import requests +from PIL import Image + + +# from transformers import pipeline +from dotenv import load_dotenv +import os +from urllib.parse import urlparse +import tldextract +import string + + +#chatbotcode +import zipfile +import gdown +import torch +from transformers import AutoTokenizer, AutoModelForCausalLM +from peft import PeftModel + +# #login +# from flask import Flask +# from flask_jwt_extended import JWTManager +# from flask_login import LoginManager +# from flask_mail import Mail +# from flask_login import LoginManager +# from flask_sqlalchemy import SQLAlchemy +# from flask_mail import Mail +# from auth.models import db, User +# from auth.routes import auth +# from flask_login import login_required + + + + +#chatbotcode + +# from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline + +# model_name = "microsoft/deberta-v3-small" + +# tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True) +# model = AutoModelForSequenceClassification.from_pretrained(model_name) + +# bert_checker = pipeline("text-classification", model=model, tokenizer=tokenizer) + +# Load environment variables from .env +load_dotenv() +#spam url import relateted +import nltk, os + +# Tell NLTK to also check the local nltk_data folder +nltk.data.path.append(os.path.join(os.path.dirname(__file__), "nltk_data")) + +from nltk.corpus import words + +# Load the words corpus +valid_words = set(words.words()) +print("engineering" in valid_words) # ✅ Should be True +print("engineerigfnnxng" in valid_words) # ❌ Should be False +import wordninja # Function to split words into valid parts +import re +from urllib.parse import urlparse +from spellchecker import SpellChecker + +import wordninja +# end urlspam +import google.generativeai as genai + +# app.py +# import streamlit as st +# from load_file import load_file + +# st.title("Download HuggingFace Repo Files in Streamlit") + +# filename = st.text_input("Enter filename from repo:", "model.safetensors") + +# if st.button("Download"): +# try: +# local_path = load_file(filename) +# st.success(f"✅ File downloaded to: {local_path}") +# st.write("You can now use this file in your app.") +# except Exception as e: +# st.error(f"❌ Error: {str(e)}") + + +# Set API key (no need to assign OpenAI() to client like that) +# openai.api_key = os.getenv("OPENAI_API_KEY") + +# def ask_openai_scientific_validation(statement): +# prompt = f"""Assess the scientific accuracy of: "{statement}"\nRespond with ✅ (possible) or ❌ (impossible), and explain simply.""" + +# try: +# client = OpenAI() # This is correct placement +# response = client.chat.completions.create( +# model="gpt-3.5-turbo", +# messages=[ +# {"role": "system", "content": "You are a scientific fact-checker."}, +# {"role": "user", "content": prompt} +# ], +# temperature=0.7, +# max_tokens=150 +# ) + + +# return response.choices[0].message.content.strip() + +# except Exception as e: +# return f"⚠️ Could not verify:\n\n{str(e)}" + + + #huggung face code start + + +# # ===================== +# # Replace your old model loads with this: +# # ===================== + +# # Models +# knn_model = load_file("Models/knn_model.pkl") +# lasso_model = load_file("Models/lasso_model.pkl") +# liar_model = load_file("Models/liar_model.joblib") +# linear_model = load_file("Models/linear_model.pkl") +# logistic_model = load_file("Models/logistic_model.pkl") +# nb_url_model = load_file("Models/nb_url_model.pkl") +# poly_model = load_file("Models/poly_model.pkl") +# rf_model = load_file("Models/rf_model.pkl") +# ridge_model = load_file("Models/ridge_model.pkl") +# supervised_model = load_file("Models/supervised_model.pkl") +# svr_model = load_file("Models/svr_model.pkl") +# voting_url_model = load_file("Models/voting_url_model.pkl") + +# # Vectorizers / Encoders / Scalers +# label_classes = load_file("Models/label_classes.npy") +# label_encoder = load_file("Models/label_encoder.pkl") +# lasso_scaler = load_file("Models/lasso_scaler.pkl") +# liar_vectorizer = load_file("Models/liar_vectorizer.joblib") +# nb_url_vectorizer = load_file("Models/nb_url_vectorizer.pkl") +# poly_transform = load_file("Models/poly_transform.pkl") +# ridge_scaler = load_file("Models/ridge_scaler.pkl") +# svr_scaler_X = load_file("Models/svr_scaler_X.pkl") +# svr_scaler_y = load_file("Models/svr_scaler_y.pkl") +# tfidf_vectorizer = load_file("Models/tfidf_vectorizer.pkl") +# url_vectorizer = load_file("Models/url_vectorizer.pkl") +# vectorizer_joblib = load_file("Models/vectorizer.joblib") +# vectorizer_pkl = load_file("Models/vectorizer.pkl") +# # huggung face code end + +MODEL_DIR = "Models" +DATA_DIR = "housedata" # Assuming your house data is here +UPLOAD_FOLDER = 'static/uploads' # NEW: Folder for temporary user uploads + +app = Flask(__name__) +app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER +CORS(app) + + +REPO_ID = "deedrop1140/nero-ml" +MODEL_DIR = "Models" + +def load_file(filename): + """Try to load model from local folder; if missing, download from Hugging Face Hub.""" + local_path = os.path.join(MODEL_DIR, filename) + + # 1️⃣ Check if file exists locally + if os.path.exists(local_path): + file_path = local_path + else: + # 2️⃣ Download from Hugging Face (Render case) + file_path = hf_hub_download(repo_id=REPO_ID, filename=filename) + + # 3️⃣ Load based on file extension + if filename.endswith((".pkl", ".joblib")): + return joblib.load(file_path) + elif filename.endswith(".npy"): + return np.load(file_path, allow_pickle=True) + elif filename.endswith((".pt", ".pth")): + return torch.load(file_path, map_location="cpu") + else: + return file_path + + +#flasklogin + + +# app.config["JWT_SECRET_KEY"] = "jwt-secret-key" +# jwt = JWTManager(app) + + + +#authstart +# app.config["SECRET_KEY"] = "super-secret" +# app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///users.db" + +# Mail +# app.config["MAIL_SERVER"] = "smtp.gmail.com" +# app.config["MAIL_PORT"] = 587 +# app.config["MAIL_USE_TLS"] = True +# app.config["MAIL_USERNAME"] = "your_email@gmail.com" +# app.config["MAIL_PASSWORD"] = "app_password" + +# mail = Mail(app) + +# login_manager = LoginManager(app) +# login_manager.login_view = "auth.login" +# db.init_app(app) +# app.register_blueprint(auth) +# jwt = JWTManager(app) +# mail = Mail(app) + +# @login_manager.user_loader +# def load_user(user_id): +# return User.query.get(int(user_id)) + +# with app.app_context(): +# db.create_all() +#authend + + +#chatbotcode +# deedrop1140/qwen-ml-tutor-assets +from transformers import ( + AutoTokenizer, + AutoModelForCausalLM, + StoppingCriteria, + StoppingCriteriaList +) +from peft import PeftModel +from huggingface_hub import hf_hub_download +import zipfile +from transformers import TextIteratorStreamer +import threading +from flask import Response + + +# ====================== +# CONFIG +# ====================== +BASE_MODEL = "Qwen/Qwen2.5-1.5B" +DATASET_REPO = "deedrop1140/qwen-ml-tutor-assets" +ZIP_NAME = "qwen-ml-tutor-best-20251213T015537Z-1-001.zip" +MODEL_DIR = "qwen-ml-tutor-best" + +DEVICE = "cuda" if torch.cuda.is_available() else "cpu" + +# ====================== +# FLASK APP +# ====================== +app = Flask(__name__) + +# ====================== +# DOWNLOAD MODEL ASSETS +# ====================== +if not os.path.exists(MODEL_DIR): + print("⬇️ Downloading LoRA adapter...") + zip_path = hf_hub_download( + repo_id=DATASET_REPO, + filename=ZIP_NAME, + repo_type="dataset" + ) + print("📦 Extracting adapter...") + with zipfile.ZipFile(zip_path, "r") as z: + z.extractall(".") + print("✅ Adapter ready") + +# ====================== +# TOKENIZER (BASE MODEL) +# ====================== +# ====================== +# LOAD TOKENIZER (FROM LORA MODEL) +# ====================== +tokenizer = AutoTokenizer.from_pretrained( + MODEL_DIR, + trust_remote_code=True +) + +if tokenizer.pad_token_id is None: + tokenizer.pad_token = tokenizer.eos_token + +# ====================== +# LOAD BASE MODEL +# ====================== +base_model = AutoModelForCausalLM.from_pretrained( + BASE_MODEL, + torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32, + trust_remote_code=True +) + +# 🔥 THIS LINE IS THE FIX (DO NOT SKIP) +base_model.resize_token_embeddings(len(tokenizer)) + +# MOVE MODEL TO DEVICE +device = "cuda" if torch.cuda.is_available() else "cpu" +base_model = base_model.to(device) + +# ====================== +# LOAD LORA ADAPTER +# ====================== +llm_model = PeftModel.from_pretrained( + base_model, + MODEL_DIR, + is_trainable=False +) + +llm_model.eval() + +print("✅ Model loaded successfully") + +# ====================== +# STOPPING CRITERIA +# ====================== +class StopOnStrings(StoppingCriteria): + def __init__(self, tokenizer, stop_strings): + self.tokenizer = tokenizer + self.stop_ids = [ + tokenizer.encode(s, add_special_tokens=False) + for s in stop_strings + ] + + def __call__(self, input_ids, scores, **kwargs): + for stop in self.stop_ids: + if len(input_ids[0]) >= len(stop): + if input_ids[0][-len(stop):].tolist() == stop: + return True + return False + +stop_criteria = StoppingCriteriaList([ + StopOnStrings( + tokenizer, + stop_strings=["User:", "Instruction:", "Question:"] + ) +]) + +# ============================= +# ROUTES +# ============================= +@app.route("/chatbot") +def chatbot(): + return render_template("chatbot.html", active_page="chatbot") + +@app.route("/chat", methods=["POST"]) +def chat(): + data = request.json + user_msg = data.get("message", "").strip() + + if not user_msg: + return jsonify({"reply": "Please ask a machine learning question."}) + + prompt = f"""Instruction: Answer the following question clearly. +Do NOT ask follow-up questions. +Do NOT continue the conversation. +Question: {user_msg} +Answer:""" + + inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE) + + streamer = TextIteratorStreamer( + tokenizer, + skip_prompt=True, + skip_special_tokens=True + ) + + generation_kwargs = dict( + **inputs, + max_new_tokens=200, + temperature=0.3, + top_p=0.9, + do_sample=True, + eos_token_id=tokenizer.eos_token_id, + pad_token_id=tokenizer.eos_token_id, + stopping_criteria=stop_criteria, + streamer=streamer + ) + + # Run generation in background thread + thread = threading.Thread( + target=llm_model.generate, + kwargs=generation_kwargs + ) + thread.start() + + def event_stream(): + for token in streamer: + yield f"data: {token}\n\n" + + yield "data: [DONE]\n\n" + + return Response( + event_stream(), + mimetype="text/event-stream" + ) + + + +#chatbotcode + +genai.configure(api_key=os.getenv("GEMINI_API_KEY")) + +def ask_gemini(statement): + model = genai.GenerativeModel("gemini-2.0-flash-001") + response = model.generate_content(f"Verify this statement for truth: {statement}") + return response.text + +#rfc +# model = load("Models/liar_model.joblib") +# vectorizer = load("Models/liar_vectorizer.joblib") + +# Load BERT fact-checker pipeline (local model) +# bert_checker = pipeline("text-classification", model="microsoft/deberta-v3-small") + +#endrfc + +#svm + +# ==== SVM Setup ==== +X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, + n_clusters_per_class=1, n_classes=2, random_state=42) +scaler = StandardScaler() +X = scaler.fit_transform(X) +X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) + +# Train SVM +svm_model = SVC(kernel="linear") +svm_model.fit(X_train, y_train) + +#endsvm +#deision tree +GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") +GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent" +#end deision tree + +# Ensure directories exist +os.makedirs(MODEL_DIR, exist_ok=True) +os.makedirs(DATA_DIR, exist_ok=True) +os.makedirs(UPLOAD_FOLDER, exist_ok=True) # NEW: Create upload folder + +def clean_text(text): + if pd.isnull(text): + return "" + text = text.lower() + text = re.sub(r"http\S+|www\S+|https\S+", '', text) + text = text.translate(str.maketrans('', '', string.punctuation)) + text = re.sub(r'\d+', '', text) + text = re.sub(r'\s+', ' ', text).strip() + return text + +# --- Helper functions for data generation (conceptual for demo) --- +def generate_linear_data(n_samples=100, noise=0.5): + X = np.sort(np.random.rand(n_samples) * 10).reshape(-1, 1) + y = 2 * X.squeeze() + 5 + noise * np.random.randn(n_samples) + return X, y + +def generate_non_linear_data(n_samples=100, noise=0.5): + X = np.sort(np.random.rand(n_samples) * 10).reshape(-1, 1) + y = np.sin(X.squeeze()) * 10 + noise * np.random.randn(n_samples) + return X, y + +def generate_noisy_data(n_samples=100, noise_factor=3.0): + X = np.sort(np.random.rand(n_samples) * 10).reshape(-1, 1) + y = 2 * X.squeeze() + 5 + noise_factor * np.random.randn(n_samples) # Increased noise + return X, y + +# Function to generate house price data (using your existing data structure for consistency) +def get_house_data(): + try: + df = pd.read_csv(os.path.join(DATA_DIR, 'train.csv')) + # Using a subset of features for simplicity in demo + features = ['GrLivArea', 'OverallQual', 'GarageCars', 'TotalBsmtSF', 'YearBuilt'] + # Check if all required columns exist + if not all(col in df.columns for col in features + ['SalePrice']): + print("Warning: Missing one or more required columns in train.csv for house data.") + return None, None + X = df[features] + y = df['SalePrice'] + return X, y + except FileNotFoundError: + print(f"Error: train.csv not found in {DATA_DIR}. Please ensure your data is there.") + return None, None + except Exception as e: + print(f"Error loading house data: {e}") + return None, None + +# Dictionary to hold all loaded models +loaded_models = {} + +# Load logistic model and vectorizer for SMS +# vectorizer = joblib.load("Models/logvectorizer.pkl") +# model = joblib.load("Models/logistic_model.pkl") +# vectorizer = load_file("Models/logvectorizer.pkl") +# model = load_file("Models/logistic_model.pkl") + + +# # Load models once NB+DT+SVM is trained +# try: +# model = load_file("Models/logistic_model.pkl") +# # vectorizer = joblib.load("Models/logvectorizer.pkl") +# # model = joblib.load("Models/logistic_model.pkl") +# vectorizer = load_file("Models/vectorizer.pkl") +# print("✅ Model and vectorizer loaded into memory successfully!") +# except Exception as e: +# vectorizer = None +# model = None +# print(f"❌ Error: Could not load model or vectorizer. Please check your file paths. Error: {e}") +# #END NB+DT+SVM + +# === Naive Bayes URL Spam Classifier (NB_spam.html) === +# === Load Model & Vectorizer === + + + +# VT_API_KEY = os.getenv("VT_API_KEY") +# nb_model = load_file("Models/nb_url_model.pkl") +# vectorizer = load_file("Models/nb_url_vectorizer.pkl") + +# if nb_model is not None and vectorizer is not None: +# print("✅ Loaded model and vectorizer.") +# else: +# print("❌ Model or vectorizer not found.") + + + + + + +def load_all_models(): + """ + Loads all necessary models into the loaded_models dictionary when the app starts. + """ + global loaded_models + + # Load Supervised Model + # Load Supervised Model +try: + supervised_model_path = load_file("linear_model.pkl") + + # Debug: check what load_file actually returned + print("DEBUG -> supervised_model_path type:", type(supervised_model_path)) + + # If load_file returned a path (string), load with joblib + if isinstance(supervised_model_path, str): + loaded_models['supervised'] = joblib.load(supervised_model_path) + else: + # If load_file already returned the model object + loaded_models['supervised'] = supervised_model_path + + print("Supervised model loaded successfully") + +except FileNotFoundError: + print(f"Error: Supervised model file not found at {supervised_model_path}. " + "Please run train_model.py first.") + loaded_models['supervised'] = None # Mark as not loaded +except Exception as e: + print(f"Error loading supervised model: {e}") + loaded_models['supervised'] = None + + +# Load models when Flask app context is ready +with app.app_context(): + load_all_models() + +@app.route('/') +def frontpage(): + return render_template('frontpage.html') +@app.route('/home') +def home(): + return render_template('home.html') + +@app.route('/Optimization') +def Optimization(): + return render_template('Optimization.html', active_page='Optimization') + +@app.route('/supervise') +def supervise(): + return render_template('supervise.html', active_page='supervise') + + +@app.route('/unsupervised') +def unsupervised(): + return render_template('unsupervised.html', active_page='unsupervised') + +# Semi-Supervised Learning page +@app.route('/semi-supervised') +def semi_supervised(): + return render_template('semi_supervised.html', active_page='semi_supervised') + +# Reinforcement Learning page +@app.route('/reinforcement') +def reinforcement(): + return render_template('reinforcement.html', active_page='reinforcement') + +# Ensemble Learning page +@app.route('/ensemble') +def ensemble(): + return render_template('ensemble.html', active_page='ensemble') + + +@app.route('/supervised', methods=['GET', 'POST']) +def supervised(): + prediction = None + hours_studied_input = None + + if loaded_models['supervised'] is None: + return "Error: Supervised model could not be loaded. Please check server logs.", 500 + + if request.method == 'POST': + try: + hours_studied_input = float(request.form['hours']) + input_data = np.array([[hours_studied_input]]) + + predicted_score = loaded_models['supervised'].predict(input_data)[0] + prediction = round(predicted_score, 2) + + except ValueError: + print("Invalid input for hours studied.") + prediction = "Error: Please enter a valid number." + except Exception as e: + print(f"An error occurred during prediction: {e}") + prediction = "Error during prediction." + + return render_template('supervised.html', prediction=prediction, hours_studied_input=hours_studied_input) + + +@app.route('/polynomial', methods=['GET', 'POST']) +def polynomial(): + if request.method == 'POST': + try: + hours = float(request.form['hours']) + + # model = joblib.load('Models/poly_model.pkl') + # poly = joblib.load('Models/poly_transform.pkl') + # model = load_file("Models/poly_model.pkl") + # poly= load_file("Models/poly_transform.pkl") + model = load_file("poly_model.pkl") + poly= load_file("poly_transform.pkl") + + transformed_input = poly.transform([[hours]]) + prediction = model.predict(transformed_input)[0] + + return render_template("poly.html", prediction=round(prediction, 2), hours=hours) + + except Exception as e: + print(f"Error: {e}") + return render_template("poly.html", error="Something went wrong.") + + return render_template("poly.html") + + +@app.route('/random_forest', methods=['GET', 'POST']) +def random_forest(): + if request.method == 'POST': + try: + hours = float(request.form['hours']) + model = load_file("rf_model.pkl") + # model = joblib.load('Models/rf_model.pkl') + prediction = model.predict([[hours]])[0] + + return render_template("rf.html", prediction=round(prediction, 2), hours=hours) + except Exception as e: + print(f"[ERROR] {e}") + return render_template("rf.html", error="Prediction failed. Check your input.") + return render_template("rf.html") + +@app.route('/prediction_flow') +def prediction_flow(): + return render_template('prediction_flow.html') + +@app.route("/lasso", methods=["GET", "POST"]) +def lasso(): + if request.method == "POST": + try: + inputs = [float(request.form.get(f)) for f in ['OverallQual', 'GrLivArea', 'GarageCars', 'TotalBsmtSF', 'YearBuilt']] + + # model = load_file("Models/lasso_model.pkl") + # scaler = load_file("Models/lasso_scaler.pkl") + # model = joblib.load("Models/lasso_model.pkl") + # scaler = joblib.load("Models/lasso_scaler.pkl") + model = load_file("lasso_model.pkl") + scaler = load_file("lasso_scaler.pkl") + + scaled_input = scaler.transform([inputs]) + + prediction = model.predict(scaled_input)[0] + return render_template("lasso.html", prediction=round(prediction, 2)) + + except Exception as e: + return render_template("lasso.html", error=str(e)) + + return render_template("lasso.html") + + +@app.route('/ridge', methods=['GET', 'POST']) +def ridge(): + prediction = None + error = None + + try: + # model = load_file("Models/ridge_model.pkl") + # scaler = load_file("Models/ridge_scaler.pkl") + # model = joblib.load(os.path.join(MODEL_DIR, 'ridge_model.pkl')) + # scaler = joblib.load(os.path.join(MODEL_DIR, 'ridge_scaler.pkl')) + + model = load_file("ridge_model.pkl") + scaler = load_file("ridge_scaler.pkl") + + + except Exception as e: + return f"❌ Error loading Ridge model: {e}", 500 + + if request.method == 'POST': + try: + features = ['OverallQual', 'GrLivArea', 'GarageCars', 'TotalBsmtSF', 'YearBuilt'] + input_data = [float(request.form[feature]) for feature in features] + input_scaled = scaler.transform([input_data]) + prediction = model.predict(input_scaled)[0] + except Exception as e: + error = str(e) + + return render_template('ridge.html', prediction=prediction, error=error) + +@app.route('/dtr', methods=['GET', 'POST']) +def dtr(): + if request.method == 'GET': + return render_template('dtr.html') + + if request.method == 'POST': + data = request.get_json() + data_points = data.get('dataPoints') if data else None + print("Received data:", data_points) + return jsonify({'message': 'Data received successfully!', 'receivedData': data_points}) + + +@app.route('/dtrg') +def drg(): + return render_template('desiciongame.html') + +# --- SVR Routes --- +@app.route('/svr') # This route is for the initial GET request to load the page +def svr_page(): + return render_template('svr.html') + +# @app.route('/decision-tree') +# def decision_tree(): +# return render_template('decision-Tree.html') + +# @app.route('/decision-tree-game') +# def decision_tree_game(): +# return render_template('Decision-Tree-Game.html') + + +@app.route('/run_svr_demo', methods=['POST']) +def run_svr_demo(): + try: + # Check if the request contains JSON (for predefined datasets) or FormData (for file uploads) + if request.is_json: + data = request.json + else: + # For FormData, data is accessed via request.form for fields, request.files for files + data = request.form + + dataset_type = data.get('dataset_type', 'linear') + kernel_type = data.get('kernel', 'rbf') + C_param = float(data.get('C', 1.0)) + gamma_param = float(data.get('gamma', 0.1)) + epsilon_param = float(data.get('epsilon', 0.1)) + + X, y = None, None + + if dataset_type == 'linear': + X, y = generate_linear_data() + elif dataset_type == 'non_linear': + X, y = generate_non_linear_data() + elif dataset_type == 'noisy': + X, y = generate_noisy_data() + elif dataset_type == 'house_data': + X_house, y_house = get_house_data() + if X_house is not None and not X_house.empty: + X = X_house[['GrLivArea']].values # Only GrLivArea for simple 1D plotting + y = y_house.values + else: + X, y = generate_linear_data() # Fallback if house data is missing/invalid + elif dataset_type == 'custom_csv': # NEW: Handle custom CSV upload + uploaded_file = request.files.get('file') + x_column_name = data.get('x_column_name') + y_column_name = data.get('y_column_name') + + if not uploaded_file or uploaded_file.filename == '': + return jsonify({'error': 'No file uploaded for custom CSV.'}), 400 + if not x_column_name or not y_column_name: + return jsonify({'error': 'X and Y column names are required for custom CSV.'}), 400 + + try: + # Read CSV into a pandas DataFrame from in-memory BytesIO object + df = pd.read_csv(io.BytesIO(uploaded_file.read())) + + if x_column_name not in df.columns or y_column_name not in df.columns: + missing_cols = [] + if x_column_name not in df.columns: missing_cols.append(x_column_name) + if y_column_name not in df.columns: missing_cols.append(y_column_name) + return jsonify({'error': f"Missing columns in uploaded CSV: {', '.join(missing_cols)}"}), 400 + + X = df[[x_column_name]].values # Ensure X is 2D for scikit-learn + y = df[y_column_name].values + except Exception as e: + return jsonify({'error': f"Error reading or processing custom CSV: {str(e)}"}), 400 + else: # Fallback for unknown dataset types + X, y = generate_linear_data() + + + if X is None or y is None or len(X) == 0: + return jsonify({'error': 'Failed to generate or load dataset.'}), 500 + + # Scale data + scaler_X = StandardScaler() + scaler_y = StandardScaler() + + X_scaled = scaler_X.fit_transform(X) + y_scaled = scaler_y.fit_transform(y.reshape(-1, 1)).flatten() + + X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size=0.2, random_state=42) + + # Train SVR model + svr_model = SVR(kernel=kernel_type, C=C_param, gamma=gamma_param, epsilon=epsilon_param) + svr_model.fit(X_train, y_train) + + # Make predictions + y_pred_scaled = svr_model.predict(X_test) + + # Inverse transform predictions to original scale for metrics + y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten() + y_test_original = scaler_y.inverse_transform(y_test.reshape(-1, 1)).flatten() + + # Calculate metrics + mse = mean_squared_error(y_test_original, y_pred) + r2 = r2_score(y_test_original, y_pred) + support_vectors_count = len(svr_model.support_vectors_) + + # Prepare data for plotting + plot_X_original = scaler_X.inverse_transform(X_scaled) + plot_y_original = scaler_y.inverse_transform(y_scaled.reshape(-1, 1)).flatten() + + x_plot = np.linspace(plot_X_original.min(), plot_X_original.max(), 500).reshape(-1, 1) + x_plot_scaled = scaler_X.transform(x_plot) + y_plot_scaled = svr_model.predict(x_plot_scaled) + y_plot_original = scaler_y.inverse_transform(y_plot_scaled.reshape(-1, 1)).flatten() + + y_upper_scaled = y_plot_scaled + epsilon_param + y_lower_scaled = y_plot_scaled - epsilon_param + y_upper_original = scaler_y.inverse_transform(y_upper_scaled.reshape(-1, 1)).flatten() + y_lower_original = scaler_y.inverse_transform(y_lower_scaled.reshape(-1, 1)).flatten() + + plot_data = { + 'data': [ + { + 'x': plot_X_original.flatten().tolist(), + 'y': plot_y_original.tolist(), + 'mode': 'markers', + 'type': 'scatter', + 'name': 'Original Data' + }, + { + 'x': x_plot.flatten().tolist(), + 'y': y_plot_original.tolist(), + 'mode': 'lines', + 'type': 'scatter', + 'name': 'SVR Prediction', + 'line': {'color': 'red'} + }, + { + 'x': x_plot.flatten().tolist(), + 'y': y_upper_original.tolist(), + 'mode': 'lines', + 'type': 'scatter', + 'name': 'Epsilon Tube (Upper)', + 'line': {'dash': 'dash', 'color': 'green'}, + 'fill': 'tonexty', + 'fillcolor': 'rgba(0,128,0,0.1)' + }, + { + 'x': x_plot.flatten().tolist(), + 'y': y_lower_original.tolist(), + 'mode': 'lines', + 'type': 'scatter', + 'name': 'Epsilon Tube (Lower)', + 'line': {'dash': 'dash', 'color': 'green'} + } + ], + 'layout': { + 'title': f'SVR Regression (Kernel: {kernel_type.upper()})', + 'xaxis': {'title': 'Feature Value'}, + 'yaxis': {'title': 'Target Value'}, + 'hovermode': 'closest' + } + } + + return jsonify({ + 'mse': mse, + 'r2_score': r2, + 'support_vectors_count': support_vectors_count, + 'plot_data': plot_data + }) + + except Exception as e: + print(f"Error in SVR demo: {e}") + return jsonify({'error': str(e)}), 500 + + +def clean_text(text): + return text.lower().strip() + + # Gradient-desent route +@app.route('/gradient-descent') +def gradient_descent(): + return render_template('Gradient-Descen.html') +#new + +@app.route('/gradient-descent-three') +def gradient_descent_three(): + return render_template('gradient-descent-three.html') + + +# Gradient-boosting route +@app.route('/gradient-boosting') +def gradient_boosting(): + return render_template('Gradient-Boosting.html') +#new +@app.route('/gradient-boosting-three') +def gradient_boosting_three(): + return render_template('gradient-boosting-three.html') + + + +# Gradient-xgboost route +@app.route('/xgboost-regression') +def xgboost_regression(): + return render_template('XGBoost-Regression.html') + +@app.route('/xgboost-tree-three') +def xgboost_regression_three(): + return render_template('xboost-tree-three.html') + +@app.route('/xgboost-graph-three2') +def xgboost_regression_three2(): + return render_template('xbost-graph-three.html') + + + +#Gradient-lightgbm route +@app.route('/lightgbm') +def lightgbm(): + return render_template('LightGBM-Regression.html') + + +@app.route('/Naive-Bayes-Simulator') +def Naive_Bayes_Simulator(): + return render_template('Naive-Bayes-Simulator.html') + +@app.route('/svm-model-three') +def svm_model_three(): + return render_template('SVM_Simulator_3D.html') + + + +#nerual network route for calssifcation +@app.route('/neural-network-classification') +def neural_network_classification(): + return render_template('Neural-Networks-for-Classification.html') + +@app.route('/Neural-Networks-for-Classification-three') +def Neural_Networks_for_Classification_three(): + return render_template('Neural-Networks-for-Classification-three.html') + + + +#hierarchical clustering route + +@app.route('/hierarchical-clustering') +def hierarchical_clustering(): + return render_template('Hierarchical-Clustering.html') + +@app.route('/hierarchical-three') +def hierarchical_three(): + return render_template('Hierarchical-three.html') + + +#Gaussian-mixture-models route +@app.route('/gaussian-mixture-models') +def gaussian_mixture_models(): + return render_template('Gaussian-Mixture-Models.html') + +@app.route('/gaussian-mixture-three') +def gaussian_mixture_three(): + return render_template('gmm-threejs.html') + + + + +#Principal-Component-Analysis +@app.route('/pca') +def pca(): + return render_template('Principal-Component-Analysis.html') + +@app.route('/pca-three') +def pca_three(): + return render_template('pca-threejs.html') + + + +#t-sne +@app.route('/t-sne') +def tsne(): + return render_template('t-SNE.html') + +@app.route('/t-sne-three') +def tsne_three(): + return render_template('t-sne-three.html') + + +# liner-discriminant-analysis +@app.route('/lda') +def lda(): + return render_template('Linear-Discriminant-Analysis.html') + + +@app.route('/lda-three') +def lda_three(): + return render_template('lda-three.html') + + +# Independent-Component-Analysis +@app.route('/ica') +def ica(): + return render_template('Independent-Component-Analysis.html') + + + +@app.route('/ica-three') +def ica_three(): + return render_template('ica-threejs.html') + + +#Apriori +@app.route('/apriori') +def apriori(): + return render_template('Apriori-Algorithm.html') + +@app.route('/apriori-three') +def apriori_three(): + return render_template('Apriori-Simulator-three.html') + + +# Eclat Algorithm +@app.route('/eclat') +def eclat(): + return render_template('Eclat-Algorithm.html') + +@app.route('/eclat-three') +def eclat_three(): + return render_template('Eclat-Algorithm-three.html') + +#genrative models +@app.route('/generative-models') +def generative_models(): + return render_template('Generative-Models.html') + +#self training +@app.route('/self-training') +def self_training(): + return render_template('Self-Training.html') + + +# TRANSDUCTIVE SVM +@app.route('/transductive-svm') +def transductive_svm(): + return render_template('Transductive-SVM.html') + + +#Graph-Based Methods +@app.route('/graph-based-methods') +def graph_based_methods(): + return render_template('Graph-Based-Method.html') + +#Agent-Environment-State +@app.route('/agent-environment-state') +def agent_environment_state(): + return render_template('Agent-Environment-State.html') + +#Action and Policy +@app.route('/action-and-policy') +def action_and_policy(): + return render_template('Action-and-Policy.html') + +#Reward-ValueFunction +@app.route('/reward-valuefunction') +def reward_valuefunction(): + return render_template('Reward-ValueFunction.html') + +#Q-Learning +@app.route('/q-learning') +def q_learning(): + return render_template('Q-Learning.html') + +#Deep Reinforcement Learning +@app.route('/deep-reinforcement-learning') +def deep_reinforcement_learning(): + return render_template('Deep-Reinforcement-Learning.html') + + +#Bagging +@app.route('/bagging') +def bagging(): + return render_template('Bagging.html') + +#Boosting +@app.route('/boosting') +def boosting(): + return render_template('Boosting.html') + +# stacking +@app.route('/stacking') +def stacking(): + return render_template('Stacking.html') + +# voting +@app.route('/voting') +def voting(): + return render_template('Voting.html') + +import re + +# Load saved model and vectorizer +# model = joblib.load("Models/logistic_model.pkl") +# vectorizer = joblib.load("Models/logvectorizer.pkl") + + +# Text cleaning +def clean_text(text): + text = text.lower() + text = re.sub(r'\W', ' ', text) + text = re.sub(r'\s+[a-zA-Z]\s+', ' ', text) + text = re.sub(r'\s+', ' ', text) + return text.strip() + +@app.route('/logistic', methods=['GET', 'POST']) +def logistic(): + prediction, confidence_percentage, cleaned, tokens, probability = None, None, None, None, None + + + # model = load_file("Models/logistic_model.pkl") + # vectorizer = load_file("Models/logvectorizer.pkl") + model = load_file("logistic_model.pkl") + vectorizer = load_file("logvectorizer.pkl") + + if request.method == "POST": + msg = request.form.get('message', '') + cleaned = clean_text(msg) + tokens = cleaned.split() + + + try: + vector = vectorizer.transform([cleaned]) + probability = model.predict_proba(vector)[0][1] + prediction = "Spam" if probability >= 0.5 else "Not Spam" + confidence_percentage = round(probability * 100, 2) + except Exception as e: + print("Error predicting:", e) + prediction = "Error" + confidence_percentage = 0 + + return render_template( + "logistic.html", + prediction=prediction, + confidence_percentage=confidence_percentage, + cleaned=cleaned, + tokens=tokens, + probability=round(probability, 4) if probability else None, + source="sms" + ) + +@app.route('/logistic-sms', methods=['POST']) +def logistic_sms(): + try: + data = request.get_json() + msg = data.get('message', '') + cleaned = clean_text(msg) + tokens = cleaned.split() + + vector = vectorizer.transform([cleaned]) + probability = model.predict_proba(vector)[0][1] + prediction = "Spam" if probability >= 0.5 else "Not Spam" + confidence_percentage = round(probability * 100, 2) + + return jsonify({ + "prediction": prediction, + "confidence": confidence_percentage, + "probability": round(probability, 4), + "cleaned": cleaned, + "tokens": tokens, + "source": "json" + }) + + except Exception as e: + print("Error in /logistic-sms:", e) + return jsonify({"error": "Internal server error", "details": str(e)}), 500 + + + +# @app.route("/logistic", methods=["GET", "POST"]) +# def logistic(): +# prediction = None +# error = None +# if request.method == "POST": +# try: +# input_text = request.form.get("message") + +# # Load the vectorizer and logistic model from Models folder +# vectorizer = joblib.load("Models/vectorizer.pkl") +# model = joblib.load("Models/logistic_model.pkl") + +# # Transform input and make prediction +# input_vector = vectorizer.transform([input_text]) +# result = model.predict(input_vector)[0] + +# prediction = "✅ Not Spam" if result == 0 else "🚨 Spam" +# except Exception as e: +# error = str(e) + +# return render_template("logistic.html", prediction=prediction, error=error) + + + + + + + #---------- LOAD MODEL & LABELS ONCE (startup) ---------- +# MODEL_PATH = os.path.join("Models", "knnmodel.joblib") # adjust if your filename is different +# LABELS_PATH = os.path.join("Models", "label_classes.npy") + +# try: +# model = joblib.load(MODEL_PATH) +# except Exception as e: +# # Keep model as None so routes can return clear error if it's missing +# current_app.logger if hasattr(current_app, "logger") else print +# print(f"Failed to load model from {MODEL_PATH}: {e}") +# model = None + +# try: +# label_classes = np.load(LABELS_PATH, allow_pickle=True) +# except Exception as e: +# print(f"Failed to load label_classes from {LABELS_PATH}: {e}") +# label_classes = None + +HF_DATASET_REPO = "deedrop1140/qwen-ml-tutor-assets" + + +def load_knn_assets(): + try: + model_path = hf_hub_download( + repo_id=HF_DATASET_REPO, + filename="knnmodel.joblib", + repo_type="dataset" + ) + + labels_path = hf_hub_download( + repo_id=HF_DATASET_REPO, + filename="label_classes.npy", + repo_type="dataset" + ) + + model = joblib.load(model_path) + label_classes = np.load(labels_path, allow_pickle=True) + + return model, label_classes + + except Exception as e: + print("❌ Failed to load KNN assets from Hugging Face:", e) + return None, None + + +# ---------- KNN VISUAL ROUTES (unchanged) ---------- +@app.route("/knn") +def knn_visual(): + return render_template("knn.html") + +@app.route('/knn_visual_predict', methods=['POST']) +def knn_visual_predict(): + data = request.get_json() + points = np.array(data['points']) # shape: (N, 3) + test_point = np.array(data['test_point']) # shape: (2,) + k = int(data['k']) + + X = points[:, :2] + y = points[:, 2].astype(int) + + knn_local = KNeighborsClassifier(n_neighbors=k) + knn_local.fit(X, y) + pred = knn_local.predict([test_point])[0] + + dists = np.linalg.norm(X - test_point, axis=1) + neighbor_indices = np.argsort(dists)[:k] + neighbors = X[neighbor_indices] + + return jsonify({ + 'prediction': int(pred), + 'neighbors': neighbors.tolist() + }) + +# ---------- IMAGE PREDICTION ROUTE (fixed) ---------- +@app.route("/knn_image") +def knn_image_page(): + return render_template("knn_image.html") + +@app.route("/predict_image", methods=["POST"]) +def predict_image(): + if model is None or label_classes is None: + return jsonify({"error": "Model not loaded"}), 500 + + if "image" not in request.files: + return jsonify({"error": "No image uploaded"}), 400 + + file = request.files["image"] + + try: + image = Image.open(file.stream).convert("L") + image = image.resize((28, 28)) + img_array = np.array(image).reshape(1, -1).astype("float32") + except Exception as e: + return jsonify({"error": f"Invalid image. {str(e)}"}), 400 + + probs = model.predict_proba(img_array)[0] + pred_index = np.argmax(probs) + pred_label = label_classes[pred_index] + confidence = round(float(probs[pred_index]) * 100, 2) + + return jsonify({ + "prediction": str(pred_label), + "confidence": f"{confidence}%", + "all_probabilities": { + str(label_classes[i]): round(float(probs[i]) * 100, 2) + for i in range(len(probs)) + } + }) + + +@app.route("/rfc") +def random_forest_page(): + return render_template("Random_Forest_Classifier.html") # Your beautiful HTML goes in rfc.html + +@app.route('/rf_visual_predict', methods=['POST']) +def rf_visual_predict(): + try: + data = request.get_json() + print("📦 Incoming JSON data:", data) + + labeled_points = data.get('points') + test_point = data.get('test_point') + + if not labeled_points or not test_point: + return jsonify({"error": "Missing points or test_point"}), 400 + + df = pd.DataFrame(labeled_points, columns=['X1', 'X2', 'Class']) + X = df[['X1', 'X2']] + y = df['Class'] + + rf_model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42) + rf_model.fit(X, y) + + test_point_np = np.array(test_point).reshape(1, -1) + prediction = int(rf_model.predict(test_point_np)[0]) + + x_min, x_max = X['X1'].min() - 1, X['X1'].max() + 1 + y_min, y_max = X['X2'].min() - 1, X['X2'].max() + 1 + xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), + np.linspace(y_min, y_max, 100)) + + Z = rf_model.predict(np.c_[xx.ravel(), yy.ravel()]) + Z = Z.reshape(xx.shape) + + return jsonify({ + 'prediction': prediction, + 'decision_boundary_z': Z.tolist(), + 'decision_boundary_x_coords': xx[0, :].tolist(), + 'decision_boundary_y_coords': yy[:, 0].tolist() + }) + + except Exception as e: + import traceback + print("❌ Exception in /rf_visual_predict:") + traceback.print_exc() # Print full error stack trace + return jsonify({"error": str(e)}), 500 + +@app.route("/liar") +def liar_input_page(): + return render_template("rfc_liar_predict.html") + + + + + + + +@app.route("/ref/liar/predictor", methods=["POST"]) +def liar_predictor(): + try: + data = request.get_json() + statement = data.get("statement", "") + + if not statement: + return jsonify({"success": False, "error": "Missing statement"}), 400 + + try: + # 🔍 LIAR Model Prediction + features = vectorizer.transform([statement]) + prediction = model.predict(features)[0] + + liar_label_map = { + 0: "It can be false 🔥", + 1: "False ❌", + 2: "Mostly false but can be true 🤏", + 3: "Half True 🌓", + 4: "Mostly True 👍", + 5: "True ✅" + } + + prediction_label = liar_label_map.get(int(prediction), "Unknown") + + except ValueError as ve: + if "features" in str(ve): + # Fallback to Gemini API + prediction_label = ask_gemini(statement) + else: + raise ve + + # 🧠 BERT-Based Scientific Check + bert_result = bert_checker(statement)[0] + bert_label = bert_result["label"] + bert_score = round(bert_result["score"] * 100, 2) + + science_label_map = { + "LABEL_0": "✅ Scientifically Possible", + "LABEL_1": "❌ Scientifically Impossible" + } + + scientific_check = f"{science_label_map.get(bert_label, bert_label)} ({bert_score:.2f}%)" + + return jsonify({ + "success": True, + "prediction": prediction_label, + "reason": "Predicted from linguistic and content-based patterns, or Gemini fallback.", + "scientific_check": scientific_check + }) + + except Exception as e: + traceback.print_exc() + return jsonify({"success": False, "error": str(e)}), 500 + + + +#svm +@app.route("/svm") +def svm_page(): + return render_template("svm.html") + +@app.route('/svm_visual_predict', methods=['POST']) +def svm_visual_predict(): + data = request.json + labeled_points = data['points'] + test_point = data['test_point'] + svm_type = data['svm_type'] + c_param = float(data['c_param']) + gamma_param = float(data['gamma_param']) # Will be ignored for linear kernel + + df = pd.DataFrame(labeled_points, columns=['X1', 'X2', 'Class']) + X = df[['X1', 'X2']] + y = df['Class'] + + # 1. Train the SVM Classifier + if svm_type == 'linear': + svm_model = svm.SVC(kernel='linear', C=c_param, random_state=42) + elif svm_type == 'rbf': + svm_model = svm.SVC(kernel='rbf', C=c_param, gamma=gamma_param, random_state=42) + else: + return jsonify({'error': 'Invalid SVM type'}), 400 + + svm_model.fit(X, y) + + # 2. Predict for the test point + test_point_np = np.array(test_point).reshape(1, -1) + prediction = int(svm_model.predict(test_point_np)[0]) + + # 3. Get Support Vectors + # support_vectors_ refers to indices of support vectors + # svc_model.support_vectors_ gives the actual support vectors + support_vectors = svm_model.support_vectors_.tolist() + + # 4. Generate data for the decision boundary + # Create a meshgrid of points to predict across the entire plot area + x_min, x_max = X['X1'].min() - 1, X['X1'].max() + 1 + y_min, y_max = X['X2'].min() - 1, X['X2'].max() + 1 + + # Extend range slightly to ensure test point is within boundary if it's an outlier + x_min = min(x_min, test_point_np[0,0] - 1) + x_max = max(x_max, test_point_np[0,0] + 1) + y_min = min(y_min, test_point_np[0,1] - 1) + y_max = max(y_max, test_point_np[0,1] + 1) + + xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), + np.linspace(y_min, y_max, 100)) + + # Predict class for each point in the meshgrid + Z = svm_model.predict(np.c_[xx.ravel(), yy.ravel()]) + Z = Z.reshape(xx.shape) + + # Convert numpy arrays to lists for JSON serialization + decision_boundary_z = Z.tolist() + decision_boundary_x_coords = xx[0, :].tolist() + decision_boundary_y_coords = yy[:, 0].tolist() + + return jsonify({ + 'prediction': prediction, + 'decision_boundary_z': decision_boundary_z, + 'decision_boundary_x_coords': decision_boundary_x_coords, + 'decision_boundary_y_coords': decision_boundary_y_coords, + 'support_vectors': support_vectors + }) + + + + + + + +@app.route('/api/explain', methods=['POST']) +def explain(): + # In a real deployed environment, you'd secure your API key. + # For Canvas, it's automatically injected if GEMINI_API_KEY is empty string. + # If running locally and not in Canvas, set GEMINI_API_KEY in your environment variables. + if not GEMINI_API_KEY and not os.getenv("FLASK_ENV") == "development": # Allow empty key in dev for local testing + return jsonify({'error': 'Missing API key'}), 500 + + payload = request.get_json() + + try: + response = requests.post( + f"{GEMINI_URL}?key={GEMINI_API_KEY}", + headers={"Content-Type": "application/json"}, + json=payload + ) + response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) + return jsonify(response.json()) + except requests.exceptions.RequestException as e: + app.logger.error(f"Error calling Gemini API: {e}") # Log the error on the server side + return jsonify({'error': str(e)}), 500 + +@app.route('/decision_tree') +def decision_tree_page(): + # This route serves your Decision Tree visualization page + # Ensure the HTML file name matches (e.g., 'decision_tree_viz.html' or 'decision_tree.html') + return render_template('decision_tree.html') # Check your actual HTML file name here + + +@app.route('/game') +def decision_tree_game(): + """Renders the interactive game page for decision trees.""" + return render_template('decision_tree_game.html') + +@app.route('/dt_visual_predict', methods=['POST']) +def dt_visual_predict(): + try: + data = request.json + labeled_points = data['points'] + test_point = data['test_point'] + max_depth = int(data['max_depth']) + + # Convert labeled_points to a pandas DataFrame + df = pd.DataFrame(labeled_points, columns=['X1', 'X2', 'Class']) + X = df[['X1', 'X2']] + y = df['Class'] + + # Check if there's enough data to train + if X.empty or len(X) < 2: + return jsonify({'error': 'Not enough data points to train the model.'}), 400 + + # 1. Train the Decision Tree Classifier (This is the "model" part) + dt_model = DecisionTreeClassifier(max_depth=max_depth, random_state=42) + dt_model.fit(X, y) + + # 2. Predict for the test point + test_point_np = np.array(test_point).reshape(1, -1) + prediction = int(dt_model.predict(test_point_np)[0]) + + # 3. Generate data for the decision boundary + x_min, x_max = X['X1'].min(), X['X1'].max() + y_min, y_max = X['X2'].min(), X['X2'].max() + + # Add a buffer to the plot range to make sure points are not on the edge + # And handle cases where min == max (e.g., all points have same X1 value) + x_buffer = 1.0 if (x_max - x_min) == 0 else (x_max - x_min) * 0.1 + y_buffer = 1.0 if (y_max - y_min) == 0 else (y_max - y_min) * 0.1 + + x_min -= x_buffer + x_max += x_buffer + y_min -= y_buffer + y_max += y_buffer + + # Ensure test point is also comfortably within the range + x_min = min(x_min, test_point_np[0,0] - 0.5) + x_max = max(x_max, test_point_np[0,0] + 0.5) + y_min = min(y_min, test_point_np[0,1] - 0.5) + y_max = max(y_max, test_point_np[0,1] + 0.5) + + # Create a meshgrid for plotting the decision boundary + xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), + np.linspace(y_min, y_max, 100)) + + # Predict class for each point in the meshgrid using the trained model + Z = dt_model.predict(np.c_[xx.ravel(), yy.ravel()]) + Z = Z.reshape(xx.shape) + + # Convert numpy arrays to lists for JSON serialization + decision_boundary_z = Z.tolist() + decision_boundary_x_coords = xx[0, :].tolist() + decision_boundary_y_coords = yy[:, 0].tolist() + + return jsonify({ + 'prediction': prediction, + 'decision_boundary_z': decision_boundary_z, + 'decision_boundary_x_coords': decision_boundary_x_coords, + 'decision_boundary_y_coords': decision_boundary_y_coords + }) + except Exception as e: + # This will print the actual error to your terminal + print(f"An error occurred in /dt_visual_predict: {e}") + # Return a more informative error message to the frontend + return jsonify({'error': f'Backend Error: {str(e)}. Check server console for details.'}), 500 + + # --- Naive Bayes Routes --- + +from urllib.parse import urlparse +from sklearn.naive_bayes import GaussianNB +from nltk.corpus import words + +nb_model = load_file("nb_url_model.pkl") +vectorizer = load_file("nb_url_vectorizer.pkl") + +# if nb_model is not None and vectorizer is not None: +# print("✅ Loaded Naive Bayes URL model") +# else: +# nb_model, vectorizer = None, None +# print("❌ vectorizer not found") + + + +@app.route('/nb_spam') +def nb_spam_page(): + return render_template('NB_spam.html') + + +import re +from urllib.parse import urlparse +from spellchecker import SpellChecker +import wordninja + + + +# ---- Whitelist (your full one, unchanged) ---- +whitelist = set([ + # Search Engines + 'google', 'bing', 'yahoo', 'duckduckgo', 'baidu', 'ask', + + # Social Media + 'facebook', 'instagram', 'twitter', 'linkedin', 'snapchat', 'tiktok', + 'threads', 'pinterest', 'reddit', 'quora', + + # Communication Tools + 'whatsapp', 'telegram', 'skype', 'zoom', 'meet', 'discord', + 'teams', 'signal', 'messenger', + + # Global E-commerce + 'amazon', 'ebay', 'shopify', 'alibaba', 'walmart', 'target', + 'etsy', 'shein', 'bestbuy', 'costco', 'newegg', + + # Indian E-commerce / Services + 'flipkart', 'myntra', 'ajio', 'nykaa', 'meesho', 'snapdeal', + 'paytm', 'phonepe', 'mobikwik', 'zomato', 'swiggy', 'ola', 'uber', 'bookmyshow', + 'ixigo', 'makemytrip', 'yatra', 'redbus', 'bigbasket', 'grofers', 'blinkit', + 'universalcollegeofengineering', + + # Education / Productivity + 'youtube', 'docs', 'drive', 'calendar', 'photos', 'gmail', 'notion', + 'edx', 'coursera', 'udemy', 'khanacademy', 'byjus', 'unacademy', + + # News / Media / Tech + 'bbc', 'cnn', 'nyt', 'forbes', 'bloomberg', 'reuters', + 'ndtv', 'indiatimes', 'thehindu', 'hindustantimes', 'indiatoday', + 'techcrunch', 'verge', 'wired', + + # Streaming / Entertainment + 'netflix', 'hotstar', 'primevideo', 'spotify', 'gaana', 'wynk', 'saavn', 'voot', + + # Dev & Tools + 'github', 'stackoverflow', 'medium', 'gitlab', 'bitbucket', + 'adobe', 'figma', 'canva', + + # Financial / Banking + 'hdfcbank', 'icicibank', 'sbi', 'axisbank', 'kotak', 'boi', 'upi', + 'visa', 'mastercard', 'paypal', 'stripe', 'razorpay', 'phonepe', 'paytm', + + # Government / Utilities + 'gov', 'nic', 'irctc', 'uidai', 'mygov', 'incometax', 'aadhar', 'rbi', + + # Others Common + 'airtel', 'jio', 'bsnl', 'vi', 'speedtest', 'cricbuzz', 'espn', 'espncricinfo', + 'wikipedia', 'mozilla', 'opera', 'chrome', 'android', 'apple', 'windows', 'microsoft' +]) + + # ... your full whitelist from before ... + + +# ---- Trusted & Bad TLDs ---- +trusted_tlds = [ + '.gov', '.nic.in', '.edu', '.ac.in', '.mil', '.org', '.int', + '.co.in', '.gov.in', '.res.in', '.net.in', '.nic.gov.in' +] + +# Expanded Bad TLDs (Rule 4) +bad_tlds = [ + '.xyz', '.tk', '.ml', '.ga', '.cf', '.top', '.gq', '.cn', + '.ru', '.pw', '.bid', '.link', '.loan', '.party', '.science', + '.stream', '.webcam', '.online', '.site', '.website', '.space', + '.club', '.buzz', '.info' +] + +# Suspicious extensions (Rule 13) +suspicious_extensions = ['.exe', '.zip', '.rar', '.js', '.php', '.asp', '.aspx', '.jsp', '.sh'] + +# Phishing keywords (Rule 11, your full list) +phishing_keywords = [ + 'login', 'verify', 'secure', 'account', 'update', 'confirm', 'authenticate', + 'free', 'bonus', 'offer', 'prize', 'winner', 'gift', 'coupon', 'discount', + 'bank', 'paypal', 'creditcard', 'mastercard', 'visa', 'amex', 'westernunion', + 'signin', 'click', 'password', 'unlock', 'recover', 'validate', 'urgency', + 'limitedtime', 'expires', 'suspicious', 'alert', 'important', 'actionrequired' +] + +# ---- Rules 5–14 ---- +rules = { + 5: r"https?://\d{1,3}(\.\d{1,3}){3}", + 6: r"@[A-Za-z0-9.-]+\.[A-Za-z]{2,}", + 7: r"(free money|win now|click here)", + 8: r"https?://[^\s]*\.(ru|cn|tk)", + 9: r"https?://.{0,6}\..{2,6}/.{0,6}", + 10: r"[0-9]{10,}", + 12: r"https?://[^\s]*@[^\s]+", + 13: r"https?://[^\s]*//[^\s]+", + 14: r"https?://[^\s]*\?(?:[^=]+=[^&]*&){5,}", +} + + +# ---- Gibberish Check Helper (Rule 15) ---- +def is_gibberish_word(word): + vowels = "aeiou" + v_count = sum(c in vowels for c in word) + return v_count / len(word) < 0.25 + +# # ---- Utility: Extract words from URL ---- +# def extract_words(url): +# parsed = urlparse(url if url.startswith(("http://", "https://")) else "http://" + url) +# raw = parsed.netloc.replace('-', '') + parsed.path.replace('-', '') +# # Split using wordninja +# words = wordninja.split(raw.lower()) +# # Keep only alphabetic words of length >= 3 +# words = [w for w in words if w.isalpha() and len(w) >= 3] +# return words +# ---- Extract words from URL ---- +def extract_words(url): + parsed = urlparse(url if url.startswith(("http://", "https://")) else "http://" + url) + parts = re.split(r'\W+', parsed.netloc + parsed.path) + final_words = [] + for word in parts: + if len(word) > 2 and word.isalpha(): + split_words = wordninja.split(word.lower()) + if len(split_words) <= 1: + split_words = [word.lower()] + final_words.extend(split_words) + return final_words + + +# --- Your original predict function, now inside the Flask app --- +@app.route("/predict", methods=["POST"]) +def predict(): + try: + data = request.get_json() + url = data.get("url", "").lower() + if not url: + return jsonify({'error': 'No URL provided'}), 400 + + parsed = urlparse(url if url.startswith(("http://", "https://")) else "http://" + url) + path = parsed.path + + # ---- SpellChecker using built-in dictionary ---- + spell = SpellChecker(distance=1) + + # ---- Extract words and check spelling ---- + words = extract_words(url) + # ignore known TLDs + tlds_to_ignore = [tld.replace('.', '',"/") for tld in trusted_tlds + bad_tlds] + words_for_spellcheck = [w for w in words if w not in tlds_to_ignore] + + misspelled = spell.unknown(words_for_spellcheck) + steps = [{"word": w, "valid": (w not in misspelled) or (w in tlds_to_ignore)} for w in words] + + if misspelled: + return jsonify({ + "prediction": 1, + "reason": f"🧾 Spelling errors: {', '.join(misspelled)}", + "steps": steps + }) + else: + return jsonify({ + "prediction": 0, + "reason": "✅ No spelling issues", + "steps": steps + }) + + except Exception as e: + return jsonify({'error': f"An issue occurred during spell checking: {str(e)}"}), 500 + + + + +@app.route('/naive_bayes') +def naive_bayes_page(): + return render_template('naive_bayes_viz.html') + + # --- New Naive Bayes Prediction Route --- +@app.route('/nb_visual_predict', methods=['POST']) +def nb_visual_predict(): + try: + data = request.json + labeled_points = data['points'] + test_point = data['test_point'] + + df = pd.DataFrame(labeled_points, columns=['X1', 'X2', 'Class']) + X = df[['X1', 'X2']] + y = df['Class'] + + # Ensure enough data and at least two classes for classification + if X.empty or len(X) < 2: + return jsonify({'error': 'Not enough data points to train the model.'}), 400 + if len(y.unique()) < 2: + return jsonify({'error': 'Need at least two different classes to classify.'}), 400 + + # Train Gaussian Naive Bayes Model + # GaussianNB is suitable for continuous data + nb_model = GaussianNB() + nb_model.fit(X, y) + + # Predict for the test point + test_point_np = np.array(test_point).reshape(1, -1) + prediction = int(nb_model.predict(test_point_np)[0]) + + # Generate data for the decision boundary + x_min, x_max = X['X1'].min(), X['X1'].max() + y_min, y_max = X['X2'].min(), X['X2'].max() + + x_buffer = 1.0 if x_max - x_min == 0 else (x_max - x_min) * 0.1 + y_buffer = 1.0 if y_max - y_min == 0 else (y_max - y_min) * 0.1 + + x_min -= x_buffer + x_max += x_buffer + y_min -= y_buffer + y_max += y_buffer + + x_min = min(x_min, test_point_np[0,0] - 0.5) + x_max = max(x_max, test_point_np[0,0] + 0.5) + y_min = min(y_min, test_point_np[0,1] - 0.5) + y_max = max(y_max, test_point_np[0,1] + 0.5) + + xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), + np.linspace(y_min, y_max, 100)) + + if xx.size == 0 or yy.size == 0: + return jsonify({'error': 'Meshgrid could not be created. Data range too narrow.'}), 400 + + # Predict class for each point in the meshgrid + # Use predict_proba and then argmax to get class for decision boundary coloring + Z = nb_model.predict(np.c_[xx.ravel(), yy.ravel()]) + Z = Z.reshape(xx.shape) + + decision_boundary_z = Z.tolist() + decision_boundary_x_coords = xx[0, :].tolist() + decision_boundary_y_coords = yy[:, 0].tolist() + + return jsonify({ + 'prediction': prediction, + 'decision_boundary_z': decision_boundary_z, + 'decision_boundary_x_coords': decision_boundary_x_coords, + 'decision_boundary_y_coords': decision_boundary_y_coords + }) + except Exception as e: + print(f"An error occurred in /nb_visual_predict: {e}") + return jsonify({'error': f'Backend Error: {str(e)}. Check server console for details.'}), 500 + +def check_with_virustotal(url): + try: + headers = {"x-apikey": VT_API_KEY} + submit_url = "https://www.virustotal.com/api/v3/urls" + + # Submit the URL for scanning + response = requests.post(submit_url, headers=headers, data={"url": url}) + url_id = response.json()["data"]["id"] + + # Fetch result + result = requests.get(f"{submit_url}/{url_id}", headers=headers) + data = result.json() + + stats = data["data"]["attributes"]["last_analysis_stats"] + malicious_count = stats.get("malicious", 0) + + if malicious_count > 0: + return True, f"☣️ VirusTotal flagged it as malicious ({malicious_count} engines)" + return False, None + except Exception as e: + print(f"⚠️ VirusTotal error: {e}") + + + + return False, None + + + + + + + + + + +@app.route('/kmeans-clustering') +def clustering(): + return render_template('clustering.html') + +#image code +@app.route('/kmeans-Dbscan-image', methods=['GET', 'POST']) +def compress_and_clean(): + final_image = None + + if request.method == 'POST': + try: + # Get form values + mode = request.form.get('mode', 'compress') + k = int(request.form.get('k', 8)) + eps = float(request.form.get('eps', 0.6)) + min_samples = int(request.form.get('min_samples', 50)) + image_file = request.files.get('image') + + if image_file and image_file.filename != '': + # Load image + img = Image.open(image_file).convert('RGB') + max_size = (518, 518) + img.thumbnail(max_size, Image.Resampling.LANCZOS) + + img_np = np.array(img) + h, w, d = img_np.shape + pixels = img_np.reshape(-1, d) + + # Apply KMeans + kmeans = KMeans(n_clusters=k, random_state=42, n_init=10) + kmeans.fit(pixels) + clustered_pixels = kmeans.cluster_centers_[kmeans.labels_].astype(np.uint8) + + # Mode 1: Just Compress + if mode == 'compress': + final_pixels = clustered_pixels.reshape(h, w, d) + + # Mode 2: Compress + Clean (KMeans + DBSCAN) + else: + # Sample to avoid MemoryError + max_dbscan_pixels = 10000 + if len(clustered_pixels) > max_dbscan_pixels: + idx = np.random.choice(len(clustered_pixels), max_dbscan_pixels, replace=False) + dbscan_input = clustered_pixels[idx] + else: + dbscan_input = clustered_pixels + + # DBSCAN + # For DBSCAN: use only 10,000 pixels max + max_dbscan_pixels = 10000 + + scaler = StandardScaler() + pixels_scaled = scaler.fit_transform(dbscan_input) + db = DBSCAN(eps=eps, min_samples=min_samples) + labels = db.fit_predict(pixels_scaled) + + # Clean noisy pixels + clean_pixels = [] + for i in range(len(dbscan_input)): + label = labels[i] + clean_pixels.append([0, 0, 0] if label == -1 else dbscan_input[i]) + + # Fill extra if sampling was used + if len(clustered_pixels) > max_dbscan_pixels: + clean_pixels.extend([[0, 0, 0]] * (len(clustered_pixels) - len(clean_pixels))) + + final_pixels = np.array(clean_pixels, dtype=np.uint8).reshape(h, w, d) + + # Save final image + final_img = Image.fromarray(final_pixels) + final_image = 'compressed_clean.jpg' + final_img.save(os.path.join(app.config['UPLOAD_FOLDER'], final_image), optimize=True, quality=90) + + except Exception as e: + return f"⚠️ Error: {str(e)}", 500 + + return render_template('kmean-dbscan-image.html', final_image=final_image) + +@app.route('/DBscan') +def DBSCAN(): + return render_template('DBSCAN.html') + + +#test routs start here + + +@app.route('/Test-layout') +def test(): + return render_template('Test-layout.html') + +@app.route('/Test-home') +def Test_home(): + return render_template('Test-home.html',active_page='Test-home') + +@app.route('/Test-supervise') +def Test_supervise(): + return render_template('Test/Test-supervise.html', active_page='Test-supervise') + + +@app.route('/Test-unsupervised') +def Test_unsupervised(): + return render_template('Test/Test-unsupervised.html', active_page='Test-unsupervised') + +# Semi-Supervised Learning page +@app.route('/Test-semi-supervised') +def Test_semi_supervised(): + return render_template('Test/Test-semi_supervised.html', active_page='Test-semi_supervised') + +# Reinforcement Learning page +@app.route('/Test-reinforcement') +def Test_reinforcement(): + return render_template('Test/Test-reinforcement.html', active_page='Test-reinforcement') + +# Ensemble Learning page +@app.route('/Test-ensemble') +def Test_ensemble(): + return render_template('Test/Test-ensemble.html', active_page='Test-ensemble') + +#Templates/Test/Quiz-Overview-Page.html +@app.route('/linear-Quiz-Overview-Page') +def linear_Test_quiz_overview(): + return render_template('Test/linear-Quiz-Overview-Page.html', active_page='linear-Quiz-Overview-Page') + + +@app.route('/Quiz-test') +def Quiz_test(): + return render_template('Test/Quiz-test.html', active_page='Quiz-test') +#if the dtat file doesnt show or dsiapay use render_data like this render_template('data/yourfile.json') + +# @app.route('/Quiz-test/Story-style intuition: The Video Game Character
+Think of a character in a video game. At any moment, the character has a set of possible moves they can make—jump, run, duck, attack. These are the character's Actions. The player controlling the character has a strategy in their head: "If a monster is close, I should attack. If there's a pit, I should jump." This strategy, this set of rules that dictates which action to take in any situation, is the Policy. In Reinforcement Learning, our goal is to teach the agent (the character) to learn the best possible policy on its own to win the game (maximize rewards).
+In the world of RL, the Action is the "what" (what the agent does) and the Policy is the "how" (how the agent decides what to do). Together, they form the core of the agent's behavior.
+ +An Action is one of the possible moves an agent can make in a given state. The set of all possible actions in a state is called the action space.
+Example: In a maze, the actions are {Up, Down, Left, Right}. In a game of tic-tac-toe, the actions are placing your mark in one of the empty squares.
Example: For a self-driving car, the action of steering can be any angle between -45.0 and +45.0 degrees. For a thermostat, the action is setting a temperature, which can be any value like 20.5°C.
The set of available actions can depend on the current state, denoted as \( A(s) \).
+ +A Policy is the agent's strategy or "brain." It is a rule that maps a state to an action. The ultimate goal of RL is to find an optimal policy—a policy that maximizes the total expected reward over time.
+Mathematically, a policy is a distribution over actions given a state: \( \pi(a|s) = P(A_t = a \mid S_t = s) \)
+Story Example: A self-driving car's policy is deterministic: "If the traffic light state is 'Red', the action is always 'Brake'." There is no chance it will do something else.
Formula: \( a = \pi(s) \)
+Story Example: A poker-playing bot might have a stochastic policy. In a certain state, its policy might be: "70% chance of 'Raising', 30% chance of 'Folding'." This randomness makes the agent's behavior less predictable to opponents and is crucial for exploration.
Formula: \( a \sim \pi(\cdot|s) \)
+It's crucial to distinguish between a policy and a value function, as they work together to guide the agent.
+ +Example: "You are at a crossroads. The policy says: Turn Left."
Example: "You are at a crossroads. The value function tells you: The path to the left has a high value because it leads to treasure. The path to the right has a low value because it leads to a dragon."
Modern RL algorithms often learn both. They use the value function to evaluate how good their actions are, which in turn helps them improve their policy.
+ +The Action and Policy are at the heart of the agent's decision-making in the RL loop.
+Example: In a real-time strategy game like StarCraft, an action could be commanding any one of hundreds of units to do any one of a dozen things, leading to millions of possible actions at any moment.
1. A discrete action space has a finite number of distinct options (e.g., move left/right). A continuous action space has actions represented by real numbers in a range (e.g., turning a steering wheel by 15.7 degrees).
+2. A deterministic policy always chooses the same action for a state. A stochastic policy outputs a probability distribution over actions. A stochastic policy is very useful for exploration (trying new things) and for games where unpredictability is an advantage (like poker).
+3. Yes, but it's harder. Some algorithms, called "policy-gradient" methods, can directly search for a good policy without learning a value function. However, many of the most successful modern algorithms learn both, using the value function to help guide improvements to the policy.
+Story-style intuition: Training a Dog
+Imagine you are training a new puppy. You don't give it a textbook on how to behave. Instead, you use a system of rewards and consequences. When the puppy sits on command, you give it a treat (a positive reward). When it chews on the furniture, you say "No!" (a negative reward). Through a process of trial-and-error, the puppy gradually learns a set of behaviors (a "policy") that maximizes the number of treats it receives over its lifetime. This is the essence of Reinforcement Learning (RL). It's about learning what to do—how to map situations to actions—so as to maximize a numerical reward signal.
+Reinforcement Learning (RL) is a type of machine learning where an agent learns to make a sequence of decisions in an environment to achieve a long-term goal. It is fundamentally different from other learning paradigms:
+Example: This is like a student studying for a test with a complete set of practice questions and the correct answers. They learn by correcting their mistakes.
Example: This is like a historian being given a thousand ancient, untranslated texts and trying to group them by language or topic, without any prior knowledge.
Example: This is like a person learning to play a video game. They don't have an answer key. They learn that certain actions lead to points (rewards) and others lead to losing a life (negative rewards), and their goal is to get the highest score possible.
The "Training a Dog" analogy helps us define the core building blocks of any RL problem.
+Example: The puppy is the agent. In a video game, the character you control is the agent.
Example: Your house, including the furniture, your commands, and the treats, is the environment. The game world, including its rules, levels, and enemies, is the environment.
Example: A state for the puppy could be a snapshot: "in the living room, toy is on the floor, owner is holding a treat." For a chess game, the state is the position of every piece on the board.
Example: In the given state, the puppy's available actions might be "sit," "bark," "run," or "chew toy."
Example: If the puppy sits, it gets a +10 reward (a treat). If it barks, it gets a -1 reward (a stern look).
Example: An initial, untrained policy for the puppy is random. A final, well-trained policy is a smart set of rules: "If I see my owner holding a treat, the best action is to sit immediately."
Example: The puppy learns that the state "sitting by the front door in the evening" has a high value. While this state itself doesn't give an immediate reward, it often leads to a highly rewarding future state: going for a walk.
RL is a continuous loop of interaction between the agent and the environment, where each step refines the agent's understanding.
+ +To formalize this process, mathematicians use a framework called a Markov Decision Process (MDP). It's simply a way of writing down all the rules of the "game" the agent is playing, assuming that the future depends only on the current state and action, not on the past (the Markov Property).
+An MDP is defined by a tuple: \( (S, A, P, R, \gamma) \)
+Example: In a slippery, icy world, if a robot in state "at square A" takes the action "move North," the transition probability might be: 80% chance of ending up in the state "at square B (north of A)," 10% chance of slipping and ending up "at square C (east of A)," and 10% chance of not moving at all ("at square A").
Example: In a maze, the reward is -1 for every step taken (to encourage finishing quickly) and +100 for taking the action that leads to the exit state.
Example: A reward of 100 you receive in two steps is worth \(100 \times \gamma^2\) to you right now. If γ=0.9, that future reward is worth 81 now. If γ=0.1, it's worth only 1 now. This prevents infinite loops and makes the agent prioritize rewards that are closer in time.
| Advantages of RL | +Challenges in RL | +
|---|---|
| ✅ Can solve complex problems that are difficult to program explicitly. Example: It's nearly impossible to write rules by hand for all situations a self-driving car might face. RL allows the car to learn these rules from experience. |
+ ❌ Large State Spaces: For problems like Go, the number of possible board states is greater than the number of atoms in the universe, making it impossible to explore them all. | +
| ✅ The agent can adapt to dynamic, changing environments. Example: A trading bot can adapt its strategy as market conditions change over time. |
+ ❌ Sparse Rewards: In many problems, rewards are only given at the very end (like winning a game). This is the "credit assignment problem" - it's hard for the agent to figure out which of its many early actions were actually responsible for the final win. | +
| ✅ A very general framework that can be applied to many different fields. | +❌ Exploration vs. Exploitation: This is a fundamental trade-off.
+ Example: When choosing a restaurant, do you exploit your knowledge and go to your favorite place that you know is great? Or do you explore a new restaurant that might be even better, but also risks being terrible? |
+
1. In Supervised Learning, the feedback is the "correct answer" from a labeled dataset. In Reinforcement Learning, the feedback is a scalar "reward" signal, which only tells the agent how good its action was, not what the best action would have been.
+2. A policy is the agent's strategy for choosing an action in a given state. A simple analogy is a recipe: for a given state ("I have eggs, flour, and sugar"), the policy (recipe) tells you which action to take ("mix them together").
+3. The discount factor controls how much the agent cares about future rewards versus immediate rewards. A γ = 0 would mean the agent is completely "myopic" or short-sighted, only caring about the immediate reward from its next action and ignoring any long-term consequences.
+4. It's the dilemma of choosing between trying something new (exploration) to potentially find a better outcome, versus sticking with what you know works well (exploitation). An example is choosing a restaurant: do you go to your favorite restaurant that you know is great (exploitation), or do you try a new one that might be even better, or might be terrible (exploration)?
+The Story: Decoding the Dog Trainer's Manual
+Story-style intuition: The Supermarket Detective
+Imagine you're a detective hired by a supermarket. Your mission is to analyze thousands of shopping receipts (transactions) to find hidden patterns. You soon notice a classic pattern: "Customers who buy bread also tend to buy butter." This is a valuable clue! The store can place bread and butter closer together to increase sales. The Apriori Algorithm is the systematic method this detective uses to sift through all the receipts and find these "frequently bought together" item combinations and turn them into powerful rules. This whole process is called Market Basket Analysis.
+The Apriori Algorithm is a classic algorithm used for association rule mining. Its main goal is to find relationships and patterns between items in large transactional datasets. It generates rules in the format "If A, then B," helping businesses understand customer behavior and make smarter decisions.
+ +To be a good supermarket detective, you need to know the lingo. The three most important metrics are Support, Confidence, and Lift.
+Example Scenario: Let's say we have 100 shopping receipts.
+Example: The support for {Bread, Butter} is 60/100 = 0.6 or 60%. This tells us that 60% of all shoppers bought bread and butter together. High support means the itemset is frequent.
+$$ \text{Confidence}(X \Rightarrow Y) = \frac{\text{Support}(X \cup Y)}{\text{Support}(X)} $$
+Example: Confidence({Bread} => {Butter}) = Support({Bread, Butter}) / Support({Bread}) = 60 / 80 = 0.75 or 75%. This means that 75% of customers who bought bread also bought butter. High confidence makes the rule strong.
+$$ \text{Lift}(X \Rightarrow Y) = \frac{\text{Confidence}(X \Rightarrow Y)}{\text{Support}(Y)} $$
+Example: Lift({Bread} => {Butter}) = Confidence({Bread} => {Butter}) / Support({Butter}) = 0.75 / 0.7 = 1.07.
+
• Lift > 1: Indicates a positive correlation (buying bread increases the likelihood of buying butter).
+
• Lift = 1: No correlation.
+
• Lift < 1: Negative correlation.
The Detective's Golden Rule: Our detective quickly realizes a simple but powerful truth: If customers rarely buy {Milk}, then they will *definitely* rarely buy the combination {Milk, Bread, Eggs}. Why waste time checking the records for a combination containing an already unpopular item? This is the Apriori Principle.
+The principle states: "All non-empty subsets of a frequent itemset must also be frequent." This is the core idea that makes the Apriori algorithm efficient. It allows the algorithm to "prune" the search space by eliminating a huge number of candidate itemsets. If {Milk} is infrequent, any larger itemset containing {Milk} is guaranteed to be infrequent and can be ignored.
+ +The algorithm works iteratively, building up larger and larger frequent itemsets level by level.
+ +Here, we'll be a supermarket detective with a small set of receipts. We need to prepare our data in a specific way (a one-hot encoded format) where each row is a transaction and each column is an item. Then, we'll use the `apriori` function to find frequent itemsets and `association_rules` to find the strong relationships.
+
+import pandas as pd
+from mlxtend.frequent_patterns import apriori, association_rules
+
+# --- 1. Create a Sample Dataset ---
+# This represents 5 shopping receipts.
+dataset = [['Milk', 'Onion', 'Nutmeg', 'Kidney Beans', 'Eggs', 'Yogurt'],
+ ['Dill', 'Onion', 'Nutmeg', 'Kidney Beans', 'Eggs', 'Yogurt'],
+ ['Milk', 'Apple', 'Kidney Beans', 'Eggs'],
+ ['Milk', 'Unicorn', 'Corn', 'Kidney Beans', 'Yogurt'],
+ ['Corn', 'Onion', 'Onion', 'Kidney Beans', 'Ice cream', 'Eggs']]
+
+# --- 2. Prepare Data in One-Hot Encoded Format ---
+# mlxtend's apriori needs the data as a DataFrame of True/False values.
+from mlxtend.preprocessing import TransactionEncoder
+te = TransactionEncoder()
+te_ary = te.fit(dataset).transform(dataset)
+df = pd.DataFrame(te_ary, columns=te.columns_)
+
+# --- 3. Find Frequent Itemsets with Apriori ---
+# We set min_support to 0.6, meaning we only want itemsets
+# that appear in at least 60% of the transactions (3 out of 5).
+frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
+print("--- Frequent Itemsets (Support >= 60%) ---")
+print(frequent_itemsets)
+
+# --- 4. Generate Association Rules ---
+# We generate rules that have a confidence of at least 70%.
+rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
+# Let's sort the rules by their "lift" to see the strongest relationships.
+sorted_rules = rules.sort_values(by='lift', ascending=False)
+print("\n--- Strong Association Rules (Confidence >= 70%) ---")
+print(sorted_rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])
+ 1. The Apriori Principle states that all subsets of a frequent itemset must also be frequent. It's important because it allows the algorithm to prune a massive number of candidate itemsets early on, making the process much more efficient.
+2. Confidence({A} => {B}) = Support({A, B}) / Support({A}) = 20% / 30% ≈ 66.7%.
+3. A Lift of 3.0 means that customers who buy diapers are 3 times more likely to buy beer than a randomly chosen customer. This indicates a strong positive association.
+4. The main bottleneck is the candidate generation step. In each pass, it can create a very large number of potential itemsets that need to be checked against the entire database, which is slow and memory-intensive.
+The Story: Decoding the Supermarket Detective's Notebook
+Story-style intuition: The Wisdom of Crowds
+Imagine you want to guess the number of jellybeans in a giant jar. If you ask one person, their guess might be way off. They might be an expert, or they might be terrible at guessing. Their prediction has high variance. But what if you ask 100 different people and take the average of all their guesses? The final averaged guess is almost always much closer to the true number than any single individual's guess. This is the "wisdom of crowds" effect. Bagging applies this same logic to machine learning. Instead of trusting one complex model (one expert guesser), we train many models on slightly different perspectives of the data and combine their predictions to get a more stable and accurate result.
+Bagging, short for Bootstrap Aggregating, is a powerful ensemble machine learning technique. Its primary goal is to reduce the variance of a model, thereby preventing overfitting and improving its stability. It works by training multiple instances of the same base model on different random subsets of the training data and then aggregating their predictions.
+ +The process of Bagging is a straightforward three-step method.
+ +Example: If our original dataset is `[A, B, C, D]`, a bootstrap sample might be `[B, A, D, B]`. Notice that 'B' was picked twice and 'C' was not picked at all. Each bootstrap sample is the same size as the original dataset.
The aggregation step is what combines the "wisdom" of the individual models. For a new data point \(x\), and \(m\) trained models:
+$$ \hat{y} = \frac{1}{m} \sum_{i=1}^{m} f_i(x) $$
+$$ \hat{y} = \text{majority\_vote}\{f_1(x), ..., f_m(x)\} $$
+| Advantages | +Disadvantages | +
|---|---|
| ✅ Significantly reduces overfitting and variance. | +❌ Increased Computational Cost: You have to train multiple models instead of just one, which takes more time and resources. | +
| ✅ Often leads to a major improvement in accuracy and stability. | +❌ Loss of Interpretability: It's easy to understand and visualize a single decision tree, but it's very difficult to interpret the combined logic of 100 different trees. | +
| ✅ Can be applied to almost any type of base model (e.g., trees, SVMs, neural networks). | +❌ Less effective for models that are already stable and have low variance (like Linear Regression). | +
In this example, we'll compare a single, complex Decision Tree to a Bagging ensemble of many Decision Trees. We expect the single tree to overfit and perform perfectly on the training data but poorly on the test data. The Bagging classifier should be more robust and perform well on both.
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import BaggingClassifier
+from sklearn.metrics import accuracy_score
+
+# --- 1. Create a Sample Dataset ---
+X, y = make_classification(n_samples=500, n_features=10, n_informative=5,
+ n_redundant=0, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# --- 2. Train a Single Decision Tree (High Variance Model) ---
+single_tree = DecisionTreeClassifier(random_state=42)
+single_tree.fit(X_train, y_train)
+y_pred_tree = single_tree.predict(X_test)
+print(f"Single Decision Tree Accuracy: {accuracy_score(y_test, y_pred_tree):.2%}")
+
+# --- 3. Train a Bagging Ensemble of Decision Trees ---
+# We create an ensemble of 100 decision trees.
+bagging_clf = BaggingClassifier(
+ base_estimator=DecisionTreeClassifier(random_state=42),
+ n_estimators=100,
+ random_state=42
+)
+bagging_clf.fit(X_train, y_train)
+y_pred_bagging = bagging_clf.predict(X_test)
+print(f"Bagging Classifier Accuracy: {accuracy_score(y_test, y_pred_bagging):.2%}")
+ 1. Bootstrap refers to creating random subsamples of the data with replacement. Aggregating refers to combining the predictions of the models trained on these subsamples (e.g., by averaging or voting).
+2. The main goal of Bagging is to reduce variance. It helps to stabilize unstable models that are prone to overfitting.
+3. You would take the average of the price predictions from all the individual models in the ensemble.
+4. Linear Regression is a low-variance (stable) model. Its predictions don't change drastically even when the training data is slightly modified. Since Bagging's main strength is reducing variance, it provides little benefit to an already stable model.
+The Story: Decoding the Jellybean Guesser's Strategy
+Story-style intuition: The Specialist Study Group
+Imagine a group of students studying for a difficult exam. Instead of studying independently (like in Bagging), they study sequentially. The first student takes a practice test and gets some questions right and some wrong. The second student then focuses specifically on the questions the first student got wrong. Then, a third student comes in and focuses on the questions that the first two *still* struggled with. They continue this process, with each new student specializing in the mistakes of their predecessors. Finally, they take the exam as a team, with the opinions of the students who studied the hardest topics given more weight. This is Boosting. It's an ensemble technique that builds a strong model by sequentially training new models to correct the errors of the previous ones.
+Boosting is a powerful ensemble technique that aims to convert a collection of "weak learners" (models that are only slightly better than random guessing) into a single "strong learner." Unlike Bagging, which trains models in parallel, Boosting is a sequential process where each new model is built to fix the errors made by the previous models.
+ +The core idea of Boosting is to iteratively focus on the "hard" examples in the dataset.
+ +The final prediction of a boosting model is a weighted sum (for regression) or a weighted majority vote (for classification) of all the weak learners.
+$$ F(x) = \sum_{m=1}^{M} \alpha_m h_m(x) $$
+There are several famous implementations of the boosting idea:
+| Advantages | +Disadvantages | +
|---|---|
| ✅ Often achieves the highest predictive accuracy among all machine learning algorithms. | +❌ Computationally Expensive: The sequential nature means it cannot be easily parallelized, which can make it slow to train. | +
| ✅ Can handle a variety of data types and complex relationships. | +❌ Sensitive to Outliers and Noisy Data: It may over-emphasize noisy or outlier data points by trying too hard to classify them correctly. | +
| ✅ Many highly optimized implementations exist (XGBoost, LightGBM). | +❌ Prone to Overfitting if the number of models is too large, without proper regularization. | +
Here are simple examples of how to use two classic boosting algorithms in scikit-learn. The setup is very similar to other classifiers.
+
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.tree import DecisionTreeClassifier
+# Assume X_train, y_train, X_test are defined
+
+# AdaBoost often uses a "stump" (a tree with depth 1) as its weak learner.
+weak_learner = DecisionTreeClassifier(max_depth=1)
+
+# Create the AdaBoost model
+adaboost_clf = AdaBoostClassifier(
+ base_estimator=weak_learner,
+ n_estimators=50, # The number of students in our study group
+ learning_rate=1.0,
+ random_state=42
+)
+adaboost_clf.fit(X_train, y_train)
+y_pred = adaboost_clf.predict(X_test)
+
+from sklearn.ensemble import GradientBoostingClassifier
+# Assume X_train, y_train, X_test are defined
+
+# Create the Gradient Boosting model
+gradient_boosting_clf = GradientBoostingClassifier(
+ n_estimators=100,
+ learning_rate=0.1,
+ max_depth=3, # Trees are often slightly deeper than in AdaBoost
+ random_state=42
+)
+gradient_boosting_clf.fit(X_train, y_train)
+y_pred = gradient_boosting_clf.predict(X_test)
+ 1. Bagging trains its models in parallel on different bootstrap samples of the data. Boosting trains its models sequentially, where each new model is trained to correct the errors of the previous ones.
+2. A "weak learner" is a model that performs only slightly better than random guessing. In boosting, simple models like shallow decision trees (stumps) are used as weak learners.
+3. Each new model in Gradient Boosting is trained to predict the residual errors of the current ensemble's predictions.
+4. Boosting is more sensitive because its core mechanism involves increasing the weights of misclassified samples. An outlier is, by definition, a hard-to-classify point, so the algorithm will focus more and more on this single point, which can distort the decision boundary and harm generalization.
+The Story: Decoding the Study Group's Strategy
++ DBSCAN is a density-based clustering algorithm that groups data points that are closely packed together and marks outliers as noise based on their density in the feature space. It identifies clusters as dense regions in the data space separated by areas of lower density. Unlike K-Means or hierarchical clustering which assumes clusters are compact and spherical, DBSCAN performs well in handling real-world data irregularities such as: +
++ The figure below shows a dataset with clustering algorithms: K-Means and Hierarchical handling compact, spherical clusters with varying noise tolerance while DBSCAN manages arbitrary-shaped clusters and noise handling. +
+ ++ 1. eps ($$\epsilon$$): This defines the radius of the neighborhood around a data point. If the distance between two points is less than or equal to $$\epsilon$$, they are considered neighbors. A common method to determine $\epsilon$ is by analyzing the k-distance graph. Choosing the right $\epsilon$ is important: +
++ 2. MinPts: This is the minimum number of points required within the $\epsilon$ radius to form a dense region. A general rule of thumb is to set MinPts $$$\ge D+1$$, where $$D$$ is the number of dimensions in the dataset. +
+ ++ DBSCAN works by categorizing data points into three types: +
++ In this interactive visualization, when you click the "Add New Point & Cluster" button, the new point you specify is appended to the existing dataset. Importantly, the entire DBSCAN clustering algorithm is then re-run from scratch on this updated dataset. This means that: +
+Story-style intuition: Upgrading the Critic's Brain
+Remember our food critic from the Q-Learning guide with their giant notebook (the Q-table)? That notebook worked fine for a small city with a few restaurants. But what if they move to a massive city with millions of restaurants, where the menu changes every night (a continuous state space)? Their notebook is useless! It's too big to create and too slow to look up.
+
To solve this, the critic replaces their notebook with a powerful, creative brain—a Deep Neural Network. Now, instead of looking up an exact restaurant and dish, they can just describe the situation ("a fancy French restaurant, feeling adventurous") and their brain can *predict* a good Q-value for any potential dish on the spot. Deep Reinforcement Learning (DRL) is this powerful combination of RL's trial-and-error learning with the pattern-recognition power of deep learning.
Deep Reinforcement Learning (DRL) is a subfield of machine learning that combines Reinforcement Learning (RL) with Deep Learning (DL). Instead of using tables to store values, DRL uses deep neural networks to approximate the optimal policy and/or value functions, allowing it to solve problems with vast, high-dimensional state and action spaces.
+ +Traditional RL methods like Q-Learning rely on tables (Q-tables) to store a value for every possible state-action pair. This approach fails spectacularly when the number of states or actions becomes very large or continuous.
+Example: An Atari Game
+The core components are the same as in classic RL, but the implementation is powered by neural networks.
+DRL agents can learn in different ways, just like people. Some focus on judging the situation (value-based), some focus on learning a skill (policy-based), and the most advanced do both at the same time (Actor-Critic).
+Analogy: This is a "critic" agent. It doesn't have an innate skill, but it's an expert at evaluating the potential of every possible move.
Analogy: This is an "actor" agent. It develops a direct instinct or muscle memory for what to do in a situation, without necessarily calculating the long-term value of its actions.
Analogy: This is like an actor on stage with a director. The actor performs, and the director (critic) provides feedback ("That was a great delivery!") to help the actor refine their performance.
DQN was a breakthrough algorithm that successfully used a deep neural network to play Atari games at a superhuman level. It introduced two key innovations to stabilize learning:
+ +The Archer's Analogy: An archer (the policy network) shoots an arrow. If the arrow hits close to the bullseye (high reward), they adjust their stance and aim (the network's weights) slightly in the same direction they just used. If the arrow misses badly (low reward), they adjust their aim in the opposite direction. Policy Gradient is this simple idea of "do more of what works and less of what doesn't," scaled up with calculus (gradient ascent).
+These methods directly optimize the policy's parameters \( \theta \) to maximize the expected return \( J(\theta) \). The core idea is to update the policy in the direction that makes good actions more likely and bad actions less likely.
+$$ \theta \leftarrow \theta + \alpha \nabla_\theta J(\theta) $$
+ +Actor-Critic methods are the state-of-the-art for many DRL problems, especially those with continuous action spaces. They combine the best of both worlds:
+This setup is more stable and sample-efficient because the Critic provides a low-variance "baseline" to judge the Actor's actions against, leading to better and faster learning.
+Example Algorithms: PPO (Proximal Policy Optimization) and SAC (Soft Actor-Critic) are two of the most popular and robust DRL algorithms used today.
1. Q-tables cannot handle very large or continuous state spaces. The number of states in problems like video games or robotics is often effectively infinite, making it impossible to create or store a table for them.
+2. Experience Replay is the technique of storing past transitions `(s, a, r, s')` in a memory buffer and then training the network on random samples from this buffer. It is important because it breaks the temporal correlation between consecutive samples, leading to more stable and efficient training.
+3. An Actor (which learns and executes the policy) and a Critic (which learns and provides feedback on the value of states or actions).
+4. An Actor-Critic method (like DDPG, PPO, or SAC) would be most suitable. Policy-based and Actor-Critic methods are naturally able to handle continuous action spaces, whereas value-based methods like DQN are designed for discrete actions.
+The Story: Decoding the DRL Agent's Brain
+Story-style intuition: The Efficient Librarian
+Imagine our Supermarket Detective (from the Apriori guide) has a new colleague, an efficient librarian. The detective uses a "horizontal" approach: they go through each shopping receipt one by one to see what's inside. The librarian uses a "vertical" approach. Instead of looking at receipts, they create an index card for every single item in the store. On the card for "Milk," they simply list the ID number of every receipt that contains milk. To find out how many people bought {Milk, Bread} together, they just take the two cards and find the common receipt IDs. This is the core idea of Eclat. It's often much faster because finding common IDs between two lists is a very quick operation.
+The Eclat Algorithm (Equivalence Class Clustering and bottom-up Lattice Traversal) is an efficient algorithm for frequent itemset mining. Unlike Apriori, which scans the database horizontally (transaction by transaction), Eclat uses a vertical data format and finds frequent itemsets by intersecting transaction ID lists. This approach can be significantly faster, especially for dense datasets.
+ +Example:
+
TID(Milk) = {T1, T3, T4}
+
TID(Bread) = {T1, T2, T4, T5}
+
The Librarian's Smart Trick: The librarian's method for finding the support of a combined itemset is incredibly fast. To find the support of {Milk, Bread}, they don't need to look at any receipts. They just take the two index cards and find the common numbers (the intersection).
+The core principle of Eclat is that the support of a larger itemset can be computed directly by intersecting the tidsets of its smaller subsets. The size of the resulting intersection is the support count.
+$$ \text{Support}(X \cup Y) = |TID(X) \cap TID(Y)| $$
+Example:
+
TID(Milk) = {T1, T3, T4}
+
TID(Bread) = {T1, T2, T4, T5}
+
TID({Milk, Bread}) = TID(Milk) ∩ TID(Bread) = {T1, T4}
+
Support({Milk, Bread}) = |{T1, T4}| = 2.
Eclat uses a depth-first search (DFS) approach to explore the search space of itemsets.
+ +| Feature | +Eclat | +Apriori | +
|---|---|---|
| Data Format | +Vertical (Item → {TID1, TID2, ...}) | +Horizontal (TID → {Item1, Item2, ...}) | +
| Search Method | +Depth-First Search (DFS) | +Breadth-First Search (BFS) | +
| Main Operation | +Tidset intersection. | +Candidate generation and database scanning. | +
| Performance | +Generally faster, especially on dense datasets. | +Can be slow due to repeated database scans and large candidate sets. | +
Since Eclat is less common in libraries like `scikit-learn`, here's a conceptual Python example using a library called `pyECLAT`. The logic mirrors the algorithm steps: we prepare the data, create an Eclat object, and call `fit()` to get the frequent itemsets.
+
+# NOTE: You would need to install pyECLAT first: pip install pyECLAT
+import pandas as pd
+from pyECLAT import ECLAT
+
+# --- 1. Create a Sample Dataset in the right format ---
+# The data is a DataFrame where each row is a transaction.
+# NaN values are used for padding.
+data = {'Transaction': [1, 2, 3, 4, 5],
+ 'Items': [['Milk', 'Beer', 'Diapers'],
+ ['Bread', 'Butter', 'Milk'],
+ ['Beer', 'Diapers', 'Milk', 'Cola'],
+ ['Bread', 'Butter', 'Beer', 'Diapers'],
+ ['Bread', 'Butter']]}
+df = pd.DataFrame(data)
+
+# --- 2. Initialize and Run the Eclat Algorithm ---
+# We create an ECLAT object from our transactions data.
+eclat_instance = ECLAT(data=df['Items'])
+
+# You can see the binary (one-hot encoded) format it uses internally
+# print(eclat_instance.df_bin)
+
+# --- 3. Find Frequent Itemsets ---
+# We set min_support to 0.4, meaning itemsets in at least 2 of the 5 transactions.
+# The 'fit' method does all the work of intersecting tidsets.
+min_support = 0.4
+rule_indices, rule_supports = eclat_instance.fit(min_support=min_support,
+ min_combination=1, # Min number of items in an itemset
+ max_combination=3) # Max number of items
+
+print("--- Frequent Itemsets (Support >= 40%) ---")
+print(rule_supports)
+ 1. Apriori scans data horizontally (it reads each transaction to see what items it contains). Eclat uses a vertical format (it looks at each item to see which transactions it appeared in).
+2. The support is the size of the intersection of the tidsets: |{1, 2, 5} ∩ {2, 4, 5, 6}| = |{2, 5}| = 2.
+3. The main disadvantage is high memory consumption, as the tidsets for very frequent items can become extremely large lists containing millions of transaction IDs.
+4. Eclat uses a Depth-First Search (DFS) strategy to traverse the lattice of potential itemsets.
+The Story: Decoding the Efficient Librarian's Index
+Story-style intuition: The Expert Fruit Sorter
+Imagine you have a pile of fruit containing two types that can be tricky to separate: lemons and limes. They look similar, and their sizes overlap. A simple sorter (like K-Means) might draw a hard line: anything yellow is a lemon. But what about a greenish lemon or a yellowish lime? GMM is an expert. It knows that limes are, *on average*, smaller and rounder, while lemons are *on average* larger and more oval. GMM models each fruit type as a flexible, oval-shaped "cloud of probability." For a fruit that's right on the border, GMM can say, "I'm 70% sure this is a lemon and 30% sure it's a lime." This is called soft clustering.
+A Gaussian Mixture Model (GMM) is a probabilistic model that assumes all the data points are generated from a mixture of a finite number of Gaussian distributions (bell curves). In simple terms, it believes the data is a mix of several different groups, where each group has a sort of "center point" and a particular shape (which can be circular or oval).
+Example: Analyzing customer data. You might have one group of customers who spend a lot but visit rarely (an oval cluster) and another group who spend a little but visit often (a different oval cluster). GMM is great at finding these non-circular groups.
+Think of it like a recipe. The final probability of any data point is a "mixture" of probabilities from each group's individual recipe. Each group's recipe defines its center, its shape, and its overall importance in the mix.
+$$ \mathcal{N}(x|\mu, \Sigma) = \text{A formula defining a bell curve} $$
+You don't need to memorize it! Just know it's the math for creating one of those oval "probability clouds."
+$$ p(x) = (\text{Weight}_A \times \text{Prob from A}) + (\text{Weight}_B \times \text{Prob from B}) + \dots $$
+ Where: +Story: The "Guess and Check" Method
+Imagine you have the fruit pile but don't know the exact size and shape of lemons and limes. You use a two-step "guess and check" process:
+
1. The "Guess" Step (Expectation): You make a starting guess for the oval shapes of the two fruit types. Then, for every single fruit in the pile, you calculate the probability it belongs to each shape. (e.g., "This one is 80% likely a lemon, 20% a lime").
+
2. The "Check & Update" Step (Maximization): After guessing for all the fruit, you update your oval shapes. You calculate the average size and shape of all the fruits you labeled as "mostly lemon" to get a *better* lemon shape. You do the same for limes.
+
You repeat these "Guess" and "Check & Update" steps. Each time, your oval shape descriptions get more accurate, until they settle on the best possible fit for the data.
Example: The Cookie Cutter Analogy
+The `covariance_type` parameter in the code controls the flexibility of your "oval shapes" or cookie cutters.
+| Model | +GMM vs. K-Means | +GMM vs. Hierarchical | +
|---|---|---|
| Cluster Assignment | +GMM is soft (probabilistic). A point is 70% in Cluster A, 30% in B. K-Means is hard (100% in Cluster A). | +GMM is probabilistic. Hierarchical is distance-based and deterministic. | +
| Cluster Shape | +GMM can model elliptical clusters. K-Means assumes spherical clusters. | +GMM models clusters as distributions. Hierarchical can produce any shape depending on linkage. | +
| Scalability | +Both scale well, but GMM is more computationally intensive per iteration. | +GMM scales much better to large datasets than hierarchical clustering. | +
GMM requires you to specify the number of clusters (K). Information criteria are used to help find the optimal K by balancing model fit with model complexity.
+Story Example: Goldilocks and the Three Models
+You test three GMMs: one with too few clusters (underfit), one with too many (overfit), and one that's just right.
+
• AIC (Akaike Information Criterion) and BIC (Bayesian Information Criterion) are like judges who score each model. They give points for fitting the data well but subtract points for being too complex. The model with the lowest score is the one that's "just right."
This simple example shows the core steps: create data, create a GMM model, train it (`.fit`), and then use it to predict which cluster new data belongs to (`.predict`) and the probabilities for each cluster (`.predict_proba`).
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.mixture import GaussianMixture
+from sklearn.datasets import make_blobs
+
+# --- 1. Create Sample Data ---
+# We'll create 300 data points, grouped into 3 "blobs" or clusters.
+X, y_true = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)
+
+# --- 2. Create and Train the GMM ---
+# We tell the model to look for 3 clusters (n_components=3).
+# random_state ensures we get the same result every time we run the code.
+gmm = GaussianMixture(n_components=3, random_state=42)
+
+# Train the model on our data. This is where the EM algorithm runs.
+gmm.fit(X)
+
+# --- 3. Make Predictions ---
+# Predict the cluster for each data point in our original dataset.
+labels = gmm.predict(X)
+
+# Let's create a new, unseen data point to test our model.
+new_point = np.array([[-5, -5]])
+
+# Predict which cluster the new point belongs to.
+new_point_label = gmm.predict(new_point)
+print(f"The new point belongs to cluster: {new_point_label[0]}")
+
+# --- 4. Get Probabilities (The "Soft" Part) ---
+# This is the most powerful feature of GMM.
+# It tells us the probability of the new point belonging to EACH of the 3 clusters.
+probabilities = gmm.predict_proba(new_point)
+print(f"Probabilities for each cluster: {np.round(probabilities, 3)}") # e.g., [[0.95, 0.05, 0.0]]
+
+# --- 5. Visualize the Results ---
+# Let's plot our data points, colored by the cluster labels GMM assigned.
+plt.figure(figsize=(8, 6))
+plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis')
+# Let's also plot our new point as a big red star to see where it landed.
+plt.scatter(new_point[:, 0], new_point[:, 1], c='red', s=200, marker='*')
+plt.title('GMM Clustering Results')
+plt.xlabel('Feature 1')
+plt.ylabel('Feature 2')
+plt.grid(True)
+plt.show()
+ The Story: Decoding the Fruit Sorter's Toolkit
+Let's clarify the advanced tools our expert fruit sorter uses.
+Story-style intuition: The Artist vs. The Art Critic
+Imagine two types of AI that both study thousands of cat photos.
+
• The Discriminative Model is like an art critic. Its only job is to learn the difference between a cat photo and a dog photo. If you show it a new picture, it can tell you, "That's a cat," but it can't create a cat picture of its own. It learns a decision boundary.
+
• The Generative Model is like an artist. It studies the cat photos so deeply that it understands the "essence" of what makes a cat a cat—the patterns, the textures, the shapes. It learns the underlying distribution of "cat-ness." Because it has this deep understanding, it can then be asked to create a brand new, never-before-seen picture of a cat from scratch.
Generative Models are a class of statistical models that learn the underlying probability distribution of a dataset. Their primary goal is to understand the data so well that they can "generate" new data samples that are similar to the ones they were trained on.
+ +Generative models come in several powerful flavors, each with a different approach to learning and creating.
+Analogy: The Master Forger. A VAE is like a forger who learns to create masterpieces. It first "compresses" a real painting into a secret recipe (a condensed set of characteristics called the latent space). It then learns to "decompress" that recipe back into a painting. By learning this process, it can later create new recipes and generate new, unique paintings.
Analogy: The Artist and Critic Game. A GAN consists of two competing neural networks: a Generator (the artist) that tries to create realistic images, and a Discriminator (the critic) that tries to tell the difference between real images and the artist's fakes. They train together in a game where the artist gets better at fooling the critic, and the critic gets better at catching fakes. This competition pushes the artist to create incredibly realistic images.
Analogy: The Sculptor. A Diffusion Model is like a sculptor who starts with a random block of marble (pure noise) and slowly chisels away the noise, step by step, until a clear statue (a realistic image) emerges. It learns this "denoising" process by first practicing in reverse: taking a perfect statue and systematically adding noise to it until it becomes a random block.
Training large generative models from scratch is a major undertaking. Here are conceptual sketches of what the code looks like using popular frameworks.
+
+import torch.nn as nn
+import numpy as np
+
+class Generator(nn.Module):
+ def __init__(self, latent_dim, img_shape):
+ super(Generator, self).__init__()
+ self.img_shape = img_shape
+ self.model = nn.Sequential(
+ # Takes a random noise vector (latent_dim) and upsamples it
+ nn.Linear(latent_dim, 128),
+ nn.LeakyReLU(0.2, inplace=True),
+ nn.Linear(128, 256),
+ nn.BatchNorm1d(256),
+ nn.LeakyReLU(0.2, inplace=True),
+ nn.Linear(256, 512),
+ nn.BatchNorm1d(512),
+ nn.LeakyReLU(0.2, inplace=True),
+ nn.Linear(512, int(np.prod(self.img_shape))),
+ nn.Tanh() # Scales output to be between -1 and 1
+ )
+
+ def forward(self, z):
+ img = self.model(z)
+ img = img.view(img.size(0), *self.img_shape)
+ return img
+
+import tensorflow as tf
+from tensorflow.keras import layers
+import numpy as np
+
+def build_generator(latent_dim, img_shape):
+ model = tf.keras.Sequential()
+
+ model.add(layers.Dense(256, input_dim=latent_dim))
+ model.add(layers.LeakyReLU(alpha=0.2))
+ model.add(layers.BatchNormalization(momentum=0.8))
+
+ model.add(layers.Dense(512))
+ model.add(layers.LeakyReLU(alpha=0.2))
+ model.add(layers.BatchNormalization(momentum=0.8))
+
+ model.add(layers.Dense(1024))
+ model.add(layers.LeakyReLU(alpha=0.2))
+ model.add(layers.BatchNormalization(momentum=0.8))
+
+ model.add(layers.Dense(np.prod(img_shape), activation='tanh'))
+ model.add(layers.Reshape(img_shape))
+
+ return model
+
+# Easiest way to get started with powerful generative models!
+from transformers import pipeline
+
+# Initialize a text generation pipeline with a pre-trained model
+generator = pipeline('text-generation', model='gpt2')
+
+# Generate text
+prompt = "In a world where AI could dream,"
+generated_text = generator(prompt, max_length=50, num_return_sequences=1)
+
+print(generated_text[0]['generated_text'])
+ 1. A generative model (the artist) learns the underlying distribution of the data, P(X), and can create new samples. A discriminative model (the critic) learns the decision boundary between classes, P(Y|X), and can only classify existing data.
+2. The Generator tries to create fake data that looks real. The Discriminator tries to distinguish between real data and the Generator's fake data.
+3. The core idea is to learn to reverse a process of gradually adding noise to an image. By mastering this "denoising" process, the model can start with pure noise and denoise it step-by-step into a coherent new image.
+4. Your model with an FID score of 5 is much better. For Frechet Inception Distance (FID), a lower score is better, as it indicates that the statistical distribution of your generated images is closer to the distribution of the real images.
+The Story: Decoding the AI Artist's Toolkit
+Story-style intuition:
+Imagine you are trying to predict the price of houses. Your first guess is just the average price of all houses—not very accurate. So, you look at your mistakes (residuals). You build a second, simple model that's an expert at fixing those specific mistakes. Then, you look at the remaining mistakes and build a third expert to fix those. You repeat this, adding a new expert each time to patch the leftover errors, until your predictions are very accurate.
++ Gradient Boosting Regression (GBR) is an ensemble machine learning technique that builds a strong predictive model by sequentially combining multiple weak learners, usually decision trees. Each new tree focuses on correcting the errors (residuals) of the previous trees. +
+ +Story example: The Improving Chef
+A chef is trying to create the perfect recipe (the model). Their first dish (initial prediction) is just a basic soup. They taste it and note the errors (residuals)—it's not salty enough. They don't throw it out; instead, they add a pinch of salt (the weak learner). Then they taste again. Now it's a bit bland. They add some herbs. This step-by-step correction, guided by tasting (calculating the gradient), is how GBR refines its predictions.
+| Parameter | +Explanation & Story | +
|---|---|
| n_estimators | +The number of boosting stages, or the number of "mini-experts" (trees) to add in the sequence. Story: How many times the chef is allowed to taste and correct the recipe. | +
| learning_rate | +Scales the contribution of each tree. Small values mean smaller, more careful correction steps. Story: How much salt or herbs the chef adds at each step. A small pinch is safer than a whole handful. | +
| max_depth | +The maximum depth of each decision tree. Controls complexity. Story: A shallow tree is an expert on one simple rule (e.g., "add salt"). A deep tree is a complex expert who considers many factors. | +
| subsample | +The fraction of data used to train each tree. Introduces randomness to prevent overfitting. Story: The chef tastes only a random spoonful of the soup each time, not the whole pot, to avoid over-correcting for one odd flavor. | +
GBR is like a master craftsman who builds something beautiful piece by piece. The final product is incredibly accurate (high predictive power), but the process is slow (slower training) and requires careful attention to detail (sensitive to hyperparameters). If not careful, the craftsman might over-engineer the product (overfitting).
+Here, we are programming our "chef" (the `GradientBoostingRegressor`). We give it the recipe book (`X`, `y` data) and set the rules (`n_estimators`, `learning_rate`). The chef then `fit`s the recipe by training on the data. Finally, we `predict` how a new dish will taste and `evaluate` how good our final recipe is.
+
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+# Example dataset
+X = np.array([[1], [2], [3], [4], [5], [6], [7], [8]])
+y = np.array([2, 5, 7, 9, 11, 13, 15, 17])
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize GBR
+gbr = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=2, random_state=42)
+
+# Train
+gbr.fit(X_train, y_train)
+
+# Predict
+y_pred = gbr.predict(X_test)
+
+# Evaluate
+mse = mean_squared_error(y_test, y_pred)
+print(f"Mean Squared Error: {mse:.2f}")
+ A bank uses GBR to predict credit risk. The first model makes a simple guess based on average income. The next model corrects for age, the next for loan amount, and so on. By chaining these simple experts, the bank builds a highly accurate system to identify customers who are likely to default, saving millions.
+Treat tuning GBR like a skilled surgeon: be careful and precise. Use cross-validation to find the best settings. Always keep an eye on the patient's vitals (validation error) to make sure the procedure is going well and stop if things get worse (early stopping). Always confirm if such a complex surgery is needed by checking if a simpler method works first (compare to baseline models).
+The Story: The Student, The Chef, and The Tailor
+These terms might sound complex, but they relate to everyday ideas. Think of them as tools and checks to ensure our model isn't just "memorizing" answers but is actually learning concepts it can apply to new, unseen problems.
++ What it is: A technique to assess how a model will generalize to an independent dataset. It involves splitting the data into 'folds' and training/testing the model on different combinations of these folds. +
++ Story Example: Imagine a student has 5 practice exams. Instead of studying from all 5 and then taking a final, they use one exam to test themselves and study from the other four. They repeat this process five times, using a different practice exam for the test each time. This gives them a much better idea of their true knowledge and how they'll perform on the real final exam, rather than just memorizing answers. This rotation is cross-validation. +
+ ++ What it is: The error of the model calculated on a set of data that it was not trained on (the validation set). It's a measure of how well the model can predict new, unseen data. +
++ Story Example: A chef develops a new recipe in their kitchen (the training data). The "training error" is how good the recipe tastes to them. But the true test is when a customer tries it (the validation data). The customer's feedback represents the "validation error". A low validation error means the recipe is a hit with new people, not just the chef who created it. +
+ ++ What it is: A modeling error that occurs when a model learns the training data's noise and details so well that it negatively impacts its performance on new, unseen data. +
++ Story Example: A tailor is making a suit. If they make it exactly to the client's current posture, including a slight slouch and the phone in their pocket (the "noise"), it's a perfect fit for that one moment. This is overfitting. The training error is zero! But the moment the client stands up straight, the suit looks terrible. A good model, like a good tailor, creates a fit that works well in general, ignoring temporary noise. +
+ ++ What it is: The process of finding the optimal combination of settings (hyperparameters like `learning_rate` or `max_depth`) that maximizes the model's performance. +
++ Story Example: Think of a race car driver. The car's engine is the model, but the driver can adjust the tire pressure, suspension, and wing angle. These settings are the hyperparameters. The driver runs several practice laps (like cross-validation), trying different combinations to find the setup that results in the fastest lap time. This process of tweaking the car's settings is hyperparameter tuning. +
+The Story: The Lost Hiker
+Imagine a hiker is lost in a thick fog on a mountain and wants to get to the lowest valley. They can't see far, but they can feel the slope of the ground under their feet. Their strategy is simple: feel the steepest downward slope and take a step in that direction. By repeating this process, they slowly but surely make their way downhill, hoping to find the bottom. In this story, the hiker is Gradient Descent, their position is the model's parameters, and the mountain's altitude is the error (or loss). The goal is to find the lowest point.
++ Gradient Descent (GD) is an optimization algorithm used to minimize a loss/cost function by iteratively updating model parameters (weights, biases). +
+ +Think of standing on a hill (the cost function surface). To reach the lowest valley (minimum loss):
+👉 Example: Linear Regression
+If the predicted line is too high, the gradient tells us to decrease slope/intercept; if too low, increase them.
+ + +The Story: The Hiker's Rulebook
+The hiker needs a precise set of instructions for each step. This formula is their rulebook. It says: "Your new position is your old position, minus a small step (the learning rate) in the direction of the steepest slope (the gradient)." This rule ensures every step they take is a calculated move towards the valley floor, preventing them from walking in circles.
++ $$ \theta_j := \theta_j - \alpha \cdot \frac{\partial J(\theta)}{\partial \theta_j} $$ +
++ $$ J(w,b) = \frac{1}{m} \sum_{i=1}^m (y_i - (wx_i + b))^2 $$ +
+Gradient wrt w: + $$ \frac{\partial J}{\partial w} = -\frac{2}{m} \sum_{i=1}^m x_i(y_i - (wx_i+b)) $$ +
+Gradient wrt b: + $$ \frac{\partial J}{\partial b} = -\frac{2}{m} \sum_{i=1}^m (y_i - (wx_i+b)) $$ +
+ +Imagine a U-shaped curve (parabola). Starting at the top, you repeatedly step downward along the slope until you reach the bottom.
+ + +The Story: Three Different Hikers
+Our lost hikers can have different personalities:
+The Story: Upgrading the Hiker's Gear
+A basic hiker is good, but a hiker with advanced gear is better. These variants are like giving our hiker special equipment to navigate the mountain more effectively.
+👉 Example: Training a CNN, Adam often converges much faster than plain GD.
+ + +The Story: Calibrating the Hiker's Tools
+Before starting, the hiker must calibrate their approach. These are the settings they control:
+👉 Example: If learning rate = 1, model may oscillate; if 0.0001, may take forever.
+ + +The Story: Reviewing the Hiking Strategy
+The "take a step downhill" strategy is simple and effective, but not foolproof.
+The Story: Choosing the Right Mountain
+This downhill hiking strategy is perfect for any "mountain" that has a smooth, continuous surface where you can always calculate a slope. This applies to countless problems in the real world, from predicting house prices (a gentle hill) to training massive AI for image recognition (a complex, high-dimensional mountain range).
+👉 Example: Logistic Regression, CNNs, RNNs all trained with GD.
+ + +The Story: Writing Down the Hiking Plan
+This code is the hiker's plan written down before they start their journey. It defines the map of the mountain (`X` and `y` data), sets the calibration (learning rate, epochs), and contains the step-by-step instructions for the hike (the loop). Finally, it plots a chart of their altitude (loss) over time to confirm they successfully made it downhill.
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Data
+X = np.array([1, 2, 3, 4, 5])
+y = np.array([2, 4, 6, 8, 10]) # y = 2x
+
+# Parameters
+w, b = 0, 0
+alpha = 0.01
+epochs = 1000
+m = len(X)
+losses = []
+
+# Gradient Descent
+for i in range(epochs):
+ y_pred = w*X + b
+ dw = -(2/m) * np.sum(X * (y - y_pred))
+ db = -(2/m) * np.sum(y - y_pred)
+
+ w -= alpha * dw
+ b -= alpha * db
+
+ loss = np.mean((y - y_pred)**2)
+ losses.append(loss)
+
+print("Final w:", w, "Final b:", b)
+
+# Plot convergence
+plt.plot(losses)
+plt.xlabel("Iterations")
+plt.ylabel("Loss")
+plt.title("Convergence Curve")
+plt.show()
+ 👉 Try changing learning rate (\(\alpha\)) and see convergence behavior.
+ + +The Story: Famous Mountains Conquered
+This hiking method isn't just a theory; it's used to conquer real-world challenges every day. It's the strategy used to train the models that power Netflix's recommendations, Google's speech recognition, and the AI that can diagnose diseases from medical scans. Each of these is a complex "mountain" that Gradient Descent learns to navigate.
+The Story: Pro-Tips for Every Hiker
+Experienced hikers have a checklist for a successful journey:
+👉 Example: A standard, robust approach for a deep learning project is to standardize the input data, use the Adam optimizer, and apply early stopping.
+Story-style intuition: The Social Network Detective
+Imagine you're a detective trying to identify the members of two rival clubs, "The Eagles" and "The Sharks," in a large social network. You only know the affiliation of a few people (labeled data), but you have the entire network map showing who is friends with whom (unlabeled data). You make a simple but powerful assumption: "People are probably in the same club as their friends." So, you start with the known members and let their club affiliation "spread" to their direct friends, and then to their friends' friends, like a rumor. Eventually, this process reveals two distinct communities in the network. This is the core idea of Graph-Based Semi-Supervised Learning (SSL). It uses the connections between data points to propagate information from the labeled few to the unlabeled many.
+Graph-Based Semi-Supervised Learning (SSL) is a family of algorithms that represents a dataset as a graph, where data points are nodes and the relationships between them are edges. It leverages the structure of this graph to infer the labels of unlabeled data points based on their proximity to labeled ones.
+ +The foundation of this method is the graph representation itself, which is built on a key assumption about the data.
+Example: In an image dataset of handwritten digits, each image is a node. An edge between two images of the digit '7' would be very strong (high weight) because their pixel values are similar. An edge between an image of a '7' and an image of a '1' would be very weak (low weight).
+Example: Imagine we have 10 data points. Two are labeled 'Class A' (blue) and one is labeled 'Class B' (red). The other seven are unlabeled (gray). After building the graph, we see the two blue points are strongly connected to a cluster of four gray points on the left. The red point is strongly connected to a cluster of three gray points on the right. The algorithm will naturally 'propagate' the blue label to the left cluster and the red label to the right one, as this is the smoothest fit for the graph's structure.
+The "Social Network Detective" needs a way to measure how "chaotic" a potential labeling of the network is. A chaotic labeling would have lots of friends from rival clubs, while a smooth labeling would have very few. This measure of chaos is captured by the Graph Laplacian.
+$$ L = D - W $$
+ Where: +Example: A Simple Graph's Laplacian
+Imagine a 3-node graph: Node 1 is connected to Node 2 (weight=1) and Node 2 is connected to Node 3 (weight=1).
+This L matrix now contains all the information about the graph's connectivity.
+$$ \sum_{i,j} W_{ij} (f(x_i) - f(x_j))^2 $$
+The general process follows a logical flow of building the graph and then spreading the information.
+Example: A Single Step of Label Propagation
+Consider an unlabeled node C, which has three neighbors: Node A (labeled Blue), Node B (labeled Blue), and Node D (labeled Red). All edge weights are equal. In the next iteration, node C looks at its neighbors. It sees two "Blue" votes and one "Red" vote. Therefore, Node C will update its own label to "Blue" because that's the majority label among its direct neighbors.
+These methods work best when the data follows certain geometric patterns.
+Example: In a dataset of animal photos, we assume that photos of cats will naturally form a tight cluster based on pixel similarity, separate from the cluster of dog photos.
Example: A set of photos of a person's face taken from different angles exists in a very high-dimensional pixel space (e.g., 10,000+ dimensions). However, the 'true' structure of this data is a simple 2D or 3D manifold representing the rotation of the head. The graph helps capture the "neighbor" relationships along this curved surface.
| Advantages | +Disadvantages | +
|---|---|
| ✅ Naturally incorporates the structure of both labeled and unlabeled data. | +❌ Graph Construction is Expensive: Building the similarity matrix for a large dataset with N samples requires calculating N² distances. Example: For a dataset of just 50,000 images, this would require 50,000 * 50,000 = 2.5 billion distance calculations, which is very slow. |
+
| ✅ Very effective when you have very few labeled samples but a large amount of unlabeled data. | +❌ Highly sensitive to how the graph is built. A poor choice of similarity metric or neighborhood size (k in k-NN) can lead to a bad result. Example: If you choose k=3 in a k-NN graph, you might miss a connection to an important fourth neighbor. If you choose k=20, you might introduce noisy connections to dissimilar points. |
+
| ✅ Works well on complex, high-dimensional data where the underlying structure is important. | +❌ Does not scale well to datasets with millions of nodes due to the computational and memory costs. | +
Example: Given a massive database of web images, you can manually label a few as 'cat', 'dog', and 'car'. The algorithm can then use visual similarity (e.g., comparing color histograms or deep learning features) to propagate these labels to the rest of the database.
Example: Label a few news articles as 'Sports' or 'Politics'. The algorithm can use word similarity (e.g., TF-IDF vectors) to build a graph and categorize millions of other articles on a news feed.
Example: Start with a few known 'pro-A' and 'pro-B' Twitter users. The algorithm can propagate these labels through the follower/friend network to estimate the political stance of millions of other users.
Scikit-learn provides easy-to-use implementations of `LabelPropagation` and `LabelSpreading`. In this example, we'll create a dataset that forms two clear "moon" shapes. This is a classic problem where linear classifiers fail. We'll label only two points (one in each moon) and let the algorithm infer the labels for all the others based on the graph structure.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_moons
+from sklearn.semi_supervised import LabelPropagation, LabelSpreading
+
+# --- 1. Create a Sample Dataset ---
+# make_moons is perfect for testing graph methods because its structure is nonlinear
+X, y_true = make_moons(n_samples=200, noise=0.08, random_state=42)
+
+# --- 2. Create a small labeled set and a large unlabeled set ---
+# We simulate a real-world scenario by providing labels for only 2 points!
+y_labeled = np.full_like(y_true, -1) # -1 is the scikit-learn code for "unlabeled"
+y_labeled[0] = y_true[0] # Label the first point
+y_labeled[-1] = y_true[-1] # Label the last point
+
+# --- 3. Train a Label Propagation Model ---
+# The model will build a k-NN graph behind the scenes
+lp_model = LabelPropagation(kernel='knn', n_neighbors=10)
+# The .fit() method does all the work: builds the graph and propagates labels
+lp_model.fit(X, y_labeled)
+y_pred_lp = lp_model.predict(X)
+
+# --- 4. Train a Label Spreading Model ---
+ls_model = LabelSpreading(kernel='knn', n_neighbors=10)
+ls_model.fit(X, y_labeled)
+y_pred_ls = ls_model.predict(X)
+
+# --- 5. Visualize the Results ---
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+
+# Plot Label Propagation Results
+# Small dots are the inferred labels, large circles are the original labeled "seeds"
+ax1.scatter(X[y_labeled == -1, 0], X[y_labeled == -1, 1], c=y_pred_lp[y_labeled == -1], cmap='viridis', marker='.')
+ax1.scatter(X[y_labeled != -1, 0], X[y_labeled != -1, 1], c=y_labeled[y_labeled != -1], cmap='viridis', marker='o', s=100, edgecolor='k')
+ax1.set_title('Label Propagation Results')
+
+# Plot Label Spreading Results
+ax2.scatter(X[y_labeled == -1, 0], X[y_labeled == -1, 1], c=y_pred_ls[y_labeled == -1], cmap='viridis', marker='.')
+ax2.scatter(X[y_labeled != -1, 0], X[y_labeled != -1, 1], c=y_labeled[y_labeled != -1], cmap='viridis', marker='o', s=100, edgecolor='k')
+ax2.set_title('Label Spreading Results')
+
+plt.show()
+ 1. The smoothness assumption means that if two data points are very similar (connected by a strong edge), they are very likely to have the same label. The algorithm tries to find a labeling that minimizes conflicts across strong edges.
+2. Nodes represent the data points (both labeled and unlabeled). Edge weights represent the similarity between two connected data points; a higher weight means greater similarity.
+3. The main bottleneck is the graph construction phase, which can require computing a similarity score (like distance) between all pairs of N nodes, an operation that scales with O(N²).
+4. Label Spreading is generally more robust to noisy data because it includes a "clamping" factor that ensures the original labeled nodes retain some of their initial influence, preventing them from being completely swayed by their neighbors.
+The Story: Decoding the Social Network Detective's Dossier
+Story-style intuition: Organizing a Family Reunion
+Imagine you are organizing a big family reunion. You start by grouping the closest relatives: siblings form small groups. Then, you merge those groups with their cousins. Next, you merge those larger groups with their aunts and uncles. You keep doing this until the entire extended family is in one giant group. Hierarchical clustering works just like this: it builds a family tree, or a dendrogram, showing how everyone is related, from the closest individuals to the entire family.
+In machine learning, clustering is an unsupervised learning technique. This means you have data, but you don't have pre-defined labels for it. The goal of clustering is to find natural groupings (or "clusters") in the data, where points within the same group are more similar to each other than to those in other groups.
+Example: You have a list of customers and their purchasing habits (e.g., spending amount, frequency of visits). Clustering would help you automatically identify groups like "high-spending loyal customers," "occasional bargain hunters," and "new visitors" without you having to define these groups first.
+Hierarchical Clustering builds a hierarchy of clusters, either from the bottom up or the top down. The result is a tree-like structure called a dendrogram, which shows the entire "family tree" of how the groups were formed.
+ +Example: We start with four friends, {A}, {B}, {C}, {D}. The algorithm first merges the two most similar, say A and B, to get {A, B}, {C}, {D}. Then it might merge C and D to get {A, B}, {C, D}. Finally, it merges these two groups into {A, B, C, D}.
+Example: We start with one big group {A, B, C, D}. The algorithm first splits it into the two most different subgroups, for instance {A, B} and {C, D}. Then it might split {A, B} into {A} and {B}, completing the process.
+Example: If Friend A is at point (1, 2) and Friend B is at (4, 6), their Euclidean distance is sqrt((4-1)^2 + (6-2)^2) = sqrt(3^2 + 4^2) = sqrt(9 + 16) = sqrt(25) = 5.
+Example: For Friend A (1, 2) and Friend B (4, 6), the Manhattan distance is |4-1| + |6-2| = 3 + 4 = 7.
+Once you have family groups, how do you decide which two groups should merge next? Do you connect them based on their two closest members (single linkage), their two most distant members (complete linkage), or the average distance between all their members (average linkage)?
+Example: Distance between {A, B} and {C} is the smaller of Distance(A, C) and Distance(B, C).
Example: Distance between {A, B} and {C} is the larger of Distance(A, C) and Distance(B, C).
Example: Distance between {A, B} and {C} is (Distance(A, C) + Distance(B, C)) / 2.
Let's walk through a simple example with four points A, B, C, D. Their initial distance matrix (Euclidean) is:
+A B C D + A 0 2 6 10 + B 2 0 5 9 + C 6 5 0 4 + D 10 9 4 0+
{A,B} C D
+ {A,B} 0 5 9
+ C 5 0 4
+ D 9 4 0
+ The dendrogram is the tree diagram that visualizes the entire merging process. The y-axis represents the distance at which clusters were merged. By "cutting" the dendrogram with a horizontal line, you can choose the final number of clusters.
+Example: For the algorithm steps above, the dendrogram would show A and B merging at a low height (distance 2). C and D would merge at a slightly higher height (distance 4). Finally, the {A, B} group and the {C, D} group would merge at an even higher height (distance 5).
+ +If you draw a horizontal "cut" line at a distance of 3, you would cross three vertical lines, giving you three clusters: {A, B}, {C}, and {D}. If you cut at a distance of 6, you would get one cluster: {A, B, C, D}.
+| Feature | +Hierarchical Clustering | +K-Means Clustering | +
|---|---|---|
| Number of Clusters | +Not needed upfront. Chosen by cutting the dendrogram. | +Must be pre-specified (K). | +
| Speed & Scalability | +Slow (O(n^2) to O(n^3)). Not for large datasets. | +Fast and scales well to large data. | +
| Output | +A full hierarchy (dendrogram) showing relationships. | +A single set of K clusters. | +
| Determinism | +Deterministic (always the same result). | +Can vary based on initial random centroids. | +
| Use-Case Example | +Understanding evolutionary relationships between species (phylogenetic trees). The hierarchy is the main goal. | +Segmenting 1 million customers into 3 pricing tiers (Gold, Silver, Bronze). Speed and scalability are key. | +
Let's use Python's `scipy` library to build our "family tree" (the dendrogram) and `scikit-learn` to perform the final clustering once we decide how many groups we want.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_blobs
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import AgglomerativeClustering
+from scipy.cluster.hierarchy import dendrogram, linkage
+
+# 1. Generate and Prepare Data
+X, y = make_blobs(n_samples=50, centers=4, cluster_std=1.2, random_state=42)
+X_scaled = StandardScaler().fit_transform(X)
+
+# 2. Build the Linkage Matrix using Scipy for the dendrogram
+linkage_matrix = linkage(X_scaled, method='ward')
+
+# 3. Plot the Dendrogram
+plt.figure(figsize=(15, 7))
+plt.title('Hierarchical Clustering Dendrogram (Ward Linkage)')
+plt.xlabel('Sample Index')
+plt.ylabel('Distance')
+dendrogram(linkage_matrix)
+plt.show()
+
+
+# 4. Perform Clustering with Scikit-learn
+# Let's say the dendrogram suggests 4 clusters is a good choice.
+agg_cluster = AgglomerativeClustering(n_clusters=4, linkage='ward')
+labels = agg_cluster.fit_predict(X_scaled)
+
+# 5. Visualize the final clusters
+plt.figure(figsize=(10, 7))
+plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels, cmap='viridis', s=50)
+plt.title('Final Clusters (n=4)')
+plt.xlabel('Feature 1')
+plt.ylabel('Feature 2')
+plt.grid(True)
+plt.show()
+
+ The Story: Decoding the Family Reunion Plan
+Let's break down some of the technical terms used in our family reunion plan to make sure everything is crystal clear.
+Example: If you're clustering customers by income (e.g., 50,000) and number of purchases (e.g., 5), the income will dominate the distance calculation. Scaling brings both to a similar range so they are weighted fairly.
Example: If your clusters look like long chains, single linkage might be appropriate. If they are tight and spherical, Ward's or complete linkage is better.
Example: If there's a huge jump in merge distance from 3 clusters to 2, it suggests that merging those last two groups creates a very dissimilar, unnatural cluster. Therefore, 3 is likely a good number of clusters.
Example: Clustering genetic data with thousands of genes is noisy. PCA can reduce this to a few key components that represent the most important genetic variations, leading to better clusters.
Story-style intuition: The Cocktail Party Problem
+Imagine you're at a crowded party. Two people, Alice and Bob, are speaking at the same time. You place two microphones in the room. Each microphone records a mixture of Alice's voice, Bob's voice, and some background noise. Your goal is to take these two messy, mixed recordings and perfectly isolate Alice's original voice into one audio file and Bob's original voice into another. This is called Blind Source Separation, and it's exactly what ICA is designed to do. ICA is a computational method that "unmixes" a set of signals to reveal the hidden, underlying sources that created them.
+ +Independent Component Analysis (ICA) is a statistical technique used to separate a multivariate signal into its underlying, additive, and statistically independent components. Unlike PCA which seeks to maximize variance and finds uncorrelated components, ICA's goal is to find components that are truly independent, which is a much stronger condition.
+ +ICA operates on the assumption that your observed data is a linear mixture of some unknown, independent sources. The whole problem can be stated with a simple formula:
+$$ X = A S $$
+The goal of ICA is to find an "unmixing matrix" W that can reverse the process:
+$$ S \approx W X $$
+To do this, ICA relies on a key insight: most real-world signals of interest (like speech or music) are non-Gaussian (they don't follow a perfect bell curve). The Central Limit Theorem states that a mixture of independent signals will tend to be "more Gaussian" than the original sources. Therefore, ICA works by finding an unmixing matrix W that makes the resulting signals as non-Gaussian as possible, thereby recovering the original independent sources.
+ +Story: The Signal Purifier's Three-Step Process
+To unmix the signals, the ICA algorithm follows a systematic process:
+The core of the ICA algorithm is an optimization problem. After preprocessing, it tries to find the components that maximize a measure of non-Gaussianity. The two most common measures are:
+| Feature | +ICA (Independent Component Analysis) | +PCA (Principal Component Analysis) | +
|---|---|---|
| Goal | +Finds components that are statistically independent. | +Finds components that are uncorrelated and maximize variance. | +
| Supervision | +Both are Unsupervised. | +|
| Component Property | +Components are not necessarily orthogonal (at right angles). | +Components are always orthogonal. | +
| Use Case | +Best for separating mixed signals (e.g., audio, EEG). | +Best for dimensionality reduction and data compression. | +
| Output Example | ++ | + |
In this example, we will create our own "cocktail party." We'll generate two clean, independent source signals (a sine wave and a sawtooth wave). Then, we'll mathematically "mix" them together. Finally, we'll use `FastICA` to see if it can recover the original two signals from the mixed recordings.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import FastICA
+
+# --- 1. Create the Original "Source" Signals ---
+np.random.seed(0)
+n_samples = 2000
+time = np.linspace(0, 8, n_samples)
+
+# Source 1: A sine wave (smooth and periodic)
+s1 = np.sin(2 * time)
+# Source 2: A sawtooth wave (sharp and structured)
+s2 = np.sign(np.sin(3 * time))
+# Combine them into a single array
+S_original = np.c_[s1, s2]
+
+# --- 2. Create a "Mixing Matrix" and Mix the Signals ---
+# This simulates how the signals get mixed in the real world
+A = np.array([[1, 1], [0.5, 2]]) # The mixing matrix
+X_mixed = np.dot(S_original, A.T)
+
+# --- 3. Apply ICA to "Unmix" the Signals ---
+# We tell ICA that we are looking for 2 independent components
+ica = FastICA(n_components=2, random_state=42)
+S_recovered = ica.fit_transform(X_mixed)
+
+# --- 4. Visualize the Results ---
+plt.figure(figsize=(12, 8))
+
+# Plot Original Sources
+plt.subplot(3, 1, 1)
+plt.title("Original Independent Sources")
+plt.plot(S_original)
+
+# Plot Mixed Signals
+plt.subplot(3, 1, 2)
+plt.title("Mixed Signals (Observed Data)")
+plt.plot(X_mixed)
+
+# Plot Recovered Signals
+plt.subplot(3, 1, 3)
+plt.title("Recovered Signals using ICA")
+plt.plot(S_recovered)
+
+plt.tight_layout()
+plt.show()
+ 1. ICA's primary goal is to find components that are statistically independent. PCA's goal is to find components that are uncorrelated and maximize variance. Independence is a much stronger condition than uncorrelation.
+2. The Central Limit Theorem suggests that mixing signals makes them "more Gaussian." ICA works by reversing this, finding a projection that makes the resulting signals as non-Gaussian as possible, which are assumed to be the original, independent sources.
+3. No, ICA did not fail. It successfully recovered the shape of the signal. ICA cannot determine the original sign (polarity) or scale (amplitude) of the sources. An upside-down signal is a perfectly valid result.
+4. You can extract a maximum of 10 components. The number of components must be less than or equal to the number of original features (observed signals).
+The Story: Decoding the Signal Purifier's Toolkit
+Story-style intuition: The Efficiency Expert
+Imagine two library builders. The XGBoost builder constructs one entire floor (level) at a time, ensuring all rooms are built before moving to the next floor. The LightGBM builder is an efficiency expert. They identify the most critical room in the entire library—the one that will provide the most value—and build that room first, even if it's on the 10th floor. They always focus on the single most impactful part of the project next, leading to a functional library much faster.
++ LightGBM (Light Gradient Boosting Machine) is a gradient boosting framework developed by Microsoft that is designed for speed and efficiency. Its key innovation is using a leaf-wise tree growth strategy instead of the conventional level-wise strategy. +
+ +Story example: The Smart Survey Taker
+LightGBM is like a very smart survey taker. Instead of asking for everyone's exact age (a continuous value), they group people into age brackets like 20-30, 30-40, etc. (Histogram-based splitting). They focus their energy on people whose opinions are most likely to change the survey's outcome (GOSS) and bundle redundant questions together (EFB) to save time.
+Story example: The Aggressive Problem-Solver
+The mathematical goal is the same as other boosting models: minimize a combined objective of loss and complexity. However, LightGBM's strategy is different. While a level-wise builder ensures a balanced structure at all times, LightGBM's leaf-wise strategy is like an aggressive problem-solver who ignores balanced development to go straight for the part of the problem that will yield the biggest reward.
+LightGBM minimizes the same objective function as XGBoost, which includes a loss term and a regularization term:
+$$ \text{Obj} = \sum_i l(y_i, \hat{y}_i) + \sum_k \Omega(f_k) $$
+The key difference is not in the *what* (the objective) but in the *how* (the strategy). The leaf-wise split strategy finds the most promising leaf and splits it, which converges on the minimum loss much faster than building out a full level of the tree.
+ +| Parameter | +Explanation & Story | +
|---|---|
| num_leaves | +The maximum number of leaves in one tree. This is the main parameter to control complexity. Story: How many specific, final conclusions an expert is allowed to have. This is more direct than `max_depth`. | +
| max_depth | +Limits the maximum depth of the tree. Used to prevent overfitting. Story: A hard limit on how many "follow-up questions" an expert can ask before reaching a conclusion. | +
| learning_rate | +The shrinkage rate. Story: How cautiously you apply the new expert's advice. | +
| n_estimators | +The number of boosting iterations. Story: How many experts you add to the team sequentially. | +
| min_data_in_leaf | +Minimum number of data points required in a leaf. Prevents creating leaves for single, noisy data points. Story: An expert isn't allowed to make a final conclusion based on just one person's opinion. | +
| boosting | +Can be `gbdt` (traditional), `dart` (adds dropout), or `goss`. Story: The overall strategy the team of experts will use. `goss` is the efficient sampling strategy unique to LightGBM. | +
LightGBM is like a high-speed bullet train. It's incredibly fast and efficient, capable of handling huge amounts of cargo (large datasets) with ease. However, it's built for long, straight tracks. On smaller, twistier routes (small datasets), its aggressive speed might cause it to fly off the rails (overfit) if the driver isn't careful with the controls (hyperparameters).
+Here, we call our "efficiency expert" from the `lightgbm` library. We create a regressor and train it on our data. We use `eval_set` to monitor performance on a validation set and stop training early if performance doesn't improve, preventing our expert from over-studying and memorizing the answers.
+
+import lightgbm as lgb
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+# Example dataset
+X = np.random.rand(500, 10)
+y = np.random.rand(500) * 20
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize LightGBM Regressor
+lgbm = lgb.LGBMRegressor(objective='regression', num_leaves=31, learning_rate=0.05,
+ n_estimators=100, random_state=42)
+
+# Train with early stopping
+lgbm.fit(X_train, y_train, eval_set=[(X_test, y_test)],
+ callbacks=[lgb.early_stopping(10, verbose=False)])
+
+# Predict
+y_pred = lgbm.predict(X_test)
+
+# Evaluate
+mse = mean_squared_error(y_test, y_pred)
+print(f"Mean Squared Error: {mse:.2f}")
+
+# Plot feature importance
+lgb.plot_importance(lgbm, max_num_features=10)
+ The Story: The Efficiency Expert's Secret Techniques
+Let's uncover the clever tricks LightGBM uses to be so fast and efficient.
++ What it is: A technique that groups continuous feature values into a fixed number of discrete bins (a histogram) before training. The algorithm then finds the best split among the bins instead of among all the unique data points. +
++ Story Example: Imagine sorting a million marbles of slightly different shades of red. It would take forever. A histogram-based approach is like creating just 10 buckets: "Bright Red," "Medium Red," "Dark Red," etc. You quickly throw each marble into a bucket. Now, finding the best dividing line between shades is incredibly fast because you only have to compare 10 buckets, not a million individual marbles. +
+ ++ What it is: Two different strategies for building decision trees. +
++ Story Example: Two players are playing a strategy game. The level-wise player upgrades all their buildings to Level 2 before starting on Level 3. They are balanced but slow. The leaf-wise player finds the single most powerful upgrade in the entire game and rushes to get it, ignoring everything else. They become powerful much faster but might have weaknesses if their strategy is countered. +
+ ++ What it is: A sampling method that focuses on the data points that the model is most wrong about. It keeps all instances with large gradients (high error) and randomly samples from instances with small gradients (low error). +
++ Story Example: A teacher wants to improve the class's test scores efficiently. Instead of re-teaching the entire curriculum to everyone, they use GOSS. They give mandatory tutoring to all students who failed the test (large gradients). For the students who passed, they only pick a random handful to attend a review session (sampling small gradients). This focuses their teaching effort where it's needed most. +
+ ++ What it is: A technique for handling sparse data (data with many zeros). It identifies features that are mutually exclusive (i.e., they are rarely non-zero at the same time) and bundles them into a single, denser feature. +
++ Story Example: You have a survey with many "Yes/No" questions that are rarely answered "Yes" at the same time, like "Do you own a cat?", "Do you own a dog?", "Do you own a bird?". EFB is like creating a single new question: "Which pet do you own?" and combining the sparse answers into one feature. This reduces the number of questions the model has to consider, speeding up the process without losing information. +
+Story-style intuition: The Smart Photographer
+Imagine you have to take a single photo of two different groups of people, say a basketball team (tall, lean) and a group of sumo wrestlers (shorter, heavy). A regular photographer (like PCA) doesn't know who is in which group, so they might take the photo from an angle that just shows the biggest spread of people, perhaps from the side. But you are a smart photographer (using LDA). You already have the guest list and know who is a basketball player and who is a sumo wrestler. So, you find the one perfect camera angle that makes the two groups look as distinct as possible. This angle will likely be one that contrasts height against weight, making the two groups form separate, tight clusters in your photo. LDA is a supervised technique that uses these known labels to find the best "camera angles" (projections) to maximize the separation between groups.
+Linear Discriminant Analysis (LDA) is a powerful technique used for both supervised classification and dimensionality reduction. Its primary goal is to find a new, lower-dimensional space to project the data onto, such that the separation (or discrimination) between the different classes is maximized. The new axes it finds are called linear discriminants.
+ +While PCA is unsupervised and only cares about finding axes that maximize the total variance (the spread of the entire dataset), LDA is supervised and has a much more specific goal. It uses the class labels to find a projection that simultaneously accomplishes two things:
+This image illustrates the core idea. Projecting onto the horizontal axis (like PCA might) causes the classes to overlap. LDA finds a new, tilted axis that perfectly separates the centers of the blue and red clusters while keeping each cluster's projection tight.
+To achieve its goals, LDA mathematically defines the two objectives and finds a projection that optimizes them. It calculates two key statistical measures:
+The perfect "camera angle" (projection matrix W) is the one that maximizes the ratio of $$S_B$$ to $$S_W$$. This is a classic optimization problem that is solved using a technique called the generalized eigenvalue problem.
+$$ S_W = \sum_{c=1}^k \sum_{x \in c} (x - \mu_c)(x - \mu_c)^T $$
+Here, $$\mu_c$$ is the mean vector (center) of a single class c. This formula essentially calculates the spread of points around their own group's center and adds it all up.
+$$ S_B = \sum_{c=1}^k N_c (\mu_c - \mu)(\mu_c - \mu)^T $$
+Here, $$\mu$$ is the mean of the entire dataset, $$\mu_c$$ is the mean of class c, and $$N_c$$ is the number of samples in class c. This formula measures how far each class center is from the overall center, giving more weight to larger classes.
+$$ J(W) = \frac{|W^T S_B W|}{|W^T S_W W|} $$
+Geometrically, LDA rotates and projects the data to find the best view for class separation. The number of new dimensions (linear discriminants) it can create is limited by the number of classes. Specifically, for a problem with **k** classes, LDA can find at most **k-1** new axes.
+Example: +
LDA is a powerful tool, but it relies on a few key assumptions about the data. The model performs best when these are met:
+| Feature | +LDA (Linear Discriminant Analysis) | +PCA (Principal Component Analysis) | +
|---|---|---|
| Supervision | +Supervised (it requires class labels to compute class separability). | +Unsupervised (it only looks at the data's features, not the labels). | +
| Goal | +To find a projection that maximizes class separability. | +To find a projection that maximizes total variance. | +
| Application | +Primarily used for classification or as a preprocessing step for classification. | +Primarily used for general data representation, visualization, and compression. | +
| Example Visualization | ++ | + |
Here, we use the Iris dataset, which has 3 classes of flowers and 4 features. Since there are 3 classes, LDA can reduce the data to a maximum of 2 components (3-1=2). We will use it first for dimensionality reduction and visualization, and then show how it can be used directly as a classifier.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.preprocessing import StandardScaler
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# --- 1. Load and Scale the Data ---
+iris = load_iris()
+X, y = iris.data, iris.target
+
+# Split data for later classification test
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Scaling is a good practice for LDA.
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+
+# --- PART A: LDA for Dimensionality Reduction ---
+
+# --- 2. Create and Apply LDA ---
+# Since there are 3 classes, we can reduce to at most 2 components.
+lda_dr = LinearDiscriminantAnalysis(n_components=2)
+
+# Fit LDA and transform the training data. Note: .fit() needs both X and y.
+X_train_lda = lda_dr.fit_transform(X_train_scaled, y_train)
+
+# --- 3. Visualize the Results ---
+plt.figure(figsize=(8, 6))
+plt.scatter(X_train_lda[:, 0], X_train_lda[:, 1], c=y_train, cmap='viridis', edgecolor='k')
+plt.title('LDA of Iris Dataset (4D -> 2D)')
+plt.xlabel('Linear Discriminant 1')
+plt.ylabel('Linear Discriminant 2')
+plt.grid(True)
+plt.show()
+
+
+# --- PART B: LDA as a Classifier ---
+
+# --- 4. Train LDA as a Classifier ---
+# We don't set n_components, so it uses the components for classification.
+lda_clf = LinearDiscriminantAnalysis()
+lda_clf.fit(X_train_scaled, y_train)
+
+# --- 5. Make Predictions and Evaluate ---
+y_pred = lda_clf.predict(X_test_scaled)
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy of LDA as a classifier: {accuracy:.2%}")
+
+ The Story: Decoding the Smart Photographer's Toolkit
++ A classifier that learns by shaping 3D probability clouds. It assumes dimensions (Weight, Sweetness, Color) are independent. +
+ +Interactive Classification Visualizer
+After training you cant train agian and cant change output so if you want add a custom data in predefine data so add before training
+Story-style intuition: The Corporate Hierarchy
+Think of a large company trying to decide if a new project proposal is a "Go" or "No-Go". The raw data (market research, costs) goes to the junior analysts (input layer). Each analyst specializes in one piece of data. They pass their summaries to mid-level managers (hidden layers), who combine these summaries to spot higher-level patterns. Finally, the CEO (output layer) takes the managers' final reports and makes the single classification decision: Go or No-Go. A Deep Neural Network is just a company with many layers of management, allowing it to understand extremely complex problems.
++ A Neural Network (NN) is a computational model inspired by the structure and function of the human brain. It's composed of interconnected nodes, called artificial neurons, organized in layers. They are excellent at finding complex patterns in data. +
+ +Story example: The Assembly Line of Information
+An NN works like an assembly line. Raw materials (input data) enter at one end. Each station (neuron) performs a specific task: it takes materials from previous stations, weighs their importance (weights), adds a standard adjustment (bias), and decides whether to pass its result along (activation function). The process of the product moving from start to finish is Forward Propagation. If the final product is faulty, a manager goes back down the line (Backpropagation), telling each station exactly how to adjust its process to fix the error.
+Story example: The Neuron's Decision
+Each neuron is a tiny decision-maker. It listens to several colleagues (inputs). It trusts some colleagues more than others (their inputs have higher weights). It also has its own personal opinion (a bias). It adds up all the weighted opinions and its own bias to get a final score. Based on this score, it decides how strongly to "shout" its conclusion to the next layer of neurons. This "shout" is governed by its activation function.
+$$ z = (w_1x_1 + w_2x_2 + \dots) + b $$
+$$ a = f(z) $$
+The Sigmoid function takes any real value and squashes it to a range between 0 and 1. This is perfect for the output layer in a binary classification task, where the output can be interpreted as a probability.
+Example: In an email spam detector, a Sigmoid output of 0.95 means there is a 95% probability that the email is spam.
+Story Analogy: The Dimmer Switch. Think of a Sigmoid function as a dimmer switch for a light. It's not just on or off; it can be 0% bright (output 0), 100% bright (output 1), or any percentage in between. This makes it ideal for representing the probability of a single outcome.
+The Softmax function is used in the output layer for multi-class classification. It takes a vector of raw scores (logits) and transforms them into a probability distribution, where each value is between 0 and 1, and all values sum up to 1.
+Example: An image classifier for animals might output raw scores of `[cat: 2.5, dog: 1.8, bird: 0.5]`. After applying Softmax, this becomes a probability distribution like `[cat: 0.65, dog: 0.29, bird: 0.06]`, indicating a 65% chance the image is a cat.
+Story Analogy: The Voting Poll. Imagine an election with multiple candidates (classes). Each candidate gets a certain number of raw votes (the logits). The Softmax function is the pollster that converts those raw vote counts into a final percentage for each candidate, ensuring the total percentage adds up to 100%. This tells you the relative likelihood of each candidate winning.
+ReLU is the most popular activation function for hidden layers. It's a very simple function: if the input is positive, it passes it through unchanged; if it's negative, it outputs zero. This simplicity makes it very fast and helps prevent the vanishing gradient problem.
+Example: If a neuron calculates a weighted sum of `z = -0.8`, the ReLU activation will be `a = 0`. If it calculates `z = 1.2`, the activation will be `a = 1.2`.
+Story Analogy: The One-Way Gate. Think of ReLU as a one-way gate that only opens for positive signals. If a positive signal arrives, the gate lets it pass through at full strength. If a negative signal arrives, the gate stays shut, blocking it completely. This simple but effective "go/no-go" mechanism is incredibly efficient for the internal workings of the network.
+Story: The Student Studying for an Exam
+A student (the model) is studying a textbook (the dataset). One full read-through of the book is an Epoch. If they study in chunks, say 32 pages at a time, that's the Batch Size. Each time they review a chunk of pages is an Iteration. How much they adjust their notes after finding a mistake is the Learning Rate. Memorizing the book word-for-word is Overfitting, while not studying enough is Underfitting.
+| Network Type | +Story & Analogy | +
|---|---|
| Deep Neural Network (DNN) | +A large corporation with many layers of management, capable of solving very complex business problems. | +
| Convolutional Neural Network (CNN) | +A team of image specialists. They use special scanning tools (filters) to find simple patterns (edges, corners) and then combine them to recognize complex objects (faces, cars). | +
| Recurrent Neural Network (RNN) | +A team that has a short-term memory. When processing a sentence, they remember the previous words to understand the context of the current word. Ideal for sequences like text or speech. | +
A Neural Network is like a powerful but mysterious alien artifact. It can perform incredible feats (learn complex patterns) that no other tool can. However, it requires a huge amount of energy to run (data and computation), it's a "black box" because its inner workings are hard to understand, and you need to press its buttons (hyperparameters) in exactly the right way to get it to work.
+Here, we use the `keras` library to build our "corporate hierarchy". We create a `Sequential` model, which is like setting up a new company. We `add` layers (departments) one by one. Then, we `compile` the company's rulebook: its goal (loss), its method for improving (optimizer), and how it will be graded (metrics). Finally, we `fit` the model, which is the process of training our new company on historical data.
+
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Dropout
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.datasets import make_classification
+
+# 1. Generate sample data
+X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_classes=2, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 2. Normalize data
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# 3. Define the model
+model = Sequential([
+ Dense(64, activation='relu', input_shape=(X_train.shape[1],)), # Hidden Layer 1
+ Dropout(0.5), # Regularization
+ Dense(32, activation='relu'), # Hidden Layer 2
+ Dense(1, activation='sigmoid') # Output Layer
+])
+
+# 4. Compile the model
+model.compile(optimizer='adam',
+ loss='binary_crossentropy',
+ metrics=['accuracy'])
+
+# 5. Train the model
+history = model.fit(X_train, y_train,
+ epochs=50,
+ batch_size=32,
+ validation_split=0.2,
+ verbose=0)
+
+# 6. Evaluate the model
+loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
+print(f"Test Accuracy: {accuracy*100:.2f}%")
+ The Story: The Company's Training Manual
+Let's demystify the core processes and rules that govern how our neural network company learns and improves.
++ What it is: The algorithm used to train neural networks. It calculates the error at the output and propagates it backward through the network layers, determining how much each weight and bias contributed to the error. This information is then used by the optimizer (like Gradient Descent) to update the weights. +
++ Story Example: In our corporate hierarchy, the final project fails (an error). Backpropagation is the process where the CEO blames the senior managers, who in turn figure out which mid-level managers gave them bad information, who then blame the junior analysts. This chain of blame assignment precisely identifies how much each employee at every level needs to adjust their work to fix the overall process. +
++ What it is: A function applied to the output of a neuron that determines whether it should be activated ("fire") or not. It introduces non-linearity into the network, allowing it to learn complex patterns. +
++ Story Example: An activation function is like a neuron's "excitement" level. A neuron listens to all the evidence, and if the total evidence exceeds a certain threshold, it gets excited and fires a strong signal. If not, it stays quiet. This on/off or graded response is what allows the network to make complex, non-linear decisions, rather than just calculating simple averages. +
+ ++ What it is: A regularization technique where, during each training iteration, a random fraction of neurons are temporarily "dropped out" or ignored. +
++ Story Example: Imagine a team of employees working on a project. To ensure no single employee becomes a single point of failure, the manager uses Dropout. Each day, they tell a few random employees to take the day off. This forces the remaining team members to become more versatile and robust, unable to rely on any one superstar. The result is a more resilient team that performs better overall. + + +
+ What it is: One complete forward and backward pass of all the training examples through the neural network. +
++ Story Example: An epoch is like one full school year for our neural network student. During the year, they study every chapter in the textbook (all the training data) at least once. For a model to become truly proficient, it often needs to go through multiple school years (epochs) to master the material. +
+Optimization (Gradient Descent): Gradient descent is an optimization algorithm used to minimize the error (loss function) of a model during the training process. It is the underlying mechanism that powers the "gradient" aspect of gradient boosting, allowing the models to iteratively improve their performance.
+Story-style intuition: The Shadow Puppet Master
+Imagine you have a complex 3D object, like a toy airplane. If you shine a light on it, you create a 2D shadow. From one angle, the shadow might look like a simple line. But if you rotate the airplane and find the perfect angle, the shadow will capture its main shape—the wings and body. PCA is like a mathematical shadow puppet master for your data. It takes high-dimensional data (the 3D airplane) and finds the best "angles" to project it onto a lower-dimensional surface (the 2D shadow), making sure the shadow preserves as much of the original shape (the variance) as possible.
+Principal Component Analysis (PCA) is a dimensionality reduction technique. Its main goal is to reduce the number of features in a dataset while keeping as much important information as possible. It doesn't just pick features; it creates new, powerful features called principal components, which are combinations of the original ones.
+Example: A dataset about houses has 10 features: square footage, number of rooms, number of bathrooms, lot size, etc. Many of these features are correlated and essentially measure the same thing: the "size" of the house. PCA can combine them into a single new feature like "Overall House Size," reducing 10 features to 1 without losing much information.
+Story: The "Data Squishing" Machine
+PCA is a five-step machine that intelligently squishes your data:
+The core of PCA relies on linear algebra to find the principal components. The process is:
+Story: Finding the Best Camera Angle
+Imagine your data is a cloud of points in 3D space. PCA is like finding the best camera angle to take a 2D picture of this cloud.
+
• The First Principal Component (PC1) is the direction (or camera angle) that shows the biggest spread of data. It's the longest axis of the data cloud.
+
• The Second Principal Component (PC2) is the direction that shows the next biggest spread, but it must be at a 90-degree angle (orthogonal) to PC1.
+
By projecting the 3D cloud onto a 2D plane defined by these two new axes, you get the most informative and representative 2D picture of your data.
Each principal component captures a certain amount of the total variance (information) from the original dataset. The "explained variance ratio" tells you the percentage of the total information that each component holds.
+Example: After running PCA, you might find:
+In this case, the first two components alone capture 95% of the total information. This means you can likely discard all other components and just use PC1 and PC2, reducing your data's complexity while retaining almost all of its structure. This is often visualized using a scree plot.
+| Comparison | +PCA (Principal Component Analysis) | +Alternative Method | +
|---|---|---|
| vs. Feature Selection | +Creates new features by combining old ones. (Making a smoothie from different fruits). | +Selects a subset of the original features. (Picking the best fruits for a fruit basket). | +
| vs. Autoencoders | +A linear method. Can't capture complex, curved patterns in data. (Taking a simple photo). | +Can learn complex, nonlinear patterns. (Drawing a detailed, artistic sketch). | +
In this example, we take the famous Iris dataset, which has 4 features, and use PCA to squish it down to just 2 features (principal components). This allows us to create a 2D scatter plot that effectively visualizes the separation between the different flower species.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+from sklearn.datasets import load_iris
+
+# --- 1. Load and Scale the Data ---
+# The Iris dataset has 4 features for 3 species of iris flowers.
+iris = load_iris()
+X = iris.data
+
+# Scaling is CRITICAL for PCA!
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# --- 2. Create and Apply PCA ---
+# We'll reduce the 4 features down to 2 principal components.
+pca = PCA(n_components=2)
+
+# Fit PCA to the scaled data and transform it.
+X_pca = pca.fit_transform(X_scaled)
+
+# --- 3. Check the Explained Variance ---
+# Let's see how much information our 2 new components hold.
+explained_variance = pca.explained_variance_ratio_
+print(f"Explained variance by component 1: {explained_variance[0]:.2%}")
+print(f"Explained variance by component 2: {explained_variance[1]:.2%}")
+print(f"Total variance explained by 2 components: {np.sum(explained_variance):.2%}")
+
+# --- 4. Visualize the Results ---
+# We can now plot our 4D dataset in 2D.
+plt.figure(figsize=(8, 6))
+plt.scatter(X_pca[:, 0], X_pca[:, 1], c=iris.target, cmap='viridis')
+plt.title('PCA of Iris Dataset (4D -> 2D)')
+plt.xlabel('First Principal Component')
+plt.ylabel('Second Principal Component')
+plt.grid(True)
+plt.show()
+ The Story: Decoding the Shadow Master's Toolkit
+Let's clarify the key terms the PCA shadow master uses.
+Story-style intuition: The Restaurant Critic's Notebook
+Imagine a food critic exploring a new city. Their goal is to find the best possible multi-course meal. The critic creates a huge notebook with a page for every restaurant (state) in the city. On each page, they list every dish (action) available. They then go out and, through trial-and-error, start assigning a score to each dish. This score, the Q-value, isn't just about how good that one dish tastes (the immediate reward). It's a prediction of the total "dining satisfaction" for the entire evening if they eat that dish and then continue to choose the best dishes at all subsequent restaurants. After visiting many restaurants over many nights, their notebook becomes the ultimate guide to the perfect dining experience. Q-Learning is this process of an agent filling out its "notebook" (the Q-table) to learn the value of every action in every state.
+Q-Learning is a classic model-free, off-policy Reinforcement Learning algorithm. Its primary goal is to learn the optimal policy for making decisions by estimating the quality of state-action pairs, known as the Q-function.
+ +The Q-function, denoted \( Q(s, a) \), represents the total expected future reward (the Return) an agent can get by taking a specific action \(a\) in a specific state \(s\) and then following the optimal policy thereafter. It's a measure of how good a particular move is in a particular situation.
+Q-Learning's objective is to find the optimal Q-function, \( Q^*(s, a) \):
+$$ Q^*(s,a) = \max_\pi \mathbb{E} \Big[ G_t \mid S_t = s, A_t = a, \pi \Big] $$
+In simple terms, this means \( Q^*(s, a) \) is the maximum possible return you can get if you start by taking action \(a\) in state \(s\).
+Example: In a maze, \( Q(\text{crossroads}, \text{go left}) \) would be the predicted total reward if the agent chooses to go left at the crossroads and then plays perfectly for the rest of the maze. This value would be high if "left" is on the optimal path to the exit, and low if it leads to a dead end.
+The Critic's Update Rule: After trying a dish (action a) at a restaurant (state s), the critic gets an immediate taste score (Reward R). They then look at their notebook for the *next* restaurant (state s') and find the score of the *best possible* dish they could order there. They combine this information to create an updated "learned value." The final updated score in their notebook is a small step from the old score towards this new learned value. The size of that step is the learning rate (α).
+The core of Q-Learning is its update rule, which is applied after every step the agent takes. It updates the Q-value for the state-action pair it just experienced.
+$$ Q(s, a) \leftarrow Q(s, a) + \alpha \Big[ \underbrace{R + \gamma \max_{a'} Q(s', a')}_{\text{New Learned Value}} - Q(s, a) \Big] $$
+The algorithm iteratively refines its Q-table until the values converge to the optimal ones.
+ +The Critic's Dilemma: On any given night, should the critic go to the restaurant and order the dish they already know has the highest score in their notebook (Exploitation)? Or should they try a random, new dish they've never had before to see if it's even better (Exploration)? If they only exploit, they might miss out on a hidden gem. If they only explore, they'll have a lot of bad meals.
+This is a fundamental challenge in RL. The most common solution is the epsilon-greedy (\(\epsilon\)-greedy) strategy:
+Imagine a simple 3x3 grid world:
+Initially, the Q-table is all zeros. As the agent explores, it will eventually stumble into the Goal. When it does, the Q-value for the state-action pair that led to the goal gets a positive update. In the next episode, if the agent reaches a state next to that one, the `max Q(s', a')` term in the update rule will now be positive, causing the "goodness" of the goal to propagate backwards through the grid, one step at a time, until the agent has a complete map of the best path from any square.
+| Advantages | +Disadvantages | +
|---|---|
| ✅ Simple and Intuitive: The core concept of updating a value table is very easy to understand and implement. | +❌ The Curse of Dimensionality: It is only feasible for problems with small, discrete state and action spaces. The size of the Q-table explodes as states/actions increase. Example: A chess board has ~10¹²⁰ states. A Q-table is impossible. |
+
| ✅ Model-Free: The agent doesn't need to know the rules of the environment (the transition probabilities P). It learns just by observing outcomes. | +❌ Slow Convergence: It can take a very large number of episodes for the Q-values to propagate through the entire state space and converge. | +
| ✅ Guaranteed Convergence: Under the right conditions (enough exploration, a learning rate that decays appropriately), Q-Learning is proven to converge to the optimal Q-values. | +❌ Cannot handle continuous spaces without modification. To handle continuous states or actions, you need to combine it with a function approximator, which leads to Deep Q-Learning (DQN). | +
The Story: Decoding the Critic's Jargon
++ An ensemble learning method for classification that operates by constructing a multitude of decision trees. +
+ +Many Decision Trees
+Each trained on a random subset
+New Data Point
+Sent to ALL trees
+Individual Predictions
+Each tree "votes" on the class
+Majority Vote
+Most common prediction wins
+Final Classification
+Robust and accurate
++ Random Forest combines the power of many individual decision trees to make a more robust and accurate classification, leveraging collective intelligence. +
++ Random Forest is an ensemble learning method that builds a "forest" of decision trees. For classification tasks, it outputs the class that is the mode of the classes (majority vote) of the individual trees. It's known for its high accuracy and ability to handle complex datasets. +
+ ++ *The plot will show the decision boundary by predicting the class for a grid of points covering the entire plot area. The color of each grid point reflects the predicted class, creating the background regions.* +
+Story-style intuition: The Immediate Feedback
+Imagine a mouse in a maze. The Reward is the immediate, tangible feedback it gets for its actions. If it takes a step and finds a tiny crumb of cheese, it gets an immediate `+1` reward. If it touches an electric wire, it gets an immediate `-10` reward. If it just moves to an empty square, it gets a small `-0.1` reward (to encourage it to hurry). The reward signal is the fundamental way the environment tells the agent, "What you just did was good/bad."
+The Reward (R) is a scalar feedback signal that the environment provides to the agent after each action. It is the primary driver of learning, as the agent's ultimate goal is to maximize the total reward it accumulates over time.
+Example: In a video game, picking up a health pack gives a `+25` reward.
Example: A self-driving car receiving a `-100` reward for a collision.
Example: In chess, most moves don't immediately win or lose the game, so they receive a reward of `0`.
Story-style intuition: The Long-Term Goal
+The mouse in the maze isn't just trying to get the next crumb of cheese; its real goal is to get the big block of cheese at the end. The Return (G) is the total sum of all the rewards the mouse expects to get from its current position until the end of the maze. A smart mouse will choose a path of small negative rewards (empty steps) if it knows that path leads to the huge `+1000` reward of the final cheese block. It learns to prioritize the path with the highest Return, not just the highest immediate reward.
+The Return (G) is the cumulative sum of future rewards. Because the future is uncertain and rewards that are far away are often less valuable than immediate ones, we use a discount factor (γ).
+$$ G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \dots $$
+The discount factor \( \gamma \) (a number between 0 and 1) determines the present value of future rewards. A \( \gamma \) of 0.9 means a reward received in the next step is worth 90% of its value now, a reward in two steps is worth 81%, and so on.
+ +Story-style intuition: The Chess Master's Insight
+A novice chess player only sees the immediate rewards (e.g., "I can capture their pawn!"). A chess master, however, understands the Value of a board position. A certain position might not offer any immediate captures, but the master knows it has a high value because it provides strong control over the center of the board and is highly likely to lead to a win (a large future return) later on. The Value Function is this deep, predictive understanding of "how good" a situation is in the long run.
+A Value Function is a prediction of the expected future return. It is the core of many RL algorithms, as it allows the agent to make decisions based on the long-term consequences of its actions.
+Answers the question: "How good is it to be in this state?"
+$$ V^\pi(s) = \mathbb{E}_\pi [G_t \mid S_t = s] $$
+This is the expected return an agent can get if it starts in state \(s\) and follows its policy \( \pi \) thereafter.
+Example: In Pac-Man, the state-value \( V(s) \) of a position surrounded by pellets is high. The value of a position where Pac-Man is cornered by a ghost is very low.
+Answers the question: "How good is it to take this specific action in this state?"
+$$ Q^\pi(s, a) = \mathbb{E}_\pi [G_t \mid S_t = s, A_t = a] $$
+This is the expected return if the agent starts in state \(s\), takes action \(a\), and then follows its policy \( \pi \) from that point on. The Q-function is often more useful for decision-making because for any state, the agent can simply choose the action with the highest Q-value.
+Example: You are Pac-Man at an intersection (state s). The Q-function would give you values for each action: \( Q(s, \text{move left}) = +50 \), \( Q(s, \text{move right}) = -200 \) (because a ghost is there). You would obviously choose to move left.
+| Aspect | +Reward (R) | +Value Function (V or Q) | +
|---|---|---|
| Timing | +Immediate and short-term. | +Long-term prediction of future rewards. | +
| Source | +Provided directly by the environment. | +Estimated by the agent based on its experience. | +
| Purpose | +Defines the fundamental goal of the task. | +Used to guide the agent's policy toward that goal. | +
| Analogy | +The `+1` point you get for eating a pellet in Pac-Man. | +Your internal estimate of the final high score you are likely to get from your current position. | +
Example: An AI agent rewarded for winning a boat race discovered a bug where it could go in circles and collect turbo boosts infinitely, never finishing the race but accumulating a huge score. It maximized the reward signal, but not in the way the designers intended.
Story-style intuition: The Ambitious Student
+Imagine a student learning to identify animals. Their teacher gives them a small, labeled set of 10 flashcards (labeled data). The student studies these cards and learns the basic differences between cats and dogs. The teacher then gives the student a huge stack of 1,000 unlabeled photos (unlabeled data). The student goes through the stack and labels the photos they are most confident about (e.g., "I'm 99% sure this is a cat"). They add these self-labeled photos, called pseudo-labels, to their original small set of flashcards. Now, with a much larger study set, they retrain their brain to become an even better animal identifier. This process of using your own knowledge to learn more is the essence of Self-Training.
+Self-Training is a simple yet powerful semi-supervised learning technique. It is used when you have a small amount of labeled data and a large amount of unlabeled data. The model is first trained on the small labeled set, and then it iteratively "bootstraps" itself by using its own predictions on the unlabeled data to improve its performance.
+ +The self-training process is an iterative loop that aims to leverage the unlabeled data effectively.
+ +Think of the model's learning process as minimizing an "error" or "loss" score. Initially, it only cares about the error on the teacher's flashcards. In self-training, it also starts caring about the error on its self-marked homework, but maybe gives it a little less weight so it doesn't get misled by a mistake.
+The learning process is guided by a combined loss function:
+$$ L = L_{sup} + \lambda L_{pseudo} $$
+Self-training can be very effective, but it relies on a few important assumptions. If these aren't true, the model can actually get worse!
+| Advantages | +Disadvantages | +
|---|---|
| ✅ Simple to implement and understand. | +❌ Error Propagation: The biggest risk. If the model makes a confident mistake, that incorrect pseudo-label is added to the training set, potentially making the model even more wrong in the next iteration. | +
| ✅ Can significantly improve model performance when labeled data is scarce. | +❌ Confirmation Bias: The model tends to reinforce its own initial biases. If it has a slight bias at the start, self-training can amplify it. | +
| ✅ Leverages vast amounts of cheap, unlabeled data. | +❌ Highly sensitive to the choice of the confidence threshold. | +
Self-training is most useful in domains where labeling is a bottleneck:
+Scikit-learn makes implementing self-training incredibly easy with its `SelfTrainingClassifier`. You simply take a standard classifier (like a Random Forest) and wrap it inside `SelfTrainingClassifier`. It handles the iterative prediction and retraining loop for you automatically.
+
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn.semi_supervised import SelfTrainingClassifier
+from sklearn.metrics import accuracy_score
+
+# --- 1. Create a Sample Dataset ---
+# We'll create a dataset with 1000 samples.
+X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
+
+# Split into a tiny labeled set and a large unlabeled set
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.95, random_state=42)
+
+# Let's "hide" most of the labels in the test set to simulate an unlabeled pool
+# A value of -1 is the default for "unlabeled" in scikit-learn
+y_unlabeled = np.full_like(y_test, -1)
+
+# Combine the small labeled training set with the large unlabeled test set
+X_combined = np.concatenate((X_train, X_test))
+y_combined = np.concatenate((y_train, y_unlabeled))
+
+# --- 2. Train a Standard Supervised Model (Baseline) ---
+base_classifier_baseline = SVC(probability=True, random_state=42)
+base_classifier_baseline.fit(X_train, y_train)
+y_pred_baseline = base_classifier_baseline.predict(X_test)
+print(f"Baseline Accuracy (trained on only {len(X_train)} labeled samples): {accuracy_score(y_test, y_pred_baseline):.2%}")
+
+# --- 3. Train a Self-Training Model ---
+# We use the same base classifier
+base_classifier_st = SVC(probability=True, random_state=42)
+self_training_model = SelfTrainingClassifier(base_classifier_st, threshold=0.95)
+
+# Train the model on the combined labeled and unlabeled data
+self_training_model.fit(X_combined, y_combined)
+
+# --- 4. Evaluate the Self-Training Model ---
+y_pred_st = self_training_model.predict(X_test)
+print(f"Self-Training Accuracy (trained on labeled + pseudo-labeled data): {accuracy_score(y_test, y_pred_st):.2%}")
+ 1. The primary motivation is to leverage large amounts of cheap, unlabeled data to improve a model's performance when labeled data is scarce or expensive to obtain.
+2. The biggest risk is error propagation. It happens when the model makes a confident but incorrect prediction, and that incorrect "pseudo-label" is added to the training set, which can corrupt the model and make it worse in subsequent iterations.
+3. A "pseudo-label" is a label for an unlabeled data point that is generated by the machine learning model itself, not by a human.
+4. The trade-off is between the quantity and quality of pseudo-labels. Lowering the threshold will add more data to the training set in each iteration (increasing quantity), but these labels will be less reliable, increasing the risk of error propagation (decreasing quality).
+The Story: Decoding the Ambitious Student's Study Guide
+Story-style intuition: The Expert Project Manager
+Imagine you need to solve a complex problem, like predicting next month's sales. Instead of hiring one expert, you hire a diverse team of specialists (the base learners): a statistician with a linear model, a data scientist with a decision tree, and a machine learning engineer with an SVM. Each specialist analyzes the data and gives you their prediction.
+
Instead of just averaging their opinions (like in Bagging), you hire a wise, experienced Project Manager (the meta-learner). The manager's job isn't to look at the original data, but to look at the *predictions* from the specialists. Over time, the manager learns which specialists are trustworthy in which situations (e.g., "The statistician is great at predicting stable trends, but the data scientist is better when there's a holiday sale"). The manager then learns to combine their advice intelligently to produce a final forecast that is better than any single specialist's prediction. This is Stacking.
Stacking (or Stacked Generalization) is a sophisticated ensemble learning technique that combines multiple machine learning models. It uses a "meta-learner" to learn the best way to combine the predictions from several "base learner" models to improve predictive accuracy.
+ +Stacking is a multi-level process that learns from the output of other models.
+ +If you have \(n\) base learners \(h_1, h_2, ..., h_n\), the meta-learner \(H\) learns a function \(f\) that combines their outputs:
+$$ H(x) = f(h_1(x), h_2(x), ..., h_n(x)) $$
+Unlike a simple average, the function \(f\) learned by the meta-learner can be a complex, non-linear combination. It might learn, for example, to trust model \(h_1\) more when its prediction is high, but trust \(h_2\) more when \(h_1\)'s prediction is low.
+ +| Advantages | +Disadvantages | +
|---|---|
| ✅ Can achieve higher predictive performance than any single model in the ensemble. | +❌ Computationally Expensive: It requires training multiple base models plus a meta-learner, often with cross-validation, making it very time-consuming. | +
| ✅ Highly flexible and can combine any type of model (heterogeneous ensembles). | +❌ Complex to Implement: The setup, especially the cross-validation process for the meta-learner's training data, is more complex than Bagging or Boosting. | +
| ✅ Can effectively learn to balance the strengths and weaknesses of different models. | +❌ Loss of Interpretability: It's extremely difficult to explain *why* a stacking ensemble made a particular prediction, as it involves multiple layers of models. | +
Scikit-learn makes it easy to build a stacking model. You define a list of your "specialist" base learners and then specify the final "project manager" meta-learner.
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import StackingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+
+# --- 1. Get Data ---
+X, y = make_classification(n_samples=500, n_features=10, n_informative=5, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# --- 2. Define the Base Learners ("The Specialists") ---
+base_learners = [
+ ('decision_tree', DecisionTreeClassifier(max_depth=5, random_state=42)),
+ ('svm', SVC(probability=True, random_state=42)),
+ ('knn', KNeighborsClassifier(n_neighbors=7))
+]
+
+# --- 3. Define and Train the Stacking Ensemble ---
+# The meta-learner is a Logistic Regression model
+stacking_clf = StackingClassifier(
+ estimators=base_learners,
+ final_estimator=LogisticRegression(),
+ cv=5 # Use 5-fold cross-validation to generate meta-features
+)
+
+# Fitting this model trains all base learners and the meta-learner
+stacking_clf.fit(X_train, y_train)
+
+# --- 4. Make Predictions ---
+y_pred = stacking_clf.predict(X_test)
+
+from sklearn.metrics import accuracy_score
+print(f"Stacking Classifier Accuracy: {accuracy_score(y_test, y_pred):.2%}")
+ 1. The meta-learner's role is to learn how to best combine the predictions from the base learners. It takes their predictions as input and makes the final prediction.
+2. Diversity is crucial because if all base learners are similar and make the same mistakes, the meta-learner has no new information to learn from. Diverse models make different kinds of errors, and the meta-learner can learn to correct for them.
+3. Cross-validation is used to generate the training data for the meta-learner. It's necessary to prevent data leakage. If the meta-learner was trained on predictions made on the same data the base models were trained on, it would simply learn to trust the base model that overfit the most.
+4. Bagging uses a simple aggregation method like averaging or majority voting. Stacking uses another machine learning model (the meta-learner) to learn a potentially complex way to combine the predictions.
+The Story: Decoding the Project Manager's Playbook
+Select a module from the sidebar to get started to know your knowledge!
+Test your knowledge with these quick-fire questions!
+You scored 0 out of 0
+ +You have already taken the quiz 3 times.
+Ensemble learning is a technique that combines multiple machine learning models to get a more robust and accurate prediction than a single model alone.
+Reinforcement learning (RL) is a subfield of machine learning where an agent learns to make decisions by taking actions in an environment to maximize some cumulative reward.
+Semi-supervised learning is a combination of supervised and unsupervised learning. It uses a small amount of labeled data and a large amount of unlabeled data to train a model. This is particularly useful when it is expensive to label data.
+Supervised learning is a type of machine learning where the model is trained on labeled data. This means the training dataset includes both the input and the correct output, and the model learns to map the input to the output.
+Unsupervised learning is a type of machine learning that looks for previously undetected patterns in a dataset with no pre-existing labels and with a minimum of human supervision.
+Used for grouping similar data points together.
+ +Used for reducing the number of features in a dataset while retaining important information.
+ +Used for discovering relationships between variables in large datasets.
+ +Story-style intuition: The Expert Path-Finder
+Imagine a standard Support Vector Machine (SVM) is a novice pathfinder. To learn a general rule for navigating any forest, they are given a training manual with a few examples of "safe" plants (blue flowers) and "dangerous" plants (red thorns) (labeled data). From this, they create a simple rule: draw a straight line halfway between the known blue and red plants. This is Inductive Learning—creating a general rule for all future forests.
+Now, imagine an expert pathfinder using a Transductive SVM (TSVM). They are given a map of a *specific* forest they must navigate. This map has the same few labeled blue and red plants, but it also shows the location of thousands of other unlabeled plants. The expert notices that these unlabeled plants form two distinct groves with a large, empty clearing between them. Instead of just drawing a line based on the two labeled plants, they adjust their path to go straight through the middle of the empty clearing. They are using the structure of the unlabeled landscape to find the safest, most confident path for *this specific forest*. This is Transductive Learning.
+Transductive Support Vector Machine (TSVM) is a semi-supervised learning algorithm that extends the standard SVM. It is designed for situations where you have a small amount of labeled data and a large amount of unlabeled data. Instead of learning a general function for unseen data, it tries to find the best possible labels for the specific unlabeled data it was given during training.
+ +The motivation behind TSVM is simple: why ignore a mountain of free information? A standard SVM trained on two labeled points has no idea about the true underlying structure of the data. TSVM operates on the powerful assumption that the unlabeled points are not random; they provide crucial clues about where the real decision boundary should lie.
+1. The SVM Scenario (Inductive): Imagine you have one labeled blue point at (-2, 0) and one labeled red point at (2, 0). A standard SVM would draw a vertical line at x=0 right between them. This seems reasonable.
+2. The TSVM Scenario (Transductive): Now, imagine you add 100 unlabeled points. You notice they form a tight cluster centered at (-4, 0) and another tight cluster at (4, 0). The original SVM line at x=0 now seems less optimal. The TSVM sees these two unlabeled clusters and adjusts its boundary to pass through the large empty space between them. The new boundary is still at x=0, but the model is now far more confident in this boundary because it is supported by the structure of the unlabeled data.
+The core idea is to find a hyperplane that not only separates the labeled data but also maximizes the margin with respect to the unlabeled data, fundamentally trying to avoid cutting through dense clusters of points.
+ +The pathfinder's rulebook has two parts. The first part is for the known spots, and the second is a new, complex chapter for the unknown terrain.
+This second rule makes the problem much harder, because the pathfinder has to guess the labels and find the best path at the same time.
+$$\min \frac{1}{2} ||w||^2 + C \sum \xi_i$$
+Because the exact TSVM optimization is hard, in practice, it's often solved with an iterative algorithm that looks very similar to self-training:
+TSVM's success hinges on the same core assumptions as most semi-supervised learning methods:
+| Advantages | +Disadvantages | +
|---|---|
| ✅ Can significantly improve the decision boundary and performance when labeled data is scarce. Example: A spam filter trained on only 50 labeled emails might be 70% accurate. By using 5,000 unlabeled emails, a TSVM could potentially boost accuracy to 95%. |
+ ❌ The optimization problem is non-convex, meaning it's hard to find the globally optimal solution and can be computationally very expensive. Example: Finding the best path might take hours or days for a very large, complex forest map, and you might still end up in a "good" valley instead of the "best" one. |
+
| ✅ Effectively leverages the structure of unlabeled data to find a better margin. Example: It doesn't just separate two patients; it draws the diagnostic line in the empty space between the entire "healthy" and "sick" populations shown in the unlabeled data. |
+ ❌ Error Propagation: If the model confidently assigns wrong pseudo-labels early on, these errors can corrupt the training process. Example: If the pathfinder initially mislabels a patch of dangerous thorns as "safe," it will actively try to draw its path closer to them, making the final path more dangerous. |
+
TSVM is most useful in fields where unlabeled data is plentiful but getting labels is a bottleneck:
+True TSVMs are not included in `scikit-learn` because they are computationally complex. However, we can approximate the behavior of a TSVM using the `SelfTrainingClassifier` with an SVM as its base. This wrapper effectively performs the iterative self-labeling workflow described above, which is a common and practical way to implement the core idea of transductive learning.
+
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn.semi_supervised import SelfTrainingClassifier
+from sklearn.metrics import accuracy_score
+
+# --- 1. Create a Sample Dataset ---
+# We simulate a scenario with 500 total data points.
+X, y = make_classification(n_samples=500, n_features=10, n_informative=5, random_state=42)
+
+# --- 2. Create a small labeled set and a large unlabeled set ---
+# This is a realistic scenario: we only have 50 labeled samples (10%).
+# The other 450 samples are our "unlabeled" pool.
+X_train, X_unlabeled, y_train, y_true_unlabeled = train_test_split(X, y, test_size=0.9, random_state=42)
+
+# To simulate the semi-supervised setting, we "hide" the labels of the unlabeled pool.
+# scikit-learn uses -1 to denote an unlabeled sample.
+y_unlabeled_masked = np.full_like(y_true_unlabeled, -1)
+X_combined = np.concatenate((X_train, X_unlabeled))
+y_combined = np.concatenate((y_train, y_unlabeled_masked))
+
+# --- 3. Train a Standard Inductive SVM (Baseline) ---
+# This model only learns from the 50 labeled samples.
+inductive_svm = SVC(probability=True, random_state=42)
+inductive_svm.fit(X_train, y_train)
+y_pred_inductive = inductive_svm.predict(X_unlabeled)
+print(f"Baseline Inductive SVM Accuracy (trained on only {len(X_train)} samples): {accuracy_score(y_true_unlabeled, y_pred_inductive):.2%}")
+
+# --- 4. Train a TSVM approximation using SelfTrainingClassifier ---
+# This wrapper will take our base SVM and perform the iterative self-labeling process.
+base_svm = SVC(probability=True, random_state=42)
+# The threshold determines how confident the model must be to create a "pseudo-label".
+tsvm_approx = SelfTrainingClassifier(base_svm, threshold=0.9)
+
+# We train the model on the combined set of labeled and unlabeled data.
+tsvm_approx.fit(X_combined, y_combined)
+
+# --- 5. Evaluate the Transductive Model ---
+# We test its performance on the same set of unlabeled data.
+y_pred_transductive = tsvm_approx.predict(X_unlabeled)
+print(f"TSVM (Approximation) Accuracy (trained with unlabeled data): {accuracy_score(y_true_unlabeled, y_pred_transductive):.2%}")
+ 1. Inductive learning aims to learn a general rule from training data that can be applied to any future unseen data. Transductive learning aims to find the optimal labels for the specific unlabeled data points it is given during training; it doesn't create a general rule.
+2. A TSVM uses the feature information from the large set of unlabeled data to help find a better decision boundary. A standard SVM ignores this and only uses the labeled data.
+3. It is non-convex because it involves assigning discrete labels to the unlabeled points. The process of searching for the best combination of labels and the best hyperplane at the same time creates a complex optimization landscape with many local minima, making it hard to find the single best solution.
+4. The biggest risk is error propagation. If the model confidently assigns incorrect pseudo-labels to the unlabeled data, these errors are baked into the next training iteration, potentially corrupting the model and making the final decision boundary worse.
+The Story: Decoding the Expert Path-Finder's Map
+Story-style intuition: The Panel of Judges
+Imagine a talent show with a panel of three judges. Each judge (a base model) has a different background: one is an expert in singing, one in dancing, and one in comedy. After a performance, each judge gives their vote for whether the contestant should pass.
+
• Hard Voting: The final decision is based on a simple majority. If two out of three judges vote "Pass," the contestant passes. This is a democratic vote where every judge has an equal say.
+
• Soft Voting: Instead of a simple "yes" or "no," each judge provides a confidence score (e.g., "I'm 90% confident they should pass"). The final decision is based on the average confidence score across all judges. This method is often better because it accounts for the *certainty* of each judge's vote.
+
A Voting Ensemble is this panel of judges, combining their diverse opinions to make a final decision that is often more robust and accurate than any single judge's opinion.
A Voting Ensemble is one of the simplest and most effective ensemble learning techniques. It works by training multiple different models on the same data and combining their predictions to generate a final output. Unlike Stacking, it does not use a meta-learner; instead, it relies on simple statistical methods like majority vote or averaging.
+ +The process is straightforward and can be run in parallel.
+ +| Advantages | +Disadvantages | +
|---|---|
| ✅ Very easy to implement and interpret. | +❌ Often less powerful than more advanced ensembles like Boosting or Stacking. | +
| ✅ Can improve predictive accuracy and create a more robust model. | +❌ It doesn't have a mechanism to explicitly correct the errors of its base models. | +
| ✅ Allows for the combination of different types of models (heterogeneous ensemble). | +❌ The performance is highly dependent on the quality and diversity of the base models. | +
Scikit-learn provides convenient `VotingClassifier` and `VotingRegressor` classes that make building a voting ensemble very simple. You just need to provide a list of the models you want to include in the panel.
+
+from sklearn.ensemble import VotingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+# Assume X_train, y_train, X_test are defined
+
+# 1. Define the panel of judges (base models)
+estimators = [
+ ('lr', LogisticRegression(random_state=42)),
+ ('dt', DecisionTreeClassifier(random_state=42)),
+ ('svc', SVC(probability=True, random_state=42)) # probability=True is needed for soft voting
+]
+
+# 2. Create the Voting Ensemble
+# 'soft' voting uses predicted probabilities and is often better
+voting_clf = VotingClassifier(estimators=estimators, voting='soft')
+
+# 3. Train and predict
+voting_clf.fit(X_train, y_train)
+y_pred = voting_clf.predict(X_test)
+
+from sklearn.ensemble import VotingRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.svm import SVR
+# Assume X_train, y_train, X_test are defined
+
+# 1. Define the panel of regressors
+regressors = [
+ ('lr', LinearRegression()),
+ ('rf', RandomForestRegressor(random_state=42)),
+ ('svr', SVR())
+]
+
+# 2. Create the Voting Ensemble (averages the predictions)
+voting_reg = VotingRegressor(estimators=regressors)
+
+# 3. Train and predict
+voting_reg.fit(X_train, y_train)
+y_pred_reg = voting_reg.predict(X_test)
+ 1. Hard Voting uses a simple majority vote of the predicted class labels. Soft Voting averages the predicted probabilities for each class and chooses the class with the highest average probability. Soft voting is usually preferred because it accounts for how confident each model is in its prediction.
+2. No, it does not. A Voting Ensemble trains its models independently and combines their outputs with a fixed rule (voting/averaging). It does not have a mechanism to sequentially correct errors like Boosting does.
+3. No, it will perform exactly the same. Since all three models are identical, they will always produce the same output, and the majority vote will always be the same as the single model's prediction. Diversity is essential for a voting ensemble to be effective.
+The Story: Decoding the Judge's Scorecard
+Story-style intuition: The Master Craftsman
+If Gradient Boosting (GBR) is a careful craftsman, XGBoost is that same craftsman given a supercharged toolkit, a blueprint for efficiency, and a strict rulebook to prevent mistakes. The toolkit lets them work faster (parallelization), and the rulebook forces them to build simpler, more robust creations (regularization), making them a champion in their field.
++ XGBoost (Extreme Gradient Boosting) is an advanced, optimized implementation of the gradient boosting framework. It's designed for speed, performance, and accuracy. +
+ +Story example: The Chef's Two Goals
+A standard chef wants to make a tasty dish (minimize loss). An XGBoost chef has two goals: make the dish tasty AND keep the recipe simple and clean (minimize complexity via regularization). Their objective is to find the perfect balance. They use advanced taste-testing techniques (2nd-order Taylor expansion) to figure out not just if the dish is too salty, but how quickly it's becoming too salty, allowing for more precise corrections.
+XGBoost aims to minimize a more advanced objective function:
+$$ \text{Obj} = \sum_i l(y_i, \hat{y}_i) + \sum_k \Omega(f_k) $$
+XGBoost uses a 2nd-order Taylor expansion to approximate the loss, which allows it to use both first-order (gradient) and second-order (Hessian) derivatives for more accurate optimization.
+ +Story example: The Hiker with a Curvature Sensor
+A standard Gradient Boosting hiker only knows the slope (gradient) under their feet. The XGBoost hiker has an advanced sensor that also measures the curvature of the ground (the Hessian). This tells them not just which way is down, but whether the path is flattening out or getting steeper. This extra information allows them to take much smarter, more direct steps towards the valley floor.
+Story: The Ultimate Multi-Tool
+XGBoost isn't just one tool; it's a complete toolkit. It has a special attachment for dealing with missing pieces (handles missing values), it can be used by a whole team at once (parallel computing), and it has an automatic shut-off switch to prevent overheating (early stopping).
+| Parameter | +Explanation & Story | +
|---|---|
| n_estimators | +The number of boosting rounds or trees. Story: How many corrective experts you hire for your team. | +
| learning_rate (eta) | +Shrinks the contribution of each tree. Story: How much you trust each new expert's advice. A small value means you only make small adjustments based on their feedback. | +
| max_depth | +Maximum depth of a tree. Story: The maximum complexity allowed for any single expert's reasoning. | +
| subsample & colsample_bytree | +Fraction of data (rows) and features (columns) used per tree. Story: Giving each expert a slightly different, random piece of the problem to work on so they don't all have the same blind spots. | +
| reg_alpha (L1) & reg_lambda (L2) | +Regularization terms. Story: A penalty system. `reg_alpha` penalizes using too many features, while `reg_lambda` penalizes using any single feature too heavily. | +
XGBoost is like a Formula 1 car. It's incredibly fast and powerful (high accuracy, fast), and it's packed with safety features (regularization). However, it requires a skilled driver to tune all the settings (many hyperparameters) and might be too much car for a simple trip to the grocery store (overkill for small datasets).
+Here, we import our "master craftsman" from the `xgboost` library. We give it data and define the rules for its toolkit (`n_estimators`, `learning_rate`). We train it with an important safety check: `early_stopping_rounds`, which tells it to stop working if its performance on a test set doesn't improve after a certain number of rounds.
+
+import xgboost as xgb
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+# Example dataset
+X = np.random.rand(100, 5)
+y = np.random.rand(100) * 10
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize XGBoost Regressor
+xgbr = xgb.XGBRegressor(objective='reg:squarederror', n_estimators=100, learning_rate=0.1,
+ max_depth=3, subsample=0.8, colsample_bytree=0.8, random_state=42)
+
+# Train with early stopping
+xgbr.fit(X_train, y_train, eval_set=[(X_test, y_test)], early_stopping_rounds=10, verbose=False)
+
+# Predict
+y_pred = xgbr.predict(X_test)
+
+# Evaluate
+mse = mean_squared_error(y_test, y_pred)
+print(f"Mean Squared Error: {mse:.2f}")
+
+# Plot feature importance
+xgb.plot_importance(xgbr)
+ The Story: The Craftsman's Advanced Toolkit
+Let's demystify the advanced tools and rules our XGBoost craftsman uses to build superior models.
++ What it is: In optimization, the Hessian measures the curvature of the loss function. While the gradient (1st derivative) points downhill, the Hessian tells you if that downhill path is a gentle slope or a steep drop-off. +
++ Story Example: A self-driving car uses the gradient to know which way the road is turning. It uses the Hessian to know how sharp that turn is. This allows it to slow down more for a hairpin bend than for a gentle curve, leading to a much smoother and more direct path. +
+ ++ What it is: A technique used to prevent overfitting by adding a penalty for model complexity to the loss function. It forces the model to be simpler and generalize better. +
++ Story Example: A writer is paid to write an article. Without regularization, they might write a 50-page, overly detailed article that is hard to read. With regularization, there's a penalty for every extra word they use. This forces them to be concise and clear, producing a better article that is useful to more people. +
+ ++ What they are: Two different types of regularization penalties. +
++ Story Example: Imagine packing for a trip. L1 Regularization is like a rule that says "for every item you pack, you pay a fee." This forces you to be ruthless and leave behind anything non-essential (shrinking weights to zero). L2 Regularization is a rule that says "the fee is based on the total weight of your suitcase." This encourages you to pack lighter items but doesn't force you to leave entire categories of items behind. +
+ ++ What it is: The process of removing sections of a decision tree (branches) that provide little predictive power, in order to reduce complexity and prevent overfitting. +
++ Story Example: A gardener grows a rose bush to get the best flowers. After it grows, they perform pruning by cutting off small, weak branches that aren't producing good buds. This directs the plant's energy to the stronger branches, resulting in bigger, healthier roses. XGBoost prunes its trees in a similar way to focus on the most important predictive rules. +
+OTP verification required
+ + +Enter the 6-digit OTP sent to your email
+ + + + + Resend OTP + ++ Ask anything about Machine Learning using the chat button. +
+ + + + + ++ Explore K-Means, an unsupervised learning algorithm that partitions data into K distinct clusters. For example, an online store uses K-Means to group customers based on purchase frequency and spending, creating segments like Budget Shoppers, Frequent Buyers, and Big Spenders for personalized marketing. +
+ ++ We are given a data set of items with certain features and values for these features like a vector. The task is to categorize those items into groups. To achieve this we will use the K-means algorithm. 'K' in the name of the algorithm represents the number of groups/clusters we want to classify our items into. +
++ The algorithm works by first randomly picking some central points called centroids and each data point is then assigned to the closest centroid forming a cluster. After all the points are assigned to a cluster, the centroids are updated by finding the average position of the points in each cluster. This process repeats until the centroids stop changing, forming clusters. The goal of clustering is to divide the data points into clusters so that similar data points belong to the same group. +
+1. Initialize Centroids
+Randomly pick K points
+2. Assign Points to Clusters
+To closest centroid
+3. Update Centroids
+Calculate new means
+4. Convergence Check
+Centroids stabilized?
++ The K-Means algorithm iteratively refines clusters. It starts by randomly selecting initial centroids. Then, each data point is assigned to the closest centroid, forming preliminary clusters. Next, the centroids are updated to the mean position of all points within their assigned clusters. This assignment and update process repeats until the centroids no longer change significantly, indicating that the clusters have converged. +
++ K-Means is an unsupervised learning algorithm that aims to partition $$n$$ observations into $$k$$ clusters in which each observation belongs to the cluster with the nearest mean (centroid), serving as a prototype of the cluster. +
++ The objective of K-Means is to minimize the sum of squared distances between data points and their assigned cluster's centroid, also known as the within-cluster sum of squares (WCSS). +
++ Where: +
+1. Input Labeled Data
+Features & Classes
+2. Build Tree
+Recursive splitting
+3. Traverse Tree
+Follow rules for new data
+4. Reach Leaf Node
+Contains class prediction
+5. Final Classification
+Based on leaf's majority
++ A Decision Tree learns a series of if-then-else rules from your data, forming a tree structure. When new data comes in, it simply follows these rules down the tree to arrive at a classification. +
++ A Decision Tree is a powerful, intuitive, and versatile supervised learning algorithm that models decisions in a tree-like structure. It provides a clear, flowchart-like representation of the choices and their potential outcomes, making it highly interpretable. By traversing its "branches," one can easily compare different paths and understand the reasoning behind a particular classification or prediction. +
+ + }})
+ + Figure 1: A simplified representation of a Decision Tree's basic structure, showing a root node, branches, and leaf nodes. +
++ The Decision Tree algorithm builds its structure by recursively partitioning the feature space into distinct, often rectangular, regions. +
++ When a new, unlabeled data point needs classification, it traverses the tree from the root. At each decision node, it follows the path corresponding to its feature values, finally arriving at a leaf node which provides the model's prediction. +
+ ++ The effectiveness of a Decision Tree heavily relies on its ability to find the best feature and split point at each node. This is determined by mathematical metrics called splitting criteria: +
++ To combat overfitting, various techniques are employed, most notably "pruning." Pruning involves removing branches that have little predictive power, simplifying the tree. +
++ Despite their challenges, Decision Trees form the building blocks for more powerful algorithms, especially ensemble methods: +
++ By understanding the fundamentals of Decision Trees, you gain a solid foundation for comprehending these more advanced and robust machine learning models. +
++ Think of your favorite animal, answer wisely, and watch the tree reveal its identity! +
+ ++ This game is a simple, fun way to explore how a **Decision Tree** algorithm works in Machine Learning. Imagine a flowchart that helps make decisions! +
++ Just like your choices guide you through this game, Decision Trees learn these question-and-answer paths from large datasets to classify new information. +
+Visualize and interact with machine learning regression in real-time!
+You can see by incres depth it more non-linaer and by decring depth it more linaer
+Explore how DTR predicts continuous values with interactive examples.
+ +It’s a smart algorithm that predicts numbers — like house prices or temperatures — by splitting data into smaller groups based on features. Imagine a tree where each branch asks a question, and leaves give the final prediction.
+The tree splits data recursively, choosing the best points to divide so that each group is as similar as possible. It stops splitting when the groups are small or deep enough.
+To predict a new value, the data point travels down the tree following the split rules until it reaches a leaf. The prediction is the average of all training points in that leaf.
+min_samples_split=2, even 2 points can split → tree memorizes tiny patterns.
+ If min_samples_split=10, need 10+ points to split → tree generalizes.
+ min_samples_leaf=1, each data point might get its own leaf.
+ If min_samples_leaf=10, each leaf must cover at least 10 points → tree generalizes.
+ ✅ Summary Memory Trick:
+ Big numbers (min_samples_split ↑, min_samples_leaf ↑) + small max_depth ↓ → simpler tree → less overfitting.
+ Small numbers (min_samples_split ↓, min_samples_leaf ↓) + big max_depth ↑ → complex tree → more overfitting.
+
The algorithm starts with your input data points (X, y). These points represent the relationship we want to model.
+ +The algorithm tries different thresholds on the feature (X) to split the data into two groups, aiming to reduce variance in each group.
+ +Data is split into left and right groups based on the threshold. Each group is more homogeneous (less variance).
+ +The algorithm repeats the splitting process on each group until max depth or minimum variance is reached, building a tree structure.
+ +To predict a new point, the tree is traversed from root to leaf by comparing the input to thresholds, returning the leaf's average value.
+ +Ensemble learning is a technique that combines multiple machine learning models to get a more robust and accurate prediction than a single model alone.
+Explore the world of artificial intelligence and machine learning
+"Test yourself and see what you know about ML"
+Assess your current machine learning knowledge and identify areas for improvement
+ +"Start your ML learning with start button"
+Build foundational skills and progress to advanced machine learning concepts
+ ++ Learn how machines find hidden groups in data. Watch points get assigned and clusters adapt in real-time! +
+Points can partially belong to multiple clusters.
+Alternates between E-step and M-step.
+Ellipses show the statistical shape of clusters.
+Algorithm stops when centers stabilize.
++ Measures model fit. Higher values = better grouping. +
+Calculating the "responsibility" (probability) that each point belongs to each cluster center.
+Moving and stretching clusters to better fit the points assigned to them.
+The point where the clusters stop moving because they've found the optimal mathematical fit.
++ EM (Expectation-Maximization) is a powerful iterative method used to find maximum likelihood estimates of parameters in statistical models, where the model depends on unobserved latent variables. +
++ Imagine you have a bag of colored marbles, but you're colorblind! You can feel their sizes and weights, but you can't see the colors. EM helps you figure out which marbles are likely the same color based on their shared physical properties. +
+The algorithm works by alternating between two main steps until it finds the best mathematical grouping.
+Assignment Phase
+Goal: Calculate the probability (responsibility) of each cluster for each data point.
+responsibility = (fit to cluster) / (total fit to all clusters)
+Update Phase
+Goal: Update cluster parameters (center, shape, weight) based on assigned points.
+new_mean = average(points × their_responsibilities)
+Random centers and circular shapes
+Assign data points to clusters
+Update cluster parameters
+Repeat 2 & 3 until stable
++ We have a classic loop: To find the centers, we need to know point assignments. To find point assignments, we need to know the centers. + EM solves this by starting with a "best guess" and iteratively refining it. +
++ Mathematically, each iteration of EM is guaranteed to increase the Log-Likelihood of the model (or leave it unchanged). This means the model always gets better at explaining the data until it hits a maximum. +
+| Feature | +K-Means | +GMM (EM) | +
|---|---|---|
| Assignment | +Hard (0 or 1) | +Soft (Probabilities) | +
| Cluster Shape | +Always circular/spherical | +Flexible ellipses (any orientation) | +
| Model Type | +Distance-based | +Distribution-based | +
| Use Case | +Simple, distinct groups | +Overlapping, varied group shapes | +
Grouping pixels by color/texture to separate objects in photos.
+Identifying different speakers in an audio stream using voice patterns.
+Finding groups of customers with similar shopping behaviors.
+Clustering gene expression data to find functional biological groups.
+Classifying climate zones based on temperature and humidity data.
+Clustering emails into 'Ham' and 'Spam' based on content features.
++ Optimize parameters by descending the loss landscape. Now with Adaptive Learning Rate logic! +
+Select a module from the sidebar to get started!
++ A simple, non-parametric, and lazy learning algorithm for classification. Use this interactive tool to understand how it works with two distinct categories! +
+ +New Data Point
+You provide X, Y
+Calculate Distances
+To ALL labeled points
+Find K-Neighbors
+Based on 'k' value
+Majority Vote
+Neighbors decide category
+Predicted Category
+Final Classification
++ KNN works by finding the 'k' closest existing data points to a new point, then classifying the new point based on the most common category among those 'k' neighbors. +
++ K-Nearest Neighbors (KNN) is a simple, non-parametric, and lazy learning algorithm. It's primarily used for classification and regression tasks. In this visualization, we focus on its classification ability in 2 dimensions (X and Y coordinates) with two distinct categories of data. +
+ ++ Let's trace a prediction flow with a test point somewhat central to the two categories. +
++ *The diamond shapes from your image are illustrative. In our plot, they are rendered as circular markers for simplicity, but the underlying principle remains the same.* +
+Expected: Number in White and background have to be Black and of a digit (0–9).
+ + + + + + + + ++ Unlock the power of Lasso Regression (L1 Regularization) to make accurate predictions. + This technique helps prevent overfitting and performs automatic feature selection, leading to simpler and more robust models. +
+ + + + ++ Lasso Regression, or Least Absolute Shrinkage and Selection Operator, is a powerful extension of linear regression. It introduces L1 Regularization to penalize large coefficients, making models more interpretable and robust. +
+ ++ The cost function that Lasso tries to minimize is: +
+ + + + + ++ Lasso shines in high-dimensional spaces with many features, especially when many of them are irrelevant. It's widely used in finance, bioinformatics, real estate, and more. +
+
+ Lasso applies L1 regularization to shrink some feature coefficients all the way to 0.
+ This means those features are completely ignored in the final prediction! Here's how it flows:
+
+ This process leads to a simpler model by automatically performing feature selection. +
++ Imagine again you're predicting house price, and you have 5 friends giving opinions: + Quality, Living Area, Garage, Basement, and Year Built. + But this time, you're tired of too much noise. You want only the really useful voices. +
+ +Used to convert raw model output into probability.
+ +Predicts probability of input being in class 1 (e.g., spam).
+ +Measures how well predictions match actual values.
+ ++ Logistic Regression doesn't just look at raw inputs. It processes and learns from data in structured steps: +
+The sigmoid maps real values into probabilities between 0 and 1. It helps decide the class based on a threshold:
++ The Naive Bayes classifier is a simple yet powerful probabilistic machine learning algorithm used for classification tasks. It's based on Bayes' theorem with a crucial "naive" assumption: it assumes that all features are independent of each other, given the class label. Despite this simplifying assumption, Naive Bayes often performs surprisingly well, especially in text classification and spam filtering. +
+ ++ Naive Bayes is built upon Bayes' theorem, which describes the probability of an event, based on prior knowledge of conditions that might be related to the event. For classification, it helps calculate the probability of a hypothesis (a class) given evidence (features). +
++ In the context of classification, we want to find the probability of a data point belonging to a certain class ($P(\text{Class}|\text{Features})$). Bayes' theorem allows us to calculate this using probabilities that are easier to estimate from the training data. +
+ ++ The "naive" part comes from the assumption that all features are conditionally independent of each other, given the class label. This means, for example, that the presence of one word in an email (e.g., "money") is independent of the presence of another word (e.g., "Viagra") given that the email is spam. While rarely true in reality, this simplification makes the calculations tractable and surprisingly effective. +
++ For continuous features (like the X and Y coordinates in our visualization), the algorithm assumes that the values associated with each class follow a Gaussian (Normal) distribution. +
++ The decision boundary generated by Gaussian Naive Bayes is often curvilinear or non-linear because it's based on the intersection of Gaussian probability distributions, which are circular or elliptical in 2D space. +
+ ++ When you interact with this visualization and add new data points or modify existing ones, the Naive Bayes model processes this "user data" in a specific way: +
++ This interactive graph demonstrates the decision boundary of a Gaussian Naive Bayes classifier in 2D space: +
++ It is named as "Naive" because it assumes the presence of one feature does not affect other features. The "Bayes" part of the name refers to its basis in Bayes’ Theorem. +
+ ++ Polynomial Regression is a type of regression analysis that models the relationship between the independent variable x + and the dependent variable y as an n-th degree polynomial. It extends simple linear regression by considering higher-degree terms. +
+ ++ y = theta_0 + theta_1x + theta_2x^2 + theta_3x^3 + ... + theta_nx^n +
+ ++ Here, theta_0, theta_1, ..., theta_n are the coefficients learned by the model. +
+ ++ To illustrate how the equation y = x^2 + 2x creates a curve, let's substitute a few values for x: +
++ An input of 0 results in an output of 0. +
++ An input of 1 yields an output of 3. +
++ With an input of 3, the output becomes 15. +
++ For an input of 5, the predicted output is 35. +
++ These examples show how the relationship between x and y is curved, not linear. +
+PolynomialFeatures from sklearn.preprocessing.+ Linear Regression is a fundamental statistical and machine learning technique used to model the relationship between a **dependent variable** (target) and one or more **independent variables** (features) by fitting a linear equation to the observed data. The goal is to predict the value of the dependent variable based on the values of the independent variables. It assumes a linear relationship between the input features and the output variable. +
+ +
+ y = beta_0 + beta_1x + epsilon
+ y: Dependent variable
+ x: Independent variable
+ beta_0: Y-intercept (the value of y when x=0)
+ beta_1: Slope of the regression line (the change in y for a one-unit change in x)
+ epsilon: Error term (the difference between the actual and predicted values)
+
+ y = beta_0 + beta_1x_1 + beta_2x_2 + ... + beta_nx_n + epsilon
+ y: Dependent variable
+ x_1, x_2, ..., x_n: Independent variables
+ beta_0: Y-intercept
+ beta_1, beta_2, ..., beta_n: Coefficients (slopes) for each independent variable
+ epsilon: Error term
+
+ Equation (2nd degree): y = beta_0 + beta_1x + beta_2x^2 + epsilon +
++ Cost Function: MSE + lambdasum_j=1p beta_j^2 +
++ Cost Function: MSE + lambdasum_j=1p |beta_j| +
++ Cost Function: MSE + lambda_1sum_j=1p |beta_j| + lambda_2sum_j=1p beta_j^2 +
+Linear Regression is widely used in various fields:
+In statistical modeling, the simple linear regression equation is often written as:
++ y = beta_0 + beta_1x + epsilon +
+For multiple independent variables x_1,x_2,...,x_n, the equation is:
++ y = beta_0 + beta_1x_1 + beta_2x_2 + ... + beta_nx_n + epsilon +
+In matrix notation, this can be written as:
++ mathbf{y} = mathbf{X}mathbf{beta} + mathbf{epsilon} +
+The goal is to find the coefficients mathbf{beta} that minimize the sum of squared errors. This can be done using the Ordinary Least Squares (OLS) method, which provides the closed-form solution:
++ mathbf{hat{beta}} = (mathbf{X}^T mathbf{X})^{-1} mathbf{X}^T mathbf{y} +
+ +Violations of these assumptions can lead to unreliable or inefficient regression models.
++ Mean Squared Error (MSE) measures the average of the squares of the errors, where the error is the difference between the actual value and the predicted value. +
++ MSE = (1/n) * sum(i=1 to n) (y_i - haty_i)^2 +
++ Gradient Descent is an iterative optimization algorithm used to find the minimum of a function. It works by repeatedly moving in the direction of the steepest descent, which is the negative of the gradient. +
++ The MSE cost function is: J(beta_0, beta_1) = (1/n) * sum(i=1 to n) (y_i - (beta_0 + beta_1x_i))^2. + The update rules are: +
++ beta_0 := beta_0 - alpha * (-2/n) * sum(i=1 to n) (y_i - haty_i) + beta_1 := beta_1 - alpha * (-2/n) * sum(i=1 to n) (y_i - haty_i)x_i +
++ Where alpha is the **learning rate**. +
+ +MSE = (1/n) * sum(i=1 to n) (y_i - haty_i)^2
+RMSE = sqrt((1/n) * sum(i=1 to n) (y_i - haty_i)^2)
+MAE = (1/n) * sum(i=1 to n) |y_i - haty_i|
++ R^2 = 1 - (sum(y_i - haty_i)^2) / (sum(y_i - bary)^2) +
++ Feature scaling is crucial for **Gradient Descent** and **Regularization** to ensure all features contribute equally to the model. Methods include Standardization and Min-Max Scaling. +
+ +Regularization techniques add a penalty to the cost function to prevent overfitting.
++ J_Ridge(beta) =... + lambda * sum(j=1 to p) beta_j^2 +
++ J_Lasso(beta) =... + lambda * sum(j=1 to p) |beta_j| +
++ J_ElasticNet(beta) =... + lambda_1 * sum(j=1 to p) |beta_j| + lambda_2 * sum(j=1 to p) beta_j^2 +
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+from sklearn.preprocessing import StandardScaler
+
+# 1. Generate Sample Data
+np.random.seed(42)
+X = 2 * np.random.rand(100, 1)
+y = 4 + 3 * X + np.random.randn(100, 1)
+
+# 2. Split Data into Training and Testing Sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 3. Initialize and Train the Linear Regression Model
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+# 4. Make Predictions
+y_pred = model.predict(X_test)
+
+# 5. Evaluate the Model
+mse = mean_squared_error(y_test, y_pred)
+rmse = np.sqrt(mse)
+mae = mean_absolute_error(y_test, y_pred)
+r2 = r2_score(y_test, y_pred)
+
+print(f"Model Coefficients: {model.coef_[0][0]:.2f}")
+print(f"Model Intercept: {model.intercept_[0]:.2f}")
+print(f"Mean Squared Error (MSE): {mse:.2f}")
+print(f"R-squared (R²): {r2:.2f}")
+
+# 6. Visualize the Regression Line
+# Note: Matplotlib requires a backend, which might not work in all environments.
+# This section is for conceptual understanding.Equation: y = x^2 + 2x
+Our model learned coefficients for:
++ (These coefficients correspond to the formula y = theta_0 + theta_1x + theta_2x^2) +
+{{ prediction }}
+See how your input travels through each decision tree
+ + +Reinforcement learning (RL) is a subfield of machine learning where an agent learns to make decisions by taking actions in an environment to maximize some cumulative reward.
++ The Random Forest Regressor is a powerful ensemble learning method. Imagine a forest of decision trees working together. + Instead of relying on a single, potentially biased tree, it combines the wisdom of many. This helps it capture complex, non-linear patterns + in your data far better than simpler models. +
+ ++ Ready to see the Random Forest Regressor in action? Click the button below to predict an exam score! +
+ + Predict a Score Now! + + + {% if prediction is defined %} +{{ prediction }}
+Based on {{ hours }} hours of study
+{{ error }}
+ {% endif %} ++ Here's a simple dataset we could use to train our Random Forest Regressor, predicting exam scores based on hours studied: +
+| + Hours Studied (X) + | ++ Exam Score (y) + | +
|---|---|
| 1 | 35 |
| 2 | 45 |
| 3 | 55 |
| 4 | 65 |
| 5 | 75 |
| 6 | 80 |
| 7 | 82 |
| 8 | 88 |
| 9 | 92 |
| 10 | 95 |
+ A Random Forest is built from many individual decision trees. For regression, it predicts by averaging the outputs of these trees. + This significantly reduces overfitting and makes the model robust. +
++ Each decision tree in the forest grows by repeatedly splitting its data. The goal is to create "pure" child nodes. For regression, "purity" means minimizing the Mean Squared Error (MSE) within a node. +
++ When you enter a new value, like 5.5 hours studied, here's the journey it takes through the Random Forest: +
++ Explore the power of Ridge Regression (L2 Regularization) for robust predictions. + This technique is excellent for handling multicollinearity and preventing overfitting by shrinking coefficients, while still retaining all features. +
+ ++ Ridge Regression helps make our prediction models more stable and less prone to errors on new data. It does this by adding a special "penalty" to its calculations. This penalty is called L2 Regularization. +
+ ++ Ridge tries to find the best prediction rule by minimizing this formula: +
+ + +
+ The symbol $$\lambda$$ (lambda) is like a "Volume Knob" for this penalty.
+
Big $$\lambda$$: Turn up the volume knob, so coefficients are shrunk *a lot*.
+
Small $$\lambda$$: Turn down the volume knob, so coefficients are shrunk *less*.
+
+ Ridge uses L2 regularization to shrink all feature weights, but never drops any feature completely. This allows it to preserve all information while still controlling model complexity. +
+ ++ Unlike Lasso, Ridge Regression keeps all your features—just with smaller, regularized weights. It’s perfect when all features have some predictive power. +
++ Ridge is a great choice when you believe all your features are somewhat useful and you want to **control how much influence they have** without completely throwing any away. +
+ +
+ Imagine your house price is being predicted by a team of 5 friends (features):
+ Quality, Living Area, Garage, Basement, and Year Built.
+ Each friend gives their opinion (a number), and we add them up to predict the price.
+
Without Ridge
Some friends shout too loudly! Their numbers dominate and cause mistakes.
With Ridge
Everyone still speaks, but Ridge adds rules so no one can shout. Voices are balanced.
Result
The prediction is more stable, fair, and doesn’t overreact to any one person.
+ ✅ Ridge doesn’t remove anyone (like Lasso does).
+ ✅ It just turns down their microphone if they’re being too loud.
+ ✅ That’s how Ridge keeps all your data and prevents wild, unstable predictions.
+
+ (This is especially helpful when features are similar or slightly redundant.) +
++ To really get a feel for how Ridge works, visual examples are best: +
++ (These dynamic visualizations can be powered by Chart.js, D3.js, or by integrating server-side plots from libraries like Matplotlib/Seaborn in your Flask application.) +
+Semi-supervised learning is a combination of supervised and unsupervised learning. It uses a small amount of labeled data and a large amount of unlabeled data to train a model. This is particularly useful when it is expensive to label data.
+Supervised learning is a type of machine learning where the model is trained on labeled data. This means the training dataset includes both the input and the correct output, and the model learns to map the input to the output.
++ A comprehensive demonstration of Linear Regression to predict exam scores based on study hours. + Explore the theory, mathematics, and practical implementation. +
++ Score = 20 × Hours + 15 +
++ Score = 20 × Hours + 15 +
+• Red Line: Regression line showing the linear relationship
+• Blue Points: Training data points
+• Green Point: Your prediction
++ Linear Regression is a fundamental supervised learning algorithm used for predicting a continuous outcome variable (dependent variable) based on one or more input features (independent variables). It models the relationship between the variables by fitting a linear equation to the observed data. +
+
+ For a simple linear regression with one input feature, the equation used by our model is:
+
Predicted Score = (20 × Hours Studied) + 15
+
+ The slope of 20 means each hour of studying contributes 20 points to your exam score. For example, if you study one more hour, your predicted score increases by 20 points. +
+ ++ The intercept of 15 represents points earned regardless of study time. This could account for: +
++ In statistical modeling, the simple linear regression equation is: +
++ The goal is to find the coefficients β₀ and β₁ that minimize the cost function, typically the Mean Squared Error (MSE). +
++ Mean Squared Error measures the average of the squares of the errors: +
++ Average of squared differences between actual and predicted values. +
++ Proportion of variance explained by the model. +
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score
+
+# 1. Generate Sample Data
+np.random.seed(42)
+X = 2 * np.random.rand(100, 1)
+y = 4 + 3 * X + np.random.randn(100, 1)
+
+# 2. Split Data
+X_train, X_test, y_train, y_test = train_test_split(
+ X, y, test_size=0.2, random_state=42
+)
+
+# 3. Initialize and Train Model
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+# 4. Make Predictions
+y_pred = model.predict(X_test)
+
+# 5. Evaluate Model
+mse = mean_squared_error(y_test, y_pred)
+r2 = r2_score(y_test, y_pred)
+
+print(f"Coefficient: {model.coef_[0][0]:.2f}")
+print(f"Intercept: {model.intercept_[0]:.2f}")
+print(f"MSE: {mse:.2f}")
+print(f"R²: {r2:.2f}")
+ + Linear Regression is a fundamental statistical and machine learning technique used to model the relationship between a **dependent variable** (target) and one or more **independent variables** (features) by fitting a linear equation to the observed data. The goal is to predict the value of the dependent variable based on the values of the independent variables. It assumes a linear relationship between the input features and the output variable. +
+ +
+ y = beta_0 + beta_1x + epsilon
+ y: Dependent variable
+ x: Independent variable
+ beta_0: Y-intercept (the value of y when x=0)
+ beta_1: Slope of the regression line (the change in y for a one-unit change in x)
+ epsilon: Error term (the difference between the actual and predicted values)
+
+ y = beta_0 + beta_1x_1 + beta_2x_2 + ... + beta_nx_n + epsilon
+ y: Dependent variable
+ x_1, x_2, ..., x_n: Independent variables
+ beta_0: Y-intercept
+ beta_1, beta_2, ..., beta_n: Coefficients (slopes) for each independent variable
+ epsilon: Error term
+
+ Equation (2nd degree): y = beta_0 + beta_1x + beta_2x^2 + epsilon +
++ Cost Function: MSE + lambdasum_j=1p beta_j^2 +
++ Cost Function: MSE + lambdasum_j=1p |beta_j| +
++ Cost Function: MSE + lambda_1sum_j=1p |beta_j| + lambda_2sum_j=1p beta_j^2 +
+Linear Regression is widely used in various fields:
+In statistical modeling, the simple linear regression equation is often written as:
++ y = beta_0 + beta_1x + epsilon +
+For multiple independent variables x_1,x_2,...,x_n, the equation is:
++ y = beta_0 + beta_1x_1 + beta_2x_2 + ... + beta_nx_n + epsilon +
+In matrix notation, this can be written as:
++ mathbf{y} = mathbf{X}mathbf{beta} + mathbf{epsilon} +
+The goal is to find the coefficients mathbf{beta} that minimize the sum of squared errors. This can be done using the Ordinary Least Squares (OLS) method, which provides the closed-form solution:
++ mathbf{hat{beta}} = (mathbf{X}^T mathbf{X})^{-1} mathbf{X}^T mathbf{y} +
+ +Violations of these assumptions can lead to unreliable or inefficient regression models.
++ Mean Squared Error (MSE) measures the average of the squares of the errors, where the error is the difference between the actual value and the predicted value. +
++ MSE = (1/n) * sum(i=1 to n) (y_i - haty_i)^2 +
++ Gradient Descent is an iterative optimization algorithm used to find the minimum of a function. It works by repeatedly moving in the direction of the steepest descent, which is the negative of the gradient. +
++ The MSE cost function is: J(beta_0, beta_1) = (1/n) * sum(i=1 to n) (y_i - (beta_0 + beta_1x_i))^2. + The update rules are: +
++ beta_0 := beta_0 - alpha * (-2/n) * sum(i=1 to n) (y_i - haty_i) + beta_1 := beta_1 - alpha * (-2/n) * sum(i=1 to n) (y_i - haty_i)x_i +
++ Where alpha is the **learning rate**. +
+ +MSE = (1/n) * sum(i=1 to n) (y_i - haty_i)^2
+RMSE = sqrt((1/n) * sum(i=1 to n) (y_i - haty_i)^2)
+MAE = (1/n) * sum(i=1 to n) |y_i - haty_i|
++ R^2 = 1 - (sum(y_i - haty_i)^2) / (sum(y_i - bary)^2) +
++ Feature scaling is crucial for **Gradient Descent** and **Regularization** to ensure all features contribute equally to the model. Methods include Standardization and Min-Max Scaling. +
+ +Regularization techniques add a penalty to the cost function to prevent overfitting.
++ J_Ridge(beta) =... + lambda * sum(j=1 to p) beta_j^2 +
++ J_Lasso(beta) =... + lambda * sum(j=1 to p) |beta_j| +
++ J_ElasticNet(beta) =... + lambda_1 * sum(j=1 to p) |beta_j| + lambda_2 * sum(j=1 to p) beta_j^2 +
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+from sklearn.preprocessing import StandardScaler
+
+# 1. Generate Sample Data
+np.random.seed(42)
+X = 2 * np.random.rand(100, 1)
+y = 4 + 3 * X + np.random.randn(100, 1)
+
+# 2. Split Data into Training and Testing Sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 3. Initialize and Train the Linear Regression Model
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+# 4. Make Predictions
+y_pred = model.predict(X_test)
+
+# 5. Evaluate the Model
+mse = mean_squared_error(y_test, y_pred)
+rmse = np.sqrt(mse)
+mae = mean_absolute_error(y_test, y_pred)
+r2 = r2_score(y_test, y_pred)
+
+print(f"Model Coefficients: {model.coef_[0][0]:.2f}")
+print(f"Model Intercept: {model.intercept_[0]:.2f}")
+print(f"Mean Squared Error (MSE): {mse:.2f}")
+print(f"R-squared (R²): {r2:.2f}")
+
+# 6. Visualize the Regression Line
+# Note: Matplotlib requires a backend, which might not work in all environments.
+# This section is for conceptual understanding.+ Explore a dynamically trained Linear Support Vector Machine, adjusting parameters and adding new data points. +
+ + +1. Input Labeled Data
+Points with known classes
+2. Map to Higher Dimension
+(If using Kernel, e.g., RBF)
+3. Find Optimal Hyperplane
+Maximizing the margin
+4. Identify Support Vectors
+Closest points define boundary
+5. Classify New Data
+Based on hyperplane position
++ The SVM algorithm processes your input data through several key steps: it first ingests your labeled data, then (optionally, using the kernel trick for non-linear cases) transforms it into a higher-dimensional space. Next, it determines the best possible decision boundary (hyperplane) that maximally separates the classes while minimizing errors. The crucial data points closest to this boundary are identified as $$'Support Vectors'$$ as they fundamentally define the separation. Finally, any new, unlabeled data point is classified based on which side of this optimized hyperplane it falls. +
++ Support Vector Machines (SVMs) are powerful supervised learning models used for classification and regression. The core idea behind SVM is to find the $$optimal hyperplane$$ that best separates data points of different classes in a high-dimensional space. +
+ ++ The key idea behind the SVM algorithm is to find the hyperplane that best separates two classes by maximizing the margin between them. This margin is the distance from the hyperplane to the nearest data points (support vectors) on each side. +
+ ++ The best hyperplane also known as the "hard margin" is the one that maximizes the distance between the hyperplane and the nearest data points from both classes. This ensures a clear separation between the classes. Let's consider a scenario like shown below where we have one blue ball in the boundary of the red ball (referring to a conceptual image similar to the one you provided earlier). +
+ ++ The blue ball in the boundary of red ones is an outlier of blue balls. The SVM algorithm has the characteristics to ignore the outlier and finds the best hyperplane that maximizes the margin. SVM is robust to outliers. A soft margin allows for some misclassifications or violations of the margin to improve generalization. The SVM optimizes the following equation to balance margin maximization and penalty minimization: +
+ +The penalty used for violations is often hinge loss which has the following behavior:
+Till now we were talking about linearly separable data that separates groups of blue balls and red balls by a straight line/linear line.
+ +When data is not linearly separable i.e it can't be divided by a straight line, SVM uses a technique called kernels to map the data into a higher-dimensional space where it becomes separable. This transformation helps SVM find a decision boundary even for non-linear data.
+ +A kernel is a function that maps data points into a higher-dimensional space without explicitly computing the coordinates in that space. This allows SVM to work efficiently with non-linear data by implicitly performing the mapping. For example consider data points that are not linearly separable. By applying a kernel function SVM transforms the data points into a higher-dimensional space where they become linearly separable.
+ +In this case (referring to your 1D to 2D mapping image) the new variable $$y$$ is created as a function of distance from the origin.
+ +Consider a binary classification problem with two classes, labeled as $$+1$$ and $$-1$$. We have a training dataset consisting of input feature vectors $$X$$ and their corresponding class labels $$Y$$. The equation for the linear hyperplane can be written as:
+ +Where:
+The distance between a data point $$x_i$$ and the decision boundary can be calculated as:
+where $$\|w\|$$ represents the Euclidean norm of the weight vector $$w$$.
+ +The predicted label $$\hat{y}$$ of a data point is given by:
+For a linearly separable dataset the goal is to find the hyperplane that maximizes the margin between the two classes while ensuring that all data points are correctly classified. This leads to the following optimization problem:
+Subject to the constraint:
+Where:
+The condition $$y_i (w^T x_i + b) \geq 1$$ ensures that each data point is correctly classified and lies outside the margin.
+ +In the presence of outliers or non-separable data the SVM allows some misclassification by introducing slack variables $$\zeta_i$$. The optimization problem is modified as:
+Subject to the constraints:
+Where:
+The dual problem involves maximizing the Lagrange multipliers associated with the support vectors. This transformation allows solving the SVM optimization using kernel functions for non-linear classification.
+The dual objective function is given by:
+Where:
+The dual formulation optimizes the Lagrange multipliers $$\alpha_i$$ and the support vectors are those training samples where $$\alpha_i > 0$$.
+ +Once the dual problem is solved, the decision boundary is given by:
+Where $$w$$ is the weight vector, $$x$$ is the test data point and $$b$$ is the bias term. Finally the bias term $$b$$ is determined by the support vectors, which satisfy:
+Where $$x_i$$ is any support vector.
+ +This completes the mathematical framework of the Support Vector Machine algorithm which allows for both linear and non-linear classification using the dual problem and kernel trick.
+ +Support Vector Regression is an extension of Support Vector Machines (SVMs) for predicting continuous values. It focuses on fitting within an ε margin.
+Think of SVR like a wise teacher who says:
+“I don’t care if a student (data point) is a little wrong — as long as the error is within a certain range, I’ll allow it.”+
That range is the epsilon margin (ε). SVR fits a function that stays close to data but only penalizes points outside ε.
+SVR minimizes this:
+ +Interactively change kernel, C, gamma, epsilon and dataset. Plotly chart below is mobile responsive.
+Imagine stretching an elastic ribbon (your prediction line) between your data points. This ribbon is not too loose (which means overfitting) and not too tight (which would miss patterns). Instead, it hugs the data with a gentle margin of error (epsilon), and only stretches beyond that when it absolutely has to.
+The wider the ribbon (large epsilon), the more forgiving SVR is. The stiffer the ribbon (small epsilon, large C), the stricter it becomes.
+SVR is a type of Support Vector Machine (SVM), a powerful supervised learning algorithm that can be used for both classification and regression. In classification, SVM finds the best boundary (hyperplane) that separates different classes. In regression (SVR), it tries to find a line or surface that fits the data within a certain tolerance (ε-insensitive zone).
+Kernels are functions that help SVR deal with non-linear data by transforming input data into higher dimensions:
+SVR has a few important knobs (hyperparameters) you can tune:
+C forces the model to fit as closely as possible, possibly overfitting. A small C allows for more slack.After training, we must evaluate how well the SVR model performs. Here’s a common process:
+MSE (Mean Squared Error) and MAE (Mean Absolute Error)Mastering these concepts helps you unlock the real power of SVR and make smarter, more flexible predictions!
+ +Story-style intuition: The Party Planner
+Imagine you have a list of 1,000 guests for a party, and you know how well each guest gets along with every other guest (based on a complex 100-dimensional personality profile). Your job is to create a 2D seating chart for the party. A simple approach (like PCA) might place guests based on one or two general traits, but you want something better. You want to make sure that "close friends" from the original list end up sitting close together at the party. t-SNE is your expert party planning assistant. It meticulously arranges the seating chart so that the local "friendship circles" from your high-dimensional list are beautifully preserved in the 2D layout. Its main goal isn't to preserve the exact distances, but to keep the neighbors together.
+t-SNE is a powerful, nonlinear dimensionality reduction technique primarily used for visualizing high-dimensional data in 2D or 3D. Unlike PCA, which focuses on preserving the overall "spread" (global variance) of the data, t-SNE focuses on preserving the local structure—it tries to keep points that are close neighbors in the original high-dimensional space as close neighbors in the low-dimensional map.
+ + +The core idea of t-SNE is to convert the high-dimensional distances between data points into probabilities representing similarities. If two points are close, there's a high probability they are "neighbors." It then tries to create a low-dimensional map where these probabilities are as similar as possible.
+Example: In a high-dimensional space of animal features, a "cat" and a "lynx" are very close. A "cat" and a "whale" are very far apart. t-SNE converts this to:
+
• High probability that a "cat" would pick a "lynx" as its neighbor.
+
• Very low probability that a "cat" would pick a "whale" as its neighbor.
+
It then arranges the points on a 2D map to reflect these same probabilities.
A key innovation is its use of a Student-t distribution in the low-dimensional map. This distribution has "heavier tails" than a normal (Gaussian) distribution, which allows it to place dissimilar points further apart, helping to prevent overcrowding in the center of the map and forming clearer, more distinct clusters.
+ + +The math behind t-SNE is like a two-part translation process:
+
1. Describe Friendships in High Dimensions: First, it creates a "friendship score" ($$p_{ij}$$) for every pair of guests on the original list.
+
2. Describe Friendships on the 2D Map: Then, it creates a similar friendship score ($$q_{ij}$$) for every pair on the 2D seating chart.
+
The Goal: It then shuffles the 2D seating chart around until the two sets of friendship scores are as similar as possible. The difference between the scores is measured by something called KL Divergence.
$$ p_{j|i} = \frac{\exp(-||x_i - x_j||^2 / 2\sigma_i^2)}{\sum_{k \neq i} \exp(-||x_i - x_k||^2 / 2\sigma_i^2)} $$
+This is then made symmetric: $$p_{ij} = (p_{j|i} + p_{i|j}) / 2n$$
+$$ q_{ij} = \frac{(1 + ||y_i - y_j||^2)^{-1}}{\sum_{k \neq l} (1 + ||y_k - y_l||^2)^{-1}} $$
+$$ KL(P || Q) = \sum_{i \neq j} p_{ij} \log \frac{p_{ij}}{q_{ij}} $$
+Think of these as the settings for your party planner assistant:
+| Feature | +t-SNE | +PCA | +
|---|---|---|
| Method | +Nonlinear | +Linear | +
| Goal | +Preserves local structure (neighbors). | +Preserves global variance (overall spread). | +
| Use Case | +Visualization and identifying clusters. | +Preprocessing, noise reduction, and data compression. | +
| Speed | +Slow (O(n²)), not for huge datasets. | +Very fast and scalable. | +
| Output Meaning | +The distances between clusters are often not meaningful. Focus on the clusters themselves. | +The components have a clear mathematical meaning (directions of max variance). | +
In this example, we'll use the famous handwritten digits dataset. Each digit is a 64-dimensional vector (an 8x8 image). We'll use t-SNE to visualize all these digits in a 2D plot. We expect to see 10 distinct clusters, one for each digit from 0 to 9.
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.manifold import TSNE
+from sklearn.datasets import load_digits
+
+# --- 1. Load the Data ---
+# The digits dataset contains 8x8 pixel images of handwritten digits (0-9).
+# Each image is a "data point" with 64 features (8*8=64).
+digits = load_digits()
+X = digits.data
+y = digits.target # The true labels (0, 1, 2, ...)
+
+# --- 2. Create and Apply t-SNE ---
+# n_components=2: We want to create a 2D map.
+# perplexity=30: A good default value to start with.
+# random_state=42: Ensures we get the same plot every time we run the code.
+tsne = TSNE(n_components=2, perplexity=30, random_state=42)
+
+# Fit t-SNE to the data and transform it. This can take a moment.
+X_tsne = tsne.fit_transform(X)
+
+# --- 3. Visualize the Results ---
+# We can now plot our 64D dataset in 2D.
+# We'll color each point on the plot according to its true digit label.
+plt.figure(figsize=(10, 8))
+plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap=plt.cm.get_cmap("jet", 10))
+plt.title('t-SNE Visualization of Handwritten Digits')
+plt.xlabel('t-SNE Component 1')
+plt.ylabel('t-SNE Component 2')
+plt.colorbar(label='Digit Label', ticks=range(10))
+plt.grid(True)
+plt.show()
+ Unsupervised learning is a type of machine learning that looks for previously undetected patterns in a dataset with no pre-existing labels and with a minimum of human supervision.
+Used for grouping similar data points together.
+ +Used for reducing the number of features in a dataset while retaining important information.
+ +Used for discovering relationships between variables in large datasets.
+ +Starting simulation...
++ XGBoost minimizes $L(\phi) = \sum l(y_i, \hat{y}_i) + \sum \Omega(f_k)$. + It uses a 2nd order Taylor expansion for fast optimization. +
+Gradient Boosting Machine Visualizer
+