Machine Learning Fundamentals

References

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

1. Dive into Deep Learning: Generalization in Deep Learning

   Inductive biases are assumptions or preferences favoring solutions with particular properties. Optimizing training loss and obtaining useful predictions on new examples are different problems. The chapter explains that neural networks can fit arbitrary training labels and that generalization need not worsen monotonically as model complexity increases; double-descent behavior is one counterexample to a universal single U-shaped complexity curve.

2. PyTorch Quickstart: forward computation, training, and loading

   Tensors hold shaped numerical data: a batch has dimensions for examples and features, while parameter tensors hold learned weights and biases. Forward computation applies the network's layers to input tensors using those parameters, producing prediction scores. Training additionally compares predictions with targets through a loss, calls backward() to compute parameter gradients, and calls optimizer.step() to update parameters; zero_grad() clears accumulated gradients. Loading recreates the architecture and restores its state dictionary. The example then predicts using eval() and no_grad(), without loss-driven parameter updates. Computing a loss for evaluation does not itself train the model.

3. PyTorch 2.9: Reproducibility

   PyTorch distinguishes random-number use from nondeterministic implementations. Seeding can reproduce a random-number sequence within a controlled environment, while deterministic-algorithm settings select deterministic alternatives or reject known nondeterministic operations. Identical seeds still do not guarantee identical results across releases, platforms, or CPU and GPU execution. Deterministic operations may also be slower.

4. Google: Supervised learning foundations

   Features are input values x; a label y is the target recorded for an example. Parameters θ are learned numbers defining a model fθ. Training repeatedly compares predictions with labels using a loss and adjusts these numbers to improve agreement. Inference evaluates the trained function on a new input without needing its label. Generalization means performing well on examples outside training; evaluation therefore compares predictions against withheld labels. Programmer-oriented illustration: training fits w and b in f(x)=wx+b from examples, whereas an authored rule such as if x>c executes a programmer-specified condition. Both execute code at inference, but the origin of their decision behavior differs.

5. Dive into Deep Learning: Linear Regression

   Linear regression predicts y_hat=b+sum_j(w_j*x_j). Each dataset row supplies features, while weights and bias are shared fitted parameters. Observed targets can differ from predictions because measurements contain noise. Squared loss penalizes each residual quadratically; averaging these losses produces the empirical training objective. Doubling a residual quadruples its squared contribution. Ordinary least squares also admits analytic fitting, so training need not always use iterative gradient updates. Learning rate and batch size are hyperparameters rather than values updated by the ordinary fitting loop.

6. Scikit-learn: scoring rules and baseline estimators

   Evaluation tools accept an explicit scoring rule; classification accuracy is sum_i 1[prediction_i=target_i]/n. Dummy estimators provide sanity-check baselines such as always selecting the training set's most frequent class. Accuracy can conceal poor minority-class performance, motivating metrics such as balanced accuracy. Methodological inference for technical tasks: define the correctness criterion and baseline before selection, evaluate candidates on the same validation cases, and apply the frozen criterion to the final test set. A syntax check, exact-answer comparison, and executable task test measure different properties.

