AI Archives - AlfaTechLab

ROC-AUC Curve

July 13, 2025July 13, 2025 by Anand Singh

जब हम binary classification करते हैं (जैसे spam/not-spam, disease/healthy), तो हमें सिर्फ accuracy से model की गुणवत्ता नहीं पता चलती। ऐसे में ROC-AUC Curve model के prediction scores को analyze करने में मदद करता है।

🔶 ROC का अर्थ:

ROC = Receiver Operating Characteristic
यह एक graphical plot है जो बताता है कि model कैसे विभिन्न thresholds पर perform करता है।

📈 ROC Curve Plot:

X-axis → False Positive Rate (FPR)
Y-axis → True Positive Rate (TPR)

Threshold को 0 से 1 तक vary करते हुए हम विभिन्न FPR और TPR को plot करते हैं — और वो बनाता है ROC curve.

📐 Formulae:

✅ True Positive Rate (TPR) aka Recall:

✅ False Positive Rate (FPR):

🔷 AUC का अर्थ:

AUC = Area Under the Curve
यह ROC curve के नीचे आने वाले क्षेत्र का मान है।
AUC का मान 0 और 1 के बीच होता है:

AUC Score	Meaning
1.0	Perfect model
0.9 – 1.0	Excellent
0.8 – 0.9	Good
0.7 – 0.8	Fair
0.5	Random guess (no skill)
< 0.5	Worse than random (bad model)

✅ Python Code (Scikit-learn + Visualization):

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt

# Sample data
X, y = make_classification(n_samples=1000, n_classes=2, n_informative=3)

# Train model
model = LogisticRegression()
model.fit(X, y)

# Get predicted probabilities
y_scores = model.predict_proba(X)[:, 1]

# Compute FPR, TPR
fpr, tpr, thresholds = roc_curve(y, y_scores)

# Compute AUC
roc_auc = auc(fpr, tpr)

# Plot
plt.figure(figsize=(8,6))
plt.plot(fpr, tpr, label=f'ROC Curve (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], 'k--', label='Random Guess')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC-AUC Curve')
plt.legend()
plt.grid(True)
plt.show()

📊 ROC vs Precision-Recall Curve:

Title Page Separator Site title

Feature	ROC Curve	Precision-Recall Curve
Focuses on	All classes (balanced data)	Positive class (imbalanced data)
X-axis	False Positive Rate	Recall
Y-axis	True Positive Rate (Recall)	Precision

✅ Imbalanced datasets पर Precision-Recall Curve ज़्यादा informative हो सकता है।

📄 Summary Table:

Concept	Description
ROC Curve	TPR vs FPR plot for various thresholds
AUC	ROC Curve के नीचे का क्षेत्र
Best Case	AUC = 1.0 (Perfect classifier)
Worst Case	AUC = 0.5 (Random guessing)
Use Cases	Binary classification performance check

📝 Practice Questions:

ROC Curve में X और Y axes क्या दर्शाते हैं?
AUC का score किस range में होता है और उसका क्या मतलब है?
ROC और Precision-Recall Curve में क्या अंतर है?
ROC curve कैसे बनता है?
क्या AUC metric imbalanced datasets के लिए reliable है?

Agent, Environment, Reward

July 13, 2025 by Anand Singh

Reinforcement Learning (RL) में एक एजेंट को एक वातावरण (Environment) में रखा जाता है।
वो किसी स्थिति (State) में होता है, वहाँ से एक Action लेता है, और बदले में उसे Reward मिलता है।

सोचिए एक रोबोट का, जो maze से बाहर निकलने की कोशिश कर रहा है — उसे सही रास्ता सीखने के लिए कई बार try करना होगा।

🔑 Key Concepts:

Term	अर्थ (Meaning)
Agent	वह learner या decision-maker जो actions लेता है
Environment	बाहरी दुनिया जिससे agent interact करता है
State (S)	उस समय की स्थिति जहाँ agent है
Action (A)	agent द्वारा उठाया गया कदम या फैसला
Reward (R)	किसी action पर environment द्वारा दिया गया feedback
Policy (π)	Agent का strategy, जो बताती है किस state में कौनसा action लेना है
Value (V)	किसी स्थिति में मिलने वाले भविष्य के rewards का अनुमान
Episode	शुरू से लेकर एक goal तक का पूरा sequence

🔄 Agent-Environment Loop:

यह एक continuous feedback loop होता है:

