AI Glossary

This glossary is manually maintened by me and offers clear, accessible definitions of terms commonly used in artificial intelligence. It is designed to support understanding across a range of experience levels, from newcomers to those more familiar with the field. As AI continues to evolve, so too will this glossary - it is a living document and I review constantly along my own learning journey:

• Last update: 25-Apr-2025.

How to Search for a Term:

• Scroll through the document - it is one big page.
• Use the Table of Contents on the right - clicking jumps to the term. It also highlights where you currently are.
• The search box on the top right corner - this also searches across the other sections of the site.
• Or the oldschool way of using the Search Function of your Browser - usually CTRL-F.

Alternatively you may want to check the Wikipedia AI Glossary, which has a massive collection of about 400 entries.

Accuracy

Accuracy is a common evaluation metric for classification models, representing the overall proportion of correct predictions made by the model across all classes. It is calculated as the number of correct predictions (True Positives + True Negatives) divided by the total number of predictions (all instances). While intuitive and easy to understand, accuracy can be a misleading metric, especially when dealing with imbalanced datasets where one class significantly outnumbers the others. In such cases, a model might achieve high accuracy simply by predicting the majority class most of the time, while performing poorly on the minority class(es) which might be of greater interest (Wikipedia, Scikit-learn Documentation).

Action

An action refers to a decision or choice made by an agent at a specific point in time, selected from a set of available options within its environment. In the context of reinforcement learning, performing an action typically causes the environment to transition to a new state and may result in the agent receiving a reward or penalty signal. Actions are the mechanism through which an agent interacts with and influences its environment, forming a fundamental part of the agent-environment interaction loop (Reinforcement Learning: An Introduction - Chapter 3).

Activation Function

An activation function is a mathematical function applied to the output signal of a neuron (or node) in an artificial neural network. Its primary role is to introduce non-linearity into the network, allowing the model to learn complex patterns and relationships in the data that would not be possible with purely linear operations. Without non-linear activation functions, a deep neural network would behave like a single-layer linear model regardless of its depth. Common examples include the Rectified Linear Unit (ReLU), Sigmoid, and Hyperbolic Tangent (Tanh) functions (Wikipedia, Deep Learning Book - Chapter 6.3).

Agent

An agent refers to any entity, whether software-based or physical (like a robot), that perceives its environment through sensors and acts upon that environment through actuators or effectors to achieve specific goals. Agents are often characterized by properties such as autonomy (operating without direct human intervention), reactivity (responding timely to changes in the environment), pro-activeness (initiating goal-directed behavior), and social ability (interacting with other agents). In artificial intelligence, the concept encompasses a wide range of systems, from simple reflex agents to complex learning agents capable of planning and reasoning to make decisions, as detailed in foundational AI texts like Russell and Norvig's Artificial Intelligence: A Modern Approach (Chapter 2).

API

API stands for Application Programming Interface. It defines a set of rules, protocols, and tools that specify how different software components should interact with each other. Essentially, it acts as an intermediary or contract, allowing one piece of software to request services or data from another system without needing to understand its internal complexity. In machine learning operations (MLOps), APIs are fundamental for model serving, providing a standardized way for applications to send input data to a deployed model endpoint and receive predictions or results in return (Wikipedia).

Artificial Intelligence (AI)

Artificial Intelligence is the broad field of computer science dedicated to developing systems that can perform tasks typically requiring human intelligence. Such tasks include learning, reasoning, problem-solving, perception (like vision and speech), language understanding, and decision-making. AI draws on insights from various disciplines including computer science, mathematics, logic, and cognitive science, aiming to build machines that can sense, reason, act, and adapt. Foundational ideas were explored in Alan Turing's seminal paper, "Computing Machinery and Intelligence", and the Stanford Encyclopedia of Philosophy entry on AI provides further context.

Attention Mechanism

An attention mechanism is a technique used in neural networks, particularly for processing sequential data, that allows the model to dynamically assign different levels of importance or "attention" to different parts of the input sequence when generating an output or making a prediction. Instead of relying solely on a fixed-length context vector (like in basic encoder-decoder models), attention mechanisms compute relevance scores between elements of the input and the current state of the output generation, effectively enabling the model to focus on the most pertinent input elements at each step. This significantly improves performance on tasks involving long sequences or complex dependencies, such as machine translation, text summarization, and question answering, and forms the core component of the influential Transformer architecture (Distill: Attention and Augmented Recurrent Neural Networks, Vaswani et al., 2017 "Attention Is All You Need").

AUC (Area Under Curve)

Stands for Area Under the Receiver Operating Characteristic (ROC) Curve. The ROC curve plots the True Positive Rate (Recall) against the False Positive Rate (1 - Specificity) at various classification threshold settings. The AUC represents the overall measure of separability between classes achieved by the model ? a higher AUC (closer to 1) indicates a better ability to distinguish between positive and negative classes across all thresholds. It's particularly useful for evaluating binary classifiers on imbalanced datasets.

Autoencoder

An unsupervised neural network architecture primarily used for dimensionality reduction, feature learning, and data compression. It consists of two main parts: an encoder that maps the input data into a lower-dimensional latent representation (encoding), and a decoder that reconstructs the original input data from this latent representation. The network is trained to minimize the reconstruction error, forcing the latent space to capture the most salient features of the data.

Automation & Pipelines

Practices and tools focused on automating the various stages of the machine learning workflow, from data preparation and model training to testing, deployment, and monitoring, often orchestrating these steps into repeatable and reliable pipelines.

Autoregressive

An autoregressive model is a type of model used for sequence generation where the prediction of the next element in the sequence is conditioned solely on the elements that have come before it. In simpler terms, the model generates the sequence step-by-step, and each new step depends on the output generated in the previous steps. For example, when generating text, an autoregressive language model predicts the next word or token based on the sequence of words it has already generated. This property makes them inherently sequential in their generation process. Many prominent generative language models, including those in the GPT family, are autoregressive. This concept also applies to time series analysis, where future values are predicted based on past values (Wikipedia, Deep Learning Book - Chapter 10.2.1).

Backpropagation

The fundamental algorithm used to train artificial neural networks. It efficiently computes the gradient of the loss function with respect to the network's weights by propagating the error backward from the output layer to the input layer, using the chain rule of calculus. These gradients are then used by an optimization algorithm (like gradient descent) to update the weights and minimize the loss.

Bagging

Short for Bootstrap Aggregating, bagging is an ensemble technique primarily aimed at reducing variance and improving stability. It involves training multiple instances of the same base learning algorithm (e.g., decision trees) independently on different random subsets of the original training data, created using bootstrap sampling (sampling with replacement). The final prediction is typically obtained by averaging (for regression) or majority voting (for classification) the predictions of all individual models. Random Forest is a well-known example of bagging.

Batch (Mini-batch)

A subset of the total training dataset used in one iteration of updating the model's parameters during training, particularly with variants of gradient descent like Mini-batch Gradient Descent or Stochastic Gradient Descent (where batch size is 1). Processing data in batches is more computationally efficient than processing one example at a time (SGD) and provides a less noisy estimate of the gradient than SGD, while still being more tractable than using the entire dataset (Batch Gradient Descent). Batch size is an important hyperparameter.

Batch Normalization

A technique used in training deep neural networks to stabilize the learning process and improve performance. It normalizes the inputs to a layer for each mini-batch by adjusting and scaling the activations. This helps to mitigate the problem of internal covariate shift (changes in the distribution of layer inputs during training), allowing for higher learning rates, faster convergence, and acting as a form of regularization.

BLEU Score

Stands for Bilingual Evaluation Understudy. A widely used metric for evaluating the quality of machine-generated text (candidate) by comparing it to one or more high-quality human reference translations (references). It measures the precision of n-grams (contiguous sequences of n words) in the candidate text compared to the references, combined with a brevity penalty to discourage overly short translations. Higher scores indicate greater similarity to the references.

Boosting

An iterative ensemble technique that aims primarily at reducing bias and building a strong classifier from a number of weak classifiers. Unlike bagging, models are trained sequentially. Each subsequent model focuses more on the instances that were misclassified by the previous models, effectively learning from the mistakes. Examples include AdaBoost (Adaptive Boosting), Gradient Boosting Machines (GBM), XGBoost, LightGBM, and CatBoost, which often achieve state-of-the-art results on structured data.

CI/CD

Stands for Continuous Integration and Continuous Delivery/Deployment. These are practices borrowed from traditional software engineering and adapted for MLOps. CI involves frequently integrating code changes and automatically testing them. CD involves automatically deploying validated changes to production (Continuous Deployment) or making them ready for deployment (Continuous Delivery). Applying CI/CD to ML includes automating testing, training, validation, and deployment of ML models and pipelines.

Classification Metrics

Quantitative measures used to evaluate the performance of models designed for classification tasks (predicting discrete categories or labels). Different metrics highlight different aspects of performance, and the choice often depends on the specific goals and characteristics of the problem (e.g., class imbalance).

Cloud ML Platforms

