Machine Learning (ML)

From PRIMO.ai
Jump to navigation Jump to search

YouTube ... Quora ...Google search ...Google News ...Bing News


Machine learning (ML) is a field devoted to understanding and building methods that let machines "learn," that is, methods that leverage data to improve computer performance on some set of tasks. It is seen as a broad subfield of artificial intelligence. Machine learning algorithms build a model based on sample data, known as training data, in order to make predictions or decisions without being explicitly programmed to do so. - Machine learning | Wikipedia

Put more plainly: in ordinary programming, a person writes the rules and the computer applies them to data. In machine learning, a person supplies data and a goal, and the computer works out the rules. That shift is why ML now sits underneath spam filters, fraud detection, product recommendations, medical image analysis, speech recognition, weather forecasting, and the large language models behind chat assistants.

The idea is older than most people assume. Arthur Samuel of IBM popularized the term "machine learning" in 1959 with a checkers program that improved by playing against itself. Frank Rosenblatt's perceptron (1958) showed that a simple artificial neuron could learn to classify patterns. Tom Mitchell's widely used 1997 textbook gave the field its standard working definition: a program learns when its performance on some task, measured by a chosen metric, improves with experience. Later milestones came from statisticians and computer scientists such as Leo Breiman (decision trees and random forests), Vladimir Vapnik (statistical learning theory and support vector machines), and Geoffrey Hinton, Yann LeCun, and Yoshua Bengio (deep learning). Today the frontier is pushed mostly by industry labs such as Google DeepMind, OpenAI, Anthropic, Meta, and DeepSeek, alongside universities and open-source communities like Hugging Face.

The problem ML addresses is that many useful tasks are too complicated, too fuzzy, or too fast-changing to specify by hand. Nobody can write explicit rules that recognize every handwritten "7" or every fraudulent transaction, but it is often possible to collect thousands or millions of examples. The central mechanism is optimization: choose a flexible family of functions, define a loss that measures how wrong a function's predictions are, and adjust the function's parameters to make that loss small on the training data, while checking that it also performs well on data it has never seen.

The paradigm shift happened in stages. Early ML relied heavily on human-designed features fed into relatively simple models. From around 2012, deep learning let models learn their own features directly from raw pixels, audio, and text. From around 2018, self-supervised pretraining on enormous unlabeled datasets produced foundation models that can be adapted to many tasks with little task-specific data. And since late 2024, a further shift has emphasized reinforcement learning and extra computation at inference time to produce models that work through problems step by step. Each stage moved more of the work from human rule-writing and feature design to data, compute, and optimization.


Machine learning replaces hand-written rules with rules learned from data. Its power and its failures come from the same source: a model learns whatever patterns the data and the objective reward, no more and no less.


The Mechanism

Let’s take a moment to point out the main building blocks of a machine learning algorithm. The complete process of machine learning can be observed as a pipeline.



At the beginning of that pipeline is, of course, data. Data can come from different sources. Other systems can generate it or humans can create it. Sometimes we use web scrapers to get the data from the web, while other times data is available in some database. More often than not, this data is unstructured and sparse. This can be a problem for algorithms, which is why the second step of the pipeline is pre-processing of the data and Feature Exploration/Learning. After data is preprocessed and prepared, we feed it to our machine learning algorithm. This is called the training process, during which the algorithm needs to learn. The machine learning algorithm itself contains different parameters within itself which make this learning possible. What do we mean by this? Well, based on these input values the algorithm creates predictions: output values. However, those predictions are not the only output that this algorithm provides.



