Python & Math Basics
for Machine Learning

# ── Integer: whole numbers ──────────────────────────────────
age = 25
num_features = 10      # ML: kitne features hain dataset mein
batch_size = 32        # Neural network training mein use hota hai

print(type(age))           # <class 'int'>
print(type(batch_size))   # <class 'int'>


# ── Float: decimal numbers ──────────────────────────────────
learning_rate = 0.001  # ML mein ye bahut important hai!
accuracy = 0.9325
loss = 2.345

print(type(learning_rate))  # <class 'float'>


# ── String: text data ───────────────────────────────────────
model_name = "Random Forest"
dataset_path = "/data/train.csv"

# f-string: formatted output (modern way)
print(f"Model: {model_name}, Accuracy: {accuracy:.2%}")
# Output → Model: Random Forest, Accuracy: 93.25%


# ── Boolean: True / False ───────────────────────────────────
is_trained = False
use_gpu = True

# Boolean is actually int in Python!
print(True + True)    # Output → 2
print(int(True))      # Output → 1


# ── Type Checking & Conversion ──────────────────────────────
x = "100"         # ye string hai, number nahi
x_int = int(x)   # convert to int → 100
x_flt = float(x) # convert to float → 100.0
print(isinstance(x_int, int))   # True

# ── LIST: ordered, changeable ───────────────────────────────
features = [1.2, 3.5, 0.8, 2.1]    # 4 input features
labels = [0, 1, 1, 0, 1]            # binary classification labels

# Indexing (0-based) — ye ML mein bahut use hota hai
print(features[0])     # 1.2  (first element)
print(features[-1])    # 2.1  (last element)
print(features[1:3])   # [3.5, 0.8] (slicing)

# Useful list operations
losses = []
losses.append(2.5)    # add element
losses.append(1.8)
losses.append(1.2)
print(len(losses))      # 3
print(min(losses))      # 1.2
print(max(losses))      # 2.5
print(sum(losses))      # 5.5


# ── TUPLE: fixed, immutable ──────────────────────────────────
image_shape = (224, 224, 3)   # height, width, channels (CNN input)
train_test_split = (0.8, 0.2)
h, w, c = image_shape          # unpacking
print(f"Image: {h}×{w}×{c}")    # Image: 224×224×3


# ── DICT: key-value pairs ────────────────────────────────────
hyperparams = {
    "learning_rate": 0.001,
    "batch_size": 32,
    "epochs": 50,
    "optimizer": "adam",
    "dropout": 0.3
}

print(hyperparams["learning_rate"])        # 0.001
print(hyperparams.get("momentum", 0.9))    # 0.9 (default)
hyperparams["epochs"] = 100               # update value

# Iterate over dict
for param, val in hyperparams.items():
    print(f"  {param}: {val}")


# ── SET: unique values ───────────────────────────────────────
all_labels = [0, 1, 2, 1, 0, 2, 2]
unique_classes = set(all_labels)
print(unique_classes)           # {0, 1, 2}
print(len(unique_classes))      # 3 classes

data = [2.5, -1.0, 3.3, -0.5, 4.1]

# Traditional loop
squared = []
for x in data:
    squared.append(x ** 2)

# Same thing — list comprehension (preferred in ML)
squared = [x ** 2 for x in data]
print(squared)   # [6.25, 1.0, 10.89, 0.25, 16.81]

# With condition: only positive values
positive = [x for x in data if x > 0]
print(positive)  # [2.5, 3.3, 4.1]

# Apply ReLU activation (replace negatives with 0)
relu = [max(0, x) for x in data]
print(relu)      # [2.5, 0, 3.3, 0, 4.1]

# Dict comprehension — normalize features
feat_names = ["age", "income", "score"]
feat_vals  = [25, 50000, 0.85]
feat_dict  = {k: v for k, v in zip(feat_names, feat_vals)}
print(feat_dict)
# {'age': 25, 'income': 50000, 'score': 0.85}

val_loss = 0.34
patience = 5
no_improve_count = 3

# Simple condition
if val_loss < 0.3:
    print("✅ Model is good!")
elif val_loss < 0.5:
    print("⚠️  Acceptable — needs tuning")
else:
    print("❌ Loss too high — check model")

# Multiple conditions with 'and' / 'or'
if no_improve_count >= patience and val_loss > 0.5:
    print("Early stopping triggered!")

