Vision Models Quick Reference

1. How to use this document

You will not read this end-to-end. Use it like a dictionary with a learning path on top.

Day 1 of your co-op: skim sections 2–4 (Prerequisites, Suggested Path, the Practical 20 list).
When you hit an unfamiliar term: Cmd-F the term in section 5.
When you need the broader AI context or deployment tools: jump to the sister AI Models & Roboflow Quick Reference (link in the navbar).

2. Prerequisites

Prerequisite knowledge:

Python: the vision ecosystem (PyTorch, Ultralytics, OpenCV) is Python. You need enough to run training scripts and process results.
Basic ML: training vs. inference, overfitting, train/val/test splits, precision/recall.
Command line: pip install ultralytics, yolo train, yolo predict.

Hardware: a laptop CPU is fine for running YOLOv8n inference at 5–10 FPS. Training even small models benefits from a GPU (T4 or better, ~$0.50/hr on Colab or RunPod).

3. Suggested learning path (5 steps)

Focus on deploying vision models on edge devices. Each step adds capability.

Step 1 — Detect objects with YOLO on a laptop

Run YOLOv8 on a sample image and a webcam feed. Understand confidence thresholds, NMS, and output parsing.

Step 2 — Optimize for a Jetson or Raspberry Pi

Convert to TensorRT or TFLite. Profile inference speed. Use FP16 or INT8 quantization to gain 2× speed with minimal accuracy loss.

Step 3 — Add segmentation and classification

Run SAM for segmentation on detected regions. Use a classifier (ResNet / MobileNet) to refine detection labels. Chain models for multi-stage pipelines.

Step 4 — Deploy as a microservice

Wrap the model in a FastAPI or Flask endpoint. Use Redis or RabbitMQ for queueing. Deploy with Docker on the edge device.

Step 5 — Integrate with a camera system

Connect RTSP cameras to the inference pipeline. Add a web UI with live bounding boxes and detection logs. Use Roboflow for dataset management and model versioning.

4. The Practical 10 — read these first

If you only read 10 entries in this glossary, read these. They cover ~90% of what you'll see in your first month on a microcontroller project.

🔥Bounding Box 🔥CNN (Convolutional Neural Network)🔥Object Detection 🔥Segmentation (Semantic / Instance / Panoptic)🔥YOLO (You Only Look Once)🔥YOLOv8 / YOLOv11 🔥Anomaly Detection (Vision)🔥Zero-Shot Detection (GroundingDINO / CLIP)🔥Self-Hosted Inference (Vision)🔥ONNX / TensorRT / OpenVINO

Each entry: a one-line definition, then a practical note in italics that says what it means on the bench. Entries marked 🔥 are the practical-10.

Letter

A

1 term

Anomaly Detection (Vision)

Identifying images or regions that deviate from a “normal” distribution — detecting defects, cracks, leaks, or unusual objects in industrial inspection. Common approaches: classification (good vs. defective), segmentation (pixel-level defect mask), feature-based (compare embeddings against a reference set). Practical: For a co-op project, start with a feature-based approach: embed all “normal” images with a pre-trained model (ResNet or CLIP), then flag any new image whose embedding distance exceeds a threshold. This needs only 20–50 normal images and zero labelled defects. For higher accuracy, use Padim or PatchCore (state-of-the-art anomaly segmentation). Roboflow supports anomaly detection workflows in the playground. See also: Classification (Image), Segmentation (Semantic / Instance / Panoptic), CLIP (Contrastive Language-Image Pre-training).

Letter

B

1 term

Bounding Box

A rectangle that defines the location of an object in an image, specified as (x_min, y_min, x_max, y_max) or (x_center, y_center, width, height) depending on the format. Practical: Most object detection models output bounding boxes in normalized coordinates (0.0–1.0 relative to image dimensions). You need to scale them back to pixel coordinates for drawing or cropping. The COCO format uses (x_min, y_min, width, height); YOLO uses (class, x_center, y_center, width, height) normalized. Bounding boxes are the output format for YOLO (You Only Look Once), Detection Transformer (DETR), and most Object Detection models. See also: Object Detection, YOLOv8 / YOLOv11, IoU (Intersection over Union).

Letter

C

4 terms

Classification (Image)