(State s_t) --[action a_t]--> (Environment) --[Reward r_t, next state s_{t+1}]--> (Agent)

Diagram:

+-----------+        action a_t         +-------------+
|           | -----------------------> |             |
|  AGENT    |                          | ENVIRONMENT |
|           | <----------------------- |             |
+-----------+     r_t, s_{t+1}         +-------------+

🧠 उद्देश्य:

Agent का लक्ष्य होता है:

Maximum cumulative reward (return) प्राप्त करना

Return:

जहाँ

γ: Discount Factor (0 < γ ≤ 1)
Future rewards की importance को नियंत्रित करता है

🎮 उदाहरण:

Problem	Agent	Environment	Reward
गेम खेलना (e.g. Chess)	Chess AI	Chess board	जीतने पर +1, हारने पर -1
Self-driving car	Car controller	सड़क और ट्रैफिक	टकराने पर -ve, सही चलने पर +ve
Robo-navigation	Robot	Maze/Grid	Exit मिलने पर +10

🧮 Formal Definition (Markov Decision Process – MDP):

Reinforcement Learning को formal रूप में एक MDP से दर्शाया जा सकता है: MDP=(S,A,P,R,γ)

जहाँ:

S: States का सेट
A: Actions का सेट
P: Transition probabilities
R: Reward function
γ: Discount factor

✅ Python Code Example (Gym Environment):

import gym

# Environment
env = gym.make("CartPole-v1")
state = env.reset()

for _ in range(10):
    env.render()
    action = env.action_space.sample()  # Random action
    next_state, reward, done, info = env.step(action)
    print("Reward:", reward)
    if done:
        break

env.close()

🎯 Summary Table:

Term	Description
Agent	Decision-maker (e.g., robot, AI model)
Environment	External system (e.g., game, world)
State	Current situation or context
Action	Agent का निर्णय या प्रयास
Reward	पर्यावरण का response, जो सीखने में मदद करता
Policy	नियम जो बताता है क्या करना है
Goal	Total reward को maximize करना

📝 Practice Questions:

Reinforcement Learning में Agent और Environment क्या भूमिका निभाते हैं?
Reward और Return में क्या अंतर है?
Discount factor (γ\gammaγ) क्या है और इसका महत्व क्या है?
RL में Policy और Value function का क्या कार्य होता है?
कोई real-life उदाहरण दीजिए जहाँ RL model प्रयोग हो सकता है।

PCA – Principal Component Analysis

July 13, 2025 by Anand Singh

PCA (Principal Component Analysis) एक statistical technique है जो high-dimensional data को कम dimensions में project करके उसका meaningful structure retain करती है।

उदाहरण के लिए:
अगर आपके पास 100 features हैं, लेकिन असल में केवल 2 features पूरे pattern को explain कर सकते हैं — तो PCA उन्हीं 2 को चुनता है।

🔶 उद्देश्य:

Features की संख्या को घटाना (Dimensionality Reduction)
Data में मौजूद variance को अधिकतम बनाए रखना
Visualization को आसान बनाना
Noise को घटाना और Model को Fast बनाना

📐 Core Idea (Mathematical):

PCA का लक्ष्य होता है:

ऐसे नए axes (Principal Components) खोजना जो original data में सबसे अधिक variance को capture करें।

🎯 Objective:

जहाँ:

X: Centered data matrix
W: Projection matrix (eigenvectors)
Z: Projected data (principal components)

🧮 Step-by-Step Working:

Standardize the Data
(mean = 0, std = 1)

Covariance Matrix Calculate करो

Eigenvalues और Eigenvectors निकालो

Top-k Eigenvectors को चुनो (सबसे बड़ी eigenvalues वाले)

Data को Project करो new space में:

✅ Python Code (Sklearn + Visualization):

from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# Load sample data
data = load_iris()
X = data.data
y = data.target

# PCA with 2 components
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Plot
plt.figure(figsize=(8,6))
plt.scatter(X_pca[:,0], X_pca[:,1], c=y, cmap='viridis')
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("PCA: Iris Dataset")
plt.grid(True)
plt.show()

📊 Explained Variance:

PCA बताता है कि हर component कितना information retain करता है:

print(pca.explained_variance_ratio_)

उदाहरण Output:

[0.9246, 0.0530] → यानी कुल 97.76% variance केवल 2 components से explain हो गया

🔎 कब इस्तेमाल करें PCA?