In Supervised Learning, we have the expected output, so we can use it to calculate how much predictions deviate from the expected results. For this, we can use different functions and measure the penalty in different ways. This function is called the loss function and the goal of the algorithm is to minimize the penalty calculated by this function. In mathematics, the expression we minimize or maximize is called an objective function. Then we use the calculated penalty to change the parameters of the machine learning algorithm to get better predictions next time. In general, this is done by minimizing the penalty we calculated. That is how the machine learning algorithm, not only produces the output values during the training process, but it changes itself so it can improve its predictions. That is how the implicit output of a machine learning algorithm is the algorithm itself. The trained algorithm is usually called the model. This name comes from mathematics. - Introduction to Machine Learning with C# and ML.NET - Rubik's Code

In practice, a complete ML project runs through these stages:

  1. Frame the problem. Decide exactly what to predict, for whom, and how success will be measured. A model that predicts "churn" is useless if nobody agreed whether churn means canceling within 30 days or 90.
  2. Collect and label data. Gather examples that resemble the conditions the model will face in use. For supervised learning, each example needs a correct answer (a label), which is often the most expensive part of the project.
  3. Prepare features. Clean errors, handle missing values, encode categories, and scale numbers. In classical ML, much of the skill lies in designing informative features; deep learning automates much of this by learning representations, or embeddings, directly.
  4. Split the data. Hold out separate sets for training, for tuning choices (validation), and for a final unbiased estimate (test). See Train, Validate, and Test. Everything learned from data, including scaling factors and feature selection, must come from the training split only, or the evaluation will be optimistic.
  5. Choose a model family. Options range from linear models and decision trees to gradient-boosted ensembles and neural networks; see Algorithm Families at a Glance below and Discriminative vs. Generative.
  6. Train. Run an optimization algorithm that adjusts parameters to reduce the loss, usually some variant of gradient descent.
  7. Evaluate and analyze errors. Measure performance on held-out data with metrics that reflect the real goal, then study the mistakes to decide whether the fix is more data, better features, a different model, or a different problem definition.
  8. Deploy and monitor. Put the model into a product or workflow, then watch for drift as the world changes. See MLOps.

Learning paradigms. The kind of data available determines the kind of learning:

Paradigm What the data looks like What the model learns Typical examples
Supervised Inputs paired with correct outputs (labels) A mapping from inputs to labels Spam filtering, credit scoring, image classification
Unsupervised Inputs without labels Structure such as clusters, densities, or compressed representations Customer segmentation, anomaly detection, topic discovery
Self-supervised Raw data in which part of the input serves as the target General-purpose representations (predict the next word, fill in a masked image patch) Pretraining large language and vision models
Semi-supervised A few labeled examples and many unlabeled ones Labels extended using structure in the unlabeled data Medical imaging with scarce expert labels
Reinforcement Rewards from interacting with an environment A policy that maximizes long-run reward Game playing, robotics, training reasoning models

Dependencies and conditions. ML works when the training data is representative of future conditions, when the target is measured reliably, when there is enough data for the model's flexibility, and when the patterns being learned actually hold outside the training sample. It struggles when the world shifts (a fraud model trained before a new scam appears), when labels are noisy or biased, and when the model can latch onto shortcuts, such as a pneumonia classifier that learns to recognize which hospital's scanner produced an X-ray rather than the disease itself.

Where uncertainty remains. For modern deep networks, practitioners can reliably train models that work but cannot fully explain why they generalize as well as they do, or exactly what internal computations produce a given output. Interpretability research (see Recent Developments) is making progress, but explanations remain partial.

The Physics

For machine learning, the "physics" is the mathematics and computation that govern how learning works and where it fails.

Learning as optimization. Most ML can be written as empirical risk minimization: choose parameters θ for a model f that minimize average loss L over n training examples, plus a regularization penalty R that discourages overly complex solutions:

<math>\hat{\theta} = \arg\min_{\theta} \; \frac{1}{n}\sum_{i=1}^{n} L\big(f_{\theta}(x_i),\, y_i\big) + \lambda\, R(\theta)</math>

The loss encodes what "wrong" means. For predicting numbers, mean squared error is common:

<math>L_{\mathrm{MSE}} = \frac{1}{n}\sum_{i=1}^{n} \big(y_i - \hat{y}_i\big)^2</math>

