How a machine went from following rules to writing them.

The expert system encodes a hypothesis directly: a conjunction of axis-aligned thresholds. Its capacity is fixed by how many clauses a human is willing to maintain, and it degrades hard once the classes stop being axis-separable.

A learner fixes a hypothesis class instead and searches it. k-NN is non-parametric: capacity grows with the data. Logistic regression is linear in whatever features you hand it. The RBF model here is a kernel expansion: a bump per prototype, which is how a linear method buys a curved boundary. The decision tree (CART, Gini impurity) carves the plane into nested axis-aligned boxes, the learned cousin of the expert system's rules. Naive Bayes fits one Gaussian per feature per class and multiplies them, assuming the features are independent given the class: crude, fast and often surprisingly good.

Unsupervised swaps the objective: k-means gets the same points with labels hidden and minimises within-cluster distance. The agreement score compares its clusters with the hidden labels afterwards, which is often worse than you expect. Reinforcement is tabular Q-learning on a grid: no dataset, only transitions and rewards, and an ε-greedy policy that trades exploring against exploiting.

Stream in (a stream processor) → object-store data lake → distributed batch jobs for normalisation → near-duplicate removal → quality classification → PII scrubbing → tokenised shards → feature store for the structured side.

Deduplication here is real MinHash + LSH banding, not a mock: each document is shingled, hashed under 64 permutations, and banded so that any pair above the Jaccard threshold collides in at least one band. Drop the band count and watch recall fall.

Unstructured data (text, images, audio, logs) has to be parsed, chunked and turned into fields or embeddings before any of this works. A 2025 peer-reviewed survey puts the unstructured share of the world's data at about 80% (Surur et al.), which is why extraction, not modelling, is usually the first bottleneck.

Preparation is also most of the calendar: practitioners consistently report that finding, loading and cleaning data takes more time than modelling. The quality lab shows why: label noise, missing values and class imbalance each cost accuracy in a different way, and each has a different fix.

Each edge's thickness is $\left|w\right|$ and its colour is the sign: positive, negative. Node fill is the activation on the current batch.

Switch the activation to sigmoid with three hidden layers and watch the loss curve flatten: gradients through stacked sigmoids shrink by roughly $0.25$ per layer. ReLU is not a better function, it is a better-conditioned one.

The pad is downsampled to 28×28. Each map is a genuine 2D cross-correlation with a fixed 3×3 kernel, ReLU'd, then 2×2 max-pooled per depth level, so the receptive field grows and the resolution halves exactly as it would in LeNet.

The RNN view runs $h_t=\tanh (W_h{h}_{t-1}+W_x{x}_t)$ over your text, with a forget gate you control. At gate 0.2 the state forgets the start of the sentence long before the end.

Each token embedding is projected three ways: query, key, value. The grid is $\mathrm{softmax}(Q{K}^T/\sqrt{d_k})$, row-normalised: row i is where token i is looking, and the row sums to 1.

Turn the causal mask off and the lower-triangular wall disappears, that wall is the only thing separating a decoder from an encoder. Heads differ because their projections differ; nothing else about them is special.

Prefill runs the whole prompt in one parallel pass; decode then runs one token at a time, and each new token attends to every earlier key and value. Caching those is what turns an $O\left(n^2\right)$ re-computation into an $O\left(n\right)$ read, at the cost of VRAM that grows linearly with context.

Top-k truncates to a fixed count; top-p (nucleus) truncates to a fixed probability mass, so it widens on uncertain steps and narrows on confident ones. The greyed bars in the chart are the candidates your current setting has cut.

The Experts tab shows a mixture-of-experts layer: a small router scores each token and sends it to 2 of 8 expert sub-networks, so only a fraction of the parameters do work on any one token. Total size and per-token compute come apart, at the price of balancing the load across experts.

Forward is closed-form: you can jump to any $t$ in one step, which is why training is cheap. Reverse is the learned part: a UNet or DiT predicts the noise ${ϵ}_{\theta }$ that was added, and the sampler subtracts a scaled portion of it.

The byte-stream view is the other branch of the family: no denoiser at all, just an autoregressive model over the literal bytes of a JPEG. The hex you are looking at is a real encode of this canvas, with its real markers parsed out.

The Families tab places diffusion among the four main generative families: autoregressive models (one piece at a time, exact likelihood), diffusion (iterative denoising), GANs (a generator trained against a discriminator, fast but unstable to train) and VAEs (an encoder to a smooth latent space and a decoder back, stable but blurrier).

