Morty: "So supervised learning is like having the answers on the back of the book?"

Rick: "Yeah, Morty. Labeled inputs, known targets, minimize a loss. Training wheels for pattern‑matching—now let's not flunk the cosmos."

Morty: "Okay, so supervised means we already know the answers?"

Rick: "Labeled input–output pairs, Morty. The model learns a mapping that minimizes a loss. Think of it like teaching someone to recognize cats by showing them thousands of pictures labeled 'cat' and 'not cat'. The algorithm finds patterns in the pixels that correlate with the labels."

Morty: "And the loss is like a score of how wrong we are?"

Rick: "Exactly. We adjust weights to make that score smaller until generalization stops improving. Lower loss means better predictions, but don't get cocky—what matters is how well it works on new, unseen data."

Morty: "Any gotchas?"

Rick: "Overfitting. Regularize, validate, and stop before you memorize the homework key. The model might learn to recognize the exact training examples instead of the underlying patterns. It's like memorizing answers without understanding the concepts—works great on the practice test, fails spectacularly on the real exam."

Morty: "So we need to test it on data it's never seen?"

Rick: "That's the validation set, Morty. Keep some data hidden during training, then see if the model can handle surprises. If training accuracy is high but validation accuracy tanks, you've got yourself a classic overfitting situation."

Morty: "Uh, so… no labels?"

Rick: "Right. We toss data into a void and let it find structure—clusters, manifolds, whatever. Curiosity without supervision, Morty."

Morty: "No labels… so what are we learning?"

Rick: "Structure, Morty. Groups, manifolds, directions of variance—whatever patterns float to the top. Imagine you have a bunch of customer data but no idea what makes them different. Unsupervised learning might discover that some customers buy luxury items while others are bargain hunters, even though nobody told it to look for that."

Morty: "How do we check if it's good?"

Rick: "Qualitative checks, downstream performance, or metrics like silhouette. Don't expect a single 'right' answer. Unlike supervised learning where you can check against ground truth, here you're exploring the unknown. Maybe the clusters make business sense, maybe they reveal hidden customer segments, or maybe they're just mathematical artifacts."

Morty: "So it's like exploring a new dimension?"

Rick: "Yeah, and trying not to get eaten by your own assumptions. The algorithm might find patterns that are real but useless, or useful but not obvious. It's like being an explorer without a map—you might discover treasure or just end up lost in a swamp of irrelevant correlations."

Morty: "When would we actually use this?"

Rick: "Data exploration, feature engineering, anomaly detection, or when you need to understand your data before building supervised models. It's reconnaissance for your data science mission, Morty."

Morty: "We get points for doing good stuff?"

Rick: "Rewards, Morty. Agent learns a policy to maximize return by trial and error. It's like arcade tokens but with Bellman equations."

Morty: "We just try stuff and see what pays off?"

Rick: "Agent, environment, rewards. Learn a policy that maximizes expected return, Morty. Think of it like learning to play a video game—you don't know the rules at first, but you get points for good moves and lose points for bad ones. Eventually you figure out the strategy that gets you the highest score."

Morty: "Do we plan ahead or just react?"

Rick: "Both—value functions evaluate, policies act. Bootstrapping stitches it together. The value function is like your inner voice saying 'this situation looks promising' or 'this is probably a bad idea.' The policy is your actual decision-making process. Sometimes you plan several moves ahead, sometimes you just react."

Morty: "And exploration?"

Rick: "Essential. Otherwise you get stuck milking mediocre rewards forever. It's the classic explore-exploit dilemma—do you keep doing what you know works, or try something new that might work better? Most RL algorithms have some mechanism to encourage trying new things, otherwise they get stuck in local optima like a rat hitting the same lever."

Morty: "So it's like learning to ride a bike?"

Rick: "Exactly, but the bike is on fire and the road keeps changing. You start terrible, crash a lot, but gradually learn what actions lead to staying upright. The reward signal is your main teacher—pain when you fall, satisfaction when you succeed."

Morty: "A model is like a brain?"

Rick: "A function, Morty. Parameters in, predictions out. Some are simple, some are monstrosities. All are hungry for data."

Morty: "So a model is like a brain-in-a-jar?"

Rick: "It's a function with tunable parameters, Morty. Some tiny, some so big they write papers. A linear regression model might have just a few parameters—maybe one for each input feature plus a bias term. A large language model might have billions of parameters, each one a tiny weight that helps the model understand language."