For classification into K categories, cross-entropy compares the predicted probabilities <math>\hat{p}_k</math> with the true label:

<math>L_{\mathrm{CE}} = -\sum_{k=1}^{K} y_k \log \hat{p}_k</math>

Gradient descent. To minimize the loss, the optimizer computes how the loss changes as each parameter changes (the gradient) and takes a small step in the downhill direction, with step size set by the learning rate η:

<math>\theta_{t+1} = \theta_t - \eta \, \nabla_{\theta} \mathcal{L}(\theta_t)</math>

Stochastic gradient descent estimates the gradient from small random batches of data, which makes training on millions of examples feasible. Backpropagation, popularized by Rumelhart, Hinton, and Williams in 1986, is the algorithm that computes these gradients efficiently through many layers of a neural network. Modern variants such as Adam adapt the step size for each parameter.

Generalization and the bias-variance tradeoff. The real goal is low error on new data, not on the training set. For squared error, expected error on a new point decomposes into three parts:

<math>\mathbb{E}\big[(y - \hat{f}(x))^2\big] = \mathrm{Bias}\big[\hat{f}(x)\big]^2 + \mathrm{Var}\big[\hat{f}(x)\big] + \sigma^2</math>

Bias is error from a model too simple to capture the pattern (underfitting). Variance is error from a model so flexible that it fits noise in the particular training sample (overfitting). The last term, σ2, is irreducible noise. Classical practice balances the first two with regularization, early stopping, cross-validation, and more data.

Double descent. Modern deep networks complicate the classical picture. Mikhail Belkin and colleagues showed in 2019 that as model size grows past the point where it can perfectly fit the training data, test error can first rise and then fall again, a pattern called double descent. Heavily overparameterized networks often generalize well, which is one reason the field moved toward very large models.

No free lunch. David Wolpert's "no free lunch" theorems show that, averaged over all possible problems, no learning algorithm beats any other. Every method succeeds by making assumptions (an inductive bias) that match the structure of real problems: convolutional networks assume nearby pixels are related, tree ensembles assume that thresholds on individual features are informative, and so on. Choosing a model is choosing assumptions.

Scaling laws. For large neural language models, performance improves predictably with more parameters, data, and compute. Jared Kaplan and colleagues at OpenAI documented power-law relationships in 2020, and DeepMind's 2022 "Chinchilla" study refined them, fitting loss as a function of parameter count N and training tokens D:

<math>L(N, D) = E + \frac{A}{N^{\alpha}} + \frac{B}{D^{\beta}}</math>

where E is an irreducible floor and A, B, α, β are fitted constants. The Chinchilla analysis implied that, for a fixed compute budget, models had been too large and trained on too little data; a rough rule of thumb that emerged was about 20 training tokens per parameter. Training compute for a dense model scales roughly as C ≈ 6ND floating-point operations, and Epoch AI estimates that the training compute of frontier models has grown roughly four to five times per year.

The computational substrate. Neural network training is dominated by large matrix multiplications, which is why graphics processors (GPUs) and specialized accelerators such as TPUs transformed the field. Software frameworks such as PyTorch and TensorFlow compute gradients automatically, letting researchers define a model and loss in a few lines of Python.