Assigning a single label to an entire image. The simplest vision task: “is this a cat or a dog?”. Models output a probability distribution over classes. Practical: Use pre-trained classifiers (ResNet, EfficientNet, ViT) from Hugging Face or torchvision for transfer learning. For a custom dataset with 10+ classes, fine-tune a pre-trained model rather than training from scratch — you need 100+ images per class. Accuracy plateau is typically at 1000+ images per class. Classification is often the first step in a pipeline before Object Detection or Segmentation (Semantic / Instance / Panoptic). See also: CNN (Convolutional Neural Network), ViT (Vision Transformer), ResNet (Residual Network).

CLIP (Contrastive Language-Image Pre-training)

A multimodal model by OpenAI that learns joint image-text embeddings. Trained on 400M (image, text) pairs to predict which caption goes with which image. The output is a shared embedding space where a photo of a dog and the text “a dog playing fetch” have nearby vectors. Practical: CLIP enables zero-shot classification: embed candidate labels (“cat”, “dog”), embed the image, pick the closest label. Also used for image search (“find me a photo of a red car”), and as a backbone for multi-modal models. Run CLIP on a CPU with transformers: from transformers import CLIPProcessor, CLIPModel. The ViT-B/32 variant is a good speed/accuracy trade-off. See also: Embeddings, ViT (Vision Transformer), Foundation Model (Vision).

CNN (Convolutional Neural Network)

A neural network architecture that uses convolutional filters to detect spatial patterns (edges, textures, shapes) in images. The standard architecture for computer vision before transformers took over. Examples: ResNet, EfficientNet, MobileNet, YOLO (backbone). Practical: CNNs are still the backbone of most real-time vision systems (YOLO, MobileNet) because they are faster and cheaper than ViT (Vision Transformer) at inference time on edge devices. A CNN processes an image by sliding learned kernels across the pixel grid, building hierarchical features (edges → textures → parts → objects). For a co-op project, use a CNN-based model if you need real-time inference on a Raspberry Pi or Jetson; use a ViT if accuracy matters more than speed. See also: ResNet (Residual Network), YOLO (You Only Look Once), Object Detection.

COCO (Common Objects in Context)

The most widely used benchmark dataset for object detection, segmentation, and captioning. 330K images, 80 object categories, 1.5M instances — each with bounding boxes, segmentation masks, and captions. Practical: Pre-trained models are almost always trained on COCO. If you start with a COCO checkpoint and fine-tune on your dataset, you need far fewer training images. COCO evaluation metrics (mAP (Mean Average Precision)) are the standard for reporting detection/segmentation performance. The 80 COCO classes cover common objects (person, car, dog, bottle, etc.) — if your domain is different (electronics components, farm animals), you will need to fine-tune. See also: Object Detection, Segmentation (Semantic / Instance / Panoptic), YOLO (You Only Look Once).

Letter

D

3 terms

Detection Transformer (DETR)

An object detection model by Meta AI that uses a transformer encoder-decoder instead of the traditional proposal-based pipeline (like Faster R-CNN). DETR treats detection as a set prediction problem (predict N objects in one pass). Practical: DETR is simpler (no NMS, no anchor boxes) but slower to train and less accurate on small objects than YOLO (You Only Look Once). Its real-world use is limited compared to YOLO, but the architecture influenced real-time DETR (RT-DETR) and segmentation models. For deployment on edge devices, YOLO is the pragmatic choice. DETR variants (Deformable DETR, DINO) are better for research. See also: Object Detection, YOLO (You Only Look Once), ViT (Vision Transformer).

Depth Estimation (Monocular)

Predicting a dense depth map from a single RGB image. Each pixel gets a depth value (distance from camera). Models output either metric depth (metres, if the camera intrinsics are known) or relative depth (closer/farther, 0–1). Practical: Use ZoeDepth or Depth Anything v2 (the current state of the art) — both run on a single GPU and generalise to unseen environments without fine-tuning. pip install depth_anything_v2 && depth_anything_v2 predict image.jpg. Depth maps enable: grasping (know how far the object is), navigation (detect obstacles), AR (place virtual objects correctly). Monocular depth is inherently ambiguous (a small near object can look like a large far object), but modern models are good enough for robotics. See also: Segmentation (Semantic / Instance / Panoptic), Object Detection, Foundation Model (Vision).

Document AI (DocAI)