# Ternary (one-liner if-else)
status = "Overfit" if val_loss > 0.6 else "OK"
print(f"Status: {status}")   # Status: OK

# Membership check with 'in'
optimizers = ["adam", "sgd", "rmsprop"]
chosen = "adam"
if chosen in optimizers:
    print(f"{chosen} is a valid optimizer")

# ── FOR loop ────────────────────────────────────────────────
# Training loop simulation
epochs = 5
loss = 2.0

for epoch in range(1, epochs + 1):
    loss *= 0.7    # simulate decreasing loss
    print(f"Epoch {epoch}/{epochs} — Loss: {loss:.4f}")

# enumerate: index bhi chahiye
class_names = ["cat", "dog", "bird"]
for idx, name in enumerate(class_names):
    print(f"  Class {idx}: {name}")

# zip: multiple lists parallel iterate karna
y_true = [1, 0, 1, 1]
y_pred = [1, 1, 1, 0]
correct = 0
for true, pred in zip(y_true, y_pred):
    if true == pred:
        correct += 1
print(f"Accuracy: {correct/len(y_true):.0%}")  # 75%

# ── WHILE loop ──────────────────────────────────────────────
threshold = 0.1
loss = 1.0
step = 0
while loss > threshold:
    loss -= 0.15
    step += 1
    print(f"Step {step}: loss = {loss:.2f}")
    if step > 20: break   # safety break

# ── Basic function ───────────────────────────────────────────
def calculate_accuracy(y_true, y_pred):
    """
    Binary classification accuracy calculate karta hai.

    Args:
        y_true (list): actual labels  [0, 1, 1, 0]
        y_pred (list): predicted labels [0, 1, 0, 0]

    Returns:
        float: accuracy between 0.0 and 1.0
    """
    correct = sum(1 for t, p in zip(y_true, y_pred) if t == p)
    return correct / len(y_true)

acc = calculate_accuracy([1,0,1,1], [1,1,1,0])
print(f"Accuracy: {acc:.2%}")   # 50.00%


# ── Default arguments ────────────────────────────────────────
def sigmoid(z, scale=1.0):
    """Sigmoid activation: converts any number to (0, 1)"""
    import math
    return 1 / (1 + math.exp(-scale * z))

print(sigmoid(0))        # 0.5  (exactly middle)
print(sigmoid(2))        # 0.88
print(sigmoid(-2))       # 0.12
print(sigmoid(2, scale=2.0))  # steeper curve


# ── *args and **kwargs ───────────────────────────────────────
def build_model(*layer_sizes, **config):
    """Model architecture define karna"""
    print("Layers:", layer_sizes)   # tuple
    print("Config:", config)       # dict

build_model(784, 256, 128, 10,
            activation="relu",
            dropout=0.3)
# Layers: (784, 256, 128, 10)
# Config: {'activation': 'relu', 'dropout': 0.3}


# ── Lambda functions (anonymous) ─────────────────────────────
relu = lambda x: max(0, x)
normalize = lambda x, mn, mx: (x - mn) / (mx - mn)

print(relu(-3))             # 0
print(relu(5))              # 5
print(normalize(75, 0, 100))  # 0.75

import numpy as np

# ── Array creation ───────────────────────────────────────────
a = np.array([1, 2, 3, 4, 5])      # 1D array (vector)
b = np.array([[1,2,3],[4,5,6]])   # 2D array (matrix)

print(a.shape)   # (5,)    — 5 elements
print(b.shape)   # (2, 3)  — 2 rows, 3 cols
print(b.dtype)   # int64
print(b.ndim)    # 2 (2-dimensional)

# ── Special arrays ───────────────────────────────────────────
np.zeros((3, 4))       # 3×4 matrix of zeros (init weights)
np.ones((2, 3))        # 2×3 matrix of ones
np.eye(3)              # 3×3 identity matrix
np.random.randn(3,3)  # random normal (weight init)
np.arange(0, 10, 2)   # [0, 2, 4, 6, 8]
np.linspace(0,1,5)    # [0, 0.25, 0.5, 0.75, 1.0]

# ── Operations (vectorized — NO loops needed!) ───────────────
x = np.array([1.0, 2.0, 3.0, 4.0])
print(x * 2)          # [2. 4. 6. 8.]
print(x ** 2)         # [1. 4. 9. 16.]
print(np.sqrt(x))     # [1. 1.41 1.73 2.]
print(x.mean())       # 2.5
print(x.std())        # 1.118