Why This Matters

  • Everyday infrastructure. ML already runs search ranking, recommendations, fraud detection, computer vision, speech recognition, translation, and language processing at enormous scale. Most of it is invisible to users.
  • A new scientific instrument. The 2024 Nobel Prizes recognized ML twice: the physics prize went to John Hopfield and Geoffrey Hinton for foundational work on artificial neural networks, and half of the chemistry prize went to Demis Hassabis and John Jumper for AlphaFold's protein structure prediction (the other half to David Baker for computational protein design). ML is now used to forecast weather, discover materials, design proteins, and even improve algorithms.
  • Engineering change. Software increasingly combines hand-written code with learned components. That requires new skills: data management, evaluation, monitoring, and handling probabilistic outputs that are usually right but occasionally wrong.
  • Economic and social impact. The same methods that personalize services also raise concerns about bias in hiring and lending, privacy, misinformation, energy use, and labor displacement. See Risk, Compliance and Regulation.
  • Scientific rigor. ML makes it easy to produce impressive numbers that do not hold up. Leakage between training and test data has undermined published results across many fields, so careful evaluation is as important as clever modeling.
  • What would change if current trends continue. If scaling, reinforcement learning, and better data keep improving models, ML systems will take on longer and more complex tasks, and the scarce skills will shift toward problem framing, evaluation, and oversight.
  • What remains uncertain. Whether progress will slow as high-quality data runs short, how far reasoning gains generalize beyond math and code, how to verify what large models have actually learned, and how to make them reliably robust outside their training distribution.

Recent Developments

The state of the field in numbers

Stanford's 2026 AI Index, released in April 2026 and covering developments in 2025, documents a field that is moving faster than its yardsticks.

  • Industry dominates frontier work. More than 90 percent of notable models released in 2025 came from industry rather than academia. The United States produced about 50 notable models in 2025 and China about 30.
  • The US-China gap has effectively closed. As of March 2026, the top US model led the top Chinese model by only about 2.7 percent on the Index's comparison, and US and Chinese models traded places at the top of rankings several times after early 2025.
  • Open and closed models diverged again. After open-weight models briefly came within 0.5 percent of the best closed models in August 2024, the gap widened to about 3.3 percent by March 2026, and six of the top ten models on the Arena leaderboard were closed-weight.
  • Benchmarks are saturating. Models are improving faster than the benchmarks designed to measure them, and on professional evaluations in areas such as tax, mortgage processing, corporate finance, and legal reasoning, top models scored roughly 60 to 90 percent, with the top 15 often separated by only a few points.
  • Transparency fell. The average score on the Foundation Model Transparency Index dropped from 58 to 40, with persistent gaps in disclosure of training data, compute, and downstream impact.

What this establishes: frontier capability is widely distributed and advancing quickly. What it does not establish: that benchmark gains translate directly into reliability in high-stakes real-world settings, which the Index itself flags as a continuing challenge.

Reasoning through reinforcement learning

A major shift since late 2024 has been training language models to "think" at length before answering, using reinforcement learning and extra computation at inference time. OpenAI's o1, released in September 2024, demonstrated large gains on math and coding from this approach, but its methods were not published. In January 2025, DeepSeek released DeepSeek-R1 with open weights and a detailed technical report, and a peer-reviewed version appeared as a Nature cover article in September 2025, making R1 the first major LLM to pass formal peer review.

  • What they tested. Whether reasoning ability can emerge from reinforcement learning alone, rewarding a model only for correct final answers on verifiable problems in math and programming, without human-written examples of reasoning steps.
  • Method. Starting from the DeepSeek-V3 base model, the team trained an intermediate model (R1-Zero) with pure reinforcement learning, then built R1 through a multistage pipeline that added a small amount of curated "cold-start" data and further supervised and reinforcement stages to fix readability problems such as language mixing.
  • Findings. Reasoning behaviors such as longer chains of thought, self-checking, and revisiting earlier steps emerged during training, and R1 performed competitively with leading reasoning models. The supplementary material reported that the reasoning-specific training cost about $294,000, on top of roughly $6 million for the underlying base model.
  • Limits. Rewards work best where answers can be checked automatically, so gains are strongest in math and code. Questions remain about how much of the capability depends on the base model, and DeepSeek addressed speculation about training on competitors' outputs by stating it did not do so deliberately, though web data may contain such content.
  • Verification. Independent groups have reproduced the core finding that pure reinforcement learning can elicit strong reasoning, and researchers describe the paper as having influenced most 2025 work on reinforcement learning for LLMs.

