Model Training and Selection Questions

Encompasses choosing appropriate model families and designing robust training strategies. Covers model selection trade offs between linear models, tree based methods, and neural networks depending on data size, interpretability, and latency constraints. Includes practical aspects of training at scale such as distributed training approaches, data and model parallelism, gradient accumulation, checkpointing, experiment tracking and versioning, design of training pipelines, hyperparameter search and resource aware tuning, handling class imbalance and noisy labels, cost management and compute efficiency, and evaluation strategies including controlled experiments and A and B testing. Also discusses retraining policies such as periodic retraining, trigger based retraining for data drift, and continuous or online learning patterns.

MediumTechnical

59 practiced

Case study: You have a transformer-based NLP model but need CPU inference latency under 50ms per request and low cost. Describe model selection and training strategies (quantization, distillation, pruning, architecture search) you would use to meet this SLA and how you'd validate production-quality performance.

Sample Answer

Clarify constraints & objective: single-request CPU P95 latency <50 ms, low cost, acceptable quality drop (specify metric budget: e.g., ≤2% absolute F1/EM drop for QA or ≤1% AUC drop). Target model family: lightweight transformer variants (DistilBERT, TinyBERT, MobileBERT, DeBERTa-small) as starting points.

Selection & training strategy:- Start with a small pre-trained backbone (DistilBERT / TinyBERT) to minimize params and FLOPs.- Knowledge distillation: perform task-specific distillation (teacher = larger SOTA model) using soft-labels + intermediate-layer mimicry and combined loss (CE + KD + feature/attention losses). Distill at full-precision first to maximize accuracy.- Quantization: apply post-training quantization-aware training (QAT) to 8-bit integer (INT8) for weights and activations targeting x86 VNNI/AVX512 paths; if needed, use mixed-precision (activation int8, some layers float16) or integer-only inference libs (ONNX Runtime, OpenVINO).- Pruning: structured pruning (head/FFN/channel) during fine-tuning with gradual magnitude-based regularization to keep latency gains deterministic. Prefer removing attention heads and reducing FFN-size rather than unstructured sparsity for CPU-friendly speedups.- Architecture search / hypersearch: do constrained NAS or manual search over depth/hidden-size/attention-heads using latency-aware objective (weighted loss = task loss + lambda * measured latency). Use progressive search: evaluate candidates on a representative CPU instance to measure real latency.- Pipeline: distill -> prune (structured) -> QAT -> compile/optimize (ONNX Runtime or Intel OpenVINO) -> autotune.

Validation for production-quality:- Accuracy: evaluate standard metrics (F1/EM/AUC) on holdout and adversarial examples; ensure metric drop within predefined SLA.- Latency & throughput: measure P50/P95/P99, cold-start vs warm, batch sizes 1..N on target CPU skeleton; include system-level overhead (serialization, tokenization). Use realistic request traces and measure end-to-end tail latency.- Resource & cost: record CPU utilization, memory, inference cost per million requests.- Robustness: test distribution shift, noisy inputs, and long-tail failure cases; run regression tests vs teacher for calibration and bias.- A/B testing: deploy canary traffic with shadow inference; compare user-facing metrics and rollback criteria.- Monitoring: production metrics (latency, error rate, quality drift), and automatic alert thresholds; periodic re-evaluation and model retrain triggers.

Trade-offs & notes:- INT8 + structured pruning + DistilBERT typically meets <50 ms on modern vCPUs; if not, consider further model slimming or moving to CPU-optimized runtimes.- Avoid aggressive unstructured pruning (sparse ops often not faster on CPUs).- Quantify cumulative accuracy loss after each compression step; prefer iterative, reversible pipeline so you can tune the compression-accuracy tradeoff.

HardTechnical

55 practiced

Coding / numerical (hard): Implement a Python function that computes layer-wise learning rate multipliers given per-layer parameter norms using the LAMB/LARS idea: scaled_lr = base_lr * clip(norm(param)/norm(grad), lower, upper). Provide numerically stable handling (avoid divide by zero) and describe how to integrate this into an optimizer step for large models.

Sample Answer

Approach: compute per-parameter L2 norms for params and grads, form ratio = param_norm / (grad_norm + eps), clip to [lower, upper], then scaled_lr = base_lr * clipped_ratio. Use numerically stable ops (eps, max) and operate per-parameter or per-layer by grouping parameters.

