ROC-AUC Curve

рдЬрдм рд╣рдо 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 ScoreMeaning
1.0Perfect model
0.9 тАУ 1.0Excellent
0.8 тАУ 0.9Good
0.7 тАУ 0.8Fair
0.5Random guess (no skill)
< 0.5Worse 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

FeatureROC CurvePrecision-Recall Curve
Focuses onAll classes (balanced data)Positive class (imbalanced data)
X-axisFalse Positive RateRecall
Y-axisTrue Positive Rate (Recall)Precision

тЬЕ Imbalanced datasets рдкрд░ Precision-Recall Curve рдЬрд╝реНрдпрд╛рджрд╛ informative рд╣реЛ рд╕рдХрддрд╛ рд╣реИред


ЁЯУД Summary Table:

ConceptDescription
ROC CurveTPR vs FPR plot for various thresholds
AUCROC Curve рдХреЗ рдиреАрдЪреЗ рдХрд╛ рдХреНрд╖реЗрддреНрд░
Best CaseAUC = 1.0 (Perfect classifier)
Worst CaseAUC = 0.5 (Random guessing)
Use CasesBinary classification performance check

ЁЯУЭ Practice Questions:

  1. ROC Curve рдореЗрдВ X рдФрд░ Y axes рдХреНрдпрд╛ рджрд░реНрд╢рд╛рддреЗ рд╣реИрдВ?
  2. AUC рдХрд╛ score рдХрд┐рд╕ range рдореЗрдВ рд╣реЛрддрд╛ рд╣реИ рдФрд░ рдЙрд╕рдХрд╛ рдХреНрдпрд╛ рдорддрд▓рдм рд╣реИ?
  3. ROC рдФрд░ Precision-Recall Curve рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  4. ROC curve рдХреИрд╕реЗ рдмрдирддрд╛ рд╣реИ?
  5. рдХреНрдпрд╛ AUC metric imbalanced datasets рдХреЗ рд▓рд┐рдП reliable рд╣реИ?

Agent, Environment, Reward

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 рдХреЛ рдирд┐рдпрдВрддреНрд░рд┐рдд рдХрд░рддрд╛ рд╣реИ

ЁЯОо рдЙрджрд╛рд╣рд░рдг:

ProblemAgentEnvironmentReward
рдЧреЗрдо рдЦреЗрд▓рдирд╛ (e.g. Chess)Chess AIChess boardрдЬреАрддрдиреЗ рдкрд░ +1, рд╣рд╛рд░рдиреЗ рдкрд░ -1
Self-driving carCar controllerрд╕рдбрд╝рдХ рдФрд░ рдЯреНрд░реИрдлрд┐рдХрдЯрдХрд░рд╛рдиреЗ рдкрд░ -ve, рд╕рд╣реА рдЪрд▓рдиреЗ рдкрд░ +ve
Robo-navigationRobotMaze/GridExit рдорд┐рд▓рдиреЗ рдкрд░ +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:

TermDescription
AgentDecision-maker (e.g., robot, AI model)
EnvironmentExternal system (e.g., game, world)
StateCurrent situation or context
ActionAgent рдХрд╛ рдирд┐рд░реНрдгрдп рдпрд╛ рдкреНрд░рдпрд╛рд╕
Rewardрдкрд░реНрдпрд╛рд╡рд░рдг рдХрд╛ response, рдЬреЛ рд╕реАрдЦрдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддрд╛
Policyрдирд┐рдпрдо рдЬреЛ рдмрддрд╛рддрд╛ рд╣реИ рдХреНрдпрд╛ рдХрд░рдирд╛ рд╣реИ
GoalTotal reward рдХреЛ maximize рдХрд░рдирд╛

ЁЯУЭ Practice Questions:

  1. Reinforcement Learning рдореЗрдВ Agent рдФрд░ Environment рдХреНрдпрд╛ рднреВрдорд┐рдХрд╛ рдирд┐рднрд╛рддреЗ рд╣реИрдВ?
  2. Reward рдФрд░ Return рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  3. Discount factor (╬│\gamma╬│) рдХреНрдпрд╛ рд╣реИ рдФрд░ рдЗрд╕рдХрд╛ рдорд╣рддреНрд╡ рдХреНрдпрд╛ рд╣реИ?
  4. RL рдореЗрдВ Policy рдФрд░ Value function рдХрд╛ рдХреНрдпрд╛ рдХрд╛рд░реНрдп рд╣реЛрддрд╛ рд╣реИ?
  5. рдХреЛрдИ real-life рдЙрджрд╛рд╣рд░рдг рджреАрдЬрд┐рдП рдЬрд╣рд╛рдБ RL model рдкреНрд░рдпреЛрдЧ рд╣реЛ рд╕рдХрддрд╛ рд╣реИред