Data: running out, synthetic data, and model collapse

  • Data limits. Epoch AI's 2024 analysis (Pablo Villalobos and colleagues, ICML 2024) estimated the effective stock of quality-adjusted public human text at about 300 trillion tokens, with a wide 90 percent confidence interval of 100 to 1,000 trillion. If trends continued, frontier training sets would match that stock sometime between 2026 and 2032 (an 80 percent interval), or earlier if models are heavily overtrained. The authors stress that this does not mean progress stops; it means gains must increasingly come from data efficiency, other modalities, private data, and synthetic data.
  • Model collapse. Ilia Shumailov and colleagues showed in Nature (2024) that indiscriminately training generative models on their own output, generation after generation, causes them to lose the rare "tails" of the original distribution and eventually degrade.
  • The counterpoint. Matthias Gerstgrasser and 13 coauthors showed in 2024 that the collapse depends on replacing real data with synthetic data. When synthetic data accumulates alongside the original real data, test error stays bounded across a range of model sizes and architectures. Other researchers argue that synthetic data still dilutes the value of real data. The practical consensus: carefully filtered synthetic data, kept alongside real data, is useful, while blindly recycling model output is risky.

Tabular data: old champions meet foundation models

For spreadsheet-style data, deep learning long lagged behind tree ensembles; a widely cited 2022 benchmark by Léo Grinsztajn and colleagues found that gradient-boosted trees and random forests still outperformed deep networks on typical medium-sized tabular datasets. In January 2025, Noah Hollmann, Frank Hutter, and colleagues at the University of Freiburg and Prior Labs published TabPFN in Nature, a transformer-based "tabular foundation model."

  • Method. Instead of training on one dataset, TabPFN was pretrained on about 100 million synthetic datasets generated from simulated causal processes, so it learns a general procedure for making predictions from small tables in a single forward pass.
  • Findings. On datasets with up to 10,000 samples, it outperformed previous methods by a wide margin; in classification, 2.8 seconds of TabPFN beat an ensemble of strong baselines tuned for four hours. The authors report it needs roughly half as much data to match the previous best accuracy.
  • Limits. The advantage applies to small and medium datasets; for very large tables, gradient boosting remains a strong and cheaper default. It also reframes "learning" itself: the model has learned an algorithm for learning, a form of meta-learning.

Opening the black box

Mechanistic interpretability aims to explain how a trained network computes its outputs. In March 2025, Anthropic published circuit-tracing research that builds "attribution graphs" showing which internal features contribute to a particular output, and applied it to a production model to study multi-step reasoning, planning ahead when writing rhymes, and shared multilingual concepts. In May 2025, the company open-sourced the tools, with an interactive interface hosted by Neuronpedia that works on open-weight models such as Gemma 2. These methods currently explain only parts of a model's computation and require substantial human analysis, but they mark a shift from treating networks as pure black boxes toward testable, partial explanations.

ML that discovers algorithms

In May 2025, Google DeepMind described AlphaEvolve, an agent that pairs Gemini language models with an evolutionary search loop and automated evaluators. It proposes code changes, tests them, and keeps the best. A scheduling heuristic it found for Google's data centers recovered about 0.7 percent of the company's worldwide compute on average; it found a way to multiply 4×4 complex-valued matrices with 48 scalar multiplications, improving on Strassen's 1969 approach for that case; and kernel optimizations cut Gemini training time by about 1 percent. The approach works only where candidate solutions can be scored automatically, but it shows ML improving the infrastructure that ML itself runs on.

Rigor: leakage and reproducibility

Sayash Kapoor and Arvind Narayanan of Princeton surveyed the literature in fields that adopted ML and found data leakage documented in 17 fields, affecting at least 294 papers, sometimes producing wildly overoptimistic conclusions. They catalogued eight types of leakage, from textbook errors such as preprocessing on the full dataset to subtle problems such as using features that would not be available at prediction time. In a case study of civil war prediction, complex ML models that appeared to beat logistic regression no longer did so once leakage was fixed. They propose "model info sheets" so reviewers can check for each leakage type. The lesson applies far beyond academia.