python

import torch

def layerwise_lr_multipliers(params, grads, base_lr, lower=0.0, upper=10.0, eps=1e-6, group_by=None):
    """
    params, grads: iterables of Tensors (same order). For grouping, provide list of lists of indices or None.
    Returns: list of learning rate multipliers aligned with params
    """
    # compute per-tensor L2 norms (flattened)
    p_norms = [p.detach().pow(2).sum().sqrt() for p in params]
    g_norms = [g.detach().pow(2).sum().sqrt() for g in grads]

    def safe_ratio(pn, gn):
        # avoid divide-by-zero; if both near zero -> ratio = 1 (no scaling)
        gn_safe = torch.max(gn, torch.tensor(eps, device=gn.device))
        ratio = pn / gn_safe
        # if pn is near zero and gn small, set ratio=1 to avoid weird scaling
        near_zero = (pn <= eps) & (gn <= eps)
        if near_zero:
            return torch.tensor(1.0, device=pn.device)
        return ratio

    if group_by is None:
        # per-parameter multipliers
        multipliers = []
        for pn, gn in zip(p_norms, g_norms):
            r = safe_ratio(pn, gn)
            r_clipped = torch.clamp(r, min=lower, max=upper)
            multipliers.append((base_lr * r_clipped).item())
        return multipliers
    else:
        # group_by: iterable of iterables of param indices -> compute one multiplier per group
        group_mult = {}
        for group in group_by:
            # sum squares across group for a single group norm
            pn_group = sum(p.pow(2).sum() for i,p in enumerate(params) if i in group).sqrt()
            gn_group = sum(g.pow(2).sum() for i,g in enumerate(grads) if i in group).sqrt()
            r = safe_ratio(pn_group, gn_group)
            r_clipped = torch.clamp(r, min=lower, max=upper)
            lr = (base_lr * r_clipped).item()
            for i in group:
                group_mult[i] = lr
        return [group_mult[i] for i in range(len(params))]

Integration into optimizer step:- Compute grads via backward().- Collect params and grads (skip params with no grad).- Call layerwise_lr_multipliers to get per-param lr.- For each param: update using chosen optimizer rule (SGD/Adam) but replace base_lr with scaled lr (or multiply step by multiplier).- For adaptive optimizers (Adam), apply LAMB-style trust ratio: compute update direction, then apply param-wise scaling: param += -scaled_lr * update_dir / (1 + weight_decay).

Complexity: O(N) to compute norms and apply updates. Edge cases: zero-valued params/grads, sparse grads (handle separately), mixed precision (use float32 eps and casts). This implementation is agnostic to model size; for very large models compute norms in fp32 and aggregate across devices using all-reduce when using distributed training.

EasyTechnical

49 practiced

Define precision, recall, F1-score, ROC AUC, and PR AUC. For a highly imbalanced binary classification problem where false positives are costly, which metric(s) would you prioritize and why? Provide an example thresholding approach to meet a business constraint.

Sample Answer

Precision, recall, F1-score, ROC AUC, and PR AUC:- Precision = TP / (TP + FP). Fraction of predicted positives that are correct.- Recall (a.k.a. sensitivity) = TP / (TP + FN). Fraction of true positives detected.- F1-score = 2 * (precision * recall) / (precision + recall). Harmonic mean balancing precision and recall.- ROC AUC = area under ROC curve (TPR vs FPR across thresholds). Measures separability independent of threshold; can be misleading on imbalanced data because FPR may be very small yet produce high AUC.- PR AUC = area under Precision-Recall curve. Focuses on performance for the positive class; more informative on imbalanced datasets.

If false positives are costly (high FP cost) and dataset is highly imbalanced, prioritize precision and PR AUC (and precision at a target recall). ROC AUC is secondary; F1 can help if you want balance but may hide precision emphasis.

Example thresholding approach to meet a business constraint (e.g., precision ≥ 0.90):- On validation set, compute model scores, sweep thresholds t in [0,1].- For each t, compute precision(t), recall(t).- Select the threshold t* = argmax recall(t) subject to precision(t) ≥ 0.90 (or if none, pick t with highest precision).- Deploy with t* and monitor calibration; re-tune periodically.