Computer vision applied to documents: classifying document type (invoice, receipt, ID card), extracting fields (date, total, name), analysing layout (table detection, reading order). The pipeline: (1) detect document region, (2) classify document type, (3) run OCR, (4) extract structured fields with an LLM or rule parser. Practical: For structured extraction (invoice totals, receipt dates), use a detection model to locate text regions, pass them through OCR (PaddleOCR or Tesseract), then parse with a regex or a small LLM. Roboflow's playground supports document classification and layout analysis out of the box. For complex multi-page documents, use a dedicated DocAI platform (Azure Form Recognizer, Google Document AI, or open-source Doctr). See also: OCR (Optical Character Recognition), Classification (Image), Object Detection.

Letter

F

1 term

Foundation Model (Vision)

A large-scale vision model pre-trained on broad data that can be adapted to many downstream tasks. Examples: SAM (Segment Anything), DINOv2, CLIP, SigLIP. Practical: Foundation models transform the workflow: instead of training a detection model from scratch, you use SAM to segment anything in an image and then map segments to your classes. DINOv2 produces high-quality feature descriptors for image matching and 3D reconstruction. Foundation models typically require a GPU for inference (SAM runs at ~2 FPS on a V100), but the quality leap is dramatic. For a co-op project, start with a task-specific model (YOLO for detection) and use foundation models for the hard cases. See also: CLIP (Contrastive Language-Image Pre-training), SAM (Segment Anything Model), Object Detection.

Letter

I

1 term

IoU (Intersection over Union)

A metric that measures the overlap between a predicted bounding box and the ground truth box. IoU = area of intersection / area of union. Ranges from 0 (no overlap) to 1 (perfect match). Practical: IoU is the fundamental building block of object detection evaluation. A prediction is considered a “true positive” if its IoU with a ground-truth box exceeds a threshold (typically 0.5, written as mAP@0.5). During NMS (Non-Maximum Suppression), boxes with IoU > 0.5–0.7 with a higher-scoring box are suppressed. For deployment, an IoU threshold of 0.5 is usually fine — higher thresholds (0.75) are for high-precision applications like autonomous driving. See also: mAP (Mean Average Precision), NMS (Non-Maximum Suppression), Bounding Box.

Letter

M

1 term

mAP (Mean Average Precision)

The standard evaluation metric for object detection. Computed by averaging the precision-recall curve across all classes and IoU thresholds. Common variants: mAP@0.5 (IoU threshold = 0.5, the COCO default for easy evaluation), mAP@0.5:0.95 (averaged over IoU thresholds 0.5 to 0.95 in 0.05 steps — the standard COCO metric, harder). Practical: When someone says their model achieves “50 mAP on COCO”, they mean mAP@0.5:0.95. A good YOLOv8 model achieves ~52 mAP on COCO. For your custom dataset, mAP is comparable only if you use the same evaluation protocol. Roboflow reports mAP automatically during model training. As a benchmark for a co-op project, mAP@0.5 > 0.8 is “good enough” for most applications. See also: IoU (Intersection over Union), COCO (Common Objects in Context), Object Detection.

Letter

N

1 term

NMS (Non-Maximum Suppression)

A post-processing step that eliminates duplicate bounding boxes for the same object. The algorithm: sort all predictions by confidence score, pick the highest-scoring box, remove any remaining box with IoU > threshold (typically 0.5–0.7). Repeat until no boxes remain. Practical: Every object detection model uses NMS (or its learned variant). The threshold is a hyperparameter: lower (0.4) = fewer detections but higher precision; higher (0.7) = more detections but more duplicates. YOLO models have NMS built into their output pipeline. Soft-NMS reduces the score of overlapping boxes instead of removing them outright — better for dense scenes. See also: IoU (Intersection over Union), Object Detection, Bounding Box.

Letter

O

4 terms

Object Detection

The vision task of locating and classifying multiple objects in an image. Outputs a set of Bounding Box coordinates with class labels and confidence scores. Practical: Object detection is the most common vision task in robotics and engineering: finding bolts on a circuit board, counting cattle in a field, detecting defects on a conveyor belt. The dominant model family is YOLO (You Only Look Once) (v8, v9, v10, v11 — v8 and v11 are the most popular in 2026). Alternatives: Faster R-CNN (slower but slightly more accurate), DETR (transformer-based, simpler pipeline). For a co-op project, start with YOLOv8 (Ultralytics) — it's one pip install away. See also: YOLOv8 / YOLOv11, Bounding Box, Classification (Image), Segmentation (Semantic / Instance / Panoptic).