Open questions

  • Will reinforcement-learned reasoning generalize beyond domains with automatically checkable answers?
  • How will progress continue once public human text is fully used, and how much can synthetic data substitute?
  • Can interpretability methods scale to explain most of what large models do, rather than selected examples?
  • How should models be evaluated now that standard benchmarks saturate and may leak into training data?
  • When do small, specialized, or tabular foundation models beat large general models on cost and reliability?

Algorithm Families at a Glance

Family Origins Typical uses Strengths Weaknesses
Linear and logistic regression Classical statistics Baselines, risk scores, interpretable predictions Fast, stable, easy to explain Misses nonlinear interactions unless features are engineered
k-nearest neighbors Fix and Hodges, 1951 Similarity search, simple classification No training phase; intuitive Slow at prediction time; struggles in high dimensions
Decision trees CART (1984), ID3 (1986) Rules, triage, explainable decisions Readable; handle mixed data types Unstable; overfit when deep
Support vector machines Cortes and Vapnik, 1995 Text and small-to-medium classification Strong theory; effective with kernels Scale poorly to very large datasets
Random forests Breiman, 2001 General tabular prediction Robust with little tuning Less accurate than boosting on many tasks
Gradient-boosted trees (XGBoost, LightGBM, CatBoost) Friedman, 2001; XGBoost, 2016 Tabular data in industry and competitions Often best accuracy on tables Need tuning; less suited to images and text
Clustering (k-means and others) 1950s and 1960s Segmentation, exploration Simple and fast Must choose cluster count; assumes particular shapes
Principal component analysis Pearson, 1901 Dimensionality reduction, visualization Fast, well understood Captures only linear structure
Neural networks and deep learning Perceptron, 1958; backpropagation, 1986 Images, audio, text, complex patterns Learn their own features; scale with data and compute Data- and compute-hungry; hard to interpret
Transformers Vaswani and colleagues, 2017 Language models, vision, multimodal systems Attention captures long-range relationships; scale exceptionally well Expensive; can produce fluent but wrong output

A practical rule of thumb: start with a simple baseline such as logistic regression, try gradient-boosted trees for tabular problems (or TabPFN for small tables), and use deep learning or pretrained foundation models for images, audio, and text, usually through fine-tuning rather than training from scratch.

A Brief History

Year Milestone
1943 Warren McCulloch and Walter Pitts propose a mathematical model of a neuron.
1950 Alan Turing's "Computing Machinery and Intelligence" suggests building machines that learn.
1958 Frank Rosenblatt introduces the perceptron, a trainable artificial neuron.
1959 Arthur Samuel popularizes the term "machine learning" with a self-improving checkers program.
1969 Marvin Minsky and Seymour Papert's Perceptrons highlights the limits of single-layer networks, contributing to reduced interest in neural networks.
1986 David Rumelhart, Geoffrey Hinton, and Ronald Williams popularize backpropagation for training multilayer networks.
1989 Yann LeCun applies convolutional neural networks to handwritten digit recognition.
1995 Corinna Cortes and Vladimir Vapnik publish support vector networks.
1997 Sepp Hochreiter and Jürgen Schmidhuber introduce the LSTM; Tom Mitchell's Machine Learning textbook formalizes the field's working definition.
2001 Leo Breiman introduces random forests; Jerome Friedman's gradient boosting machine is published.
2006 Hinton and colleagues revive deep networks with layer-wise pretraining.
2009 The ImageNet dataset is released, enabling large-scale vision benchmarks.
2012 AlexNet wins the ImageNet challenge by a wide margin using GPUs, launching the deep learning boom.
2014 Ian Goodfellow and colleagues introduce generative adversarial networks.
2016 DeepMind's AlphaGo defeats Lee Sedol at Go, combining deep learning and reinforcement learning.
2017 "Attention Is All You Need" introduces the transformer architecture.
2018 BERT and the first GPT models popularize large-scale pretraining; Bengio, Hinton, and LeCun receive the Turing Award.
2020 GPT-3 demonstrates few-shot learning at scale; AlphaFold 2 achieves breakthrough accuracy in protein structure prediction.
2022 ChatGPT brings large language models to the public.
2024 Nobel Prizes in Physics (Hopfield and Hinton) and Chemistry (Baker, Hassabis, and Jumper) recognize ML; OpenAI's o1 introduces large-scale reasoning models.
2025 DeepSeek-R1 shows reasoning can be elicited through reinforcement learning and passes peer review in Nature; TabPFN brings foundation models to tabular data; AlphaEvolve discovers improved algorithms.