Morty: "How do we pick one?"

Rick: "Start simple, watch validation, escalate complexity only if it earns its keep. Begin with something like logistic regression—it's interpretable and fast. If it's not performing well enough, maybe try a random forest. Still not good enough? Neural networks. But each step up the complexity ladder means more data requirements, longer training times, and harder debugging."

Morty: "And k‑NN isn't even training?"

Rick: "Lazy learning. You store data and suffer at query time. k-NN doesn't build a model during training—it just memorizes all the examples. When you ask for a prediction, it searches through all stored examples to find the k nearest neighbors and averages their labels. Fast training, slow inference."

Morty: "So bigger models are always better?"

Rick: "Hell no, Morty. Bigger models overfit easier, cost more to run, and are harder to understand. Sometimes a simple model that captures the main pattern is better than a complex one that memorizes noise. It's about finding the sweet spot between underfitting and overfitting."

Morty: "Are parameters the knobs?"

Rick: "They're the weights, Morty. The numbers the optimizer cranks so the model stops embarrassing itself."

Morty: "Parameters change during training, right?"

Rick: "Yeah. Gradients nudge them toward lower loss each update. Think of parameters as the model's memory—they encode everything the model has learned about the patterns in your data. In a neural network, they're the connection strengths between neurons."

Morty: "Do all parameters get updated the same?"

Rick: "Not necessarily—different layers, schedules, and weight decay can treat them differently. Early layers in a neural network might learn slowly with small learning rates, while the final layer learns faster. Some parameters might be frozen during transfer learning, others might have different regularization."

Morty: "So they're the dials the model learns to twist?"

Rick: "Exactly, Morty. Imagine the model as a complex machine with millions of tiny dials. During training, the optimizer figures out how to adjust each dial to make better predictions. Some dials barely move, others get cranked hard. The art is in getting them all to work together."

Morty: "How many parameters do models usually have?"

Rick: "Ranges from dozens to trillions. A simple linear model might have one parameter per feature. GPT-3 has 175 billion parameters. More parameters mean more capacity to learn complex patterns, but also more risk of overfitting and higher computational costs."

Morty: "So these are settings we pick?"

Rick: "Yeah. Learning rate, depth, regularization. You tune 'em or watch your model crash like a rickety portal gun."

Morty: "We pick hyperparameters before we start?"

Rick: "Yep. They shape the learning process—too spicy or too bland ruins dinner. Think of hyperparameters as the recipe settings for cooking your model. Learning rate is how fast you turn up the heat, batch size is how much you cook at once, number of layers is how complex your dish gets."

Morty: "How do we choose them?"

Rick: "Search: grid, random, Bayesian, or bandits. Validate honestly, avoid leakage. Grid search tries every combination like a methodical scientist. Random search is like throwing darts—surprisingly effective and way faster. Bayesian optimization is the smart approach that learns from previous attempts."

Morty: "And automate it?"

Rick: "If you like compute bills, sure. Automated hyperparameter tuning can burn through cloud credits faster than Jerry burns through excuses. But it's often worth it—the difference between good and great hyperparameters can make or break your model."

Morty: "What happens if we get them wrong?"

Rick: "Learning rate too high? Your loss function bounces around like a ping-pong ball. Too low? Training takes forever and might never converge. Wrong architecture depth? Either underfitting or overfitting hell. It's like tuning a musical instrument—everything has to be just right for harmony."

Morty: "Features are like clues?"

Rick: "Inputs, Morty. Pixels, ages, frequencies. Better clues, better models—unless you leak future info and blow up reality."

Morty: "Features are our clues to the answer?"

Rick: "Clues and context. Good ones make learning easy; bad ones make models hallucinate. Think of features as the sensory inputs for your model—they're how the algorithm perceives the world. In image recognition, features might be pixel values, edges, or textures. For predicting house prices, features could be square footage, neighborhood, and number of bedrooms."

Morty: "So engineering matters?"

Rick: "Often more than model choice, Morty. But don't leak the future. A brilliant feature engineer can make a simple linear model outperform a fancy neural network with bad features. Features are where domain expertise meets machine learning—knowing what matters in your problem space."

Morty: "Leak the… future?"

Rick: "Using info unavailable at prediction time. Multiverse-breaking mistake. Like using tomorrow's stock price to predict today's stock price—technically perfect accuracy, completely useless in practice. Always ask: 'Would I have this information when making real predictions?'"