7. scikit-learn: Preprocessing data

   One-hot encoding represents a categorical feature using one binary column per category: the matching column is 1 and the others are 0. Unlike arbitrary integer codes, this does not impose a numeric ordering among categories. Standardization transforms each nonconstant feature as z_j=(x_j-mu_j)/s_j, using the mean and standard deviation fitted on training examples and retained for later inputs. Combining this transformation with the squared-Euclidean objective in reused note web-ml-kmeans-objective-and-assumptions gives distance squared sum_j((x_j-x'_j)/s_j)^2. Thus centering cancels in pairwise differences, while relative scaling changes each feature's contribution and can change cluster assignments.

8. TravisTorrent: Data Format

   Each TravisTorrent row represents a build job and combines repository information, Travis API fields, and build-log analysis. The schema distinguishes build and job identifiers, API-reported build status and full build duration, and log-derived setup, test, and build-command durations. It also records project identity and repository attributes. These distinctions support explicitly choosing the prediction unit and duration target before constructing a learning dataset.

9. scikit-learn: Common pitfalls and recommended practices

   Preprocessing transformations learned during training must also be applied to later inputs. Fit transformation state on training data, then use transform on held-out or production data without refitting. Leakage occurs when model construction uses information unavailable at prediction time, including test-derived preprocessing statistics. Pipelines combine transformations with estimators and fit them on the appropriate training subset during cross-validation. The documentation demonstrates that selecting features before splitting can produce misleading performance even with randomly assigned targets.

10. The Selective Labels Problem: Evaluating Algorithmic Predictions in the Presence of Unobservables

    Observed outcomes can depend on earlier human decisions, so the labeled sample need not represent the people on whom a replacement model would act. This paper studies bail decisions: a release outcome is observed only for defendants released. Evaluating on that selected subset can misstate performance for a new decision policy. The same structural concern applies to underwriting when repayment outcomes are observed only for granted loans; that financial example is an inference from the mechanism, not an experiment in this paper.

11. Stop Burning Tokens: Why self-improvement needs domain expertise first - Annabell Schäfer, Langfuse

    Deterministic scoring can conceal ambiguity in the labels being treated as ground truth.

12. L2 regularization and generalization

    L2 regularization penalizes sum_j(w_j^2); training minimizes predictive loss plus lambda times that penalty. Combining this documented penalty with binary log loss gives a beginner objective J(w,b)=-(1/N)*sum_i[y_i*log(p_i)+(1-y_i)*log(1-p_i)]+lambda*sum_j(w_j^2), with p_i=sigmoid(b+w·x_i). Here the intercept is deliberately left unpenalized. Overfitting means fitting training-specific patterns that fail to generalize to unseen examples. Increasing lambda discourages large weights but excessive shrinkage can impair predictions; lambda=0 removes the penalty. Select its strength using validation performance. Early stopping instead halts training when validation loss starts worsening.

13. scikit-learn: Decision Trees

    Decision trees learn rules from features and produce piecewise-constant predictions. Training recursively partitions examples using a feature and threshold, grouping similar target values. Candidate splits are evaluated using a task-dependent loss or impurity measure. This contrasts with a single weighted linear relationship and illustrates fitting through discrete split selection rather than gradient descent. The documented CART implementation constructs binary trees.

14. Rumelhart, Hinton and Williams: Learning Representations by Back-Propagating Errors

    The 1986 paper addresses how intermediate units can learn useful features when training examples specify only desired outputs. A forward pass computes activations; a backward pass applies the chain rule to calculate how each weight affects output error. Those derivatives support gradient-based weight updates. Its demonstrations include learning mirror symmetry and representations of family relationships. Unlike fixed feature analyzers, the intermediate representations change through training.

15. Geirhos et al.: Shortcut Learning in Deep Neural Networks

    Geirhos and colleagues define shortcuts as decision rules that perform well under standard testing conditions but fail under more challenging conditions. Their toy classification example permits shape-, size- and location-based rules to succeed on training and same-distribution test examples; systematically changing size or location distinguishes those rules. They identify architecture, data and training choices as sources of inductive bias that affect which rule is learned.

16. Legendre: Nouvelles méthodes pour la détermination des orbites des comètes

    Adrien-Marie Legendre's 1805 work presents the “method of least squares” for overdetermined observational equations: choose unknown quantities so the sum of squared errors is minimized. Its appendix derives the resulting equations and shows that, when estimating one quantity from repeated observations, minimizing squared deviations yields their arithmetic mean. Legendre applies the method to astronomical and meridian measurements.

17. Rosenblatt: The Perceptron—A Probabilistic Model for Information Storage and Organization in the Brain

    Rosenblatt's 1958 paper at Cornell Aeronautical Laboratory investigated recognition and generalization through a network whose effective signal strengths change with experience. Its simplified perceptron combines sensory inputs, association units and competing responses. Reinforcing active association units makes the corresponding response more likely on subsequent presentations. The paper analyzes several reinforcement dynamics rather than describing a single universal learning rule.

18. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding

    BERT constructs prediction targets from ordinary text: selected token positions are corrupted, and training predicts the original tokens using cross-entropy. The original text supplies the answers without separate human annotation for each prediction. This is a concrete example of self-supervised target construction, distinct from grouping observations into clusters. The paper subsequently fine-tunes pretrained parameters for downstream tasks.

19. How We Built Zeta2: Training an Edit Prediction Model in Production — Ben Kunkle, Zed

    Zeta2's distillation pipeline checks frontier-model predictions for task-specific failures and repairs flagged outputs before using them as student targets.

20. scikit-learn: Clustering

    K-means divides observations into a chosen number of groups represented by centroids, the groups' mean feature vectors. It seeks to minimize within-cluster squared Euclidean distances. Its objective favors compact, isotropic groups and can behave poorly for elongated or irregularly shaped clusters. This provides an explicit learning objective without externally supplied category targets.

21. Reinforcement Learning: An Introduction — second-edition draft

    Reinforcement learning improves a policy using rewards from interaction rather than labels specifying demonstrated actions. The objective is expected return: G_t = sum_k gamma^k R_(t+k+1), with gamma controlling discounting. In a finite episode with only terminal reward R_T, this reduces to gamma^(T-t-1)R_T: the outcome evaluates a trajectory without identifying which earlier decisions helped. Temporal credit assignment propagates that information to earlier choices. Monte Carlo methods update from completed returns; TD prediction uses V(s) <- V(s) + alpha[r + gamma V(s') - V(s)], bootstrapping from the next state's estimate. Policy improvement then favors actions with higher expected return; prediction updates alone do not change the policy.

22. scikit-learn: Mean absolute error

    For residuals e_i=y_i−ŷ_i, mean absolute error is MAE=(1/n)Σ|e_i|, whereas mean squared error is MSE=(1/n)Σe_i². MAE therefore penalizes residual magnitude linearly: doubling an error doubles its contribution. MSE uses a quadratic penalty: doubling an error quadruples its contribution, so large residuals exert relatively greater influence.

23. Logistic regression: binary log loss

    For N examples with binary labels y_i and predictions p_i, mean log loss is L=-(1/N)*sum_i[y_i*log(p_i)+(1-y_i)*log(1-p_i)]. A positive example contributes -log(p_i); a negative contributes -log(1-p_i). Confident incorrect predictions receive large penalties. Training adjusts parameters to reduce this loss, with regularization limiting overfitting. Mathematical application: when labels encode clicks, the objective rewards predicting those labels, not independently measured utility. Replacing labels or weighting examples changes the training objective and can change the interpretation of the output.

24. Training language models to follow instructions with human feedback

    The training loop separates demonstrations, ranked responses, and fresh policy rollouts. A scalar reward model learns preferences via -log sigmoid(r(x,y_w)-r(x,y_l)); the absolute score is less meaningful than the difference for the same prompt. PPO then generates responses and optimizes their learned reward with a per-token penalty for departure from the supervised reference. In expectation the log-probability-ratio penalty gives KL(pi_theta || pi_ref). A learned value function estimates expected return for advantage estimation. The paper also mixes pretraining gradients into some RL runs to reduce regressions on retained NLP tasks. It partitions prompts by user identity, rather than randomly splitting near-related prompts across sets.

25. Weak supervision needs evaluation beyond supervisor agreement

    Oversight becomes difficult when an evaluator cannot reliably judge behavior available to a stronger model: matching its labels can reproduce its mistakes. The paper trains a weak model on ground-truth labels, obtains its predictions on held-out examples, and trains a stronger student on those weak labels. It compares ground-truth test performance with both the weak supervisor and a strong model trained directly on ground truth. Performance gap recovered is PGR=(student-weak)/(strong_ceiling-weak), requiring a nonzero denominator. PGR=0 means no improvement over the supervisor; PGR=1 matches the experimental ceiling. Independent correctness scores and agreement on supervisor-wrong examples distinguish useful generalization from imitation. Experiments show task-dependent generalization and overfitting to weak labels; an auxiliary confidence loss improves some NLP results.

26. Minibatch Stochastic Gradient Descent — Dive into Deep Learning

    Training evaluates a loss on a batch, differentiates it with respect to model parameters, and updates those parameters. In minibatch SGD, the update subtracts the learning rate times the mean example gradient: theta_next = theta - eta * mean_i gradient_theta loss_i. A gradient indicates local sensitivity of the chosen loss, not a symbolic edit to a particular rule. Minibatches trade statistical noise against efficient vectorized computation; changing batch size changes both optimization and execution behavior.

27. PyTorch: Optimizing Model Parameters

    Supervised examples pair inputs x with target labels y. A parameterized function fθ predicts from x; a loss measures disagreement with y. Training repeatedly computes predictions, loss, gradients and parameter updates. For ordinary gradient descent, θ ← θ − η∇θL, where η is the learning rate and L is the batch loss. PyTorch implements this through backward() and optimizer.step(), clearing accumulated gradients between updates. Ordinary inference evaluates fθ on new inputs without an optimizer update. The example uses model.eval() for evaluation behavior and no_grad() to avoid constructing gradients.

28. Training an LLM from Scratch, Locally

    Use a short low-rate warm-up, increase to a peak, and then reduce the learning rate with cosine decay.

29. Robbins and Monro: A Stochastic Approximation Method

    Herbert Robbins and Sutton Monro's September 1951 paper studies finding a value x where an unknown expected response M(x) equals a target a when experiments return noisy observations Y(x). Their recursive procedure chooses successive experimental levels and updates the estimate using the latest response and a positive step-size sequence. Under stated monotonicity, boundedness and step-size conditions, they prove convergence in probability.

30. Language Models are Few-Shot Learners

    Few-shot inference supplies demonstrations as input conditioning while keeping model weights fixed; fine-tuning changes pretrained weights through training. Examples consume bounded context and influence subsequent predictions without becoming parameter updates. Separately, benchmark contamination means evaluation material overlaps training data, weakening claims of generalization to unseen examples. GPT-3's study compares original scores with subsets lacking detected n-gram overlap, but acknowledges false positives and possible distribution differences between clean and original subsets. Conceptually, contamination concerns exposure to evaluation data; optimizing a proxy concerns objective mismatch, while biased reviewer labels concern measurement. Those problems can occur independently.

31. Dive into Deep Learning: generalization in classification

    For a fixed classifier f, empirical error on n labeled examples is sum_i 1[f(x_i) != y_i]/n. Population error is the expectation of that disagreement over the underlying data distribution. A fresh representative test set estimates population error; fitting or memorizing training examples does not establish performance on unseen examples. Consequently, a deterministic predictor can repeatedly return the same incorrect answer: repeatability constrains computation, not agreement with the target. This last statement is an inference from the fixed-classifier definition, not a measured claim about a particular LLM.

32. NIST/SEMATECH e-Handbook: How do we Use the Model Beyond the Data Domain?

    Interpolation predicts within the domain covered by observed inputs; extrapolation predicts outside it. Good fit at observed points does not guarantee good predictions farther away. Extending a fitted relationship beyond observations assumes that its form remains useful there; an empirical equation does not automatically incorporate the underlying engineering mechanism. NIST recommends additional confirmatory observations for both kinds of prediction. Applied to a constructed single-input build-size example, more frequent large projects within the historical size range remain within the interpolation domain, whereas sizes beyond that range require extrapolation.

33. scikit-learn: Cross-validation for grouped and time-series data

    Groups of dependent observations violate ordinary independent-sample assumptions. Group-aware splitting keeps selected groups out of training when assessing them. Time-series splitting instead trains on earlier folds and evaluates later observations. These address different dependencies: holding out an entity and forecasting its future are different evaluation questions.

34. Google ML Crash Course: Dividing Datasets

    Training data fits model parameters; validation data guides model and hyperparameter choices; a held-out test set evaluates the selected system. Repeatedly modifying the system in response to test results indirectly fits that test set even without gradient updates on its examples. Validation sets can also become overused. Test data should be sufficiently large, representative of deployment and free of training duplicates. Engineering application: prevent related records or future information from leaking across splits when deployment requires generalization across entities or time.

35. Generalization in Adaptive Data Analysis and Holdout Reuse

    Selecting later analyses using earlier results makes the selection depend on the reused dataset. Aggregate scores can therefore influence selection even when individual test cases remain hidden; ordinary fixed-analysis guarantees no longer follow automatically. Engineering application: after using evaluation failures or scores to revise a coding agent, retain useful failures for regression testing but evaluate the revised configuration on fresh, independently sampled untouched cases for an ordinary holdout claim. Reuse is possible under specialized safeguards: Thresholdout compares training and holdout averages using noisy thresholds, releases controlled answers and stops when its overfitting budget is exhausted.

36. Cawley and Talbot: On Over-fitting in Model Selection and Subsequent Selection Bias in Performance Evaluation

    Cawley and Talbot show that optimizing hyperparameters against a finite-sample model-selection criterion can overfit that criterion, even though those choices are not ordinary fitted parameters. Their experiments demonstrate optimistic performance estimates when model selection is conducted outside the resampling process. They argue that selection must be treated as part of fitting and repeated independently within each evaluation trial, as in nested cross-validation.

37. Cross-validation and held-out evaluation

    Testing on data used to fit or repeatedly tune a system can overestimate generalization. The documentation separates training, validation for selection, and an untouched final test set; cross-validation does not eliminate the need for final held-out evaluation. Applied to model judges, tune rubrics and examples on calibration data, freeze the judge, then measure agreement with independent human labels on unseen examples. Applied to context policies, select retrieval and compression settings on development tasks and evaluate the selected policy on held-out tasks. Repeatedly changing settings after seeing test results converts that test set into development data.

38. scikit-learn: DummyRegressor

    DummyRegressor with strategy='mean' learns the mean of the training targets and returns that constant for every prediction. Its predictions disregard input features. This supplies a concrete regression baseline against which a feature-dependent predictor can be assessed; median and specified-quantile strategies provide alternative constant predictions.

39. NIST: Confidence Intervals for a Proportion

    An observed proportion estimates a population rate with sampling uncertainty. NIST's published example finds four defective items among twenty, an observed rate of 20%; its displayed exact-binomial bounds for a 90% interval are approximately 7.1% and 40.1%. Applied to independent pass/fail evaluations, such an interval concerns the underlying error rate, not an interval of possible outcomes for one case. Small samples or few failures make simple normal approximations unreliable.

40. Dive into Deep Learning: Model Selection, Underfitting, and Overfitting

    The chapter contrasts insufficiently expressive models with models that fit training examples much better than validation examples. Its polynomial example varies model complexity and dataset size. Increasing polynomial degree enlarges the available function family and cannot increase the best achievable training fit error, but does not ensure better predictions. A fair-coin example shows how a finite sample's majority class can look more predictable than the underlying process actually is.

41. Hoerl and Kennard: Ridge Regression—Biased Estimation for Nonorthogonal Problems

    Hoerl and Kennard's February 1970 paper addresses unstable least-squares coefficients when predictors are strongly related. Ridge estimation introduces a positive adjustment that shortens the coefficient vector, accepting bias to reduce sensitivity to the observed sample. Their analysis separates squared bias from parameter-estimation variance and establishes conditions under which their sum is smaller than for ordinary least squares. Regularization therefore has statistical roots in stabilizing estimation, rather than originating as a neural-network remedy.

42. scikit-learn: Validation Curves—Plotting Scores to Evaluate Models

    A sample-size learning curve compares training and validation scores while varying the number of training examples. A validation curve instead varies a hyperparameter. These answer different questions: whether additional examples might help, versus how a modeling choice changes fit and generalization. In the documentation's examples, some models retain low training and validation scores as data grows, whereas others show a gap that additional examples can reduce.

43. NIST: How Can I Predict the Value and Estimate the Uncertainty of a Single Response?

    A point prediction supplies one estimated outcome. A prediction interval describes uncertainty about a new observation, whereas a confidence interval for the mean response concerns the estimated average at specified inputs. In NIST's regression setting, prediction uncertainty includes both uncertainty in the estimated mean and variation of the new observation. Increasing the training sample can narrow uncertainty about the mean while leaving substantial uncertainty about an individual outcome. Nominal interval coverage is a repeated-sampling property under the construction's assumptions.

44. Hüllermeier and Waegeman: Aleatoric and Epistemic Uncertainty in Machine Learning

    Aleatoric uncertainty is unresolved outcome variation given the available inputs; epistemic uncertainty is limited knowledge about the predictive relationship. Even knowing the outcome distribution can leave an individual outcome uncertain. Additional examples can reduce uncertainty about the fitted relationship without removing that variation. The distinction depends on the information and model available: adding an informative feature can resolve variation that previously appeared irreducible. Uncertainty about a particular future outcome also differs from uncertainty about the model's average risk.

45. Jürgens et al.: Is Epistemic Uncertainty Faithfully Represented by Evidential Deep Learning Methods?

    Different internal uncertainty representations can produce the same predictive distribution. For the paper's unregularized inner-loss objectives with Dirichlet or normal-inverse-gamma representations, multiple parameter settings yield identical outcome predictions but different reported epistemic uncertainty. Thus, fitting observed outcomes alone need not uniquely determine a decomposition into uncertainty sources.

46. AI Engineering 201: Inference

    Log probabilities expose information about generation that text-only responses conceal, but proprietary APIs can restrict that visibility.

47. Guo et al.: On Calibration of Modern Neural Networks

    Confidence calibration asks whether predictions assigned a probability of correctness p are correct with frequency p. For example, predictions assigned 0.8 confidence should be correct about 80% of the time, rather than every prediction being individually guaranteed. Reliability diagrams compare observed accuracy and average confidence within probability bins. The paper demonstrates that a classifier can have better accuracy yet worse calibration: its CIFAR-100 ResNet is more accurate than its LeNet comparison but substantially overconfident.

48. Ovadia et al.: Can You Trust Your Model's Uncertainty?

    The study evaluates uncertainty on original test data, shifted inputs and entirely different datasets. Its experiments show that calibration obtained on an ordinary validation distribution need not persist after shift. On rotated or translated MNIST, methods with similar accuracy can differ in probability quality and confidently wrong predictions. CIFAR-10 and ImageNet corruption experiments also show worsening accuracy and calibration as corruption increases.

49. Hébert-Johnson et al.: Multicalibration—Calibration for the Computationally-Identifiable Masses

    Assigning everyone in a population its average outcome probability can satisfy population-level calibration while ignoring substantial differences within that population. Consequently, aggregate calibration does not establish useful individual discrimination or calibration within every subgroup. The paper motivates checking calibration across specified, potentially overlapping subpopulations rather than relying only on a pooled result.

50. Elkan: The Foundations of Cost-Sensitive Learning

    A decision should minimize expected consequences, using probabilities and a consistently defined cost matrix. The most probable class need not produce the best action. For binary decisions with zero cost for correct decisions, false-positive cost C_FP and false-negative cost C_FN, choose positive when C_FP(1-p) is no greater than C_FN p. Rearranging gives the threshold p >= C_FP/(C_FP+C_FN). This is an algebraic specialization of the paper's decision rule, not an empirical result.

51. Axelsson: The Base-Rate Fallacy and the Difficulty of Intrusion Detection

    The fraction of alerts that correspond to real events depends jointly on event prevalence, detection rate and false-positive rate. A small false-positive rate can produce many false alarms when non-events dominate. Constructed illustration: among 10,000 cases with 100 events, 80% event detection yields 80 true alerts and 20 misses; a 1% false-positive rate among 9,900 non-events adds 99 false alerts. Only 80 of 179 alerts are then true. These counts illustrate the paper's probability relationship.

52. Geifman and El-Yaniv: Selective classification and risk control

    A selective classifier combines prediction f(x) with acceptance g(x)∈{0,1}; g=0 means abstain. Coverage is φ=P(g(X)=1). With positive coverage, selective risk is R=E[loss(f(X),Y)g(X)]/φ, the error among accepted predictions. Raising a confidence threshold rejects more inputs; error falls only if the score usefully orders mistakes. The paper's SGR procedure uses labeled examples and binomial upper bounds, adjusted for its threshold search, to bound accepted-set error with a specified failure probability δ. A target error is supported only when the returned bound meets that target.

53. Agents reported thousands of bugs, how many were real? - Ian Butler and Nick Gregory

    An agent can find a real defect yet be impractical to use when it surrounds that finding with many false alarms.

54. Dive into Deep Learning: environment and distribution shift

    Distribution shift occurs when deployment data follow a different distribution from training data. Covariate shift changes P(X) while retaining P(Y|X); label shift changes P(Y) while retaining P(X|Y). Such assumptions describe different failure and correction conditions. Performance estimated on the source distribution need not transfer to the target distribution. Unlike sampling randomness, which changes token choices for given scores, distribution shift changes which inputs and targets the predictor encounters. That comparison is a synthesis with the generation documentation.

55. Dive into Deep Learning: Concept Shift

    Concept shift can change the conditional relationship P(Y|X), rather than only the frequency of inputs. The textbook illustrates this through changing category definitions and geographical differences in names for the same objects.

56. Rabanser, Günnemann and Lipton: Failing Loudly

    Detecting changed input distributions and establishing degraded predictions are different tasks. The paper reports a COIL-100 rotation-angle split where detected shift did not harm the tested classifier. Directly measuring target error requires target labels; the authors investigate labeling selected anomalous examples as a heuristic. Their input-distribution test does not test the input-outcome relationship. Consequently, a change confined to that relationship could escape an input-only test; this last statement follows from the test's defined null hypothesis.

57. Ross, Gordon and Bagnell: A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning

    Ross, Gordon and Bagnell show why sequential prediction differs from ordinary fixed-input supervised learning: a policy's action changes the observations it encounters later. Training only on expert-encountered states can therefore leave a learned policy unprepared for states caused by its own mistakes. DAgger iteratively executes a policy, obtains expert actions for encountered states and aggregates those examples so training better covers the policy-induced state distribution.

58. Agents are Robots Too: What Self-Driving Taught Me About Building Agents — Jesse Hu, Abundant

    Departures from human-demonstration trajectories can put an agent into unfamiliar states and compound its errors; the talk connects this to DAgger and out-of-distribution behavior.

59. Hernán and Robins: Causal Inference—What If

    A causal effect compares outcomes under alternative interventions. A counterfactual outcome describes what would occur under a specified action. Shared causes of action and outcome create confounding: their observed association includes a path other than the action's effect.

60. When observational action records identify causal effects

    For action A, pre-action covariates L and potential outcome Y^a, standard adjustment identifies E[Y^a]=sum_l E[Y|A=a,L=l]P(L=l) under consistency, conditional exchangeability and positivity. Consistency links observed outcomes to a sufficiently specified intervention. Exchangeability requires Y^a independent of A given L: measured covariates adequately remove action-outcome confounding. Positivity requires P(A=a|L=l)>0 wherever the target population has support. Unmeasured common causes can invalidate exchangeability; actions never taken in relevant states leave their effects unidentified by this adjustment. Predictive accuracy on observed actions does not repair either failure.

61. Feature attribution is not a real-world intervention effect

    Attribution methods distribute a prediction's difference from a reference value among input features. Results depend on how omitted features are averaged: conditioning on observed features preserves statistical associations, whereas intervening on model inputs and averaging other inputs marginally asks a different question. The paper shows that conditional attribution can assign relevance to a correlated feature the predictor does not use. Its intervention concerns inputs to a computational predictor, explicitly distinguished from causal relations among real-world variables. Therefore, changing a feature's attribution or changing that input in software does not establish how an intervention on the corresponding real-world quantity changes the actual outcome.

62. Holland: Statistics and Causal Inference

    A unit's causal effect compares its potential outcomes under two specified treatments, but only the outcome under the received treatment is observed. Population averages offer a statistical route around this missing comparison. Random assignment makes treatment assignment independent of potential outcomes, allowing differences in observed group averages to estimate the average effect. Without that independence, the observed association need not equal the causal effect. An average effect also need not describe the effect on a particular unit.

63. Perdomo et al.: Performative Prediction

    When predictions guide actions, deploying a predictor can change the distribution of future inputs and outcomes. The paper formalizes this by making the data distribution depend on the deployed model. Traffic predictions influencing traffic patterns are one motivating example. Fitting the historical distribution is then different from performing well on the distribution produced by acting on the model. Repeated retraining is not automatically a solution; convergence requires additional conditions.

64. Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

    The human-AI interaction loop is cyclical: interfaces that encourage rubber-stamping can turn model-influenced approvals into misleading evaluation and training labels.

65. Rolling-origin forecast evaluation

    Time-series cross-validation moves the forecast origin forward. At each origin T, the training set contains only earlier observations, and forecasts are scored against subsequent observations. Repeating this produces an out-of-sample error series; multi-step evaluation scores the horizon actually needed rather than only one-step predictions. Engineering consequence: preprocessing, model fitting and model selection must respect each origin's information boundary. Using a future observation anywhere in constructing its forecast defeats the chronological split.

66. How Autoresearch Is Changing ML Research — Zhengyao Jiang, Weco AI

    In the reported fraud-detection experiment, separating test-data access from training preprocessing removed observed leakage that had inflated scores under a shared API.

67. Beyond Static Intelligence: Evaluating Continual Learning

    Repeated SQL question answering can test whether retained schema knowledge reduces exploration, while simulated migrations test whether the agent discards obsolete knowledge.

68. How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS

    The MLP combines weighted inputs and biases with activation functions, connecting successive neuron layers through dense transformations.

69. How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS

    The foggy-mountain analogy presents optimization as using local slope information to seek parameter settings with lower prediction error.

70. Stop Burning Tokens: Why self-improvement needs domain expertise first - Annabell Schäfer, Langfuse

    Use separate fit, validation, and untouched test datasets, with distinct roles in the optimization loop.

71. Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

    The When Machines Mislead case study inserted fake copy-typing alerts into legitimate historical exam sessions and found that skilled proctors accepted half of those alerts.