Why Every ML Engineer Should Practice Explaining Their Code Aloud

import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)
X = torch.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).float().unsqueeze(1)
train_dl = DataLoader(TensorDataset(X[:800], y[:800]), batch_size=32, shuffle=True)
val_dl = DataLoader(TensorDataset(X[800:], y[800:]), batch_size=64)

model = nn.Sequential(nn.Linear(10, 32), nn.ReLU(), nn.Dropout(0.2), nn.Linear(32, 1))
loss_fn = nn.BCEWithLogitsLoss()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    model.train()
    total = 0.0
    for xb, yb in train_dl:
        opt.zero_grad()
        loss = loss_fn(model(xb), yb)
        loss.backward()
        opt.step()
        total += loss.item() * len(xb)

    model.eval()
    correct = 0
    with torch.no_grad():
        for xb, yb in val_dl:
            pred = (torch.sigmoid(model(xb)) > 0.5).float()
            correct += (pred == yb).sum().item()
    print(f"epoch {epoch} train_loss={total/800:.3f} val_acc={correct/200:.3f}")

"Each epoch has a training half and an evaluation half.

model.train() turns dropout on. For each batch I clear old
gradients with zero_grad, because PyTorch adds gradients by
default. Then forward pass, loss, backward to compute
gradients, and step to update the weights.

I use BCEWithLogitsLoss, so the model outputs raw logits and
the loss applies the sigmoid internally, which is more
numerically stable than a separate sigmoid plus BCELoss.

loss.item() gives a plain float, so I don't keep the graph
alive while summing.

For validation, model.eval() turns dropout off and no_grad
stops gradient tracking, which saves memory and time."

import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin

class QuantileCapper(BaseEstimator, TransformerMixin):
    """Cap each numeric column at quantiles learned in fit."""

    def __init__(self, lower=0.01, upper=0.99):
        self.lower = lower
        self.upper = upper

    def fit(self, X, y=None):
        X = pd.DataFrame(X)
        self.low_ = X.quantile(self.lower)
        self.high_ = X.quantile(self.upper)
        return self

    def transform(self, X):
        X = pd.DataFrame(X).copy()
        return X.clip(lower=self.low_, upper=self.high_, axis=1)


train = pd.DataFrame({"amount": np.arange(1, 101)})
test = pd.DataFrame({"amount": [-50, 50, 10_000]})
cap = QuantileCapper().fit(train)
print(cap.transform(test)["amount"].tolist())

"fit learns the 1st and 99th percentile of each column from
the training data and stores them with a trailing underscore,
which is the scikit-learn convention for learned attributes.

transform only applies those stored limits. It copies the
input first, so the caller's dataframe is not modified.

On the test set, an extreme value of 10,000 gets capped at
the training 99th percentile. If I had called fit on the test
set, the cap would move to include that outlier, which is
leakage, and live data could be treated differently from
test data.

Because it follows the BaseEstimator API, I can put it in a
Pipeline and it refits correctly on every fold."

import pandas as pd
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

df = pd.read_csv("C:/Users/me/Desktop/data.csv")

enc = OneHotEncoder()
X = enc.fit_transform(df[["city", "plan"]])
y = df["churned"]

X_tr, X_te, y_tr, y_te = train_test_split(X, y)
model = LogisticRegression().fit(X_tr, y_tr)

scores = []
for i, row in df.iterrows():
    scores.append(row["usage"] * 0.37)
print(model.score(X_te, y_te))

from pathlib import Path
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder

DATA = Path("data") / "customers.csv"      # relative path
USAGE_WEIGHT = 0.37                        # named, not magic

df = pd.read_csv(DATA)
X, y = df[["city", "plan"]], df["churned"]
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, stratify=y, random_state=42)       # reproducible

model = Pipeline([
    ("enc", ColumnTransformer([
        ("cat", OneHotEncoder(handle_unknown="ignore"), ["city", "plan"])
    ])),
    ("clf", LogisticRegression(max_iter=1000)),
])
model.fit(X_tr, y_tr)                        # encoder fit on train only

scores = df["usage"] * USAGE_WEIGHT          # vectorised
print(model.score(X_te, y_te))

POINT-AND-EXPLAIN (15 minutes)

1. Open a training or preprocessing script you wrote.
2. Ask a friend to point at any line, or pick lines at random.
3. For each line, answer aloud at four levels:
   - What does it do?
   - Why is it here?
   - What breaks if I delete it? Loud or silent?
   - What else could I have written instead?
4. Mark any line where you said 'I'm not sure'.
5. Look those up, test them, and repeat tomorrow.

DELETE-A-LINE (20 minutes)

Take the training loop above (or yours) and, one at a time:

[ ] Remove opt.zero_grad()      -> what happens to the loss?
[ ] Remove model.eval()         -> does val accuracy change?
[ ] Remove torch.no_grad()      -> check memory and speed
[ ] Replace loss.item() with loss -> what type is total?
[ ] Use BCELoss without sigmoid -> what error or result?

Write one sentence for each result. These sentences are
your best interview answers, because you saw them happen.

REVIEW MY OWN SCRIPT: ______________

1. Correctness issues found: _______________
2. Leakage risks found: ____________________
3. Reproducibility gaps: ___________________
4. Readability / speed fixes: ______________

The ONE change that mattered most: ________
How I would explain it in 30 seconds:
_______________________________________