Morty: "What makes a good feature?"

Rick: "Relevance, availability, and stability, Morty. It should be correlated with your target, available when you need predictions, and not change meaning over time. A feature that's perfect in your training data but unavailable in production is worse than useless—it's a trap."

Morty: "Labels are answers?"

Rick: "Targets, Morty. The thing you're trying to predict. Numbers or categories. No label, no supervision."

Morty: "Labels are the answers we compare to?"

Rick: "Exactly. Noisy labels mislead, so curate. Garbage in, garbage universes out. Labels are your ground truth—what you want the model to learn to predict. In spam detection, labels are 'spam' or 'not spam'. In house pricing, the label is the actual sale price."

Morty: "What about class imbalance?"

Rick: "Reweight, resample, or tune thresholds—metrics must match reality. If 99% of your emails are not spam, your model will just predict 'not spam' for everything and be 99% accurate but completely useless. You need to balance the training data or adjust how you evaluate performance."

Morty: "So labels can be the bottleneck?"

Rick: "Frequently, Morty. Getting high-quality labels is often the hardest part of machine learning. Think medical diagnosis—you need expert doctors to label X-rays, which is expensive and time-consuming. Bad labels create bad models, period."

Morty: "How do we get better labels?"

Rick: "Multiple annotators, clear guidelines, quality checks, and sometimes active learning where the model asks for labels on the most uncertain examples. And always remember—your model can only be as good as your labels allow it to be."

Morty: "A dataset is just… a bunch of examples?"

Rick: "Collections of reality slices, Morty. Train, validate, test—don't mix 'em or you'll contaminate timelines."

Morty: "Dataset equals rows of reality?"

Rick: "Rows and context. Quality, coverage, and drift resistance matter more than size alone. A dataset is your model's entire understanding of the world. If it's biased, incomplete, or outdated, your model will be too. Think of it as a representative sample of all possible situations your model might encounter."

Morty: "How do we keep it clean?"

Rick: "Version it, audit it, and track provenance like it's plutonium. Every time you update your dataset, version it. Know where each data point came from, when it was collected, and how it was processed. Data lineage is crucial for debugging and compliance."

Morty: "And splits?"

Rick: "Disjoint, time‑aware when needed, consistent preprocessing across them. Your train, validation, and test sets should never overlap—that's cheating. For time series data, respect temporal order. And whatever preprocessing you do to training data, do exactly the same to validation and test data."

Morty: "How big should datasets be?"

Rick: "Depends on the complexity, Morty. Simple problems might need hundreds of examples, complex deep learning might need millions. But remember: 1000 high-quality, relevant examples often beat 100,000 noisy, irrelevant ones."

Morty: "We divide the data into three piles?"

Rick: "Train to learn, validation to tune, test to judge. Keep 'em disjoint or you're just flattering yourself, Morty."

Morty: "Three piles, three purposes?"

Rick: "Train learns, validation tunes, test judges. Keep them separate or you flatter yourself. Training data teaches the model patterns, validation data helps you pick the best hyperparameters, and test data gives you an honest assessment of real-world performance."

Morty: "Time series, too?"

Rick: "Use temporal splits. Random shuffles can lie to you, Morty. With time series, you can't randomly mix past and future—always split chronologically. Train on older data, validate on recent data, test on the most recent data. Otherwise you're cheating by using future information."

Morty: "And never peek?"

Rick: "Never. The test set is sacred, Morty. Look at it once, at the very end, after everything else is finalized. If you keep peeking and adjusting based on test performance, you're essentially training on your test set."

Morty: "What about the split ratios?"

Rick: "Common rule is 60/20/20 or 70/15/15, but it depends on your data size. With millions of examples, you can get away with smaller validation and test sets. With hundreds, you might need larger portions to get reliable estimates."

Morty: "Overfitting is memorizing, right?"

Rick: "Yeah. The model writes the answers on its arm and fails the real exam. Regularize, augment, stop early, Morty."

Morty: "Memorizing the homework key, huh?"

Rick: "Yeah. Low training error, high test regret. The model learns the training data so well that it memorizes irrelevant details and noise instead of the underlying patterns. It's like a student who memorizes the exact wording of practice problems but can't solve new ones with different wording."

Morty: "How do we fix it?"

Rick: "Simplify, regularize, augment, or get more data—and watch validation like a hawk. Use a simpler model, add regularization penalties, augment your training data with variations, or collect more diverse examples. The key is monitoring validation performance—when it starts getting worse while training improves, you're overfitting."