Integrated suites of services offered by cloud providers (e.g., Google Cloud AI Platform/Vertex AI, AWS SageMaker, Azure Machine Learning) designed to support the end-to-end machine learning lifecycle. These platforms typically provide managed services for data preparation, model training, hyperparameter tuning, model deployment, monitoring, MLOps pipelines, and collaboration tools, simplifying the development and operationalization of ML solutions.

Computer Vision (CV)

The scientific field focused on how computers can gain high-level understanding from digital images or videos. It seeks to automate tasks that the human visual system can do, involving the extraction, analysis, and understanding of information from visual data to enable applications like image recognition, object detection, facial recognition, autonomous driving, and medical image analysis.

Confusion Matrix

A table used to visualize the performance of a classification model. It summarizes the counts of correct and incorrect predictions, broken down by each class. The rows typically represent the actual classes, and the columns represent the predicted classes. It shows True Positives (TP), True Negatives (TN), False Positives (FP, Type I error), and False Negatives (FN, Type II error), which are used to calculate other metrics like accuracy, precision, recall, and F1 score.

Context

In machine learning and especially Natural Language Processing (NLP), context refers to the surrounding information that influences the meaning or interpretation of a specific piece of data, typically a word or token within a sequence. For sequence models like RNNs or Transformers (including LLMs), context is the sequence of preceding tokens that the model processes to understand relationships, dependencies, and meaning, enabling it to generate coherent and relevant subsequent tokens or make informed predictions. It also commonly refers to the information provided in the input prompt given to an LLM, which includes instructions, examples, and background needed to frame the task. The amount of preceding sequence information a model can effectively utilize is often limited by its "context window." Mechanisms like attention allow models to selectively focus on the most relevant parts of the context (Vaswani et al., 2017 "Attention Is All You Need", Brown et al., 2020 "Language Models are Few-Shot Learners" - discusses in-context learning).

Contrastive Learning

A self-supervised or unsupervised learning technique primarily used to learn meaningful representations (embeddings) of data without explicit labels. It works by training a model to distinguish between similar data points ('positive pairs') and dissimilar data points ('negative pairs'). The model learns to map positive pairs closer together and negative pairs further apart in the embedding space, thereby capturing underlying data structure and semantic similarity.

Convolutional Neural Network (CNN)

A Convolutional Neural Network (CNN or ConvNet) is a class of deep neural networks particularly effective for processing data with a grid-like topology, such as images (2D grid of pixels) or time-series data (1D grid). Inspired by the human visual cortex, CNNs employ specialized layers, primarily convolutional layers, which apply learnable filters (or kernels) across the input data. These filters automatically learn spatial hierarchies of features, starting from simple patterns like edges and textures in early layers to more complex motifs and object parts in deeper layers. Other key components often include pooling layers (to reduce dimensionality and provide invariance to small translations) and fully connected layers (typically used for final classification or regression). CNNs have become the standard architecture for many computer vision tasks, including image classification, object detection, and segmentation (Wikipedia, Stanford CS231n Course Notes on CNNs).

Cross-Validation

A robust evaluation technique, particularly useful when the amount of available data is limited, designed to provide a more reliable estimate of model performance and generalization ability than a single train-test split. In k-fold cross-validation, the data is divided into 'k' equal-sized subsets (folds). The model is trained k times, each time using k-1 folds for training and the remaining fold for validation. The final performance metric is typically the average of the metrics obtained across all k iterations.

curl

curl is a widely used open-source command-line tool (--> man curl) and library (libcurl) for transferring data specified with URL syntax. Created by Daniel Stenberg, it supports a vast range of network protocols, including HTTP, HTTPS, FTP, SFTP, SCP, LDAP, and more. Its primary function is to send or receive data from or to a server, making it invaluable for tasks like downloading files, testing web services, inspecting HTTP headers, and interacting with APIs programmatically. Due to its versatility, scriptability, and availability across most operating systems, curl is a fundamental tool for developers, system administrators, and in automated workflows, including those involving data fetching or interaction with machine learning model deployment endpoints (curl Official Website, Wikipedia).

Data Augmentation

A set of techniques used to artificially increase the size and diversity of a training dataset, particularly valuable when labeled data is scarce, expensive to obtain, or when aiming to improve model robustness against variations. It involves generating new, synthetic training examples by applying realistic transformations to existing data points while preserving their associated labels. Examples include rotating, flipping, cropping, or changing the brightness/contrast of images; adding noise to audio signals; or replacing words with synonyms or paraphrasing sentences in text data.

Data Concepts

Foundational terminology used to describe the nature, structure, components, and types of data employed within machine learning projects. Establishing a clear understanding of these concepts is essential for correctly formulating problems, selecting appropriate algorithms and tools, interpreting data, and evaluating model results effectively.

Data Handling & Preparation

The crucial collection of techniques and processes applied to raw, often messy, real-world data to transform it into a clean, consistent, structured, and suitable format for effective input into machine learning algorithms. This stage is often one of the most time-consuming aspects of an ML project but is absolutely critical, as the quality of the data directly impacts the performance, robustness, and reliability of the final model ("garbage in, garbage out").

Data Preprocessing

A fundamental and broad step in the data handling pipeline that involves applying various operations to raw data before it is fed into a machine learning model. Common tasks include handling missing values (e.g., through imputation methods like mean/median filling or deletion of records/features), identifying and correcting errors or inconsistencies, dealing with outliers, scaling numerical features (e.g., normalization, standardization), and encoding categorical features into appropriate numerical representations.

Data Set

An organized collection of individual data instances (also commonly referred to as samples, examples, records, or observations). Datasets are typically structured in a tabular format, where rows represent individual instances and columns represent features or attributes of those instances. Datasets are partitioned and used for various stages of the ML workflow, primarily training, validation (for tuning), and testing (for final evaluation).

Data Splitting & Validation

The critical practice of dividing the available dataset into distinct subsets to train the model, tune its hyperparameters, and evaluate its final performance in an unbiased manner. Proper splitting ensures that the model's ability to generalize to new, unseen data is reliably assessed, preventing overly optimistic performance estimates based solely on the data it was trained on.

Decision Tree

A versatile supervised learning model used for both classification and regression tasks. It works by recursively partitioning the data into smaller subsets based on the values of input features, creating a tree-like structure where internal nodes represent feature tests (e.g., 'age < 30?'), branches represent the outcomes of the tests, and leaf nodes represent the final predicted outcome (a class label or a continuous value). They are highly interpretable but can be prone to overfitting.

Deep Learning

Deep Learning is a subfield of machine learning based on artificial neural networks characterized by having multiple processing layers - often referred to as "deep" architectures - between the input and output. This depth allows models to learn hierarchical representations of data, where each layer transforms the input into a slightly more abstract and composite representation, as detailed in foundational texts like the Deep Learning Book.
For instance, in image processing, initial layers might detect simple features like edges, while deeper layers combine these features to recognize more complex patterns like objects or faces. This capability for automatic feature learning from raw data, without extensive manual engineering, is a key distinction from many traditional machine learning methods. The success and rapid advancement of Deep Learning have been significantly fueled by the availability of large datasets and breakthroughs in parallel computing, particularly using GPUs.

Deployment & Serving

The processes and infrastructure involved in taking a trained machine learning model and making it available for use by end-users or other applications, including monitoring its ongoing performance and health in the production environment.

Diffusion Model

A type of generative model inspired by thermodynamics, which learns to generate data by reversing a gradual process of adding noise (diffusion). During training, the model learns to predict the noise that was added at each step. To generate a new sample, the model starts with random noise and iteratively applies the learned noise prediction process in reverse, gradually denoising the input until a clean data sample is formed. Known for generating high-quality images.

Dimensionality Reduction

A set of techniques used in unsupervised learning (and sometimes preprocessing) to reduce the number of input features (dimensions) of a dataset while aiming to preserve as much important information or underlying structure as possible. This is useful for mitigating the "curse of dimensionality," improving computational efficiency, reducing noise, enabling data visualization (by reducing to 2 or 3 dimensions), and sometimes improving model performance. Principal Component Analysis (PCA) and t-SNE are common examples.

Distance, Probabilistic & Support Models

A collection of machine learning algorithms based on different underlying principles: measuring similarity (distance), leveraging probability theory, or finding optimal separating boundaries (support vectors). These models offer diverse approaches to classification and regression tasks.

Docker

Docker is an open-source platform designed to automate the deployment, scaling, and management of applications by using OS-level virtualization to deliver software in packages called containers. A container bundles an application's code along with all its dependencies, libraries, and configuration files, ensuring that it runs uniformly and consistently across different computing environments – from a developer's laptop to testing servers and production clouds. In MLOps, Docker is heavily utilized to package machine learning models and their environments, ensuring reproducibility and simplifying deployment by creating portable, self-contained units that isolate the application from the underlying infrastructure (Docker Official Website, Wikipedia).

Dropout

A regularization technique used in training neural networks to prevent overfitting. During each training iteration, dropout randomly sets the outputs of a fraction of neurons in a layer to zero. This forces the network to learn more robust features that are not overly reliant on any single neuron, effectively training multiple thinned networks simultaneously. During inference, dropout is typically turned off, and neuron outputs may be scaled.

Early Stopping

