Glossary of Common Computer Vision Terms

Computer vision - and machine learning in general - is one of those fields that can seem hard to approach because there are so many industry-specific words (or common words used in novel ways) that it can feel a bit like you're trying to learn a new language when you're trying to get started.

This glossary defines over 150+ common computer vision terms, from ablation study and anchor box through transformers, vision-language models, and zero-shot detection.

• Ablation Study - removing features from a model one by one to see how much each contributes to performance. Common in research papers about new model architectures that contain many novel contributions.
• Accuracy - the proportion of correct versus incorrect predictions a model makes. Common in classification models that have a single correct answer, as opposed to object detection where predictions range from perfect to close to completely wrong. Top-5 accuracy means the correct answer appeared in the model's five most confident predictions; top-1 and top-3 accuracy are also common.
• Activation - the equation of a neural network cell that transforms data as it passes through the network. See activation function.
• Activation Function - the mathematical equation that transforms data input through a neural network. Common activation functions include sigmoid, tanh, and ReLU.
• Active Learning - a feedback loop where a deployed model's real-world predictions are collected, reviewed, and added back into the training dataset, so the model improves on exactly the data it struggles with in production.
• Agent - a conversational layer over the Roboflow platform. Describe a computer vision task in plain English, such as counting vehicles crossing a line, and the Agent designs, configures, and tests the workflow for you, drawing on your models, datasets, and Workflows without requiring you to assemble blocks or write code.
• AGPL-3.0 - the GNU Affero General Public License v3, a strong copyleft open source license. Software that incorporates AGPL-3.0 code must release its own source code under the same license, and unlike ordinary GPL, that obligation extends to software offered over a network, so deploying an AGPL model behind an API still triggers it. Several YOLO versions are AGPL-3.0 licensed, which is why commercial teams either purchase a separate license or choose a permissively licensed model instead.
• Anchor Box - a set of predefined box shapes some object detection models use to help predict bounding box locations. Modern transformer-based detectors like RF-DETR are anchor-free: they predict boxes directly without predefined shapes.
• Annotation - the answer key for each image. Annotations are markup placed on an image (bounding boxes for object detection, polygons or a segmentation map for segmentation) to teach the model the ground truth.
• Annotation Format - the particular way of encoding an annotation. There are many ways to describe a bounding box's size and position (JSON, XML, TXT) and to delineate which annotation goes with which image.
• Annotation Group - describes what types of object you are identifying, for example Chess Pieces or Vehicles. Classes (rook, pawn) are members of an annotation group.
• Apache 2.0 - a permissive open source license that allows commercial use, modification, and distribution without requiring you to open source your own code, and includes an explicit patent grant. Models and tools under Apache 2.0 are safe to ship inside commercial products, which is one reason Robfolow's RF-DETR is released under it.
• Architecture - a specific neural network layout (layers, neurons, blocks). Architectures often come in multiple sizes whose design is similar except for the number of parameters; RF-DETR, for example, ranges from Nano to Large.
• AUC - area under the curve. An evaluation metric for a prediction system that is trading off precision at the expense of recall. The precision recall curve slopes downward as confidence decreases, allowing more, but less precise, predictions.
• Augmentation - creating more training examples by distorting input images so the model does not overfit on specific training examples. For example, you may flip, rotate, blur, or add noise.
• Auto Label - AI-assisted labeling that uses foundation models to draft annotations across a dataset from a text description of each class, so human labelers review and correct rather than draw every box.
• AutoML - one-click training of models that optimize themselves, usually hosted in the cloud. A reasonable starting point and baseline for some problems.
• Backbone - the base feature-extraction network an object detection model is built on. In a classic detector, the backbone feeds a neck and a head.
• Backprop - back propagation is how neural networks improve. For each batch of training data, the network does a forward pass, then computes the gradient of each neuron from the end working backwards, and adjusts each weight slightly in the direction that most reduces the loss function. Over millions of iterations, this is how a model learns to fit the training data.
• Bag of Freebies - a collection of augmentation techniques shown to improve performance regardless of model architecture, popularized by papers in the YOLO lineage that built the techniques into their training pipelines.
• Batch Inference - making predictions on many frames at once to take advantage of the GPU's ability to perform parallel operations. This improves throughput for offline (as opposed to real-time) prediction.
• Batch Size - the number of images a model trains on in each step. A hyperparameter with pros (faster training) and cons (increased memory usage); it can also affect overall accuracy, and choosing well depends on several factors.
• Black Box - a system that is hard to inspect to understand what is going on. Neural networks are often described as black boxes because it can be hard to explain why they make a particular prediction. Model explainability is an active field of study.
• Block - many computer vision models are composed of blocks that describe a set of interconnected neurons; configurations of blocks make up a layer, and many layers make up a model.
• Bounding Box - a rectangular region of an image containing an object, commonly described by its min/max x/y positions or a center point (x/y) plus width and height (w/h), along with its class label.
• Channel - images are composed of one or more channels, each with one value per pixel. A grayscale image may have one channel describing brightness. A color image typically has three (red, green, blue). A fourth channel is sometimes used for depth or transparency.
• Checkpoint - a point-in-time snapshot of a model's weights. Often captured at the end of each epoch so you can return to it if performance later degrades from overfitting.
• Class - a type of thing to be identified. A model identifying chess pieces might have classes like white-pawn, black-rook, and white-queen; the annotation group would be Chess Pieces.
• Class Balance - the relative distribution of examples across classes. Models generally perform better when classes have a relatively even number of examples. Classes with too few examples are under-represented; classes with many more are over-represented.
• Classification - a computer vision task that determines whether a certain class is present in an image, without locating it.
• CLIP - a model from OpenAI that embeds images and text into a shared space, so visual content can be compared against arbitrary words. CLIP-style embeddings underpin zero-shot classification, semantic image search, and open vocabulary methods.
• COCO - the Microsoft Common Objects in Context dataset, with over 2 million labeled instances across 80 classes ranging from person to handbag. A standard benchmark for comparing detection models, and its JSON annotation format is widely used for other datasets.
• Colab - Google Colaboratory, a platform providing hosted Jupyter Notebooks with access to GPUs.
• Computer Vision - the field pertaining to making sense of imagery. Images are a collection of pixel values; with computer vision we take those pixels and gain an understanding of what they represent.
• Confidence - a model is inherently statistical. Along with its prediction, it outputs a confidence value quantifying how sure it is that the prediction is correct.
• Confidence Threshold - the bar below which predictions are discarded.
• Container - a virtualized environment that packages its dependencies into a portable unit. Docker is the most common way to create containers.
• Converge - over training, a model gets closer to a hypothetical most-accurate set of weights. That march toward maximum performance is convergence. The opposite is divergence, where a model gets worse over time.
• Convert - translating annotations or images from one format into another. Each model requires input in a specific format; if data is not already in that format, it needs converting with a custom script or a tool like Roboflow.
• Convolution - a type of block that helps a model learn relationships between nearby pixels.
• Convolutional Neural Network (CNN, ConvNet) - a common network type in computer vision. Early layers learn features like lines and color blocks, middle layers learn textures and corners, and final layers combine those into higher-level concepts like ears and clocks. For a decade CNNs dominated vision; transformer-based architectures now match or exceed them on many tasks.
• CoreML - Apple's format for encoding model weights to take advantage of the hardware-accelerated neural engine on iPhone and iPad devices.
• Cross Validation - a category of statistical techniques for measuring how well a model will generalize to new data.
• CUDA - NVIDIA's method of writing general-purpose GPU-optimized code. This is how GPU devices originally designed for 3D games accelerate neural networks.
• CuDNN - NVIDIA's CUDA Deep Neural Network library, a set of tools built on CUDA for efficiently running neural networks on the GPU.
• curl - a command line program commonly used to upload and download files.
• Custom Dataset - a set of images and annotations pertaining to a domain-specific problem, in contrast to a research benchmark dataset like COCO.
• Darknet - a C-based neural network framework created by PJ Reddie, the inventor of the original YOLO family of object detection models. Now primarily of historical interest.
• Data - information of any kind: images, text, sound, or tabular.
• Dataset - a collection of data and a ground truth of outputs used to train a machine learning model by example. For object detection, the images plus the annotations you want the model to learn to predict.
• Deploy - taking a trained model and using it for inference on real-world data, whether hosted on a server or installed on an edge device.
• DETR - detection transformer. A family of object detection architectures that treat detection as a direct set prediction problem using transformers, removing hand-designed components like anchor boxes and non-maximum suppression. RF-DETR is a real-time member of this family.
• Differentiable - for backprop to work, every operation the neural network performs must have a computable derivative so the gradient can be determined.
• Distributed - spread across multiple devices. Distributed training usually means using multiple GPUs, often on separate machines.
• Docker - the common standard for building containers.
• Domain Specific - problems or techniques that are not generally applicable. Detecting tumors in X-rays involves cancer biology that would not transfer to measuring traffic flows in satellite imagery.
• Download - moving a file from a remote machine to another machine, such as pulling a dataset from Roboflow to a training machine.
• Early Stopping - detecting when a model has reached peak performance and terminating training before completion. Stopping early can prevent overfitting and save compute.
• Edge Deployment - deploying to a device that makes predictions without sending data to a central server over the internet: a phone, a Raspberry Pi, an NVIDIA Jetson, a robot, or an on-site computer with a GPU.
• EMA - exponential moving average. Helps smooth noisy inputs.
• Embedding - a numeric vector representation of an image, text, or other input, positioned so that similar items are near each other. Embeddings power image search, deduplication, clustering, and zero-shot methods.
• Environment - a set of machine specifications, operating system, programming language, and frameworks, such as Ubuntu on a cloud GPU instance running PyTorch.
• Epochs - the number of times training runs through the full training dataset.
• EXIF - metadata attached to images, such as orientation, GPS data, capture device, and shutter speed.
• Export - in Roboflow, a serialized version of a dataset that can be downloaded.
• F1 - a measure of prediction efficacy combining recall (guessing enough times) with precision (guessing correctly when the system does guess). High F1 means guessing correctly whenever there is a guess to be made.
• False Negative - when a model fails to predict an object that is actually present.
• False Positive - when a model predicts an object is present when it is not.
• Family - a set of related models. The core concepts stay the same while new techniques are added over successive versions.
• Feature - a derived property of the data learned by a model. A set of convolutions may learn to recognize zigzag lines; zigzag lines are then a learned feature.
• Feature Fusion - combining derivative data features in a neural network.
• Feature Pyramid Network (FPN) - a feature fusion strategy in object detectors that combines convolutional neural network features sequentially.
• Filter Null - removing some proportion of null examples from a dataset so a model does not learn to optimize its loss by predicting null too often.
• FLIR - forward looking infrared. Infrared measures heat in the infrared spectrum rather than color in the visual spectrum; models can be trained on infrared imagery as well as visual.
• FLOPS - floating point operations per second, a measure of computing power. A GPU rated at 8 TFLOPS performs 8 trillion floating point operations per second.
• Foundation Model - a large model trained on broad data that performs many tasks without task-specific training, and can be adapted or prompted for specific uses. In vision, examples include SAM for segmentation, CLIP for image-text matching, and large vision-language models.
• FP8 - 8-bit floating point (quarter precision). Reducing numeric precision shrinks memory usage and speeds up inference, usually with minimal accuracy loss, and takes advantage of tensor cores on modern GPUs.
• FP16 - 16-bit floating point (half precision).
• FPS - frames per second. In real-time inference, the measure of how many sequential inference operations a model performs. Higher is faster.
• Framework - deep learning frameworks implement neural network concepts. Some are designed for training and inference (PyTorch, TensorFlow, JAX), others particularly for fast inference (TensorRT, OpenVINO, ONNX Runtime).
• GAN Synthesis - using a generative adversarial network to create more training data.
• Generalize - the ability of a model to make accurate predictions on input data it has never seen before.
• Generate - in Roboflow, processing images into their final form, including preprocessing and augmentation.
• GPU - graphics processing unit. Originally developed for 3D games, GPUs excel at the matrix operations that are the foundation of neural networks, running calculations in parallel far faster than a CPU.
• GPU Memory - the amount of information a GPU can hold. A bigger GPU processes more in parallel and supports bigger models or batch sizes; running out of GPU memory crashes the program.
• Gradient - a set of directions, calculated by taking the derivative of the loss function, that will most improve predictions. By repeatedly stepping in the direction of the gradient, a neural network improves over the course of training.
• Grounding - connecting language to specific regions of an image, as in grounded object detection where a text phrase is localized with a box. Grounding DINO is a widely used zero-shot grounded detector.
• Ground Truth - the answer key for a dataset, used to compute the loss during training and the metrics during evaluation. A model learns to predict based on the ground truth it is given to replicate, so quality matters enormously.
• Head - the portion of an object detector where prediction is made. The head consumes features produced in the neck.
• Health Check - tools in Roboflow that help you understand the composition of a dataset (size, dimensions, class balance).
• Hold Out Set - another name for the test set: the part of a dataset reserved until after training to check how well the model generalizes.
• Hosted Dataset - a dataset stored in the cloud so it can be accessed from whichever machine you are training on.
• Hosted Model - trained weights located in the cloud that return predictions via an API, as opposed to an edge-deployed model. Roboflow's Serverless Hosted API is an example.
• Hyperparameter - the levers for tuning a model during training, such as learning rate and batch size.
• Inference - making predictions using the weights saved after training. Roboflow Inference is also the name of the open source engine for running models and Workflows in the cloud or on edge devices.
• Instance Segmentation - a segmentation task that produces a separate pixel mask for each individual object, so two adjacent forklifts get two masks. Compare semantic segmentation, which labels pixels by class without separating instances.
• IoU - intersection over union. A metric measuring how well a predicted region matches the ground truth: the area of overlap divided by the total area covered by both.
• Jetson - an edge computing device family from NVIDIA with an onboard GPU, commonly used to run vision models on-site.
• JSON - a freeform data serialization format originally part of JavaScript, now used much more broadly. Many annotation formats use JSON to encode bounding boxes.
• Jupyter Notebook - a common data science tool for executing Python code visually, cell by cell, with results displayed inline.
• Keypoint Detection - a model type that predicts points rather than boxes. Often used for human pose estimation or finger tracking, where position matters but size does not.
• Label - the class of a specific object in a dataset. In classification, the entirety of the prediction; in object detection, the non-spatial component of the bounding box.
• Layer - layers are made of neurons (commonly organized in blocks). Deep neural networks are composed of several layers; adding layers makes a network deeper, more expressive, and harder to train.
• Learning Rate - a hyperparameter defining the size of the steps taken along the gradient after each batch. Too small and the model converges slowly; too large and the weights can explode and diverge. Learning rates commonly change over the course of training on a schedule.
• LiDAR - laser imaging detection and ranging. A sensor that uses lasers to measure depth, found in self-driving cars and some consumer devices.
• LiteRT - Google's runtime for on-device inference, the current name for TensorFlow Lite. It executes compact .tflite models on Android, iOS, and embedded devices.
• Localization - identifying where in an image an object resides: the x/y component of detection, as opposed to the class label.
• Loss Function - a differentiable calculation of how far off a prediction is, used to compute the gradient that steers training. Loss is usually tracked separately on the training set (training loss) and validation set (validation loss); lower means more accurate predictions.
• Machine Learning - teaching computers by example. Instead of writing the rules that convert inputs to outputs, you give the system many examples of inputs and desired outputs and let it learn the rules.
• mAP - mean average precision, the standard metric for judging object detection performance. Commonly reported as mAP50 (IoU threshold of 0.5) or mAP50-95 (averaged across thresholds).
• Memory Footprint - how much space in memory a model takes, largely a function of parameter count and batch size. It needs to fit in GPU memory.
• Metadata - ancillary information stored about data, such as when it was collected. For images, often stored as EXIF.
• Metrics - evaluation metrics assess the performance of a machine learning system.
• Mixed Precision - using both full and half precision floating point numbers during training, which increases speed without degrading performance.
• Mobile Deployment - deploying to an edge device like a mobile phone, where battery usage and heat dissipation come into play.
• Model - a specific incarnation of an architecture, with a defined input size and weights layout.
• Model Configuration - adjusts an architecture into a specific model and sets its hyperparameters.
• Model Drift - the gradual loss of accuracy a deployed model suffers as real-world conditions (lighting, environments, products) shift away from the training data. Detecting drift is the job of model monitoring.
• Model Size - the number of parameters a model has, also measurable as the size of the weights file on disk.
• Mosaic - an advanced augmentation that combines multiple images from the training set, shown to improve object detection training performance.
• Multimodal Model - a model that processes more than one type of input, most commonly images and text together. Vision-language models are the multimodal models most relevant to computer vision.
• Neck - the portion of a classic object detection model that forms features from the backbone before the head makes predictions.
• Neural Architecture Search - automatically trying many variations of model layouts and hyperparameters to find the optimal configuration for an accuracy or latency target.
• Neuron - also known as a parameter or perceptron: a mathematical function that multiplies its inputs by learned weights and outputs a single value fed into other neurons.
• NMS - non-maximum suppression. A post-processing step in many detectors that removes duplicate overlapping predictions for the same object, keeping only the most confident. DETR-family models are designed not to need it.
• Non-Destructive - an operation that can be reversed without losing information. Roboflow's preprocessing and augmentation are non-destructive because they do not overwrite source values.
• Normalization - standardizing data inputs based on a distribution.
• Novel - an insight is novel if it is a new idea.
• nvidia-smi - a tool for inspecting the state of an NVIDIA GPU, including how much GPU memory is being consumed.
• NVIDIA Container Toolkit - a helper library for creating Docker containers that can access the host machine's GPU.
• Null Annotation - a purposely empty annotation that helps teach a model that an object is not always present.
• Object Detection - a category of computer vision models that both classify and localize objects with a rectangular bounding box.
• Occlusion - when an object is partially obscured behind another object. Simulating occlusion prevents a model from becoming overly dependent on one distinctive feature, so it can still recognize a cat when its head is hidden behind a chair.
• OCR - optical character recognition: reading text from images, whether printed labels, serial numbers, or documents.
• Offline Prediction - the opposite of real-time prediction: when the model has no hard time limit for returning an answer, such as indexing a photo library overnight.
• ONNX - a cross-platform, cross-framework serialization format for model weights. Converting to ONNX simplifies deployment dependencies and is often an intermediate step in converting weights for edge devices.
• Ontology - the categorization and hierarchy of your classes. As a project grows, standardizing nomenclature across the team becomes more important.
• Open Vocabulary - the ability to detect or segment arbitrary categories described in text at inference time, rather than a fixed list of trained classes. SAM 3 and Grounding DINO are open vocabulary models.
• OpenCV - a computer vision framework popularized before deep learning became ubiquitous, excelling at edge detection, image stitching, and object tracking, and now integrating learning-based techniques as well.
• OpenVINO - Intel's inference framework, designed for fast inference on CPU and VPU devices.
• Output - the result of a process. The output of training is a set of weights; the output of inference is a prediction.
• Outsourced Labeling - paying a labeling workforce to annotate images. Most effective when little domain expertise is needed to determine the correct annotation.
• Overfitting - when a model memorizes specific training examples to the point that performance on the validation set degrades. Countered by collecting more data, augmentation, and regularization.
• Paper - academic literature, usually peer-reviewed, describing novel techniques. Often freely published to sites like arXiv.
• Parameters - the weights of a model, one per connection between neurons, each adjusted during backpropagation.
• Pascal VOC - the Visual Object Classes benchmark. Largely replaced by newer datasets like COCO in the literature, but its XML annotation format remains widely used by labeling tools and models.
• Performance - how fast and accurate a model is.
• Pipeline - the process of going from raw images to a prediction: collecting images, annotation, quality assurance, preprocessing and augmentation, training, evaluation, deployment, and inference, then repeating the cycle to improve.
• Playground - a browser-based environment for trying computer vision models against your own images with no setup. Useful for comparing architectures, sanity-checking whether an off-the-shelf model already handles your task, and exploring model behavior before committing to training.
• Platform - a computer vision platform is a (usually cloud-hosted) meta-tool that manages all or part of the pipeline.
• Polygon - a usually non-rectangular region defining an object in more detail than a bounding box. Polygon annotations train segmentation models and improve object detection performance by keeping boxes accurate through augmentation.
• Pose Estimation - predicting the position and orientation of a body or object as a set of keypoints, such as tracking a worker's posture for ergonomic analysis.
• Precision - a measure of how precise a model is at prediction time: true positives divided by all positive guesses.
• Prediction - an attempt by a model to replicate the ground truth, usually accompanied by a confidence value per class.
• Preprocessing - deterministic steps performed on all images (training, validation, testing, and production) before feeding them into the model.
• Pretrained Model - a model already trained on another dataset. Much of what it learns (lines, corners, color patterns) applies broadly, so pretraining on a large dataset like COCO reduces the number of custom images needed for good results.
• Production - the deployment environment where a model runs on real-world images, as opposed to the environment where it was developed.
• Prompt - the input that steers a foundation model: a text phrase for open vocabulary detection or segmentation, a point or box for SAM-style interactive segmentation, or an instruction for a vision-language model.
• PyTorch - a popular open source deep learning framework, the dominant choice for research and much of production.
• Quantization - converting model weights to lower-precision numbers (such as INT8) to shrink the model and speed up inference, especially on edge hardware, usually with small accuracy tradeoffs.
• RasPi - the Raspberry Pi, an inexpensive Linux-based microcomputer with a broad ecosystem of compatible peripherals, capable of running lightweight vision models on-device.
• Realtime - when a model must return predictions within a fixed time budget, such as keeping up with a video feed's frame rate.
• Recall - a measure of whether a prediction system guesses enough: true positives divided by all possible true positives.
• Region Attribute - additional properties beyond class name and location added to boxes or polygons in some annotation tools; metadata at the object level rather than the image level.
• Regression - a model that predicts one or more real numbers (an age, a pixel location) where closeness to the ground truth is measurable, as opposed to classification where a prediction is simply right or wrong.
• Regularization - techniques that reduce overfitting by penalizing heavily weighted features, forcing the model to stay flexible.
• Remap - changing class composition after annotation. Ontologies often need to evolve as you learn more about the problem.
• Repo - short for repository: version-controlled storage for code that enables change tracking and collaboration.
• Requirements - the third-party code needed to replicate an environment: libraries, frameworks, drivers. For Python projects, stored in requirements.txt; for Docker containers, defined by the Dockerfile.
• Resolution - the number of pixels in an image, width times height, measured in megapixels.
• RF-DETR - Roboflow's real-time detection transformer for object detection and instance segmentation. Anchor-free, NMS-free, available in sizes from Nano to Large, and released under a commercial-friendly license.
• Runtime Environment - where machine learning code executes: CPU, GPU, VPU, or TPU.
• SAM (Segment Anything Model) - Meta's family of foundation models for segmentation. SAM and SAM 2 segment objects from clicks and boxes in images and video; SAM 3 adds concept prompts, segmenting every instance of a category described by a short text phrase.
• Segmentation - a type of model that classifies individual pixels, used when the exact outlines of objects are needed. See instance segmentation and semantic segmentation.
• Self Adversarial Training - a technique where the model strategically starves itself of the information it relies on most, forcing it to learn other ways to make predictions.
• Semantic Segmentation - a segmentation task that assigns a class to every pixel without separating individual objects: all road pixels are road, all forklift pixels are forklift, regardless of how many forklifts there are.
• Split - segregating subsets of data for different purposes. Usually three: train (for the model to mimic), valid (for evaluation during training), and test (held back to measure generalization).
• SSD - single shot detector: a model that localizes and classifies in a single pass, in contrast to two stage detectors.
• State of the Art - a model performing better on a benchmark dataset than any previously known model.
• Subjective - performance observed intuitively but not necessarily measurable, as when two models score similarly but one's outputs are clearly better to a human judge.
• Supervision - Roboflow's open source Python library of reusable computer vision utilities. It handles the plumbing around models: converting detections between formats, drawing boxes, labels, and masks on images, filtering and counting detections, and processing video. The sv.Detections object is a common interchange format in inference code.
• Synthetic Data - images created rather than collected, using 3D rendering, generative models, or context augmentation.
• Tensor - a possibly multi-dimensional array of numbers with a defined size and type, which makes operations on it easy to optimize and parallelize on hardware accelerators.
• Tensor Core - the part of NVIDIA GPUs specifically optimized for deep learning, especially mixed-precision networks.
• Tensorboard - a tool for tracking and visualizing training metrics such as loss and mean average precision, compatible with major frameworks.
• TensorFlow - Google's open source deep learning framework.
• TensorFlow Lite - the former name of LiteRT, Google's serialization format and runtime for running models on mobile and edge devices. See LiteRT.
• TensorRT - NVIDIA's inference optimization tooling for deploying models on NVIDIA hardware.
• Test Set Bleed - when data from the test set leaks into the training set, defeating the purpose of the hold out set and invalidating generalization estimates.
• TFRecord - a binary data format compatible with TensorFlow, storing images and annotations in a single file.
• Tile - splitting an image into a grid of smaller images run through a model independently to boost effective resolution. Effective for small object detection at the expense of running the model several times per image.
• TPU - tensor processing unit, Google's hardware accelerator for tensor operations, available in the cloud and as an edge module.
• Tradeoff - when two competing concerns pull in opposite directions, such as the continuum between fast-but-less-accurate and slow-but-accurate models.
• Train - iteratively adjusting a model's parameters to converge on the weights that best mimic the training data.
• Transfer Learning - using pretrained weights to bootstrap a model's learning: transferring knowledge learned on another dataset, then fine-tuning it on a new domain.
• Transformer - a neural network architecture built on attention, which lets the model weigh relationships between all parts of its input at once. Transformers underpin modern language models and, increasingly, vision models including DETR-family detectors and vision-language models.
• Tune - adjusting hyperparameters to find the settings that produce the best model.
• Two Stage Detector - a category of typically older object detection models that first localize, then classify, as opposed to single shot detectors that do both in one pass.
• Validate - during training, the validation set is used to assess generalization. These examples do not contribute to the gradient; they are used to calculate metrics over time.
• Version - a point-in-time snapshot of a dataset, recording exactly which images, preprocessing, and augmentation steps were used, so results are reproducible and changes are attributable to the model rather than the data pipeline.
• Vision AI Agent - a system that perceives with vision models, reasons with a multimodal model, acts, and repeats. Built in practice by chaining models and logic, for example with Roboflow Workflows.
• Vision-Language Model (VLM) - a multimodal model that jointly understands images and text, enabling tasks like visual question answering, captioning, and structured data extraction from images. Examples include GPT-class and Gemini-class models and open alternatives.
• Vision Transformer (ViT) - a transformer architecture applied directly to images by splitting them into patches treated like tokens. The backbone behind many modern vision models.
• Weights - the parameters a model's neurons use to determine whether to fire, learned via backpropagation during training and then serialized for inference.
• Workflow - the process you follow from image to decision. In Roboflow, Workflows is the low-code builder for chaining models, logic, and integrations into a deployable application.
• XML - a hierarchical data format, most commonly used in computer vision with the Pascal VOC XML annotation format.
• YAML - a markup language commonly used for configuration files.
• YOLO - You Only Look Once, a family of single-shot object detection models that popularized real-time detection. Successive versions remain widely known; for training custom detection models, transformer-based architectures like RF-DETR now offer better accuracy per parameter with commercial-safe licensing.
• Zero-Shot - performing a task on classes or concepts a model was never explicitly trained on, typically by describing them in text. Zero-shot detection and segmentation make it possible to prototype without labeling or training, and to auto-label datasets for training smaller, faster models.

Cite this Post

Use the following entry to cite this post in your research:

Brad Dwyer. (May 1, 2026). Glossary of Common Computer Vision Terms. Roboflow Blog: https://blog.roboflow.com/glossary/