Artificial Intelligence

The standard division is by what the data provides. Supervised learning fits a function from labelled examples, such as emails marked spam or not; unsupervised learning finds structure in unlabelled data; semi-supervised learning uses a little of each; and reinforcement learning learns a policy from rewards.[3] Self-supervised learning is a further category that uses unlabelled data differently from clustering: the data supplies its own targets, as when a model is trained to predict a missing part of its input, and it is how large language models are pretrained.[4]

Beneath these categories lie different attitudes to what a model is for. One source describes frequentism, Bayesianism, likelihoodism, causal inference and machine learning as distinct mindsets, each with its own assumptions and limits, and subtitles itself "the many cultures of learning from data".[5] Another draws the line between prediction and explanation: a statistical model assumes a parametric form and seeks its best parameters in order to explain, while a non-parametric machine learning model forgoes explanatory power for predictive power.[6]

Linear and logistic regression, support vector machines, decision trees and their ensembles, k-nearest neighbours, k-means clustering and naive Bayes make up the classical toolkit, and they remain the right choice for most tabular data. The hundred-page overview walks supervised learning through a spam-detection support vector machine before setting up the notation, derivatives, gradients and probability that the rest of the subject needs.[3] A from-scratch treatment implements k-means to extract a colour palette from interface screenshots, and a multinomial naive Bayes classifier, with log probabilities and Laplace smoothing, to classify film reviews at about 86 percent accuracy.[7] Metaheuristic search sits beside these: genetic algorithms improve a population of candidate solutions using a fitness score as feedback, and one source grows a reusable engine across eighteen puzzles while noting that the engine does not learn in the machine learning sense.[8] A tabular reference covers gradient boosting, hyperparameter optimisation and, in its 2026 edition, tabular foundation models.[6]

Feature engineering, choosing and shaping the inputs, often matters more than the choice of algorithm; feature selection methods are grouped into filter, wrapper and embedded families, each with a Python implementation.[9] Low-code libraries compress the whole workflow: PyCaret's compare_models call trains and ranks every available regression model by a chosen metric in one line.[10] The Python ecosystem that carries all of this, pandas, scikit-learn, PyTorch, TensorFlow, Keras, XGBoost and the explainability libraries, is catalogued one library at a time elsewhere.[11]

A model is judged on data it has not seen, which is why data is split into training and test sets and why cross-validation resamples the split; one pipeline-oriented introduction spends as much time on data definition, cleaning and resampling as on algorithms.[12] Applied machine learning is largely the management of what goes wrong between a notebook and production: data leakage, where information from the test set or the future reaches training; distribution shift, where the world changes after training; and imbalanced data.[13] Time series add a rule of their own. Before any model, one source asks whether a series is forecastable at all, and it points out that the random train-test splits used in ordinary regression are usually invalid for forecasting because they mix past and future.[14]

Predictions carry uncertainty of two kinds, aleatoric (noise in the world) and epistemic (ignorance in the model), and a well-made model reports it through calibrated probabilities and prediction intervals, which conformal prediction can supply without distributional assumptions.[6]

As models are used for decisions about people, explaining a prediction has become a requirement in its own right; the GDPR's right to an explanation is one driver.[6] Shapley values, introduced in game theory by Lloyd Shapley in 1953 to share a cooperative game's payout fairly, were first applied to machine learning around 2010, and SHAP (Lundberg and Lee, 2017) made them practical: it produces one value per input feature that says how that feature contributed to a prediction.[15] One source devotes a whole book to the method, its estimators and maskers for linear, tree, neural, image and text models, and its limits, including the problem of correlated features,[15] while the tabular reference is frank about where SHAP and LIME fall short.[6]

One source builds the whole mechanism up from a single regression, visualising gradient descent, loss surfaces and learning rates before introducing tensors, automatic differentiation, the optimiser and a reusable training class in PyTorch.[16] A code-free guide explains what networks do in terms of reshaping the feature space until the classes separate, and sets out bias and variance, baselines and success thresholds.[4] The same construction can be done in JavaScript, by hand and then with TensorFlow.js, running in the browser.[17] The main frameworks are Google's TensorFlow (2015), with Keras as its high-level API, and Facebook's PyTorch (2016); one short tutorial builds components in raw TensorFlow before using tf.keras,[18] and a project-driven book trains a Keras regression with dropout and early stopping and serves it as a Flask API on App Engine.[19]

Convolutional networks for images, recurrent networks and LSTMs for sequences, attention and the Transformer, and diffusion models for generation are the architectures a reader now needs, and one guide covers each in prose and diagrams along with self-supervised and contrastive learning.[4] Object detection illustrates how a task shapes an architecture: RetinaNet adds a focal loss so that the many easy background regions do not swamp the few objects, and its quality is measured by intersection over union and mean average precision.[19] Project collections apply the same frameworks to image classification, LSTM forecasting and anomaly detection, object detection and BERT sentiment analysis.[20] Classical computer vision, filtering, edges, the Hough transform, camera models, features and tracking, predates deep learning and still underlies it; one set of course notes covers it in full while deliberately leaving out convolutional networks.[21]

Training large networks is a problem of moving numbers between graphics processors. Data, pipeline and tensor parallelism split a model and its data across GPUs, and collective operations such as all-reduce synchronise them. In the data centre those operations appear as elephant flows between GPUs, carried over RDMA at line rate; because ordinary equal-cost multipath routing sends every packet of a flow down one path, such flows congest it, and AI back-end networks answer with flowlet load balancing, adaptive routing and packet spraying.[22] At the other end of the scale, a trained model can run on a phone: Apple's Core ML takes converted models in its mlmodel format, and getting a model through conversion, preprocessing and the format's limits was enough to fill a 500-page guide, which its author later declared out of date as the platform moved on.[23] Between the two sit the managed machine learning services of the public clouds.[24]