# ── Broadcasting: auto-expand dimensions ─────────────────────
A = np.array([[1,2,3],[4,5,6]])  # (2, 3)
b = np.array([10, 20, 30])        # (3,)
print(A + b)
# [[11 22 33]   ← 1+10, 2+20, 3+30
#  [14 25 36]]  ← 4+10, 5+20, 6+30

class LinearRegression:
    """
    Simple Linear Regression ko OOP se implement karna.
    y = w * x + b
    """

    def __init__(self, learning_rate=0.01):
        self.lr = learning_rate
        self.w = 0.0    # weight (slope)
        self.b = 0.0    # bias (intercept)
        self.loss_history = []

    def predict(self, x):
        return self.w * x + self.b

    def train(self, X, y, epochs=100):
        n = len(X)
        for epoch in range(epochs):
            # Forward pass
            y_hat = [self.predict(xi) for xi in X]

            # Compute MSE loss
            loss = sum((p-t)**2 for p,t in zip(y_hat, y)) / n
            self.loss_history.append(loss)

            # Gradients (partial derivatives)
            dw = (2/n) * sum((p-t)*xi
                           for p,t,xi in zip(y_hat,y,X))
            db = (2/n) * sum(p-t
                           for p,t in zip(y_hat,y))

            # Update weights
            self.w -= self.lr * dw
            self.b -= self.lr * db

        return self

    def __repr__(self):
        return f"LinearRegression(w={self.w:.3f}, b={self.b:.3f})"


# Usage
model = LinearRegression(learning_rate=0.1)
X_train = [1, 2, 3, 4, 5]
y_train = [2, 4, 6, 8, 10]    # y = 2x
model.train(X_train, y_train, epochs=200)
print(model)                    # LinearRegression(w=2.000, b=0.000)
print(model.predict(6))         # 12.0 ← correct!

import numpy as np

# Define vectors
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Vector addition
print(a + b)                  # [5 7 9]

# Scalar multiplication
print(3 * a)                  # [3 6 9]

# Dot product — 3 ways to do it in NumPy
print(np.dot(a, b))           # 32  (1×4 + 2×5 + 3×6)
print(a @ b)                  # 32  (modern syntax)
print(sum(a * b))             # 32  (element-wise then sum)

# Magnitude (L2 norm)
magnitude_a = np.linalg.norm(a)
print(f"||a|| = {magnitude_a:.4f}")  # 3.7417

# Unit vector (normalized)
a_unit = a / np.linalg.norm(a)
print(a_unit)              # [0.267 0.534 0.802]
print(np.linalg.norm(a_unit))  # 1.0 (unit vector)

# Cosine similarity — vector similarity measure
cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
print(f"Cosine Similarity: {cos_sim:.4f}")  # 0.9746
# ↑ Very similar! (close to 1.0 means very similar)

import numpy as np

# ── Matrix creation ──────────────────────────────────────────
W = np.array([[1,2,3],   # Weight matrix (3×3)
               [4,5,6],
               [7,8,9]])
x = np.array([1, 0, 1])   # input vector

# Matrix × vector (neural network forward pass!)
z = W @ x                # [4, 10, 16]
print("W @ x =", z)

# Matrix multiplication
A = np.random.randn(3, 4)   # (3×4)
B = np.random.randn(4, 2)   # (4×2)
C = A @ B                   # (3×2) ← result
print(C.shape)               # (3, 2)

# Transpose
print(W.T.shape)             # (3, 3) — transpose
print(A.T.shape)             # (4, 3) — transpose

# Inverse (only for square matrices)
M = np.array([[2,1],[1,1]])
M_inv = np.linalg.inv(M)
print(M @ M_inv)            # Identity matrix (approx)

# Eigenvalues & Eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(W)
print("Eigenvalues:", eigenvalues)
# Used in PCA for dimensionality reduction!

import numpy as np

# ── Simple Gradient Descent from scratch ────────────────────
# Problem: y = 2x + 3  →  find w and b

np.random.seed(42)
X = np.array([1, 2, 3, 4, 5], dtype=float)
y = 2 * X + 3 + np.random.randn(5) * 0.1  # small noise

# Initialize
w, b = 0.0, 0.0
lr = 0.01     # learning rate
n = len(X)

print(f"{'Epoch':>6} {'Loss':>10} {'w':>8} {'b':>8}")
print("-" * 36)