A vision encoder produces patch embeddings; a projector maps them into the language model's embedding space; they are interleaved with text tokens in one sequence. Cross-attention variants keep the streams separate and let text queries attend to frozen image keys, cheaper, and easier to bolt onto an existing model.

The agent trace is a ReAct loop: Thought → Action → Observation, with a scratchpad that accumulates. Every tool call in the run below is really executed against the in-page tools, including the one that fails.

Three classes of processor run models today. A CPU has a few large cores built for low latency and branching code. A GPU has many small cores that execute the same instruction across wide groups of data. An AI accelerator spends its area on fixed matrix engines (systolic arrays), large on-chip SRAM and stacked high-bandwidth memory. Most modern GPUs now include matrix engines too, so the line between the last two is blurring.

Decoding is usually memory-bound. At batch size 1, every generated token reads every weight once, so tokens per second is close to memory bandwidth divided by model size in bytes. Batching many users together reuses each weight across requests and pushes the workload towards the compute roof. Smaller number formats (8-bit, 4-bit) help twice: more multiplies per cycle and fewer bytes to move.

The seven tasks follow the OECD Framework for the Classification of AI Systems (2022): recognition, event detection, forecasting, personalisation, interaction support, goal-driven optimisation, and reasoning with knowledge structures. The same framework treats action autonomy separately, which is why it is a dial here rather than an eighth task.

Naming the task early tells you what data you need, how to evaluate the system and how it fails. Recognition is judged on precision and recall per group, forecasting on calibration, goal-driven systems on whether the objective matches the intent. Each draws on earlier chapters: recognition on §04 and §08, interaction on §05 and §06, forecasting on §01 and §03, event detection on §02, goal-driven optimisation on §01's reinforcement learner.

The questions are written for this guide around the seven characteristics of trustworthy AI in the NIST AI Risk Management Framework (2023): valid and reliable, safe, secure and resilient, accountable and transparent, explainable and interpretable, privacy-enhanced, and fair with harmful bias managed. What changes per task is where they bite. Recognition fails unevenly across groups; prediction fails as the world drifts; goal-driven systems find loopholes in the objective.

In the EU, the AI Act's Article 50 transparency duties have applied since 2 August 2026: people must be told when they are talking to an AI, and synthetic content must be marked (generative systems already on the market have until 2 December 2026 for the marking duty). Most high-risk obligations were moved by the 2026 Digital Omnibus to 2 December 2027 (Annex III) and 2 August 2028 (Annex I products).

The demo is model-predictive control with sampled rollouts: at every step the rover simulates N action sequences H steps ahead in its internal model, scores them, executes one action and replans. Swap the hand-written model for a learned one and you have the core loop of world-model agents.

Four directions are active at once. Reasoning models spend more computation at answer time, writing out and checking intermediate steps (first released in 2024, with open-weight versions in 2025). World models learn how scenes change from large amounts of video (several research releases in 2025). Vision-language-action models turn camera frames and an instruction into robot motion (2024 to 2025). And agents, from §08, connect all of these to tools.

The architecture is a stack. At the bottom sit physical qubits (superconducting circuits, trapped ions, neutral atoms, photons or electron spins, depending on the design), then control electronics and often cryogenics, then an error-correction layer that turns many noisy physical qubits into a few reliable logical ones, then logical gates, a compiler, and a classical computer that runs the hybrid program around it.

Where it could matter for AI: simulating molecules and materials that no classical computer can, producing data and ground truth for scientific models; some linear-algebra and sampling routines; and optimisation, where an advantage is not yet proven. The traffic also runs the other way: machine learning already helps decode errors and calibrate qubits. Training or serving an LLM is not on the near-term list, because those workloads need terabytes of data moved through dense arithmetic, which is exactly what quantum hardware is worst at.

The design is defence in depth, five layers that fail independently. Charter: first principles written in plain language and ratified by several keyholders (family, clinician, manufacturer, an independent auditor). Ledger: the charter's hash, the approved-weights registry and every high-stakes decision are appended to a tamper-evident chain; changing the charter needs M-of-N signatures and a public waiting period. Silicon: the AI chip boots only weights and charter whose hashes match the registry, and a small, separately verified governor sits between the planner and the motors, enforcing measurable limits the model cannot override. Model: trained against the charter, with a second runtime monitor reviewing intent. Human: anything high-stakes escalates to a named person.