Confusing Machine Learning Terms Explained in Simple Words

from sklearn.linear_model import Ridge
import numpy as np

X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])

model = Ridge(alpha=1.0)        # alpha is a HYPERPARAMETER (you choose it)
model.fit(X, y)

print("coef_      :", model.coef_)       # PARAMETERS learned from data
print("intercept_ :", model.intercept_)

from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import cross_val_score
import numpy as np

rng = np.random.default_rng(1)
X = rng.uniform(0, 10, (200, 1))
y = np.sin(X).ravel() + rng.normal(0, 0.3, 200)

for depth in [1, 4, 20]:
    tree = DecisionTreeRegressor(max_depth=depth, random_state=0)
    score = cross_val_score(tree, X, y, cv=5, scoring="r2").mean()
    print(f"depth={depth:<2}  CV R2={score:.2f}")
# depth 1: high bias (too simple); depth 20: high variance (overfits)

from sklearn.model_selection import train_test_split

X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)          # lock away the test set
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.25, random_state=42)  # 0.25 x 0.8 = 20% validation

# Tune on (X_train, X_val). Evaluate on X_test ONCE at the end.

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# WRONG: scaler.fit(X) on all data, then cross-validate
#        (test folds influence the scaling -> leakage)

# RIGHT: put scaling inside the pipeline so each fold
#        fits the scaler on its own training part only
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
print(cross_val_score(pipe, X, y, cv=5).mean())

import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler

x = np.array([[10], [20], [30], [40], [100]])

print(MinMaxScaler().fit_transform(x).ravel())   # 0 to 1
print(StandardScaler().fit_transform(x).ravel()) # mean 0, std 1

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({"city": ["Noida", "Delhi", "Pune", "Delhi"],
                   "size": ["S", "M", "L", "M"]})

# One-hot for unordered categories
print(pd.get_dummies(df["city"], prefix="city"))

# Ordinal encoding when order is real (S < M < L)
enc = OrdinalEncoder(categories=[["S", "M", "L"]])
print(enc.fit_transform(df[["size"]]).ravel())   # [0. 1. 2. 1.]

Term A:
Term B:
A in one line:
B in one line:
Everyday analogy:
scikit-learn example:
Mistake if confused:

- Precision vs recall
- L1 vs L2 regularisation
- Bagging vs boosting
- Supervised vs unsupervised learning
- Epoch vs batch (deep learning)
- Generative vs discriminative models
- Online vs batch learning

For each pair:
1. Define A in one sentence
2. Define B in one sentence
3. State the key difference
4. Give one situation where it matters
5. Mention what goes wrong if you confuse them