Case	उपयोग
बहुत सारे features हों	✅
Model slow या overfit कर रहा हो	✅
Feature correlation ज़्यादा हो	✅
Features sparse हों (जैसे TF-IDF)	✅

⚠️ Limitations:

Limitation	Explanation
Interpretability कम हो जाती है	PCs original features से अलग होते हैं
केवल linear patterns detect करता है	Complex nonlinear pattern नहीं देख सकता
Scaling आवश्यक है	बिना scaling result गलत हो सकता है

📊 Summary Table:

Feature	PCA
Type	Dimensionality Reduction
Preserves	Maximum Variance
Based On	Eigenvalues & Eigenvectors
Suitable For	High-dimensional, numeric data
Output	Reduced dimension components

📝 Practice Questions:

PCA का उद्देश्य क्या होता है?
Covariance matrix किस लिए बनाई जाती है?
Eigenvectors और Eigenvalues का क्या अर्थ है PCA में?
Explained Variance Ratio क्या दर्शाता है?
PCA कब काम नहीं करता?

Hierarchical Clustering

July 13, 2025 by Anand Singh

Hierarchical Clustering एक ऐसा algorithm है जो डेटा को छोटे clusters से शुरू करके धीरे-धीरे उन्हें merge करता है, जिससे एक Tree-like Structure (Dendrogram) बनता है।यह Unsupervised Learning का एक और महत्वपूर्ण algorithm है जो clustering को सभी levels पर hierarchical रूप में करता है:

सोचिए:
पहले व्यक्ति को परिवारों में बांटा गया → फिर परिवार को समाजों में → फिर समाज को राज्यों में।
यही काम करता है Hierarchical Clustering।

🔶 Clustering Approaches:

Method	Description
Agglomerative	Bottom-Up: हर point एक cluster से शुरू करता है → फिर merge होते हैं
Divisive	Top-Down: पूरा dataset एक cluster है → फिर split होते हैं

👉 सबसे सामान्य तरीका: Agglomerative Clustering

🧠 Algorithm Steps (Agglomerative):

हर data point को एक अलग cluster मानो
Closest दो clusters को merge करो
Distance matrix update करो
Step 2 और 3 को तब तक दोहराओ जब तक एक ही cluster न बच जाए

🔍 Linkage Criteria (क्लस्टर्स के बीच दूरी कैसे मापें?)

Linkage Type	Definition
Single	Closest points के बीच की दूरी
Complete	Farthest points के बीच की दूरी
Average	सभी pairwise distances का average
Ward	Variance को minimize करता है (default)

📐 Distance Calculation:

✅ Python Code (SciPy + Matplotlib):

import numpy as np
import matplotlib.pyplot as plt
from scipy.cluster.hierarchy import dendrogram, linkage

# Sample Data
X = np.array([[1, 2],
              [2, 3],
              [5, 8],
              [6, 9]])

# Step 1: Linkage matrix
Z = linkage(X, method='ward')

# Step 2: Dendrogram Plot
plt.figure(figsize=(8, 5))
dendrogram(Z, labels=["A", "B", "C", "D"])
plt.title("Hierarchical Clustering Dendrogram")
plt.xlabel("Data Points")
plt.ylabel("Distance")
plt.show()

🌲 Dendrogram क्या दर्शाता है?

Dendrogram एक tree diagram होता है जो दिखाता है कि कैसे data points और clusters आपस में जुड़े हुए हैं।

Y-axis = merging distance
Horizontal cuts = Desired number of clusters

✂️ अगर आप Y-axis पर एक horizontal लाइन खींचें → आपको अलग-अलग clusters मिलेंगे।

🔧 Clustering का निर्माण (sklearn):

from sklearn.cluster import AgglomerativeClustering

model = AgglomerativeClustering(n_clusters=2)
model.fit(X)

print("Cluster Labels:", model.labels_)

🔬 Use Cases:

क्षेत्र	उदाहरण
Bioinformatics	Gene expression analysis
Marketing	Customer segmentation
Sociology	Social group formation
Document Analysis	Document/topic clustering

⚖️ Pros & Cons:

✅ फायदे:

कोई need नहीं है k (cluster count) को पहले से जानने की
Dendrogram से cluster insights आसानी से मिलते हैं
Complex shape वाले clusters को भी पकड़ सकता है

❌ नुकसान:

बड़े datasets पर slow होता है
Distance metrics और linkage method पर भारी निर्भरता
Non-scalable for huge data