Example code to pick t*:

python

import numpy as np
from sklearn.metrics import precision_recall_curve

scores = model.predict_proba(X_val)[:,1]
prec, rec, thresh = precision_recall_curve(y_val, scores)

target_prec = 0.90
valid = np.where(prec[:-1] >= target_prec)[0]  # precision array length = len(thresh)+1
if len(valid):
    # choose threshold with max recall among valid thresholds
    idx = valid[np.argmax(rec[valid])]
    t_star = thresh[idx]
else:
    # fallback: highest precision
    idx = np.argmax(prec[:-1])
    t_star = thresh[idx]

Monitor FP cost, calibrate probabilities (Platt/isotonic) if needed, and continuously validate on fresh data.

MediumTechnical

44 practiced

Coding (Python): Implement a stratified k-fold splitter that supports (a) binary and multiclass labels, (b) an optional time_group column where all rows in the same group must be kept in the same fold, and (c) a reproducible random seed. Focus on correctness and API rather than performance.

Sample Answer

Approach: treat each time_group (or each row if no time_group) as an atomic unit with a label-distribution vector. Shuffle groups reproducibly, then greedily assign each group to the fold that minimizes the current class-distribution imbalance (standard heuristic for stratified grouping).

python

import numpy as np
import pandas as pd
from collections import defaultdict

class StratifiedGroupKFold:
    def __init__(self, n_splits=5, random_state=None):
        self.n_splits = n_splits
        self.rng = np.random.default_rng(random_state)

    def split(self, X, y, time_group=None):
        """
        X: ignored (kept for API parity) but can be DataFrame/array length n
        y: array-like of labels (binary or multiclass)
        time_group: array-like same length as y, or None. All rows with same group must be in same fold.
        Yields: (train_idx, test_idx) index arrays
        """
        y = np.asarray(y)
        n = len(y)
        if time_group is None:
            groups = np.arange(n)  # each row its own group
        else:
            groups = np.asarray(time_group)
        # map group -> indices
        grp_to_idx = defaultdict(list)
        for i, g in enumerate(groups):
            grp_to_idx[g].append(i)
        unique_groups = list(grp_to_idx.keys())
        # compute label counts per group
        labels = np.unique(y)
        label_to_pos = {lab: i for i, lab in enumerate(labels)}
        grp_counts = {}
        for g in unique_groups:
            counts = np.zeros(len(labels), dtype=int)
            for i in grp_to_idx[g]:
                counts[label_to_pos[y[i]]] += 1
            grp_counts[g] = counts
        # shuffle groups reproducibly
        self.rng.shuffle(unique_groups)
        # initialize fold distributions
        fold_counts = [np.zeros(len(labels), dtype=int) for _ in range(self.n_splits)]
        fold_groups = [set() for _ in range(self.n_splits)]
        # greedy assignment: put group into fold that will minimize imbalance
        for g in unique_groups:
            best_fold = None
            best_score = None
            for f in range(self.n_splits):
                new = fold_counts[f] + grp_counts[g]
                # score: sum squared differences from ideal proportion
                total = np.sum([fc + (grp_counts[g] if idx==f else 0) for idx,fc in enumerate(fold_counts)], axis=0)
                ideal = total / self.n_splits
                score = np.sum((new - ideal)**2)
                if best_score is None or score < best_score:
                    best_score = score
                    best_fold = f
            fold_counts[best_fold] += grp_counts[g]
            fold_groups[best_fold].add(g)
        # yield indices
        for f in range(self.n_splits):
            test_idx = []
            for g in fold_groups[f]:
                test_idx.extend(grp_to_idx[g])
            test_idx = np.array(sorted(test_idx))
            train_idx = np.array([i for i in range(n) if i not in set(test_idx)])
            yield train_idx, test_idx

Key points:- Maintains label proportions across folds while keeping groups intact.- Reproducible via numpy.random.Generator seed.- Works for binary and multiclass by using one-hot-like count vectors.

Complexity: O(G * K * L) where G = #groups, K = n_splits, L = #classes (suitable since focus is correctness).

Edge cases:- Fewer unique groups than n_splits (some folds empty) — caller should validate.- Highly imbalanced labels may still be approximate; greedy heuristic not optimal but effective.