PCA тАУ Principal Component Analysis

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:

LimitationExplanation
Interpretability рдХрдо рд╣реЛ рдЬрд╛рддреА рд╣реИPCs original features рд╕реЗ рдЕрд▓рдЧ рд╣реЛрддреЗ рд╣реИрдВ
рдХреЗрд╡рд▓ linear patterns detect рдХрд░рддрд╛ рд╣реИComplex nonlinear pattern рдирд╣реАрдВ рджреЗрдЦ рд╕рдХрддрд╛
Scaling рдЖрд╡рд╢реНрдпрдХ рд╣реИрдмрд┐рдирд╛ scaling result рдЧрд▓рдд рд╣реЛ рд╕рдХрддрд╛ рд╣реИ

ЁЯУК Summary Table:

FeaturePCA
TypeDimensionality Reduction
PreservesMaximum Variance
Based OnEigenvalues & Eigenvectors
Suitable ForHigh-dimensional, numeric data
OutputReduced dimension components

ЁЯУЭ Practice Questions:

  1. PCA рдХрд╛ рдЙрджреНрджреЗрд╢реНрдп рдХреНрдпрд╛ рд╣реЛрддрд╛ рд╣реИ?
  2. Covariance matrix рдХрд┐рд╕ рд▓рд┐рдП рдмрдирд╛рдИ рдЬрд╛рддреА рд╣реИ?
  3. Eigenvectors рдФрд░ Eigenvalues рдХрд╛ рдХреНрдпрд╛ рдЕрд░реНрде рд╣реИ PCA рдореЗрдВ?
  4. Explained Variance Ratio рдХреНрдпрд╛ рджрд░реНрд╢рд╛рддрд╛ рд╣реИ?
  5. PCA рдХрдм рдХрд╛рдо рдирд╣реАрдВ рдХрд░рддрд╛?

Hierarchical Clustering

Hierarchical Clustering рдПрдХ рдРрд╕рд╛ algorithm рд╣реИ рдЬреЛ рдбреЗрдЯрд╛ рдХреЛ рдЫреЛрдЯреЗ clusters рд╕реЗ рд╢реБрд░реВ рдХрд░рдХреЗ рдзреАрд░реЗ-рдзреАрд░реЗ рдЙрдиреНрд╣реЗрдВ merge рдХрд░рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдПрдХ Tree-like Structure (Dendrogram) рдмрдирддрд╛ рд╣реИредрдпрд╣ Unsupervised Learning рдХрд╛ рдПрдХ рдФрд░ рдорд╣рддреНрд╡рдкреВрд░реНрдг algorithm рд╣реИ рдЬреЛ clustering рдХреЛ рд╕рднреА levels рдкрд░ hierarchical рд░реВрдк рдореЗрдВ рдХрд░рддрд╛ рд╣реИ:

рд╕реЛрдЪрд┐рдП:
рдкрд╣рд▓реЗ рд╡реНрдпрдХреНрддрд┐ рдХреЛ рдкрд░рд┐рд╡рд╛рд░реЛрдВ рдореЗрдВ рдмрд╛рдВрдЯрд╛ рдЧрдпрд╛ тЖТ рдлрд┐рд░ рдкрд░рд┐рд╡рд╛рд░ рдХреЛ рд╕рдорд╛рдЬреЛрдВ рдореЗрдВ тЖТ рдлрд┐рд░ рд╕рдорд╛рдЬ рдХреЛ рд░рд╛рдЬреНрдпреЛрдВ рдореЗрдВред
рдпрд╣реА рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ Hierarchical Clusteringред


ЁЯФ╢ Clustering Approaches:

MethodDescription
AgglomerativeBottom-Up: рд╣рд░ point рдПрдХ cluster рд╕реЗ рд╢реБрд░реВ рдХрд░рддрд╛ рд╣реИ тЖТ рдлрд┐рд░ merge рд╣реЛрддреЗ рд╣реИрдВ
DivisiveTop-Down: рдкреВрд░рд╛ dataset рдПрдХ cluster рд╣реИ тЖТ рдлрд┐рд░ split рд╣реЛрддреЗ рд╣реИрдВ