Morty: "Early stopping?"

Rick: "Classic and effective. Stop training when validation performance plateaus or starts degrading, even if training performance could still improve. Save the model state from when validation was best, not when training finished."

Morty: "How do we spot it?"

Rick: "Large gap between training and validation performance, Morty. If your model gets 99% accuracy on training data but only 70% on validation, that's a classic overfitting red flag. The model is too complex for the amount of data you have."

Morty: "Underfitting means it's too simple?"

Rick: "Too weak to capture the signal. Give it capacity, time, or smarter features."

Morty: "The model's just not smart enough?"

Rick: "Or not trained enough. Add capacity, train longer, or build better features. Underfitting is the opposite of overfitting—the model is too simple to learn even the basic patterns in your data. It's like trying to fit a curved line with a straight line—it just can't capture the complexity."

Morty: "Any risks?"

Rick: "Swing too far and you overfit. It's a bias‑variance seesaw. The art is finding the sweet spot between too simple (underfitting) and too complex (overfitting). You want just enough model complexity to capture the real patterns without memorizing noise."

Morty: "So tune, don't blindly crank."

Rick: "Bingo. Start simple and gradually increase complexity while monitoring validation performance. Add layers, parameters, or training time incrementally. Stop when validation performance plateaus or starts degrading."

Morty: "How do we recognize underfitting?"

Rick: "Both training and validation performance are poor, Morty. If your model can't even learn the training data well, it's probably underfitting. The validation performance will be bad but close to training performance—they're both struggling."

Morty: "It's how wrong we are?"

Rick: "A scalar shame-meter. MSE, cross-entropy—lower it and maybe you'll impress one timeline. The loss function is how you teach the model what 'wrong' means. It's the feedback signal that drives learning."

Morty: "Why different loss functions?"

Rick: "Different problems, different measures of wrongness, Morty. Mean Squared Error for regression penalizes big mistakes heavily. Cross-entropy for classification cares about probability distributions. Huber loss is robust to outliers. The choice shapes how your model learns."

Morty: "How does it actually work?"

Rick: "Compare predictions to truth, compute badness, backpropagate to update weights. The optimizer uses the loss gradient to figure out which direction to nudge each parameter. Lower loss means better predictions, in theory."

Morty: "Any gotchas?"

Rick: "Loss can be gamed, Morty. A model might minimize training loss by memorizing noise. That's why we use validation loss to judge real performance. Also, some losses don't match real-world objectives—optimizing for accuracy might not optimize for fairness."

Morty: "Paying attention—literally?"

Rick: "Queries, keys, values. We weight what's relevant so the model stops staring into space, Morty."

Morty: "Queries point to keys?"

Rick: "Scores pick values to mix—attention directs computation. Think of it like this: you have a question (query), a bunch of topics (keys), and detailed answers (values). The attention mechanism figures out which topics are most relevant to your question, then mixes together the corresponding answers based on relevance."

Morty: "Multi‑head?"

Rick: "Parallel focuses for different patterns. Each head learns to pay attention to different aspects—one might focus on grammar, another on meaning, another on relationships between words. It's like having multiple experts each with their own specialty, then combining their insights."

Morty: "Self vs cross?"

Rick: "Self looks within; cross looks across modalities or sequences. Self-attention lets words in a sentence pay attention to other words in the same sentence—like 'it' referring back to 'cat'. Cross-attention looks between different sources, like when you're translating and need to figure out which English word corresponds to which French word."

Morty: "Why is this such a big deal?"

Rick: "Because it solved the long-range dependency problem, Morty. Before attention, models would forget important context from earlier in the sequence. Now they can directly connect to any relevant information, regardless of distance. It's what made transformers possible and kicked off the modern AI revolution."

Morty: "So it's like having perfect memory?"

Rick: "Perfect memory with smart indexing. The model doesn't just remember everything—it learns what to remember and when it's relevant. It's the difference between a cluttered attic and a well-organized library."

Morty: "The big attention architecture?"

Rick: "Stacks of attention and feed-forward layers with skips and norms. Dominates NLP, vision—pretty much your homework, Morty."

Morty: "Stacks of attention blocks?"

Rick: "Plus feed‑forwards, skips, and norms. Each transformer block has a self-attention layer that lets tokens talk to each other, followed by a feed-forward network that processes each token independently. Residual connections and layer normalization keep gradients flowing during training."