The idea is older than the architecture. Count-based n-gram models estimated the next word from the previous few; bag-of-words representations and then learned word embeddings gave words vectors; recurrent networks read sequences one token at a time. One source retraces exactly this path, from bag of words through count-based models and RNNs to a Transformer coded in PyTorch, so that the modern architecture reads as the natural next step,[1] and its course version adds quizzes, exercises and video interviews with the author.[25] An illustrated study guide covers the same ground from word2vec and RNNs to BERT, GPT and T5, with fine-tuning and preference tuning.[26]

Text first becomes tokens, which can be whole words, parts of words or punctuation,[27] usually through byte-pair encoding. Each token becomes a vector, an embedding. The decoder block that follows applies self-attention, which lets every position weigh every earlier position, in several heads at once; positions are encoded, in current models by rotary position embedding; a position-wise feed-forward layer follows; residual connections and normalisation keep the stack trainable; and a key-value cache avoids recomputing attention over the prompt at each step.[1] The last layer produces logits, scores for every token in the vocabulary, from which the next token is chosen.[28] A plain-English guide calls the result a "guess the next word" machine that balances probability with some randomness for diversity and loops to generate text, while noting there is more going on than statistical prediction.[2]

The amount of text a model can attend to at once is its context window; by 2024 some models accepted millions of tokens.[27] Models also fabricate: hallucination is treated as a standing property to be managed,[1] and reasoning models, which plan before answering, are one of the ways the behaviour has been improved.[2] Mixture-of-experts designs route each token through a subset of the network's parameters.[28]

A model is pretrained on a large corpus, then adapted. Supervised fine-tuning on instruction and response pairs teaches it to follow instructions; preference methods, reinforcement learning from human feedback and direct preference optimisation, shape its behaviour; and parameter-efficient methods such as low-rank adapters (LoRA) make adaptation feasible on modest hardware. One workshop-style book takes the whole path as thirty-six projects, from a single autograd scalar to a GPT and on through pretraining, distributed training, KV caches, speculative decoding, mixture of experts, fine-tuning, RLHF and DPO, quantisation and newer architectures such as Mamba and RWKV, each with a deliberate "break it" step.[29] A hands-on manual keeps the same pretrain, fine-tune, DPO and deploy pipeline at the scale of 125 to 350 million parameters so that it runs on a laptop or in Google Colab.[30] For adapting open models on consumer GPUs the decisive details are configuration: data types, 4-bit and 8-bit quantisation, which modules LoRA targets, chat templates and memory settings, with GGUF export for local inference.[31]

Prompt engineering is the craft of writing the input so that the output is useful: giving the model a role, asking it to work step by step, supplying examples, structuring the answer. One guide organises the craft as a library of about twenty named templates with quizzes and exercises, and extends it to reasoning models and context engineering;[32] another prefers "prompt imagination" to prompt engineering and offers the mental model of an expert in your basement who knows nothing of your situation until you tell them.[2] The language-model text closes with prompting and hallucination after the Transformer chapters.[1]

A model's knowledge stops at its training data. Retrieval-augmented generation (2020) adds the user's own documents at query time: text is split, embedded as vectors and searched by similarity, and the best passages are placed in the prompt. The practice has grown patterns of its own, hybrid retrieval, reranking and context engineering,[33][27] and is explained for non-specialists as the way to make a model answer from your material.[2] It is built in every language that can call a model: in Swift with a vector store on Apple platforms,[34] and in Common Lisp alongside agents and knowledge graphs.[35]

An agent is a program that calls a model in a loop, gives it tools to act with and memory to act on, and acts on what comes back. One source builds a terminal coding agent in plain Python with only an HTTP library and a test framework, no SDK and no agent framework: an Agent class with brain, tools, memory and loop, a raw call to the model's API, conversation history as memory, and, because API calls are slow, expensive and non-deterministic, a FakeBrain test double so the whole test suite runs without making a single call.[36] Framework-level treatments cover ReAct agents, durable agents with checkpoints, human-in-the-loop steps and multi-agent supervisors,[33] and a pattern catalogue names tool use, streaming, self-healing data and agent orchestration as reusable architecture.[27] The Model Context Protocol (2024) standardises how an assistant reaches tools and data.

Coding agents such as Claude Code are the first widely used agents, and a literature on running them has followed. A production reference covers the agent loop and context, the stack of tools, subagents, hooks, skills, MCP and plugins, governance through permissions, sandboxing and audit, and evaluation, observability and cost, with worked examples from financial services.[37] Harness engineering names the files, tools, gates and conventions around a non-deterministic agent that narrow its output to something shippable, and argues that reliability rather than determinism is the goal.[38] Developer-experience teams measure the effect with the SPACE, DX Core 4 and DORA frameworks, and one source argues that most automation should remain deterministic scripts and hooks, with the model as the remainder.[39] Product teams fold the same tools into prototyping, code editors and agents across the delivery cycle,[40] and requirements writing is being recast so that an agent can implement a use case directly from its specification.[41]

Putting a model into production is an engineering project with its own lifecycle, from scoping and team structure through data preparation, feature engineering and training to deployment, monitoring and maintenance.[13] Ordinary software practice applies: one source structures a deep learning codebase with classes and configuration, unit-tests it with mocks, adds logging and schema validation, and serves the model with Flask, uWSGI and Nginx in Docker and Kubernetes, with pipelines in TFX and Vertex AI.[42] The deployment step can be as small as a Flask endpoint on a managed platform[19] or a Streamlit app,[10] and the cloud providers' managed services take over much of the rest.[24] For agents, evaluation moves to the centre: evals, often with a model as judge, and observability of every call are what make a non-deterministic system operable.[37]