OCR (Optical Character Recognition)

Extracting text from images. Modern pipeline: (1) text detection (find text regions, often with a detection model), (2) text recognition (read the text in each region). Practical: For a co-op project, use Tesseract (open-source, works on CPU) for printed text, or PaddleOCR (higher accuracy, Chinese + English support). For challenging cases (handwriting, skewed text, low light), use a vision model + fine-tuned OCR: detect the region with YOLO, then read with TrOCR or a custom CRNN. Roboflow supports OCR pre-processing with document AI models. Fastest path: pip install pytesseract + preprocess image (grayscale, threshold, deskew). See also: Object Detection, Preprocessing / Augmentations, Segmentation (Semantic / Instance / Panoptic).

OBB (Oriented Bounding Box)

A bounding box with a rotation angle, used for objects that are not axis-aligned — aerial images (planes, ships in satellite photos), text in natural scenes, rotated industrial parts. Format: (x_center, y_center, width, height, angle). Practical: YOLOv8-OBB is the easiest entry point: yolo train model=yolov8n-obb.pt data=DOTAv1.5.yaml epochs=100 imgsz=1024. The DOTA dataset (1.7M instances, 18 classes) is the standard benchmark. OBB models require ~2× the resolution of axis-aligned detectors for comparable accuracy (same object, angled box needs more pixels to decide orientation). Use OBB only when the object's orientation matters (grasping, text reading, aerial analysis); for most ground-level robotics, axis-aligned boxes are fine. See also: YOLOv8 / YOLOv11, Object Detection, Bounding Box.

ONNX / TensorRT / OpenVINO

Three model optimisation frameworks for deploying vision models on different hardware. ONNX Runtime: cross-platform (CPU, GPU, ARM), supports any model exported to ONNX format. NVIDIA TensorRT: optimises for NVIDIA GPUs (up to 5× faster than raw PyTorch), supports FP16/INT8 precision. Intel OpenVINO: optimises for Intel CPUs, GPUs, and VPUs (best on Intel hardware). Practical: Export from Ultralytics: yolo export model=yolov8n.pt format=onnx (ONNX), format=engine (TensorRT), format=openvino (OpenVINO). For a local server running on any platform, use ONNX Runtime. For an NVIDIA GPU server, use TensorRT (INT8 precision gives 2× speedup with minimal accuracy loss). For a laptop with an Intel CPU, use OpenVINO — it runs YOLOv8n at 30+ FPS on a modern Intel Core. All three support batching: set batch=16 for server-side optimised throughput. See also: Self-Hosted Inference (Vision), YOLOv8 / YOLOv11, Object Detection.

Letter

P

2 terms

Pose Estimation

Detecting keypoints on a person or object: joints (elbow, knee, shoulder) for human pose, or specific landmarks for animal/robot pose. Outputs a set of (x, y, confidence) keypoints. Practical: YOLOv8-pose is the easiest entry point: one command yolo predict model=yolov8n-pose.pt source=image.jpg. For multi-person pose, YOLO handles up to ~10 people in a frame. Use for: ergonomics analysis, gesture control, animal behaviour monitoring. Higher accuracy options: OpenPifPaf, MMPose. Keypoint definitions follow the COCO 17-keypoint skeleton for humans. See also: YOLOv8 / YOLOv11, Object Detection, COCO (Common Objects in Context).

Preprocessing / Augmentations

Transformations applied to images before they enter the model. Preprocessing (always applied): resize to model input size, normalize pixel values (mean/std or 0–1), convert colour space. Augmentations (applied during training): random crops, flips, rotations, colour jitter, mosaic, mixup — to improve generalization. Practical: Use Roboflow's built-in preprocessing (auto-orient, resize to 640×640, auto-adjust contrast) and augmentation (flip, ±15° rotation, ±10% brightness). During training, augment heavily; during inference, only preprocess (no augmentation). The Ultralytics YOLO trainer applies augmentations automatically. A good rule: each training image should produce 3–5 unique augmented versions per epoch. See also: YOLO (You Only Look Once), Roboflow Inference, Object Detection.

Letter

R

1 term

ResNet (Residual Network)