Morty: "Why so dominant?"

Rick: "Scales well and models long‑range dependencies. Unlike RNNs that process sequences step-by-step, transformers can look at all positions simultaneously. This parallelization makes training much faster, and the attention mechanism captures relationships between distant tokens that RNNs often forget."

Morty: "Any downsides?"

Rick: "Context window limits and compute hunger. Attention complexity scales quadratically with sequence length, so transformers hit memory and compute walls with very long sequences. They also need lots of data and computation to train effectively."

Morty: "What made them revolutionary?"

Rick: "The 'Attention is All You Need' paper, Morty. They showed you could ditch recurrence and convolution entirely, just use attention. This unlocked massive parallelization and led to the current AI revolution—GPT, BERT, Vision Transformers, everything."

Morty: "A huge text-predictor brain?"

Rick: "Gigantic transformers trained on oceans of text to guess the next token. Prompt it right or it rambles like Jerry."

Morty: "Huge text predictors?"

Rick: "Autoregressive token guessers. Prompt savvy makes them useful, Morty. Think of them as incredibly sophisticated autocomplete systems—they've read basically everything on the internet and learned to predict what word comes next in any context."

Morty: "Fine‑tuning or prompts?"

Rick: "Both—choose based on data, control, and cost. Prompting is like asking a really smart friend for help—you describe what you want and hope they understand. Fine-tuning is like hiring that friend and training them specifically for your exact job. Prompting is cheap and flexible, fine-tuning gives you more control but costs more."

Morty: "Safety?"

Rick: "Guardrails or you'll get cosmic nonsense. These models will confidently tell you that sharks are mammals or help you make explosives if you ask nicely enough. They need safety training, content filters, and careful prompt engineering to behave responsibly."

Morty: "How do they actually work?"

Rick: "They break text into tokens, encode them as vectors, then use attention mechanisms to understand relationships between all the tokens. When generating, they sample from a probability distribution over all possible next tokens. The magic is in the training—they learn patterns from billions of examples."

Morty: "Why are they so good at everything?"

Rick: "Scale and emergent abilities, Morty. Train a big enough model on enough data, and it starts showing capabilities nobody explicitly taught it—like reasoning, coding, and creative writing. It's like crossing a threshold where quantity becomes quality."

Morty: "We tell it what to do?"

Rick: "Context, constraints, examples. Good prompts steer; bad ones summon gibberish from the abyss, Morty."

Morty: "We steer with text?"

Rick: "Context + constraints + examples—give it rails to run on. Think of prompting as programming with natural language. You're not coding logic, you're describing the task, providing context, and showing examples of what good output looks like."

Morty: "Few‑shot helps?"

Rick: "Shows patterns to imitate. Zero-shot is 'translate this French text'. Few-shot is 'here are three examples of French-to-English translations, now translate this new one'. The examples teach the model the specific style and format you want."

Morty: "And system messages?"

Rick: "Set behavior—like telling me to be nice. System prompts define the model's role and personality. 'You are a helpful assistant' vs 'You are a cynical scientist' will produce very different responses to the same user question."

Morty: "What makes prompts work well?"

Rick: "Clarity, specificity, and structure, Morty. Be explicit about what you want, provide relevant context, use clear formatting, and give examples when needed. The model can't read your mind—it only has your prompt to work with."

Morty: "Any tricks?"

Rick: "Chain of thought prompting—ask the model to think step by step. Role playing—have it act as an expert. Temperature tuning—adjust randomness. And always test variations to see what works best for your use case."

Morty: "Adversaries that teach each other?"

Rick: "Generator learns to fool; discriminator learns to detect—training is a knife‑edge balance."

Morty: "Stability hacks?"

Rick: "Spectral norm, gradient penalties, better losses like WGAN."

Morty: "Mode collapse?"

Rick: "Diversify with techniques like minibatch discrimination."

Practical snippets grouped by concept. Use these alongside the glossary for hands-on intuition.