Practical Checklist: Doing ML Well

Most failed ML projects fail for ordinary reasons, not exotic ones. Before trusting a model:

  • Define the target and the metric with the people who will use it. Accuracy is misleading for rare events; a fraud model that predicts "not fraud" every time can be 99.9 percent accurate. Use precision, recall, the area under the precision-recall curve, or cost-weighted metrics where classes are imbalanced.
  • Build a baseline first. A simple model, or even a rule of thumb, tells you whether added complexity is worth it.
  • Split data the way the model will be used. For time-dependent problems, train on the past and test on the future. Keep all records from the same patient, customer, or device in the same split.
  • Hunt for leakage. Fit all preprocessing on the training data only, and remove any feature that would not exist at prediction time. Suspiciously good results usually mean a leak.
  • Use cross-validation and report uncertainty. A single test score can be lucky; confidence intervals and repeated splits reveal how stable results are.
  • Check calibration. If a model says 80 percent, events should happen about 80 percent of the time, especially when probabilities drive decisions.
  • Do error analysis. Read the mistakes. Patterns in errors point to missing data, mislabeled examples, or subgroups where the model underperforms.
  • Test for fairness and robustness. Compare performance across relevant groups and under realistic shifts in the data.
  • Document and monitor. Record data sources, intended use, and limitations, and monitor live performance for drift. Communities such as Kaggle offer practice, but production work demands this extra discipline.

Featured Videos

Load video
YouTube

Machine Learning for Everybody (freeCodeCamp full course): a long-form beginner course covering core concepts and hands-on examples.

Load video
YouTube

Resources

Additional Viewing

Load video
YouTube

MIT 6.S191: Introduction to Deep Learning, Lecture 1 (2026 edition). Alexander Amini opens MIT's intensive introductory course with the foundations: perceptrons, neural networks, loss functions, gradient descent, backpropagation, and regularization. The 2026 edition was released in March 2026 alongside slides and software labs at introtodeeplearning.com, making it one of the most current free introductions to the mechanics described on this page. Watch on YouTube

Load video
YouTube

MIT 6.S191: Deep Reinforcement Learning (2026 edition). Alexander Amini introduces reinforcement learning, from value functions and Q-learning to policy gradients, with examples from games and robotics. It provides the background needed to understand how reinforcement learning is now used to train reasoning models such as DeepSeek-R1. Watch on YouTube

Load video
YouTube

Deep Dive into LLMs like ChatGPT, Andrej Karpathy (February 2025, about 3.5 hours). Karpathy walks through the full training pipeline of a modern language model: data collection and tokenization, pretraining, supervised fine-tuning, and reinforcement learning, including reasoning models. It shows how the general ML principles on this page play out at the largest scale, and why models have uneven abilities and hallucinate. Watch on YouTube

References

State of the field

Foundations

Recent research

Recognition

Retrieved from "https://primo.ai/w/index.php?title=Machine_Learning_(ML)&oldid=46375"