A CNN architecture that introduced skip connections (residual blocks): the input to a layer is added to its output, allowing gradients to flow through very deep networks (50, 101, 152 layers). Practical: ResNet-50 and ResNet-101 are the default backbone for many detection and segmentation models (including the YOLO family). Pre-trained ResNet weights (on ImageNet) are the standard starting point for transfer learning in vision. A ResNet-50 backbone runs at ~50 FPS on a Jetson Nano. Use torchvision.models.resnet50(weights='IMAGENET1K_V2') to get started. See also: CNN (Convolutional Neural Network), Classification (Image), Object Detection.

Letter

S

3 terms

SAM (Segment Anything Model)

A foundation model by Meta AI that can segment any object in an image with zero-shot generalization. Accepts prompts: points, bounding boxes, or text. Practical: SAM is a game-changer for data labelling: instead of manually drawing masks, click on the object and SAM segments it. Run SAM with pip install segment-anything and the ViT-H model (2.5 GB). SAM runs at ~2 FPS on a GPU; the lightweight SAM variants (MobileSAM, FastSAM, EdgeSAM) run on CPU or edge devices. SAM is not a production detection model — use it for data annotation and generating Segmentation (Semantic / Instance / Panoptic) masks for training. See also: Foundation Model (Vision), Segmentation (Semantic / Instance / Panoptic), CLIP (Contrastive Language-Image Pre-training).

Segmentation (Semantic / Instance / Panoptic)