# Supervised Learning<br>
from sklearn.linear_model import LogisticRegression<br>
model = LogisticRegression()<br>
model.fit(X_train, y_train)<br>
preds = model.predict(X_val)<br>
```<br>

```python<br>
# Unsupervised Learning<br>
from sklearn.cluster import KMeans<br>
km = KMeans(n_clusters=3)<br>
labels = km.fit_predict(X)<br>
```<br>

```python<br>
# Reinforcement Learning (Q-learning)<br>
Q[s, a] = Q[s, a] + alpha * (r + gamma * max(Q[s_next, a_]) - Q[s, a])<br>
```<br>

```python<br>
# Regularization (L2 / Weight Decay)<br>
import torch<br>
opt = torch.optim.SGD(model.parameters(), lr=1e-2, weight_decay=1e-4)<br>
```<br>

```python<br>
# Loss Function (Cross-Entropy)<br>
import torch.nn.functional as F<br>
loss = F.cross_entropy(logits, targets)<br>
```<br>

```python<br>
# Gradient Descent<br>
w = w - lr * grad_w<br>
```<br>

```python<br>
# Optimizer (Adam)<br>
import torch<br>
opt = torch.optim.Adam(model.parameters(), lr=1e-3)<br>
```<br>

```python<br>
# Softmax<br>
import numpy as np<br>
def softmax(z):<br>
    e = np.exp(z - np.max(z))<br>
    return e / e.sum()<br>
```<br>

```python<br>
# Classification Metrics<br>
from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score<br>
precision = precision_score(y_true, y_pred)<br>
recall   = recall_score(y_true, y_pred)<br>
f1       = f1_score(y_true, y_pred)<br>
acc      = accuracy_score(y_true, y_pred)<br>
```<br>

```python<br>
# Confusion Matrix<br>
from sklearn.metrics import ConfusionMatrixDisplay<br>
ConfusionMatrixDisplay.from_predictions(y_true, y_pred)<br>
```<br>

```python<br>
# ROC / AUC<br>
from sklearn.metrics import RocCurveDisplay, roc_auc_score<br>
RocCurveDisplay.from_predictions(y_true, y_score)<br>
auc = roc_auc_score(y_true, y_score)<br>
```<br>

```python<br>
# Tokenization (Transformer tokenizers)<br>
from transformers import AutoTokenizer<br>
tok = AutoTokenizer.from_pretrained("bert-base-uncased")<br>
batch = tok(["Hello world", "ML is fun"], padding=True, return_tensors="pt")<br>
```<br>

```python<br>
# Attention (Scaled Dot-Product)<br>
import numpy as np<br>
def scaled_dot_product_attention(Q, K, V):<br>
    scores = (Q @ K.T) / np.sqrt(Q.shape[-1])<br>
    weights = np.exp(scores - scores.max(axis=-1, keepdims=True))<br>
    weights = weights / weights.sum(axis=-1, keepdims=True)<br>
    return weights @ V<br>
```<br>

```python<br>
# Transformer (PyTorch built-in)<br>
import torch<br>
import torch.nn as nn<br>
model = nn.Transformer(d_model=128, nhead=8, num_encoder_layers=2, num_decoder_layers=2)<br>
src = torch.randn(10, 32, 128)<br>
tgt = torch.randn(9,  32, 128)<br>
out = model(src, tgt)<br>
```<br>

```python<br>
# LLM Generation (Transformers)<br>
from transformers import AutoModelForCausalLM, AutoTokenizer<br>
tok = AutoTokenizer.from_pretrained("gpt2")<br>
lm  = AutoModelForCausalLM.from_pretrained("gpt2")<br>
inp = tok("Hello, I'm a language model", return_tensors="pt")<br>
gen = lm.generate(**inp, max_length=50, temperature=0.8, top_p=0.9)<br>
print(tok.decode(gen[0], skip_special_tokens=True))<br>
```<br>

```python<br>
# Beam Search / Sampling Controls<br>
lm.generate(**inp, num_beams=5)<br>
lm.generate(**inp, temperature=0.7, top_p=0.9)<br>
```<br>

```python<br>
# Cross-Validation<br>
from sklearn.model_selection import cross_val_score<br>
from sklearn.linear_model import LogisticRegression<br>
scores = cross_val_score(LogisticRegression(), X, y, cv=5)<br>
```<br>

```python<br>
# Data Augmentation (Vision)<br>
from torchvision import transforms<br>
aug = transforms.Compose([<br>
    transforms.RandomResizedCrop(224),<br>
    transforms.RandomHorizontalFlip(),<br>
    transforms.ColorJitter(0.2, 0.2, 0.2, 0.1),<br>
])<br>
```<br>

```python<br>
# Normalization / Standardization<br>
from sklearn.preprocessing import StandardScaler<br>
scaler = StandardScaler().fit(X_train)<br>
X_train_std = scaler.transform(X_train)<br>
X_val_std   = scaler.transform(X_val)<br>
```<br>

```python<br>
# Dropout / BatchNorm / LayerNorm<br>
import torch.nn as nn<br>
layer = nn.Sequential(<br>
    nn.Linear(128, 128),<br>
    nn.ReLU(),<br>
    nn.Dropout(p=0.5),<br>
    nn.LayerNorm(128),<br>
)<br>
```<br>

```python<br>
# Transfer Learning / Fine-Tuning<br>
import torch<br>
import torchvision.models as models<br>
model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)<br>
for p in model.parameters():<br>
    p.requires_grad = False<br>
