Computer vision · SDK

Ultralytics YOLO

Ultralytics

Run object detection and segmentation using the Ultralytics model tooling.

Official documentation Download development spec

ULTRALYTICS YOLO / DEVELOPER FIELD GUIDE

Choose an interface. Define a verifiable result.

Company or project context, ten technical entry points and a practical analysis of every reference.

2026-10-08 · Integration not tested

Company / project overview

Original summary of official company or project statements; use the source for the full original page.

Ultralytics YOLO · About
Origins	Ultralytics describes Glenn Jocher’s work on accessible computer vision as its starting point.
Mission	The company emphasizes accessible open-source AI for developers and businesses.
Company context	The About page includes the team, values, products and commercial licensing links.

Complete official About page ↗

About reference — TA analysis
Audience	Buyers, partners and product owners shortlisting an AI provider.
Our assessment	Use positioning and company history for initial fit. Obtain project-specific deployment, support and commercial terms separately.

Official project and developer sources reviewed; no provider API was called. Expected outputs below are our illustrative contracts, not measured results.

Top 10 technical entry points

Ten documented technical entry points, selected by task; not ten independent SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · PredictionAPI / SDK / developer guide	Run a chosen model on images or video.Application developer
02 · TrainingAPI / SDK / developer guide	Train model weights on a dataset.ML engineer
03 · ValidationAPI / SDK / developer guide	Evaluate a model on labelled data.ML / QA
04 · Model exportAPI / SDK / developer guide	Export model artifacts to a target format.Edge deployment team
05 · Video trackingAPI / SDK / developer guide	Associate detections across frames.Video application team
06 · Benchmark modeAPI / SDK / developer guide	Compare runtime formats on a selected device.Performance engineer
07 · Object detectionAPI / SDK / developer guide	Detect instances using bounding boxes.Inspection developer
08 · Instance segmentationAPI / SDK / developer guide	Produce instance masks.Measurement / vision team
09 · Pose estimationAPI / SDK / developer guide	Estimate configured keypoints.Motion application team
10 · Oriented boxesAPI / SDK / developer guide	Locate objects with rotated boxes.Aerial / parts vision team

Reference analysis

Capabilities summarize official documentation. Constraints and proposed tests are our engineering assessment.

API / SDK / developer guide

Prediction

Prediction · TA
Target audience	Application developer
Documented capability	Run a chosen model on images or video.
Input → output	Image / frame → task-specific results
Execution environment	Local application / pinned library and model
Our decision constraint	Pin weights and preprocessing; results vary by task.
Our suggested validation	Verify original-image coordinate mapping.

Official reference · Prediction ↗

API / SDK / developer guide

Training

Training · TA
Target audience	ML engineer
Documented capability	Train model weights on a dataset.
Input → output	Dataset + configuration → weights and logs
Execution environment	Local application / pinned library and model
Our decision constraint	Training completion is not proof of generalization.
Our suggested validation	Keep evaluation images out of training.

Official reference · Training ↗

API / SDK / developer guide

Validation

Validation · TA
Target audience	ML / QA
Documented capability	Evaluate a model on labelled data.
Input → output	Weights + held-out data → metrics
Execution environment	Local application / pinned library and model
Our decision constraint	Aggregate metrics can hide rare defect failures.
Our suggested validation	Report per-class recall and false positives.

Official reference · Validation ↗

API / SDK / developer guide

Model export

Model export · TA
Target audience	Edge deployment team
Documented capability	Export model artifacts to a target format.
Input → output	Weights → exported artifact
Execution environment	Local application / pinned library and model
Our decision constraint	Export success does not guarantee target runtime support.
Our suggested validation	Compare target outputs against the original model.

Official reference · Model export ↗

API / SDK / developer guide

Video tracking

Video tracking · TA
Target audience	Video application team
Documented capability	Associate detections across frames.
Input → output	Frames → boxes and tracking IDs
Execution environment	Local application / pinned library and model
Our decision constraint	Tracking IDs are temporary track identities, not people identities.
Our suggested validation	Test occlusion, re-entry and ID switches.

Official reference · Video tracking ↗

API / SDK / developer guide

Benchmark mode

Benchmark mode · TA
Target audience	Performance engineer
Documented capability	Compare runtime formats on a selected device.
Input → output	Model + hardware → timing and metric report
Execution environment	Local application / pinned library and model
Our decision constraint	Published benchmarks are not your hardware measurements.
Our suggested validation	Record warmup, precision and batch size.

Official reference · Benchmark mode ↗

API / SDK / developer guide

Object detection

Object detection · TA
Target audience	Inspection developer
Documented capability	Detect instances using bounding boxes.
Input → output	Image → classes, scores and boxes
Execution environment	Local application / pinned library and model
Our decision constraint	Default classes may exclude your defects.
Our suggested validation	Verify class mapping on representative parts.