Pixel-level classification of images. Semantic: every pixel gets a class label (road, car, sky). Instance: each object instance gets a separate mask (car #1, car #2). Panoptic: combines semantics + instances (everything is classified, and countable things are separated). Practical: YOLOv8-seg does instance segmentation out of the box. Use for: picking objects with a robot arm (grasp mask), background removal (person segmentation), agricultural weed detection. For semantic segmentation, use DeepLabV3+ or SegFormer. Panoptic segmentation is more research-grade — use it only if you need both semantics and instances from one model. See also: YOLOv8 / YOLOv11, Object Detection, SAM (Segment Anything Model).

Self-Hosted Inference (Vision)

Running a computer vision model on your own hardware rather than a cloud API. Common stacks: Docker + FastAPI + ONNX Runtime (generic, works on CPU/GPU), Roboflow Inference (pre-built Docker with GPU support), Triton Inference Server (NVIDIA, high-throughput), vLLM + LLaVA (for vision-language models). Practical: The simplest self-hosted setup: export your YOLO model to ONNX (yolo export model=yolov8n.pt format=onnx), wrap it with FastAPI (POST /predict receives an image, runs inference, returns boxes), deploy via Docker. For GPU acceleration, use the nvidia/cuda base image and nvidia-docker. Raspberry Pi 5 runs YOLOv8n at 15+ FPS with the CPU-only ONNX Runtime. Always benchmark your specific model + hardware before committing — throughput varies wildly (e.g. YOLOv8x on a Jetson Orin is 30× slower than YOLOv8n). See also: ONNX / TensorRT / OpenVINO, Roboflow Inference, YOLOv8 / YOLOv11.

Letter

T

1 term

Tracking (SORT / DeepSORT / BoT-SORT)

Assigning consistent IDs to objects across video frames. Simple online tracking: predict each object's next position (Kalman filter), match detections to existing tracks (Hungarian algorithm on IoU). DeepSORT adds appearance features (re-identification embeddings) for better re-acquisition after occlusion. Practical: YOLOv8 + BoT-SORT is the recommended stack in 2026: yolo track model=yolov8n.pt source=video.mp4. Tracking enables counting (people through a doorway), speed estimation, and trajectory analysis. For a multi-camera setup, you need cross-camera re-identification (DeepSORT embedding or foundation model features). The main failure mode is ID switching (same object gets a new ID after occlusion). See also: YOLOv8 / YOLOv11, Object Detection, Bounding Box.

Letter

V

2 terms

ViT (Vision Transformer)

A transformer model applied to images by splitting them into fixed-size patches (16×16 pixels) and treating each patch like a token in an NLP model. Introduced by Dosovitskiy et al. (2021). Practical: ViTs outperform CNNs at scale (large models + large datasets) but need more data and compute at training time. For a co-op project with limited data, a pre-trained ResNet or EfficientNet will outperform a ViT trained from scratch. ViTs are the backbone of many Foundation Model (Vision) (CLIP, DINOv2, SAM). Use the transformers library: from transformers import ViTImageProcessor, ViTForImageClassification. ViT-base (86M params) needs ~2 GB VRAM for inference. See also: Transformer Architecture, CNN (Convolutional Neural Network), CLIP (Contrastive Language-Image Pre-training).

Visual Question Answering (VQA)

Answering natural-language questions about an image. Given an image and a question (“How many people are in this photo?”), the model outputs an answer. Modern VQA models are vision-language models (LMMs) like LLaVA, GPT-4o, or Qwen-VL. Practical: For co-op projects, use LLaVA-NeXT (open-source, runs on a single GPU): pip install llava && llava infer --image photo.jpg --question “What colour is the car?”. VQA replaces complex multi-model pipelines with a single model call. Use cases: quality assurance (“Is there a defect on the PCB?”), scene understanding (“Are there obstacles in the robot's path?”), data extraction (“What is the reading on the pressure gauge?”). For deterministic answers, set temperature = 0. See also: LLM (Large Language Model), Object Detection, OCR (Optical Character Recognition).

Letter

Y

2 terms

YOLO (You Only Look Once)

The dominant family of real-time object detectors. Instead of sliding windows or region proposals, YOLO treats detection as a single regression problem: a single CNN pass predicts bounding boxes + class probabilities simultaneously. Practical: In 2026, YOLOv8 and YOLOv11 (Ultralytics) are the default starting points. One-liner: pip install ultralytics && yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'. YOLO models come in sizes: N (nano, ~3 MB), S (small, ~11 MB), M (medium, ~25 MB), L (large, ~44 MB), X (xlarge, ~68 MB). Nano runs on a Raspberry Pi 4 at 15+ FPS. Xlarge needs a GPU but is more accurate. YOLO also supports segmentation, pose, classification, and OBB (oriented bounding boxes). See also: YOLOv8 / YOLOv11, Object Detection, CNN (Convolutional Neural Network).

YOLOv8 / YOLOv11

The two most popular YOLO versions in 2026. YOLOv8 (Ultralytics, 2023) improved anchor-free detection, added segmentation + pose heads, and introduced a cleaner training API. YOLOv11 (Ultralytics, 2025) adds a reparameterized backbone for higher accuracy at the same speed, improved feature fusion, and native export to more formats (CoreML, TFLite, TensorRT, OpenVINO). Practical: Use YOLOv8n for Raspberry Pi / edge; use YOLOv11x for server/cloud. Both share the same API: from ultralytics import YOLO; model = YOLO('yolov8n.pt'); results = model('image.jpg'). Training: yolo train model=yolov8n.pt data=coco128.yaml epochs=100 imgsz=640. The Ultralytics HUB (ultralytics.com/hub) provides free cloud training for small datasets. See also: YOLO (You Only Look Once), Object Detection, Roboflow Inference.

Letter

Z

1 term

Zero-Shot Detection (GroundingDINO / CLIP)

Detecting objects in an image without any training on those specific classes. GroundingDINO takes a text prompt (“a red fire hydrant”) and outputs bounding boxes for matching objects. CLIP can be used for zero-shot classification or region scoring. Practical: For a co-op project, zero-shot detection is ideal for exploration: before you label a dataset, run GroundingDINO on 100 images to see what your model would detect. pip install groundingdino-py && grounding_dino predict image.jpg --prompt “a yellow cone”. Accuracy is lower than a fine-tuned YOLO model (expect 20–40% mAP vs. 60–80% with fine-tuning), but it costs zero labelling effort. Use it to bootstrap a dataset: run GroundingDINO, correct the false positives, then fine-tune YOLO on the corrected labels. See also: CLIP (Contrastive Language-Image Pre-training), Object Detection, YOLO (You Only Look Once).

No matches

Try a different term, or press Esc to clear the search.

6. Quick reference tables

6.1 Edge deployment options

Device	Format	FPS (YOLOv8n)	Power
NVIDIA Jetson Orin Nano	TensorRT	~200	7–15 W
Raspberry Pi 5	TFLite / ONNX	~10	5 W
Apple M-series Mac	Core ML	~60	5–10 W
Intel NUC + Arc GPU	OpenVINO	~120	15–25 W
Google Coral TPU	TFLite Edge TPU	~30	2 W

7. Further reading

🔥 Jetson inference docs — github.com/dusty-nv/jetson-inference
🔥 MediaPipe solutions — developers.google.com/mediapipe
📚 OpenCV with CUDA — opencv.org
📚 Roboflow Inference — roboflow.com/inference

Last updated: July 2026. Maintained as a living document — if a term on your co-op isn't here, add it.