model.fc = torch.nn.Linear(model.fc.in_features, num_classes)<br>
for p in model.layer4.parameters():<br>
    p.requires_grad = True<br>
opt = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4)<br>
```<br>

```python<br>
# One-Hot Encoding<br>
import pandas as pd<br>
X = pd.DataFrame({"color": ["red", "green", "blue"]})<br>
X_oh = pd.get_dummies(X, columns=["color"])  # one-hot columns<br>
```<br>

```python<br>
# PCA / Dimensionality Reduction<br>
from sklearn.decomposition import PCA<br>
pca = PCA(n_components=2)<br>
X2 = pca.fit_transform(X)<br>
```<br>

```python<br>
# Linear / Logistic Regression<br>
from sklearn.linear_model import LinearRegression, LogisticRegression<br>
reg = LinearRegression().fit(X, y_cont)<br>
clf = LogisticRegression().fit(X, y_bin)<br>
```<br>

```python<br>
# SVM / k-NN / Decision Trees<br>
from sklearn.svm import SVC<br>
from sklearn.neighbors import KNeighborsClassifier<br>
from sklearn.tree import DecisionTreeClassifier<br>
svm = SVC().fit(X, y)<br>
knn = KNeighborsClassifier(n_neighbors=5).fit(X, y)<br>
dt  = DecisionTreeClassifier().fit(X, y)<br>
```<br>

```python<br>
# Random Forest<br>
from sklearn.ensemble import RandomForestClassifier<br>
rf = RandomForestClassifier(n_estimators=200, max_depth=10).fit(X, y)<br>
```<br>

```python<br>
# Pruning / Quantization<br>
import torch<br>
quantized = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)<br>
import torch.nn.utils.prune as prune<br>
for module in model.modules():<br>
    if isinstance(module, torch.nn.Linear):<br>
        prune.l1_unstructured(module, name="weight", amount=0.2)<br>
        prune.remove(module, "weight")<br>
```<br>

```python<br>
# Naive Bayes<br>
from sklearn.naive_bayes import GaussianNB<br>
nb = GaussianNB().fit(X, y)<br>
```<br>

```python<br>
# Autoencoder (Skeleton)<br>
import torch.nn as nn<br>
class AE(nn.Module):<br>
    def __init__(self, d):<br>
        super().__init__()<br>
        self.enc = nn.Sequential(nn.Linear(d, 64), nn.ReLU(), nn.Linear(64, 16))<br>
        self.dec = nn.Sequential(nn.Linear(16, 64), nn.ReLU(), nn.Linear(64, d))<br>
    def forward(self, x):<br>
        z = self.enc(x)<br>
        return self.dec(z)<br>
```<br>

```python<br>
# VAE (Reparameterization Trick)<br>
import torch<br>
def reparam(mu, logvar):<br>
    std = torch.exp(0.5 * logvar)<br>
    eps = torch.randn_like(std)<br>
    return mu + eps * std<br>
```<br>

```python<br>
# GAN (Training Loop Sketch)<br>
for x in dataloader:<br>
    d_loss = D_loss(D(x), D(G(z)))<br>
    d_opt.zero_grad(); d_loss.backward(); d_opt.step()<br>
    g_loss = G_loss(D(G(z)))<br>
    g_opt.zero_grad(); g_loss.backward(); g_opt.step()<br>
```<br>

```python<br>
# Diffusion (Denoising Step Sketch)<br>
x_{t-1} = denoise(x_t, t, eps_theta)<br>
```<br>

```python<br>
# Inference / Latency<br>
import time<br>
start = time.perf_counter()<br>
_ = model(x)<br>
latency_ms = (time.perf_counter() - start) * 1000<br>
```<br>

</details>