HardTechnical

54 practiced

Problem solving / security (hard): Propose a pragmatic and scalable plan to improve adversarial robustness of models in production. Cover training-time defenses (adversarial training, randomized smoothing), evaluation protocols (attack budgets, metrics), runtime detection/mitigation, and monitoring to detect ongoing adversarial activity.

Sample Answer

Requirements & goals:- Reduce worst-case degradation under realistic attack budgets (L_p, semantic), keep clean accuracy within acceptable drop (<5–10%), detect/mitigate live attacks, and scale to production inference rates.

Training-time defenses:- Adversarial training (PGD/Fast AT): incorporate strong projected-gradient attacks during training with curriculum (start small eps, increase) and mix clean+adv examples (e.g., 70/30) to balance accuracy.- Randomized smoothing for certified L2 robustness: train classifier and apply Gaussian smoothing at inference to provide provable L2 radius; use it for high-risk predictions.- Ensembling & model weight-space augmentation: small ensembles trained with different seeds/augmentations to diversify failure modes.- Preprocessing defenses: train with data transformed by common input filters (JPEG, bit-depth reduction) to harden against simple perturbations.- Distillation + adversarial fine-tuning: use robust teacher to transfer robustness where full AT is too costly.

Evaluation protocol:- Define threat model(s): L_inf (eps values relevant to input scale), L_2, and semantic (paraphrase, style) attacks for NLP/vision.- Attack budget examples: images 8/255 L_inf, 0.5 L2; NLP: word/sub-token substitutes with semantic similarity >= .8.- Use adaptive white-box attacks (PGD, CW, BPDA as needed), black-box attacks (NES, boundary), and query-limited attacks. Include randomized smoothing-specific certified bounds.- Metrics: robust accuracy at budget(s), certified radius coverage, clean accuracy, calibrated false positive/negative for detectors, time-to-detect, query-rate anomaly score.- Continuous red-team: automated adversary library + periodic human red-team.

Runtime detection & mitigation:- Detection: monitor per-input signals — prediction confidence, gradient-norms, ensemble disagreement, input reconstruction error (autoencoder), statistical tests vs training distribution (Mahalanobis, ODIN-like).- Mitigation pipeline: if detector flags: 1) apply robust fallback (smoothed model / ensemble majority), 2) trigger input sanitization (denoise, re-tokenize/paraphrase) and re-evaluate, 3) escalate high-risk cases to conservatively reject or route to human review for sensitive ops.- Rate-limiting & query-throttling to prevent probing attacks; add per-IP/user exponential backoff + CAPTCHAs for public APIs.

Monitoring & operationalization:- Telemetry: log inputs (hashed/obfuscated for privacy), model confidences, detector scores, gradient-based features, query patterns, and downstream outcomes.- Alerts & thresholds: anomalous spike in low-confidence or high-detector-score inputs, sudden drop in clean/robust eval metrics, unusual query distribution. Define SLA for investigation.- Canary datasets & synthetic attacks: continuously run internal adversarial tests in CI against deployed model (daily) and compare to baseline; gate deployments on no-regression.- Drift detection: embed concept-drift monitors (KL divergence over feature embeddings) and trigger retrain/finetune pipelines.- Post-incident: forensic capture, replay attacks in sandbox, update training regimen, rotate models/ensembles.- Governance: document threat models, periodic risk reviews, maintain reproducible attack-playbooks and recovery runbooks.

Trade-offs & scalability:- Adversarial training is compute-heavy; use mixed precision, short fine-tune schedules, and selective AT on critical layers or distilled smaller models for edge.- Randomized smoothing adds inference cost (multiple noise samples); apply only to high-risk endpoints or sample-efficient certification techniques.- Balance false positives from detectors vs availability—use multi-signal fusion and progressive mitigation (sanitization before rejection).

Summary: combine robust training (AT + smoothing + ensembles), rigorous adaptive evaluation, layered runtime detection+fallbacks, and continuous telemetry + red-teaming. Prioritize defenses by risk (sensitive endpoints first), automate CI/monitoring, and iterate based on observed attacks.

Unlock Full Question Bank

Get access to hundreds of Model Training and Selection interview questions and detailed answers.

Join thousands of developers preparing for their dream job.