A form of regularization used during the iterative training of models like neural networks to prevent overfitting. It involves monitoring the model's performance on a separate validation set during training and stopping the training process when the performance on the validation set starts to degrade (i.e., the validation loss increases), even if the performance on the training set is still improving. The model parameters from the point of best validation performance are typically saved.

Embedding

An embedding is a learned representation, typically a relatively low-dimensional, dense vector of real numbers, used to represent discrete or high-dimensional data items such as words, sentences, images, users, or nodes in a graph. The key idea is that these vector representations capture meaningful semantic relationships or underlying features of the original data, such that similar items are positioned closer together in the multi-dimensional embedding space. This transformation makes complex, often non-numeric data suitable for input into mathematical models like neural networks and allows algorithms to leverage similarities and patterns effectively. Embeddings can be learned through various methods, including unsupervised techniques (like Word2Vec or GloVe for words) or as part of a larger supervised or self-supervised deep learning model (Google Developers ML Crash Course, Wikipedia).

Encoding

The essential process of converting categorical (non-numeric) features, such as text labels, categories (e.g., 'red', 'blue', 'green'), or identifiers, into a numerical representation that machine learning algorithms can understand and process, as most algorithms operate solely on numerical inputs. Common encoding methods include One-Hot Encoding (which creates a new binary column for each unique category), Label Encoding (which assigns a unique integer to each category, suitable for ordinal data or tree-based models), and Ordinal Encoding (assigning integers based on a meaningful order).

Ensemble Techniques

Advanced machine learning methods that combine the predictions from multiple individual models (often called base learners or weak learners) to produce a single, potentially more accurate, robust, and generalizable final prediction than any single constituent model. The key idea is that combining diverse models can reduce variance, bias, or improve overall predictive power.

Environment

The external system, simulation, or real-world setting with which the reinforcement learning agent interacts. It defines the space of possible states the agent can be in, the set of actions available in each state, the rules governing transitions between states based on actions (dynamics), and the mechanism for generating reward signals based on the agent's actions and resulting states.

Epoch

One complete pass through the entire training dataset during the training of a machine learning model, particularly neural networks. Training typically involves multiple epochs, allowing the model to see and learn from each training example multiple times, iteratively refining its parameters. The optimal number of epochs is a hyperparameter often determined using techniques like early stopping.

Experiment Tracking

The practice of systematically logging and managing all relevant information associated with machine learning experiments, including code versions, datasets used, hyperparameters, model configurations, evaluation metrics, and resulting artifacts (e.g., trained models). Experiment tracking tools (like MLflow Tracking, Weights & Biases, Comet ML) enable reproducibility, comparison between experiments, collaboration, and better understanding of model development processes.

F1 Score

A classification metric that provides a single score balancing both Precision and Recall. It is calculated as the harmonic mean of Precision and Recall: 2 * (Precision * Recall) / (Precision + Recall). The F1 score is particularly useful when dealing with imbalanced classes, as it requires both high precision and high recall for a high score.

Feature

An individual, measurable property, characteristic, or attribute of a data instance that serves as an input variable to a machine learning model. Features represent the information used by the model to make predictions or decisions; they are analogous to columns in a spreadsheet or fields in a database record. Examples include pixel intensity values in an image, word frequencies in a text document, a person's age, temperature readings, or categorical attributes like 'color' or 'product category'. Feature selection and engineering are critical steps in ML.

Feature Engineering

The creative and often domain-knowledge-driven process of selecting, transforming, combining existing features, or creating entirely new features from the raw data with the explicit goal of improving the predictive performance, interpretability, or robustness of a machine learning model. Techniques can range from simple transformations (e.g., log transform) to complex derivations like creating interaction terms, polynomial features, extracting information from timestamps (e.g., day of week), binning continuous variables, or applying domain-specific calculations.

Feature Store

A centralized repository or platform used in MLOps to manage, store, discover, and serve features (input data variables) for machine learning models. Feature stores help ensure consistency between features used during training and inference, facilitate feature reuse across different models and teams, manage feature computations, and provide low-latency access to features for real-time prediction serving.

Fine-tuning

The process of adapting a pre-trained Large Language Model for a specific downstream task or domain. This typically involves further training the model (or parts of it) on a smaller, labeled dataset relevant to the target task (e.g., sentiment analysis, medical text summarization). Fine-tuning leverages the general knowledge acquired during pre-training and specializes the model for better performance on the specific application.

Foundation Model

A foundation model refers to a large-scale machine learning model trained on vast quantities of broad, often unlabeled data, typically using self-supervised learning techniques. These models, exemplified by large language models (like GPT-3, BERT) or large vision models, learn versatile, general-purpose representations and capabilities from the pre-training data.
A key characteristic is their adaptability: they can be fine-tuned or adapted with relatively little task-specific data to perform well on a wide range of downstream tasks, thus serving as a "foundation" for numerous applications. The term gained prominence through the work of Stanford's Center for Research on Foundation Models (CRFM) (Stanford HAI - On the Opportunities and Risks of Foundation Models).

Gated Recurrent Units (GRU)

GRU (Gated Recurrent Unit) is a type of gated recurrent neural network introduced by Cho et al. in 2014, similar in purpose to LSTM but featuring a simplified architecture. Like LSTMs, GRUs aim to overcome the vanishing gradient problem inherent in simple RNNs, enabling the effective learning of long-range dependencies in sequential data.
A GRU employs two primary gates: an update gate and a reset gate. The update gate controls how much information from the previous hidden state should be retained and how much new information should be added, effectively combining the input and forget gates of an LSTM. The reset gate determines how much of the past information to forget when computing the current candidate activation. Due to its simpler structure and fewer parameters compared to LSTM, GRUs can be computationally more efficient while often achieving comparable performance on various sequence modeling tasks (Cho et al., 2014, Towards Data Science: Understanding GRUs).

Generalization

A critical measure of a machine learning model's effectiveness, representing its ability to apply the patterns learned during training to accurately process new, unseen data drawn from the same underlying distribution as the training data. Good generalization signifies that the model has captured the true underlying relationships rather than just memorizing the training examples, which is the ultimate goal for most ML applications.

Generative Adversarial Network (GAN)

A Generative Adversarial Network (GAN) is a class of machine learning frameworks, introduced by Ian Goodfellow and colleagues in 2014, designed for generative modeling. It consists of two neural networks, a Generator and a Discriminator, that compete against each other in a zero-sum game. The Generator's goal is to create data samples (e.g., images, sounds) that are indistinguishable from real data, while the Discriminator's goal is to accurately distinguish between real data samples and the "fake" samples produced by the Generator. Through this adversarial training process, the Generator progressively learns to produce increasingly realistic and high-quality data that mimics the distribution of the training dataset (Goodfellow et al., 2014, Wikipedia).

Generative Deep Learning Models

A class of deep learning models whose primary goal is to generate new data samples that resemble the distribution of the training data. These models learn the underlying patterns and structures within the data and can then synthesize novel examples, such as creating realistic images, generating coherent text, or composing music.

GGUF

GGUF (Georgi Gerganov Universal Format) is a file format developed by the llama.cpp project - founded by Georgi Gerganov - specifically designed for efficiently storing and running quantized Large Language Models (LLMs) locally, particularly optimized for CPU inference but also supporting GPU offloading.
Its key feature is native support for quantization, allowing model weights to be stored using lower precision (e.g., 4-bit, 5-bit, 8-bit integers instead of 16-bit floats), which significantly reduces the model's file size and RAM requirements, enabling large models to run on consumer-grade hardware.
GGUF typically consolidates the model architecture details, quantized weights, and tokenizer information into a single, portable file. It is the successor to the earlier GGML format, offering improvements like better extensibility and metadata handling. GGUF has become a popular standard for distributing models intended for local execution via tools like Ollama, LM Studio, and others relying on the llama.cpp library (llama.cpp GitHub, Hugging Face Blog Explanation of GGUF).

Ghibli Style

"Ghibli Style" refers to the distinct visual aesthetic strongly associated with the acclaimed Japanese animation studio, Studio Ghibli, recognized globally for films directed by Hayao Miyazaki and Isao Takahata (Wikipedia: Studio Ghibli). Artistically, it often features a hand-drawn look, detailed natural environments, whimsical elements, expressive characters, and atmospheric storytelling.
In the context of AI, "Ghibli Style" became a viral phenomenon as a prompt modifier for text-to-image generation model: The launch of OpenAI's GPT-4o Image Generation on March 25th, '25 (Wikipedia: GPT-4o) allowed millions of users to generate images mimicking this style. This surge led to extensive online sharing (such as this example from yours truly) and solidified the term's status as a popular AI art descriptor (Know Your Meme: Studio Ghibli AI Generator), while also sparking significant discussions regarding AI ethics and copyright implications for original artists and studios (TechCrunch, Reuters).

GPT