for epoch in range(200):
    # ① Forward pass: predict
    y_hat = w * X + b

    # ② Compute MSE loss
    loss = np.mean((y_hat - y) ** 2)

    # ③ Compute gradients
    dw = (2/n) * np.sum((y_hat - y) * X)
    db = (2/n) * np.sum(y_hat - y)

    # ④ Update parameters
    w -= lr * dw
    b -= lr * db

    if epoch % 40 == 0:
        print(f"{epoch:>6} {loss:>10.4f} {w:>8.4f} {b:>8.4f}")

print(f"\nFinal: w≈{w:.2f}, b≈{b:.2f}")
# Final: w≈2.00, b≈3.00 ← correctly found!

import numpy as np

ages = np.array([22, 25, 27, 28, 29,
                  30, 32, 35, 38, 65])  # 65 is an outlier!

# ── Central Tendency ─────────────────────────────────────────
print(f"Mean:   {np.mean(ages):.1f}")    # 33.1 (pulled by 65)
print(f"Median: {np.median(ages):.1f}")  # 29.5 (robust!)

# ── Spread ───────────────────────────────────────────────────
print(f"Std Dev:  {np.std(ages):.2f}")   # 12.23
print(f"Variance: {np.var(ages):.2f}")   # 149.69
print(f"Range:    {ages.max()-ages.min()}")  # 43

# ── Percentiles & IQR ────────────────────────────────────────
q1 = np.percentile(ages, 25)
q3 = np.percentile(ages, 75)
iqr = q3 - q1
print(f"Q1={q1}, Q3={q3}, IQR={iqr}")

# Outlier detection using IQR method
lower = q1 - 1.5 * iqr
upper = q3 + 1.5 * iqr
outliers = ages[(ages < lower) | (ages > upper)]
print(f"Outliers: {outliers}")       # [65]

# ── Standardization (Z-score normalization) ──────────────────
# This is what StandardScaler does internally!
ages_scaled = (ages - np.mean(ages)) / np.std(ages)
print("Z-scores:", np.round(ages_scaled, 2))
print(f"New mean: {ages_scaled.mean():.6f}")  # ≈ 0.0
print(f"New std:  {ages_scaled.std():.6f}")   # ≈ 1.0

# ── Correlation ──────────────────────────────────────────────
study_hours = np.array([2, 4, 6, 8, 10])
exam_score  = np.array([50, 60, 70, 80, 90])
corr = np.corrcoef(study_hours, exam_score)[0,1]
print(f"Correlation: {corr:.4f}")  # 1.0 (perfect linear!)

import numpy as np

# ── Basic Probability ────────────────────────────────────────
outcomes = ["spam", "ham", "spam", "ham", "ham",
             "spam", "ham", "ham", "spam", "ham"]

p_spam = outcomes.count("spam") / len(outcomes)
p_ham  = 1 - p_spam
print(f"P(spam) = {p_spam:.1f}")   # 0.4
print(f"P(ham)  = {p_ham:.1f}")    # 0.6

# ── Bayes Theorem — Spam Classifier ─────────────────────────
# P(spam | "free") = P("free" | spam) × P(spam) / P("free")

p_spam         = 0.40    # prior: 40% emails are spam
p_free_spam    = 0.80    # P("free" in email | it's spam)
p_free_ham     = 0.10    # P("free" in email | it's ham)

# P("free") = total probability
p_free = (p_free_spam * p_spam) + (p_free_ham * (1 - p_spam))

# Bayes update
p_spam_free = (p_free_spam * p_spam) / p_free
print(f"P(spam | 'free') = {p_spam_free:.2%}")
# P(spam | 'free') = 84.21% ← word "free" makes it likely spam!


# ── Normal Distribution ──────────────────────────────────────
data = np.random.normal(loc=170, scale=10, size=1000)
# Human heights: mean=170cm, std=10cm
print(f"Mean height:  {data.mean():.1f} cm")
print(f"Std Dev:      {data.std():.1f} cm")

# 68-95-99.7 rule
mu, sigma = data.mean(), data.std()
within_1s = np.sum((data >= mu-sigma) & (data <= mu+sigma)) / 1000
print(f"Within 1σ: {within_1s:.1%}")   # ≈ 68%

within_2s = np.sum((data >= mu-2*sigma) & (data <= mu+2*sigma)) / 1000
print(f"Within 2σ: {within_2s:.1%}")   # ≈ 95%