Official reference · Object detection ↗

API / SDK / developer guide

Instance segmentation

Instance segmentation · TA
Target audience	Measurement / vision team
Documented capability	Produce instance masks.
Input → output	Image → masks and instance labels
Execution environment	Local application / pinned library and model
Our decision constraint	Pixel masks are not calibrated physical measurements.
Our suggested validation	Compare boundaries to reference masks.

Official reference · Instance segmentation ↗

API / SDK / developer guide

Pose estimation

Pose estimation · TA
Target audience	Motion application team
Documented capability	Estimate configured keypoints.
Input → output	Image → keypoint coordinates
Execution environment	Local application / pinned library and model
Our decision constraint	Skeleton semantics depend on the chosen model.
Our suggested validation	Check missing points and visibility conditions.

Official reference · Pose estimation ↗

API / SDK / developer guide

Oriented boxes

Oriented boxes · TA
Target audience	Aerial / parts vision team
Documented capability	Locate objects with rotated boxes.
Input → output	Image → oriented bounding geometry
Execution environment	Local application / pinned library and model
Our decision constraint	Angle conventions must match your downstream adapter.
Our suggested validation	Test rotated examples near wraparound angles.

Official reference · Oriented boxes ↗

Official documentation overview

Official documentation overview · Supporting reference analysis
TA	Developers and product owners selecting the supported technical path.
Our validation advice	Choose the operation, supported version and runtime before assigning implementation.

Official reference · Official documentation overview ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Model and SDK evaluation; exact weights, dependencies and applicable licenses must be chosen before deployment. No inference is run here.

Illustrative contract · no API call or model execution · not measured provider output

Detected object

Expected behavior — illustrative, not executed
Input	Image plus chosen detection weights
Expected result	ok with class, score and xyxy pixels
Acceptance	Box stays within image and class maps correctly

No detection

Expected behavior — illustrative, not executed
Input	Valid image below chosen threshold
Expected result	ok; detections=[]
Acceptance	Do not invent boxes

Weights unavailable

Expected behavior — illustrative, not executed
Input	Missing or incompatible model artifact
Expected result	error; model_unavailable
Acceptance	No fabricated prediction

Export mismatch

Expected behavior — illustrative, not executed
Input	Original and exported model on same sample
Expected result	comparison with deltas; not automatic pass
Acceptance	Meet agreed accuracy delta before deployment

Map the expected result to your application

Review the scenarios below and map the actual SDK response into this internal contract. No credential, API call or live output is included. Replace example data only after your own integration test.

Expected output JSON — illustrative, not measured · UltralyticsYOLO-expected-results.json

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "Ultralytics YOLO",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "detections": [
      {
        "class_id": 0,
        "label": "sample-part",
        "score": 0.86,
        "xyxy_pixels": [
          20,
          30,
          120,
          160
        ]
      }
    ]
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Result states	ok means the selected operation returned a valid result; a valid empty result differs from error. Pending work remains pending until a terminal result. Do not infer real-world correctness from API success.
Reproducibility	Record input ID, library/model version, configuration, runtime and coordinate/score conventions. Examples contain invented sample values.
Acceptance — proposed	Use representative authorized samples plus empty, malformed and unavailable-runtime cases. Agree quality and latency targets before running tests. No measured accuracy, cost or speed is claimed.
Operation boundary	Model and SDK evaluation; exact weights, dependencies and applicable licenses must be chosen before deployment. No inference is run here.

Related route to assess: Roboflow

Development assessment

Defect candidate detector

Development concept · integration not tested

Provider capabilities above are based on official documentation or repositories. The proposed product, inputs, deliverable and acceptance criteria below are our development assessment.

Integration pilot

Validate runtime, schemas or hardware together before estimating a deployable product.

Proposed inputs: A small authorized image dataset, task definition and reference annotations.
Proposed deliverable: A reviewable result with image references, labels or annotation state; keep original files.
Acceptance criterion: Compare the supported operation against a labeled sample; report errors and missing results separately.
Dependencies: Dataset access, image rights and a supported model or annotation project.

Integration condition

Review the selected code and model licenses before commercial distribution.

Development sequence

Confirm access to Ultralytics YOLO, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Defect candidate detector”.
Normalize the result with source, time and explicit error state; keep the provider response for review.
Run the acceptance criterion before estimating rollout effort or committing a customer deliverable.

How to validate demand

Record product views, documentation clicks, specification downloads and contextual hub clicks. These are event counts, not unique people or completed integrations.

This feasibility assessment uses implementation conditions. No traffic-based rank or delivery-time promise is assigned.

Ultralytics YOLO

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Official documentation overview

Expected results before implementation

Detected object

No detection

Weights unavailable

Export mismatch

Map the expected result to your application

Defect candidate detector

Integration condition

Development sequence

How to validate demand

Related products