GPT stands for Generative Pre-trained Transformer, a family of autoregressive Large Language Models (LLMs) developed by OpenAI. First introduced with GPT-1 in a 2018 paper (Wikipedia), these models are based on the Transformer architecture and utilize a two-phase approach: extensive unsupervised pre-training on diverse text data, followed by task-specific fine-tuning or, increasingly with later models, direct use via prompting. The "Generative" aspect signifies their core capability of producing sequential text.
The public release of ChatGPT in November 2022, initially powered by models from the GPT-3.5 series, marked a significant cultural moment, bringing widespread public awareness and interaction to the potential of large-scale generative models (Radford et al., 2018 "Improving Language Understanding by Generative Pre-Training" (GPT-1), OpenAI Website, Wikipedia: OpenAI, Wikipedia: GPT).

GPU

GPU stands for Graphics Processing Unit, a specialized electronic circuit originally designed by various companies throughout the 1980s and 90s to rapidly manipulate memory and accelerate the creation of images for display output. While initially focused purely on graphics rendering, their underlying architecture proved highly suitable for general-purpose parallel computation tasks.
A pivotal moment occurred around 2007 with the introduction of programming frameworks like NVIDIA's CUDA (Compute Unified Device Architecture), which allowed developers to harness GPU power for non-graphics applications, significantly impacting scientific computing and machine learning. Unlike CPUs, which typically feature a small number of powerful cores optimized for sequential task execution, GPUs possess a massively parallel architecture containing hundreds or even thousands of simpler cores designed to execute the same instruction simultaneously across large datasets (SIMD/SIMT). This architectural difference makes GPUs exceptionally efficient at matrix multiplications and vector operations, which are computationally intensive but highly parallelizable bottlenecks in training deep neural networks.
Key specifications relevant to ML include the number of processing cores (e.g., CUDA cores for NVIDIA, Stream Processors for AMD), the amount and type of dedicated high-bandwidth memory (like HBM or GDDR), and the memory bandwidth itself, crucial for feeding the numerous cores with data. This parallel processing capability drastically reduces training times for complex models, enabling the development of larger AI systems and accelerating research progress (NVIDIA: CPU vs GPU, 2009, Wikipedia).

Gradient Descent

A widely used iterative optimization algorithm for finding the minimum of a function, commonly the loss function in machine learning and deep learning. It works by taking steps in the direction opposite to the gradient (the direction of steepest descent) of the function at the current point. Variants like Stochastic Gradient Descent (SGD) and Mini-batch Gradient Descent compute the gradient on smaller subsets of data for efficiency and faster convergence in large datasets. Adam and RMSprop are popular adaptive variants.

Group Relative Policy Optimization (GRPO)

Group Relative Policy Optimization (GRPO) is a reinforcement learning (RL) algorithm that enhances reasoning in large language models (LLMs) by comparing groups of responses in a single step, eliminating the need for a critic model. Unlike Proximal Policy Optimization (PPO), GRPO’s critic-free approach reduces computational overhead, making it efficient for tasks like mathematical reasoning, as seen in DeepSeekMath. It ranks responses within a group to optimize learning, improving chain-of-thought (CoT) reasoning in models like DeepSeek-R1. (Nathan Lambert on GRPO)

Hyperparameter

A configuration variable for the learning algorithm itself, whose value is set before the training process begins and is not learned directly from the data during training (unlike model parameters like weights). Examples include the learning rate, the number of hidden layers or neurons in a neural network, the 'K' value in K-Means clustering, or the strength of regularization. Optimal hyperparameters are typically found through experimentation and tuning procedures like grid search or cross-validation.

Image Classification

A fundamental Computer Vision task where the goal is to assign a single categorical label to an entire input image based on its content. For example, classifying an image as containing a 'cat', 'dog', or 'car'. Models are trained on labeled datasets to recognize visual patterns characteristic of each category.

Image Generation

A Computer Vision task focused on creating new, synthetic images that appear realistic or possess specific desired characteristics. This is often achieved using generative deep learning models like Generative Adversarial Networks (GANs), Diffusion Models, or Variational Autoencoders (VAEs), trained on large datasets of existing images.

Image Recognition

A broad term within Computer Vision that generally refers to the task of identifying and detecting objects, features, or patterns within an image. It often encompasses tasks like image classification (assigning a label to the entire image) and object detection (identifying and locating specific objects within the image).

Image Segmentation

A Computer Vision task that involves partitioning an image into multiple segments or regions, often with the goal of assigning a class label to every pixel in the image (semantic segmentation) or distinguishing between different instances of the same object class (instance segmentation). This provides a much more detailed understanding of the image content compared to classification or object detection.

Inference

The operational phase after a model has been successfully trained, where the fixed, learned model is deployed and used to make predictions, classifications, or decisions on new, previously unseen data inputs. Unlike the training phase, the model's parameters are not updated during inference. This is the stage where the model provides practical value in real-world applications, processing inputs to generate useful outputs (Wikipedia).

Instruction Tuning

A specific type of fine-tuning for Large Language Models aimed at improving their ability to follow human instructions and perform tasks described in natural language prompts. The model is fine-tuned on a dataset composed of examples formatted as (instruction, input, output) triples, teaching it to respond helpfully and accurately to diverse commands or questions presented in the prompt.

Interpretability

Interpretability, often closely related to Explainable AI (XAI), refers to the degree to which a human can understand the reasoning behind decisions or predictions made by an AI or machine learning model. It aims to answer why a model arrived at a specific output, going beyond simply knowing what the output is. This understanding is crucial for debugging models, building user trust, ensuring fairness by detecting potential biases, complying with regulations requiring explanations, and extracting domain knowledge from the model's learned patterns. While simpler models like linear regression or decision trees tend to be more inherently interpretable, complex models such as deep neural networks are often described as "black boxes." Techniques exist to provide insights into these complex models, though there can sometimes be a trade-off between a model's predictive power and its ease of interpretation (Christoph Molnar: Interpretable Machine Learning, Wikipedia: Explainable AI, Dario Amodei: The Urgency of Interpretability).

Intersection over Union (IoU)

A common evaluation metric used in object detection and image segmentation tasks to measure the overlap between the predicted bounding box (or segmentation mask) and the ground truth bounding box (or mask). It is calculated as the area of the intersection divided by the area of the union of the predicted and ground truth regions. A higher IoU value indicates a better localization accuracy for the prediction.

K-Means Clustering

A popular and relatively simple iterative unsupervised learning algorithm used to partition a dataset into a predefined number (K) of distinct, non-overlapping clusters. It works by randomly initializing K cluster centroids and then repeatedly assigning each data point to the cluster whose centroid is nearest (typically using Euclidean distance) and subsequently recalculating each centroid as the mean of the points assigned to it, until convergence.

k-Nearest Neighbors (k-NN)

A simple, non-parametric supervised learning algorithm used for both classification and regression. For prediction on a new data point, it identifies the 'k' closest data points (neighbors) in the training set based on a distance metric (e.g., Euclidean distance). For classification, it assigns the most common class among the k neighbors; for regression, it assigns the average value of the k neighbors. It's instance-based, meaning it doesn't learn an explicit model but relies on the entire training data during inference.

Kubernetes

An open-source container orchestration system for automating the deployment, scaling, and management of containerized applications (like those created with Docker). In MLOps, Kubernetes is often used to manage the deployment and scaling of model serving infrastructure, handle load balancing, automate rollouts and rollbacks, and ensure high availability and resilience for ML models in production.

L1 Regularization (Lasso)

A regularization technique that adds a penalty term to the loss function equal to the absolute value of the magnitude of the model's coefficients (weights). This penalty encourages sparsity, meaning it tends to shrink some coefficients exactly to zero, effectively performing feature selection by removing less important features from the model. It helps prevent overfitting and can improve model interpretability. Lasso stands for Least Absolute Shrinkage and Selection Operator.

L2 Regularization (Ridge)

A regularization technique that adds a penalty term to the loss function equal to the squared magnitude of the model's coefficients (weights). This penalty discourages large weights, shrinking them towards zero but typically not exactly to zero (unlike L1). It helps prevent overfitting by reducing model complexity and improving generalization, particularly when dealing with multicollinearity among features. Also known as weight decay.

Label (Target)

In the context of supervised learning, the label (also known as the target variable, output, response, or ground truth) is the known, correct value or category associated with a specific input data instance in the training and evaluation datasets. It represents the 'answer' that the model is trying to learn to predict based on the input features. For example, in an email spam detection task, the label for each email would be 'spam' or 'not spam'; in predicting house prices, the label would be the actual sale price.

Learning Paradigms & Techniques

The major categories and specific methodologies that define how machine learning algorithms are designed to learn from data. These paradigms differ primarily based on the type of data available (e.g., labeled, unlabeled) and the nature of the feedback or guidance provided to the learning algorithm during the training process.

Linear & Tree-Based Models

Foundational categories of machine learning models. Linear models assume a linear relationship between features and the target variable, while tree-based models partition the feature space using a series of hierarchical decisions. Both are widely used due to their interpretability and effectiveness on certain types of problems.

Linear Regression

A fundamental supervised learning algorithm used for predicting a continuous numerical target variable based on one or more input features. It assumes a linear relationship between the features and the target, aiming to find the best-fitting straight line (or hyperplane in higher dimensions) through the data points by minimizing the sum of squared differences between predicted and actual values (least squares).

Llama