📊 Summary Table:

Feature	Hierarchical Clustering
Input	Only Features (No Labels)
Output	Cluster assignments + Dendrogram
Method	Agglomerative / Divisive
Speed	Slow (high computational cost)
Visualization	Dendrogram

📝 Practice Questions:

Hierarchical Clustering कैसे कार्य करता है?
Agglomerative vs Divisive clustering में क्या अंतर है?
Linkage criteria में Ward method क्यों उपयोगी है?
Dendrogram कैसे interpret किया जाता है?
क्या Hierarchical Clustering large datasets के लिए उपयुक्त है?

K-Means Clustering

July 18, 2025July 13, 2025 by Anand Singh

K-Means Clustering एक Unsupervised Learning Algorithm है जो डेटा को kkk अलग-अलग clusters में बांटने का कार्य करता है, जहाँ हर cluster में डाले गए डेटा आपस में एक-दूसरे से अधिक समान होते हैं।

उदाहरण:
आप एक दुकान के ग्राहकों को उनके ख़रीदने की आदतों के आधार पर 3 समूहों में बाँटना चाहते हैं — High, Medium, और Low spenders।

🔶 उद्देश्य:

K-Means का लक्ष्य है:

Data Points को इस तरह से बांटना कि प्रत्येक Cluster का “Centroid” अपने Points से न्यूनतम दूरी पर हो।

📐 Mathematical Objective:

K-Means का Loss Function (Inertia) होता है:

जहाँ:

🧠 Algorithm Steps:

kkk initial centroids randomly चुनें
हर point को सबसे पास वाले centroid के cluster में assign करें
हर cluster का नया centroid calculate करें
Step 2 और 3 को तब तक दोहराएं जब तक cluster assignment stable ना हो जाए

✅ Python Code (with Visualization):

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import numpy as np

# Dummy Data
X = np.array([[1, 2], [1, 4], [1, 0],
              [10, 2], [10, 4], [10, 0]])

# KMeans Model
model = KMeans(n_clusters=2, random_state=0)
model.fit(X)

# Output
print("Labels:", model.labels_)                  # Cluster assignments
print("Centroids:", model.cluster_centers_)      # Cluster centers

# Visualization
plt.scatter(X[:, 0], X[:, 1], c=model.labels_, cmap='viridis')
plt.scatter(model.cluster_centers_[:, 0], model.cluster_centers_[:, 1], 
            c='red', marker='X', s=200, label='Centroids')
plt.title("K-Means Clustering")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.grid(True)
plt.show()

🔬 Elbow Method (Best k कैसे चुनें?)

Elbow Method यह देखने में मदद करता है कि कितने clusters लेने से सबसे अच्छी grouping मिलेगी।

📈 Plot Inertia vs k:

inertia = []
K = range(1, 10)

for k in K:
    km = KMeans(n_clusters=k)
    km.fit(X)
    inertia.append(km.inertia_)

plt.plot(K, inertia, marker='o')
plt.xlabel('Number of Clusters k')
plt.ylabel('Inertia (Within Sum of Squares)')
plt.title('Elbow Method for Optimal k')
plt.show()

जहाँ graph में “elbow” बनता है — वही optimal k होता है।

🔎 Real Life Applications:

Domain	Application Example
Marketing	Customer Segmentation
Healthcare	Disease pattern clustering
Finance	Risk Grouping / Fraud Detection
E-commerce	Product Recommendation (user grouping)

⚖️ K-Means के फायदे और नुकसान:

✅ फायदे:

Simple और Fast
High-dimensional data पर काम करता है
Easily scalable

❌ नुकसान:

kkk पहले से पता होना चाहिए
Non-spherical clusters को handle नहीं कर पाता
Outliers पर sensitive होता है
Local minima में फँस सकता है (initial centroid पर निर्भरता)

📊 Summary Table:

Feature	K-Means
Type	Unsupervised Clustering
Input	Only Features (No Labels)
Output	Cluster IDs
Distance Metric	Euclidean Distance (Mostly)
Speed	Fast
Shape Assumption	Spherical Clusters

📝 Practice Questions:

K-Means का उद्देश्य क्या होता है?
Loss function J का अर्थ क्या है?
Elbow Method का क्या उपयोग है?
K-Means कब खराब perform करता है?
K-Means clustering में initialization क्यों महत्वपूर्ण होता है?