ЁЯСЙ рд╕рдмрд╕реЗ рд╕рд╛рдорд╛рдиреНрдп рддрд░реАрдХрд╛: Agglomerative Clustering


ЁЯза Algorithm Steps (Agglomerative):

  1. рд╣рд░ data point рдХреЛ рдПрдХ рдЕрд▓рдЧ cluster рдорд╛рдиреЛ
  2. Closest рджреЛ clusters рдХреЛ merge рдХрд░реЛ
  3. Distance matrix update рдХрд░реЛ
  4. Step 2 рдФрд░ 3 рдХреЛ рддрдм рддрдХ рджреЛрд╣рд░рд╛рдУ рдЬрдм рддрдХ рдПрдХ рд╣реА cluster рди рдмрдЪ рдЬрд╛рдП

ЁЯФН Linkage Criteria (рдХреНрд▓рд╕реНрдЯрд░реНрд╕ рдХреЗ рдмреАрдЪ рджреВрд░реА рдХреИрд╕реЗ рдорд╛рдкреЗрдВ?)

Linkage TypeDefinition
SingleClosest points рдХреЗ рдмреАрдЪ рдХреА рджреВрд░реА
CompleteFarthest points рдХреЗ рдмреАрдЪ рдХреА рджреВрд░реА
Averageрд╕рднреА pairwise distances рдХрд╛ average
WardVariance рдХреЛ 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:

рдХреНрд╖реЗрддреНрд░рдЙрджрд╛рд╣рд░рдг
BioinformaticsGene expression analysis
MarketingCustomer segmentation
SociologySocial group formation
Document AnalysisDocument/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:

FeatureHierarchical Clustering
InputOnly Features (No Labels)
OutputCluster assignments + Dendrogram
MethodAgglomerative / Divisive
SpeedSlow (high computational cost)
VisualizationDendrogram

ЁЯУЭ Practice Questions:

  1. Hierarchical Clustering рдХреИрд╕реЗ рдХрд╛рд░реНрдп рдХрд░рддрд╛ рд╣реИ?
  2. Agglomerative vs Divisive clustering рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  3. Linkage criteria рдореЗрдВ Ward method рдХреНрдпреЛрдВ рдЙрдкрдпреЛрдЧреА рд╣реИ?
  4. Dendrogram рдХреИрд╕реЗ interpret рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ?
  5. рдХреНрдпрд╛ Hierarchical Clustering large datasets рдХреЗ рд▓рд┐рдП рдЙрдкрдпреБрдХреНрдд рд╣реИ?

K-Means Clustering

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:

  1. kkk initial centroids randomly рдЪреБрдиреЗрдВ
  2. рд╣рд░ point рдХреЛ рд╕рдмрд╕реЗ рдкрд╛рд╕ рд╡рд╛рд▓реЗ centroid рдХреЗ cluster рдореЗрдВ assign рдХрд░реЗрдВ
  3. рд╣рд░ cluster рдХрд╛ рдирдпрд╛ centroid calculate рдХрд░реЗрдВ
  4. 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:

DomainApplication Example
MarketingCustomer Segmentation
HealthcareDisease pattern clustering
FinanceRisk Grouping / Fraud Detection
E-commerceProduct 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:

FeatureK-Means
TypeUnsupervised Clustering
InputOnly Features (No Labels)
OutputCluster IDs
Distance MetricEuclidean Distance (Mostly)
SpeedFast
Shape AssumptionSpherical Clusters

ЁЯУЭ Practice Questions:

  1. K-Means рдХрд╛ рдЙрджреНрджреЗрд╢реНрдп рдХреНрдпрд╛ рд╣реЛрддрд╛ рд╣реИ?
  2. Loss function J рдХрд╛ рдЕрд░реНрде рдХреНрдпрд╛ рд╣реИ?
  3. Elbow Method рдХрд╛ рдХреНрдпрд╛ рдЙрдкрдпреЛрдЧ рд╣реИ?
  4. K-Means рдХрдм рдЦрд░рд╛рдм perform рдХрд░рддрд╛ рд╣реИ?
  5. K-Means clustering рдореЗрдВ initialization рдХреНрдпреЛрдВ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реЛрддрд╛ рд╣реИ?