Llama refers to a family of Large Language Models (LLMs) developed and released by Meta AI. These models are based on the Transformer architecture and have been released in successive iterations, from Llama 1 to 4. Meta AI released the first Llama version in February 2023. Llama models are typically offered in various sizes (e.g., measured in billions of parameters) to accommodate different computational capabilities and application needs (Meta AI Blog Announcement for Llama 4 (April '25, Llama models on Hugging Face).

LLM

LLM stands for Large Language Model, a type of deep neural network specifically architected for processing and generating human language. Internally, an LLM first converts input text into a sequence of numerical tokens using a specialized tokenizer, which operates based on a predefined vocabulary – the set of all unique tokens (words, subwords) the model recognizes.
These token sequences are then processed through numerous layers (typically dozens, sometimes exceeding a hundred in the largest models) of a deep neural network, predominantly based on the Transformer architecture.
Each layer applies complex mathematical transformations, utilizing mechanisms like self-attention to weigh the importance of different tokens and capture context across long sequences. The model's parameters (weights and biases), numbering from hundreds of millions to hundreds of billions, are learned during extensive pre-training on massive text datasets. This scale and architecture enable LLMs to encode linguistic knowledge and perform diverse language tasks (Wikipedia, Vaswani et al., 2017 "Attention Is All You Need").

Logistic Regression

A supervised learning algorithm used primarily for binary classification problems (predicting one of two outcomes, e.g., yes/no, spam/not spam), despite its name including "regression". It models the probability of the default class using a logistic function (sigmoid) applied to a linear combination of input features. The output probability is then thresholded (typically at 0.5) to make the final class prediction.

Loss Function

A mathematical function that quantifies the discrepancy or error (the "loss") between the model's predictions and the actual ground truth values (labels) for the instances in the training or validation data. The learning process aims to iteratively minimize this function's value by adjusting the model's parameters. The choice of an appropriate loss function is critical and depends heavily on the specific machine learning task (e.g., Mean Squared Error for regression, Cross-Entropy Loss for classification).

LSTM (Long Short-Term Memory)

LSTM, standing for Long Short-Term Memory, is a specialized type of Recurrent Neural Network (RNN) architecture designed by Sepp Hochreiter and Jürgen Schmidhuber in 1997 to effectively learn long-range dependencies in sequential data. Standard RNNs often suffer from the vanishing gradient problem, making it difficult for them to capture relationships between elements far apart in a sequence.
LSTMs address this issue through a more complex internal structure centered around a memory cell, which can maintain information over long periods. This cell's state is carefully regulated by three primary gating mechanisms: the input gate (controlling what new information enters the cell), the forget gate (controlling what information is discarded from the cell), and the output gate (controlling what part of the cell state is output). This gating system allows LSTMs to selectively remember or forget information, making them highly successful for tasks like machine translation, speech recognition, time series forecasting, and sentiment analysis (Hochreiter & Schmidhuber, 1997, Christopher Olah's Blog: Understanding LSTMs).

Machine Learning (ML)

A core subfield of Artificial Intelligence focused specifically on the development and study of algorithms and statistical models that enable computer systems to perform specific tasks without being explicitly programmed with rules for those tasks. Instead, these systems learn patterns, relationships, and decision boundaries directly from empirical data through a process often called 'training', progressively improving their performance on the task as they are exposed to more data.

Machine Learning Models

This section categorizes and describes various types of algorithms and structures used in machine learning to learn patterns from data and perform tasks like classification, regression, clustering, etc. It covers a range of models from simpler linear approaches to more complex ensemble methods and neural networks.

Machine Translation

An NLP task focused on automatically translating text or speech from one natural language (source language) to another (target language) while preserving the meaning. Modern machine translation systems heavily rely on deep learning models, particularly Transformer-based architectures (like those used in Google Translate or DeepL), trained on large parallel corpora.

Mean Absolute Error (MAE)

A regression metric calculated as the average of the absolute differences between the predicted values and the actual values. Unlike MSE, MAE treats all errors equally regardless of their magnitude and is less sensitive to outliers. Its units are the same as the target variable's units, making it more interpretable than MSE in terms of average prediction error magnitude.

Mean Average Precision (mAP)

A standard metric for evaluating the performance of object detection and instance segmentation models. It calculates the average precision (AP) across multiple Intersection over Union (IoU) thresholds and/or across all object classes. AP for a single class is derived from the precision-recall curve. mAP provides a single comprehensive score that reflects both the classification accuracy and localization accuracy of the detector across different conditions.

Mean Squared Error (MSE)

A common regression metric calculated as the average of the squared differences between the predicted values and the actual values. Squaring the errors penalizes larger errors more heavily than smaller ones and ensures the result is always non-negative. Its units are the square of the target variable's units.

Mixture-of-Experts (MoE)

Mixture-of-Experts (MoE) is a neural network architecture designed to increase model capacity and computational efficiency by employing conditional computation. Instead of processing every input with the entire network, an MoE layer consists of multiple specialized sub-networks called 'experts' and a 'gating network'. For a given input, the gating network dynamically determines which expert(s) are best suited to process it, activating only that small subset of the network's parameters. This allows MoE models, particularly Large Language Models, to scale to vastly larger parameter counts while keeping the computational cost (FLOPs) per input relatively low compared to dense models of similar size. Early concepts date back to 1991 (Jacobs et al.), with significant advancements in sparse MoEs for large scale models detailed later (Shazeer et al., 2017 "Outrageously Large Neural Networks", Fedus et al., 2021 "Switch Transformers").

Model Context Protocol (MCP)

The Model Context Protocol (MCP), introduced by Anthropic in 2024, is an open-source standard enabling AI agents to interface seamlessly with external tools and data sources, such as databases or APIs. It emerged to address fragmented AI integrations, where agents faced challenges accessing live data and required custom APIs for each tool, hindering scalability and real-time functionality. Likened to a "USB-C for AI," MCP standardizes communication, supporting secure, bidirectional interactions across models to enable tasks like workflow automation or coding, as detailed in its technical specification. It enhances agentic AI in fields like enterprise systems and web automation.

ML Operations (MLOps)

A set of practices, principles, and tools that aims to deploy, manage, monitor, and govern machine learning models in production reliably and efficiently. MLOps combines ML development (Dev) with IT operations (Ops) to automate and streamline the end-to-end ML lifecycle, bridging the gap between model building and operational deployment.

ML Pipeline

An end-to-end workflow that orchestrates and automates the sequence of steps involved in a machine learning project, typically including data ingestion, preprocessing, feature engineering, model training, evaluation, validation, and deployment. ML pipelines promote reproducibility, efficiency, scalability, and easier management and monitoring of the entire ML process. Tools like Kubeflow Pipelines, Apache Airflow, or cloud platform services are often used to build and manage these pipelines.

Model

In the context of machine learning, a model represents the specific computational artifact or structure that is learned from data during the training process. It encapsulates the patterns, relationships, or decision logic extracted from the training data. Examples include a trained neural network with specific weights, a decision tree with its split points, or the coefficients of a linear regression equation. This learned representation is then used during the inference phase to make predictions or decisions on new, unseen data.

Model Deployment

The process of integrating a trained machine learning model into an existing production environment (e.g., a web application, mobile app, or internal system) so that it can receive input data and provide predictions or decisions to users or downstream systems. Deployment strategies include embedding the model directly, serving via an API, or deploying on edge devices.

Model Evaluation

The crucial process of assessing the performance and quality of a trained machine learning model to understand how well it performs its intended task and how effectively it generalizes to new, unseen data. This involves using various quantitative metrics suited to the specific type of machine learning problem (e.g., classification, regression).

Model Monitoring

The ongoing process of tracking and evaluating the performance, health, and behavior of a deployed machine learning model in the production environment. This involves monitoring operational metrics (e.g., latency, throughput, errors), data drift (changes in input data distribution), concept drift (changes in the relationship between inputs and outputs), and prediction accuracy over time to ensure the model remains reliable and to trigger retraining or intervention when needed.

Model Registry

A centralized system or repository used in MLOps to store, version, manage, and track trained machine learning models. It serves as a catalogue for models, storing metadata such as training parameters, evaluation metrics, artifacts, lineage, and deployment status. Model registries facilitate collaboration, reproducibility, governance, and streamlined deployment processes.

Model Serving

The infrastructure and mechanisms used to host a trained machine learning model and make its prediction capabilities accessible, typically via network requests (like an API). Model serving platforms handle tasks like loading models, managing versions, scaling resources to handle prediction requests efficiently, and ensuring low latency and high availability for real-time inference.

Multimodal AI (LMM)

An emerging area of Artificial Intelligence focused on building models that can process, understand, and reason about information from multiple modalities (types of data) simultaneously, such as text, images, audio, and video. LMM likely stands for Large Multimodal Model. The goal is to create AI systems with a more holistic understanding, closer to human perception.

Multimodal Transformers

Extensions or adaptations of the Transformer architecture designed to handle inputs from multiple modalities concurrently. These models often employ mechanisms like cross-modal attention to fuse information and learn relationships between different data types (e.g., aligning text descriptions with image regions). They form the basis for many advanced multimodal AI applications.

Naïve Bayes

A family of simple probabilistic classifiers based on applying Bayes' theorem with strong (naïve) independence assumptions between the features. Despite this often unrealistic assumption, Naïve Bayes models are computationally efficient and have proven effective in various real-world tasks, particularly text classification (e.g., spam filtering) and medical diagnosis, especially when dealing with high-dimensional data.

Named Entity Recognition (NER)

An NLP task focused on identifying and categorizing named entities mentioned in unstructured text into predefined categories such as person names, organizations, locations, medical codes, time expressions, quantities, monetary values, percentages, etc. NER is crucial for information extraction, knowledge base population, and contextual understanding.

Natural Language Processing (NLP)

Natural Language Processing (NLP) is an interdisciplinary field at the intersection of computer science, artificial intelligence, and linguistics, concerned with enabling computers to understand, interpret, manipulate, and generate human language (text and speech). Its goal is to bridge the gap between human communication and computer understanding. NLP powers a wide range of applications, including machine translation, sentiment analysis, chatbots, text summarization, named entity recognition, and question answering systems. Modern NLP heavily relies on machine learning and deep learning techniques, particularly models like Recurrent Neural Networks (RNNs) and Transformers, to learn patterns and context from vast amounts of language data.

Neural Network

An Artificial Neural Network (ANN), often simply called a Neural Network, is a computational model inspired by the structure and function of biological neural networks in brains. It consists of interconnected processing units called neurons (or nodes), typically organized in layers: an input layer, one or more hidden layers, and an output layer. Each connection between neurons has an associated weight, which modulates the signal passing through it. Neurons compute an output based on the weighted sum of their inputs passed through an activation function. Neural networks "learn" by iteratively adjusting these weights based on training data, typically using algorithms like backpropagation and gradient descent to minimize the difference between the network's predictions and the actual target values. This allows them to model complex, non-linear relationships and patterns in data, forming the foundation of deep learning (Wikipedia, Deep Learning Book - Chapter 6).

Neural Network Fundamentals

The basic building blocks, components, and concepts that form the foundation of artificial neural networks, the core structures used in deep learning. Understanding these elements is essential for comprehending how deep learning models are constructed and function.

Neural Network Training & Regularization

The processes, algorithms, and techniques involved in optimizing the parameters (weights and biases) of a neural network based on training data, along with methods used to prevent overfitting and improve the model's ability to generalize to unseen data.

NLP Evaluation Metrics

Quantitative measures specifically designed to evaluate the performance of models on Natural Language Processing tasks, particularly those involving text generation, such as machine translation or summarization.

Normalization

A specific type of data scaling technique commonly used in preprocessing, typically referring to Min-Max scaling. It rescales the values of numerical features to fit within a predefined, fixed range, most commonly [0, 1] or sometimes [-1, 1]. This is achieved by subtracting the minimum value and dividing by the range (maximum minus minimum) of the feature. Normalization ensures that features with naturally larger value ranges do not disproportionately influence distance-based algorithms (like k-NN) or the convergence speed and stability of gradient-based optimization methods used in training models like neural networks.

NumPy

NumPy (Numerical Python) is a fundamental open-source library for numerical computation in Python, initially created by Travis Oliphant in 2005 by consolidating earlier numerical libraries. It provides efficient support for large, multi-dimensional arrays (ndarrays) and matrices, along with a comprehensive collection of high-level mathematical functions to operate on these arrays. NumPy's strength lies in its performance, achieved through optimized C implementations for array operations, making it significantly faster than native Python lists for numerical tasks. It forms the bedrock of the scientific Python ecosystem, serving as a core dependency for libraries like SciPy, Pandas, Matplotlib, and Scikit-learn (NumPy Official Website, NumPy Documentation).

Object Detection

A Computer Vision task that goes beyond image classification by not only identifying what objects are present in an image but also locating their positions, typically by drawing bounding boxes around each detected object and assigning a class label to each box. This is crucial for applications like autonomous driving and surveillance.

Ollama

Ollama is an open-source tool designed to simplify the process of downloading, setting up, and running large language models (LLMs), embeddings, and other generative AI models locally on a user's own computer (macOS, Windows, Linux). It streamlines local AI execution by bundling model weights, configuration, and a model runner into easily manageable packages, typically interacted with via a command-line interface (e.g., ollama run llama3). This significantly lowers the barrier to entry for developers and researchers wanting to experiment with or build applications using powerful models offline, ensuring privacy and reducing reliance on cloud-based APIs. Ollama supports a wide range of popular open-source models, often leveraging optimized formats like GGUF, and includes a built-in API server for programmatic interaction with the local models (Ollama Official Website, Ollama Model List, by date, Ollama GitHub).

One-Shot Learning

One-shot learning refers to a type of classification problem within machine learning where the goal is for a model to correctly classify new data instances belonging to classes for which only a single labeled example has been provided during the familiarization or "support" phase. This contrasts significantly with traditional supervised learning, which typically requires numerous examples per class for effective training. One-shot learning is particularly relevant in scenarios where collecting labeled data for new classes is difficult, expensive, or time-consuming, such as in facial recognition (enrolling a new face with one picture) or rare object detection. Models designed for one-shot learning often focus on learning a similarity function or a metric space where instances of the same class are close, rather than learning class-specific features directly from the single example. It is closely related to few-shot learning (learning from a small number, k>1, examples) and zero-shot learning (classifying examples from classes unseen during training, usually using auxiliary information). (Wikipedia, Fei-Fei et al., 2006 "One-Shot Learning of Object Categories, PDF")

One-Shot Prompting

One-shot prompting is a technique used when interacting with Large Language Models (LLMs) where the input prompt includes exactly one example illustrating the desired task format or output style, followed by the actual query or input for which the user wants a response. This single example serves as a demonstration or template, guiding the LLM to perform the task more accurately or in the desired format by leveraging its in-context learning capabilities. It represents a middle ground between zero-shot prompting (providing no examples) and few-shot prompting (providing multiple examples), offering a way to provide context with minimal prompt length. The effectiveness of these prompting strategies was extensively demonstrated in the original GPT-3 paper (Brown et al., 2020 "Language Models are Few-Shot Learners").

Probably Approximately Correct (PAC) Model

The Probably Approximately Correct (PAC) learning model is a foundational framework within computational learning theory, introduced by Leslie Valiant in 1984, that mathematically formalizes the concept of successful learning from data. It doesn't describe a specific algorithm architecture but rather a theoretical model of the learning process itself. The PAC model seeks guarantees that a learning algorithm will, with high probability (the "Probably" part, typically quantified as at least 1-δ), find a hypothesis (a model or function) whose error on unseen data drawn from the same distribution is small (the "Approximately Correct" part, typically quantified as at most ε). A key focus of PAC analysis is determining the sample complexity – the number of training examples required to achieve these (ε, δ) guarantees for a given concept class and hypothesis space – thereby providing insights into the efficiency and feasibility of learning (Valiant, 1984 "A Theory of the Learnable", Wikipedia).

Overfitting

A common pitfall in machine learning where the model learns the training data too precisely, capturing not only the underlying patterns but also noise, outliers, and specific idiosyncrasies present only in that particular training set. This results in high accuracy on the training data but poor performance (low generalization) on new, unseen data because the learned patterns do not apply broadly. It often occurs when the model is excessively complex relative to the amount or quality of training data.

Parameters

In machine learning, parameters refer to the internal variables of a model whose values are learned directly from the training data during the training process. Unlike hyperparameters (which are configured before training), parameters are the values the model adjusts iteratively, typically using optimization algorithms like gradient descent, to minimize a loss function and capture the underlying patterns in the data. In neural networks, the primary parameters are the weights associated with the connections between neurons and the biases associated with the neurons themselves. In simpler models like linear regression, parameters are the learned coefficients and intercept. The number of parameters determines the model's capacity and complexity, ranging from a few in simple models to hundreds of billions in large deep learning models. Once training is complete, these learned parameters are fixed and used during inference to make predictions (Our World in Data, Wikipedia).

Pixel

Short for 'picture element', a pixel is the smallest controllable element of a picture represented on a digital screen or in a digital image file. Digital images are composed of a grid of pixels, where each pixel has a specific location and typically stores color information (e.g., RGB values for red, green, and blue intensities) or grayscale intensity. Pixels are the fundamental units processed by most computer vision algorithms.

Policy

The strategy, mapping, or decision-making function employed by the reinforcement learning agent to select an action when it observes a particular state. The policy essentially defines the agent's behavior. It can be deterministic (always choosing the same action for a given state) or stochastic (choosing actions based on a probability distribution over the available actions for a given state). The primary goal of RL is often to learn the optimal policy.

Pre-training

The initial, computationally intensive phase of training a Large Language Model (or foundation model). During pre-training, the model learns general language patterns, grammar, world knowledge, and reasoning capabilities by processing massive amounts of unlabeled text data using self-supervised learning objectives (e.g., predicting masked words, predicting the next word). This phase establishes the model's core understanding of language.

Precision

A classification metric that measures the proportion of positive predictions made by the model that were actually correct. It answers the question: "Of all the instances the model predicted as positive, how many truly were positive?" Calculated as True Positives / (True Positives + False Positives). High precision is important when the cost of a false positive is high.

Prompt Engineering

Prompt engineering is the process of structuring the input text (the prompt) provided to a generative model, typically a Large Language Model (LLM), to elicit a desired response or behavior. It involves strategically crafting the input—incorporating instructions, context, examples (zero-shot, one-shot, few-shot), or specific formatting—to effectively guide the model's generation process for a target task. This technique leverages the model's in-context learning capabilities, allowing users to control and specialize the output for specific applications without modifying the underlying model parameters (Wikipedia, Prompt Engineering Guide).

PyTorch

PyTorch is a popular open-source machine learning library, primarily developed by Meta AI (formerly Facebook's AI Research lab) and released in 2016. It is widely recognized for its Python-first integration, making it feel intuitive for Python developers, and its use of dynamic computation graphs (define-by-run), which offer flexibility during model development and debugging. Key strengths include strong GPU acceleration, a rich ecosystem of tools and libraries for deep learning research and deployment, and a large, active community. PyTorch operations are primarily based on Tensors, similar to NumPy arrays but with added capabilities for GPU computation and automatic differentiation (PyTorch Official Website, PyTorch GitHub).

Question Answering

A key application of Large Language Models where the model processes a given context (e.g., a document or passage of text) and answers questions based on the information contained within that context. Advanced LLMs can also answer open-domain questions by leveraging the vast knowledge learned during pre-training, sometimes without needing explicit context provided in the prompt.

R-squared (R^2 Score)

Also known as the coefficient of determination, this regression metric represents the proportion of the variance in the dependent variable (target) that is predictable from the independent variables (features) included in the model. It ranges from negative infinity to 1, where 1 indicates a perfect fit (the model explains all the variance), 0 indicates the model performs no better than predicting the mean, and negative values indicate the model performs worse than predicting the mean.

RAG

Retrieval-Augmented Generation (RAG) is an architectural approach used to improve the quality, accuracy, and relevance of responses generated by Large Language Models (LLMs). Instead of relying solely on the LLM's internal, parametric knowledge (learned during training), RAG systems first retrieve relevant information from an external knowledge source (like a collection of documents, a database, or search engine results) based on the user's prompt or query. This retrieved context is then combined with the original prompt and fed into the LLM, which uses this augmented information to generate its final response. This process helps to mitigate issues like LLM hallucination, provides access to up-to-date or domain-specific information not present in the model's training data, and can allow for better source attribution (Lewis et al., 2020 "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks", Pinecone: What is RAG?).

Random Forest

An ensemble learning method that builds multiple decision trees during training and outputs the mode of the classes (classification) or mean prediction (regression) of the individual trees. It introduces randomness by using bootstrap aggregating (bagging) to create different training subsets for each tree and by considering only a random subset of features at each split point. This typically results in a more robust model with lower variance and better generalization than a single decision tree.

Recall (Sensitivity)

A classification metric that measures the proportion of actual positive instances that were correctly identified by the model. It answers the question: "Of all the truly positive instances, how many did the model correctly predict?" Calculated as True Positives / (True Positives + False Negatives). Also known as Sensitivity or True Positive Rate. High recall is important when the cost of a false negative is high.

Recurrent Neural Network (RNN)

A Recurrent Neural Network (RNN) is a class of artificial neural networks specifically designed to process sequential data, such as text, speech, or time series, where the order of information is crucial. Unlike feedforward networks, RNNs possess connections that form directed cycles, allowing them to maintain an internal state or 'memory' that captures information about previous inputs encountered in the sequence. This internal state is updated at each step as the network processes the sequence element by element, enabling the output at a given step to depend not only on the current input but also on the context learned from prior inputs.
While powerful for modeling sequences, simple RNNs often struggle with learning long-range dependencies due to issues like vanishing or exploding gradients. This led to the development of more sophisticated variants like Long Short-Term Memory (LSTM) and Gated Recurrent Units (GRU) (Deep Learning Book - Chapter 10, Christopher Olah's Blog: Understanding LSTMs).

Regression Metrics

Quantitative measures used to evaluate the performance of models designed for regression tasks (predicting continuous numerical values). These metrics quantify the difference or error between the model's predicted values and the actual target values.

Reinforcement Learning

Reinforcement Learning (RL) is a paradigm of machine learning concerned with how intelligent agents ought to take sequences of actions in an environment to maximize a cumulative reward signal. Distinct from supervised learning (which uses labeled data) and unsupervised learning (which finds patterns in unlabeled data), RL agents learn optimal behaviors, encapsulated in a policy, through trial-and-error interactions. The agent observes the environment's state, performs an action, transitions to a new state, and receives a numerical reward or penalty. This feedback loop allows the agent to learn which actions lead to better long-term outcomes. RL is widely applied in domains like game playing (e.g., AlphaGo), robotics control, autonomous systems, recommendation systems, and resource management (Sutton and Barto, Reinforcement Learning: An Introduction, Wikipedia, AlphaGo Movie on Youtube).

Reward

A numerical feedback signal provided by the environment to the reinforcement learning agent after it performs an action or transitions to a new state. This signal represents the immediate desirability or success of that action or state. Positive rewards encourage the preceding behavior, while negative rewards (penalties) discourage it. The agent's fundamental goal is typically to learn a policy that maximizes the sum of discounted rewards received over time.

ROUGE Score

Stands for Recall-Oriented Understudy for Gisting Evaluation. A set of metrics primarily used for evaluating automatic summarization and sometimes machine translation. ROUGE measures the recall of n-grams (ROUGE-N) or the longest common subsequence (ROUGE-L) between the machine-generated text (summary) and one or more human-generated reference summaries. Higher scores indicate better overlap and content coverage compared to the references.

Sentiment Analysis

An NLP task, often considered a subfield of text classification, that aims to determine the emotional tone, opinion, or attitude expressed in a piece of text. It typically involves classifying text as positive, negative, or neutral, but can also involve identifying specific emotions (e.g., joy, anger, sadness) or determining the polarity and intensity of sentiment towards specific aspects or entities mentioned in the text (Aspect-Based Sentiment Analysis).

Stacking

Short for Stacked Generalization, stacking is an ensemble technique that combines predictions from multiple different types of base models (e.g., a decision tree, an SVM, a k-NN model) by training a final 'meta-model' or 'blender'. The base models are trained on the original data, and their predictions on a hold-out set (or via cross-validation) serve as the input features for the meta-model, which learns how to best combine these predictions to make the final output.

State

A specific configuration or situation of the environment at a particular point in time, ideally capturing all the necessary information for the reinforcement learning agent to make an informed decision about its next action. States can range from simple discrete values to complex high-dimensional vectors (e.g., pixel data from a camera). The agent's policy maps states to actions.

Supervised Learning

A prevalent machine learning paradigm where the algorithm learns from a dataset containing explicitly labeled examples, meaning each input data point is paired with a corresponding correct output or target value. The goal is for the model to learn a mapping function that can accurately predict the output label for new, unseen input examples. Common tasks include classification (predicting discrete categories) and regression (predicting continuous numerical values).

Support Vector Machine (SVM)

A powerful supervised learning algorithm used for classification, regression, and outlier detection. For classification, SVM aims to find the optimal hyperplane (a decision boundary) that best separates data points belonging to different classes in the feature space, maximizing the margin (distance) between the hyperplane and the nearest data points (support vectors) of any class. Kernels can be used to handle non-linearly separable data by mapping it to higher dimensions.

Temperature

Temperature is a hyperparameter used during the sampling phase of sequence generation, particularly with Large Language Models (LLMs), to control the level of randomness or creativity in the output.
It works by rescaling the logits (the raw scores output by the model for each possible next token) before they are converted into probabilities via the softmax function. A lower temperature (e.g., values closer to 0, like 0.2) sharpens the probability distribution, making the model more confident and deterministic; it primarily selects the highest-probability tokens, resulting in more focused, coherent, but potentially repetitive text.
Conversely, a higher temperature (e.g., values greater than 1, like 1.5) flattens the distribution, increasing the likelihood of sampling lower-probability tokens, leading to more diverse, surprising, creative, but potentially less coherent or relevant output. A temperature of 1 uses the original probabilities predicted by the model. Adjusting temperature allows users to fine-tune the trade-off between coherence and creativity in generated text (Hugging Face Blog: How to generate text).

Tensor

A tensor is a mathematical object that generalizes scalars, vectors, and matrices to potentially higher dimensions, representing multilinear relationships between vector spaces. In machine learning and deep learning, tensors serve as the fundamental data structure for holding and manipulating numerical information. A scalar (a single number) is considered a rank-0 tensor, a vector (a 1D array) a rank-1 tensor, and a matrix (a 2D array) a rank-2 tensor. Higher-rank tensors allow for the representation of complex data structures like color images (e.g., height, width, color channels) or batches of sequential data, making them essential for deep learning computations (Wikipedia | Wolfram MathWorld).

TensorFlow

TensorFlow, initially released by the Google Brain team in November 2015, is a powerful open-source software library extensively used for numerical computation and machine learning, especially deep learning. Evolving from Google's internal systems, it gained widespread adoption due to its key strengths: flexibility in modeling, scalability across diverse hardware platforms (CPUs, GPUs, TPUs), and a comprehensive ecosystem supporting the journey from research experimentation to robust production deployment. It represents computations as data flow graphs operating on tensors (TensorFlow Official Website, TensorFlow Whitepaper 2016).

Text Classification

A fundamental NLP task that involves assigning predefined categories or labels to blocks of text (e.g., sentences, paragraphs, documents). Examples include spam detection (classifying emails as 'spam' or 'not spam'), sentiment analysis (classifying reviews as 'positive', 'negative', or 'neutral'), and topic categorization (assigning news articles to topics like 'sports', 'politics', 'technology').

Text Generation

A core capability and common application of Large Language Models. This involves using the model to produce human-like text, which can range from completing sentences or paragraphs to writing articles, emails, code, creative stories, dialogues, summaries, and more, based on an initial prompt or context.

Token

A token is a fundamental unit of text generated by the process of tokenization in Natural Language Processing (NLP). It represents an instance of a sequence of characters grouped together as a useful semantic unit for processing. Depending on the tokenization strategy employed, a token could be a word (e.g., "cat"), a subword or part of a word (e.g., "token", "ization" from "tokenization" using certain algorithms), a single character, or punctuation. Creating these discrete units is a crucial first step in preparing raw text for analysis or input into machine learning models, as models typically operate on sequences of tokens rather than raw character streams (Hugging Face Tokenizers Documentation, Stanford NLP - Tokenization).

Train-Test Split

A fundamental technique where the dataset is divided into two primary, non-overlapping subsets: a training set and a test set. The training set is used exclusively to train the model (learn parameters), while the test set is held back and used only once at the very end to provide an unbiased evaluation of the final trained model's performance on unseen data. Common split ratios are 70/30, 80/20, or 90/10 (train/test).

Training

The crucial phase where a machine learning model is developed by being systematically exposed to a dataset (the training set). During this iterative process, the model adjusts its internal parameters (e.g., weights and biases in a neural network) guided by an optimization algorithm (like gradient descent) aiming to minimize a defined loss function, thereby learning to map inputs to desired outputs or uncover underlying data patterns effectively.

Training Set

The specific subset of the overall dataset that is used exclusively to train the machine learning model. During the training phase, the model iteratively processes the instances in this set, compares its predictions to the known labels (in supervised learning), calculates the loss, and adjusts its internal parameters (e.g., weights) accordingly to minimize the loss. It's crucial to keep the training set separate from validation and test sets to ensure an unbiased assessment of the model's ability to generalize.

Transfer Learning

A powerful machine learning technique where a model developed (pre-trained) for one task is reused as the starting point for a model on a second, related task. Typically, the features and weights learned by the pre-trained model (often trained on a very large dataset, like ImageNet for vision or large text corpora for NLP) are leveraged, and only the final layers are retrained or fine-tuned on the target task's smaller dataset. This significantly reduces training time and data requirements for the new task.

Transformer Architecture

The Transformer is a neural network architecture introduced by Google researchers in the seminal 2017 paper "Attention Is All You Need." It revolutionized sequence-to-sequence modeling, particularly in Natural Language Processing (NLP), largely replacing recurrent architectures like RNNs and LSTMs for many state-of-the-art tasks.
Its core innovation is the self-attention mechanism, which enables the model to weigh the importance of different input tokens relative to each other when processing any given token, regardless of their distance within the sequence. This allows for effective capture of long-range dependencies and context. Unlike RNNs, the Transformer architecture avoids recurrence and processes sequences largely in parallel, significantly speeding up training.
Key components typically include an encoder and a decoder (each composed of stacked identical layers), multi-head self-attention mechanisms, position-wise feed-forward networks, and positional encodings to incorporate sequence order information. The Transformer forms the foundation for most modern Large Language Models (LLMs) like BERT, GPT, and T5 (Vaswani et al., 2017 "Attention Is All You Need", Jay Alammar: The Illustrated Transformer).

Underfitting

Underfitting occurs in machine learning when a model is too simple to capture the underlying patterns and structure present in the training data. This results in poor performance not only on new, unseen data (test set) but also on the training data itself. An underfit model fails to learn the relevant relationships between input features and the target variable, often because it lacks sufficient complexity (e.g., a linear model trying to fit non-linear data) or has not been trained for enough iterations. It signifies that the model has high bias and cannot adequately represent the data's complexity (GeeksforGeeks: Underfitting and Overfitting, Towards Data Science: Overfitting vs. Underfitting).

Unsupervised Learning

Unsupervised learning is a machine learning paradigm where the algorithm learns patterns and structures from data that does not have predefined labels or target outputs. Unlike supervised learning, the model is not given explicit "correct answers" to learn from. Instead, the goal is to autonomously discover hidden relationships, groupings, or representations within the input data itself. Common tasks include clustering (grouping similar data points together), dimensionality reduction (reducing the number of features while preserving important information), anomaly detection (identifying unusual data points), and density estimation. Unsupervised techniques are crucial for exploring data, uncovering latent structures, and feature extraction (Wikipedia, Deep Learning Book - Chapter 5.1.3).

Validation Set

A validation set is a subset of the available data, separate from both the training set and the test set, used during the machine learning model development process. Its primary purpose is to provide an unbiased evaluation of a model fit on the training set while tuning hyperparameters (e.g., learning rate, number of layers) or performing model selection (e.g., choosing between different algorithms or architectures). Performance metrics calculated on the validation set guide the iterative refinement of the model. Using a separate validation set helps prevent overfitting the model selection process to the final test set, thereby ensuring that the test set performance remains a reliable estimate of the model's generalization ability on truly unseen data (Scikit-learn Documentation on Cross-validation, Wikipedia: Training, validation, and test sets).

Variational Autoencoder (VAE)

A generative model based on the autoencoder architecture but with a probabilistic twist. Instead of mapping the input to a single point in the latent space, the VAE encoder maps the input to a probability distribution (typically Gaussian). The decoder then samples from this distribution to reconstruct the input. This probabilistic approach allows VAEs to generate new data samples by sampling points from the learned latent distribution and decoding them. They combine aspects of deep learning and Bayesian inference.

Vibe Coding

Coined by Andrej Karpathy in February 2025, "Vibe Coding" describes a software development approach primarily leveraging Large Language Models (LLMs), where the user guides the AI through natural language prompts, often without understanding or direct manipulation of the generated code's specific implementation details.
The emphasis is on iteratively refining prompts based on the observed behavior or overall "vibe" of the output until it aligns with the desired outcome, making it particularly relevant for individuals with limited traditional coding experience.
This practice aligns with Karpathy's earlier observation in January 2023 that "The hottest new programming language is English," highlighting the shift towards using natural language as the primary interface for instructing code generation AIs (Karpathy's 'Vibe Coding' Tweet, Karpathy's 'English' Tweet, Wikipedia).

Vision-Language Models

A specific category of multimodal AI models designed to understand and generate information across both visual (images or video) and textual modalities. These models can perform tasks like image captioning (generating text descriptions for images), visual question answering (answering questions about an image), text-to-image generation, and retrieving images based on text descriptions. Examples include CLIP, DALL-E, and Flamingo.

vLLM

vLLM is an open-source library designed to significantly enhance the performance of Large Language Model (LLM) inference and serving. Developed by researchers (initially associated with UC Berkeley), its key innovation is PagedAttention, an attention algorithm inspired by traditional operating system techniques for virtual memory and paging. PagedAttention efficiently manages the large and dynamic memory requirements of the attention mechanism's key-value cache (KV cache) during LLM inference, reducing internal memory fragmentation and enabling near-optimal memory usage. This results in substantially higher throughput (more requests processed concurrently or sequentially) and allows serving larger models or more requests with the same GPU hardware compared to standard inference frameworks like Hugging Face Transformers (vLLM Project GitHub).

Vocabulary

In Natural Language Processing (NLP) and particularly for Large Language Models (LLMs), the vocabulary refers to the complete set of unique tokens (which can be words, subwords, or characters) that a specific model has been trained to recognize and process. It is typically established during the tokenization process and defines the universe of linguistic units the model understands. Any token encountered in input text that is not part of this predefined vocabulary is considered an "out-of-vocabulary" (OOV) token. Models employ various strategies to handle OOV tokens, such as mapping them to a special <UNK> (unknown) token or using subword tokenization techniques (like BPE or WordPiece) which break down unknown words into known subword units present in the vocabulary. The size and composition of the vocabulary significantly impact the model's size, computational requirements, and its ability to handle diverse language (Stanford NLP - Text Preprocessing, Example: TinyLlama 32k).

Word Embeddings

Numerical vector representations of words in a continuous, relatively low-dimensional space. These embeddings capture semantic relationships between words, such that words with similar meanings or contexts tend to have similar vector representations (i.e., they are closer in the embedding space). Examples include Word2Vec, GloVe, and FastText, which are often learned from large text corpora and used as input features for downstream NLP models (TensorFlow Word Embeddings Tutorial, Jay Alammar: The Illustrated Word2vec).