Machine Learning Terminology Every Beginner Should Learn

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.DataFrame({
    "age": [22, 35, 41, 28, 50, 33, 26, 45],
    "monthly_spend": [300, 1200, 800, 450, 2000, 700, 350, 1500],
    "churned": [1, 0, 0, 1, 0, 0, 1, 0],
})

X = df[["age", "monthly_spend"]]   # features
y = df["churned"]                   # label

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y)
print(X_train.shape, X_test.shape)

# A leaky feature is one that would not be known
# at prediction time.
columns = {
    "age": "known at signup",
    "monthly_spend": "known before prediction",
    "cancellation_date": "only known AFTER churn",
}
for col, when in columns.items():
    flag = "LEAK - remove" if "AFTER" in when else "ok"
    print(f"{col:18} {when:25} {flag}")

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

X, y = make_classification(n_samples=600, n_features=10,
                           flip_y=0.1, random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)

for depth in [2, 5, None]:   # None = grow until pure (overfits)
    m = DecisionTreeClassifier(max_depth=depth, random_state=0)
    m.fit(X_tr, y_tr)
    print(f"depth={depth}: train={m.score(X_tr, y_tr):.2f} "
          f"test={m.score(X_te, y_te):.2f}")

import numpy as np

# One feature, simple linear model y = w*x, learned by gradient descent
x = np.array([1, 2, 3, 4], dtype=float)
y = np.array([2, 4, 6, 8], dtype=float)
w, lr = 0.0, 0.01

for epoch in range(1, 6):          # an epoch = one pass over data
    pred = w * x
    loss = ((pred - y) ** 2).mean()  # mean squared error
    grad = (2 * (pred - y) * x).mean()
    w -= lr * grad
    print(f"epoch {epoch}: loss={loss:.3f} w={w:.3f}")

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.metrics import confusion_matrix

X, y = make_classification(n_samples=500, random_state=1)
model = LogisticRegression(max_iter=1000)

scores = cross_val_score(model, X, y, cv=5)
print("5-fold accuracy:", scores.round(2), "mean", scores.mean().round(2))

model.fit(X[:400], y[:400])
print(confusion_matrix(y[400:], model.predict(X[400:])))

# pip install fastapi uvicorn scikit-learn joblib
# Run: uvicorn serve:app --reload
import joblib
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = joblib.load("model.joblib")   # saved earlier with joblib.dump

class Customer(BaseModel):
    age: float
    monthly_spend: float

@app.post("/predict")
def predict(c: Customer):
    prob = model.predict_proba([[c.age, c.monthly_spend]])[0][1]
    return {"churn_probability": round(float(prob), 3)}

Term: Overfitting
Plain meaning: Model memorises training data, fails on new data
Example: Train accuracy 0.99, test accuracy 0.70
How to spot: Big train-test gap
How to fix: Simpler model, more data, regularisation
Related: Underfitting, validation set

Data:        feature, label, dataset, split, leakage
Training:    model, loss, epoch, hyperparameter, overfitting
Evaluation:  accuracy, precision, recall, F1, cross-validation
Deployment:  inference, API, latency, drift, monitoring

Explain each in one sentence, without notes:

1. Difference between a feature and a label
2. Why we keep a test set aside
3. What overfitting looks like in numbers
4. When recall matters more than precision
5. What drift is and why it needs monitoring