Ultralytics YOLO26
Panoramica
Ultralytics YOLO26 è l'ultima evoluzione nella serie YOLO di rilevatori di oggetti in tempo reale, progettata da zero per dispositivi edge e a basso consumo. Introduce un design ottimizzato che rimuove inutili complessità, integrando innovazioni mirate per offrire un deployment più rapido, leggero e accessibile.

Esplora ed esegui i modelli YOLO26 direttamente su Ultralytics Platform.
L'architettura di YOLO26 è guidata da tre principi fondamentali:
- Semplicità: YOLO26 è un modello end-to-end nativo, che produce previsioni direttamente senza la necessità della soppressione dei non massimi (NMS). Eliminando questo passaggio di post-elaborazione, l'inferenza diventa più veloce, leggera e facile da distribuire in sistemi reali. Questo approccio rivoluzionario è stato introdotto per la prima volta in YOLOv10 da Ao Wang presso la Tsinghua University ed è stato ulteriormente sviluppato in YOLO26.
- Efficienza di Deployment: Il design end-to-end elimina un'intera fase della pipeline, semplificando drasticamente l'integrazione, riducendo la latenza e rendendo il deployment più solido in ambienti eterogenei.
- Innovazione nell'Addestramento: YOLO26 introduce l'ottimizzatore MuSGD, un ibrido tra SGD e Muon, ispirato alle scoperte di Kimi K2 di Moonshot AI nell'addestramento LLM. Questo ottimizzatore garantisce maggiore stabilità e una convergenza più rapida, trasferendo i progressi dell'ottimizzazione dai modelli linguistici alla visione artificiale.
- Ottimizzazioni specifiche per attività: YOLO26 introduce miglioramenti mirati per attività specializzate, tra cui la perdita per segmentazione semantica e moduli proto multi-scala per la Segmentazione, la stima della log-verosimiglianza residua (RLE) per una stima della Posa ad alta precisione, e una decodifica ottimizzata con perdita angolare per risolvere problemi di confine in OBB.
Insieme, queste innovazioni offrono una famiglia di modelli che raggiunge una maggiore precisione sugli oggetti piccoli, fornisce un deployment fluido e viene eseguita fino al 43% più velocemente su CPU, rendendo YOLO26 uno dei modelli YOLO più pratici e pronti per il deployment ad oggi per ambienti con risorse limitate.
Caratteristiche principali
-
Rimozione DFL Il modulo Distribution Focal Loss (DFL), sebbene efficace, spesso complicava l'esportazione e limitava la compatibilità hardware. YOLO26 rimuove interamente la DFL, semplificando l'inferenza e ampliando il supporto per dispositivi edge e a basso consumo.
-
Inferenza End-to-End senza NMS A differenza dei rilevatori tradizionali che si affidano alla NMS come fase di post-elaborazione separata, YOLO26 è nativamente end-to-end. Le previsioni vengono generate direttamente, riducendo la latenza e rendendo l'integrazione nei sistemi di produzione più veloce, leggera e affidabile.
-
ProgLoss + STAL Funzioni di perdita migliorate aumentano la precisione di rilevamento, con notevoli miglioramenti nel riconoscimento di oggetti piccoli, un requisito critico per IoT, robotica, immagini aeree e altre applicazioni edge.
-
Ottimizzatore MuSGD Un nuovo ottimizzatore ibrido che combina SGD con Muon. Ispirato a Kimi K2 di Moonshot AI, MuSGD introduce metodi di ottimizzazione avanzati dall'addestramento LLM nella visione artificiale, consentendo un addestramento più stabile e una convergenza più veloce.
-
Inferenza su CPU fino al 43% più veloce Specificamente ottimizzato per l'edge computing, YOLO26 offre un'inferenza su CPU significativamente più rapida, garantendo prestazioni in tempo reale su dispositivi privi di GPU.
-
Miglioramenti nella Segmentazione di Istanza Introduce la perdita di segmentazione semantica per migliorare la convergenza del modello e un modulo proto aggiornato che sfrutta informazioni multi-scala per una qualità delle maschere superiore.
-
Stima della Posa di Precisione Integra la Residual Log-Likelihood Estimation (RLE) per una localizzazione dei keypoint più accurata e ottimizza il processo di decodifica per una maggiore velocità di inferenza.
-
Decodifica OBB perfezionata Introduce una perdita angolare specializzata per migliorare la precisione di rilevamento per oggetti di forma quadrata e ottimizza la decodifica OBB per risolvere problemi di discontinuità dei bordi.

Attività e modalità supportate
YOLO26 si basa sulla gamma versatile di modelli stabilita dalle precedenti versioni Ultralytics YOLO, offrendo un supporto avanzato per varie attività di visione artificiale:
| Modello | Nomi dei file | Attività | Inferenza | Validazione | Addestramento | Esporta |
|---|---|---|---|---|---|---|
| YOLO26 | yolo26n.pt yolo26s.pt yolo26m.pt yolo26l.pt yolo26x.pt | Rilevamento | ✅ | ✅ | ✅ | ✅ |
| YOLO26-seg | yolo26n-seg.pt yolo26s-seg.pt yolo26m-seg.pt yolo26l-seg.pt yolo26x-seg.pt | Segmentazione di istanza | ✅ | ✅ | ✅ | ✅ |
| YOLO26-sem | yolo26n-sem.pt yolo26s-sem.pt yolo26m-sem.pt yolo26l-sem.pt yolo26x-sem.pt | Segmentazione semantica | ✅ | ✅ | ✅ | ✅ |
| YOLO26-pose | yolo26n-pose.pt yolo26s-pose.pt yolo26m-pose.pt yolo26l-pose.pt yolo26x-pose.pt | Posa/Keypoint | ✅ | ✅ | ✅ | ✅ |
| YOLO26-obb | yolo26n-obb.pt yolo26s-obb.pt yolo26m-obb.pt yolo26l-obb.pt yolo26x-obb.pt | Rilevamento orientato | ✅ | ✅ | ✅ | ✅ |
| YOLO26-cls | yolo26n-cls.pt yolo26s-cls.pt yolo26m-cls.pt yolo26l-cls.pt yolo26x-cls.pt | Classificazione | ✅ | ✅ | ✅ | ✅ |
Questo framework unificato garantisce che YOLO26 sia applicabile al rilevamento in tempo reale, alla segmentazione di istanza, alla segmentazione semantica, alla classificazione, alla stima della posa e al rilevamento di oggetti orientati: il tutto con supporto per addestramento, validazione, inferenza ed esportazione.
yolo26-p2.yaml e yolo26-p6.yaml aggiungono una head di rilevamento P2 (oggetti piccoli) o P6 (input grande) e vengono forniti solo come architetture YAML. Non vengono rilasciati pesi specifici per scala come yolo26*-p2.pt o yolo26*-p6.pt. Istanzia una configurazione scalata da YAML (ad esempio, YOLO("yolo26n-p6.yaml")) e addestrala o effettua il fine-tuning come necessario.
Metriche di prestazione
Consulta la Documentazione sul Rilevamento per esempi di utilizzo con questi modelli addestrati su COCO, che includono 80 classi pre-addestrate.
| Modello | dimensione (pixel) | mAPval 50-95 | mAPval 50-95(e2e) | Velocità CPU ONNX (ms) | Velocità T4 TensorRT10 (ms) | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 |
I valori di Params e FLOPs si riferiscono al modello fuso dopo model.fuse(), che unisce i livelli Conv e BatchNorm e rimuove l'head di rilevamento ausiliario uno-a-molti. I checkpoint preaddestrati mantengono l'intera architettura di addestramento e potrebbero mostrare conteggi più elevati.
Esempi di utilizzo
Questa sezione fornisce semplici esempi di addestramento e inferenza con YOLO26. Per la documentazione completa su queste e altre modalità, consulta le pagine della documentazione su Previsione, Addestramento, Validazione ed Esportazione.
Nota che l'esempio seguente riguarda i modelli YOLO26 Rilevamento per il rilevamento di oggetti. Per ulteriori attività supportate, consulta la documentazione su Segmentazione, Segmentazione semantica, Classificazione, OBB e Posa.
PyTorch pretrained *.pt models as well as configuration *.yaml files can be passed to the YOLO() class to create a model instance in Python:
from ultralytics import YOLO
# Load a COCO-pretrained YOLO26n model
model = YOLO("yolo26n.pt")
# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Run inference with the YOLO26n model on the 'bus.jpg' image
results = model("path/to/bus.jpg")YOLO26 presenta un'architettura a doppia testa che offre flessibilità per diversi scenari di distribuzione:
- Head uno-a-uno (Predefinita): Produce previsioni end-to-end senza NMS, generando
(N, 300, 6)con un massimo di 300 rilevamenti per immagine. Questa head è ottimizzata per un'inferenza rapida e una distribuzione semplificata. - Head uno-a-molti: Genera output YOLO tradizionali che richiedono post-elaborazione NMS, generando
(N, nc + 4, 8400)dovencè il numero di classi. Questa head solitamente ottiene una precisione leggermente superiore al costo di un'elaborazione aggiuntiva.
Puoi passare da una head all'altra durante l'esportazione, la previsione o la validazione:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Use one-to-one head (default, no NMS required)
results = model.predict("image.jpg") # inference
metrics = model.val(data="coco.yaml") # validation
model.export(format="onnx") # export
# Use one-to-many head (requires NMS)
results = model.predict("image.jpg", end2end=False) # inference
metrics = model.val(data="coco.yaml", end2end=False) # validation
model.export(format="onnx", end2end=False) # exportLa scelta dipende dai tuoi requisiti di distribuzione: usa la head uno-a-uno per la massima velocità e semplicità, oppure la head uno-a-molti quando la precisione è la priorità assoluta.
YOLOE-26: Segmentazione di istanze a vocabolario aperto
YOLOE-26 integra l'architettura ad alte prestazioni YOLO26 con le capacità a vocabolario aperto della serie YOLOE. Consente il rilevamento e la segmentazione in tempo reale di qualsiasi classe di oggetti utilizzando prompt testuali, prompt visivi o una modalità senza prompt per un'inferenza zero-shot, eliminando efficacemente i vincoli dell'addestramento su categorie fisse.
Sfruttando il design end-to-end senza NMS di YOLO26, YOLOE-26 offre un'inferenza rapida nel mondo aperto. Questo lo rende una soluzione potente per applicazioni edge in ambienti dinamici dove gli oggetti di interesse rappresentano un vocabolario ampio ed evolutivo.
Consulta la documentazione su YOLOE per esempi di utilizzo con questi modelli addestrati sui set di dati Objects365v1, GQA e Flickr30k.
| Modello | dimensione (pixel) | Tipo di prompt | mAPminival 50-95(e2e) | mAPminival 50-95 | mAPr | mAPc | mAPf | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|---|---|
| YOLOE-26n-seg | 640 | Testo/Visivo | 23.7 / 20.9 | 24.7 / 21.9 | 20.5 / 17.6 | 24.1 / 22.3 | 26.1 / 22.4 | 4.8 | 6.0 |
| YOLOE-26s-seg | 640 | Testo/Visivo | 29.9 / 27.1 | 30.8 / 28.6 | 23.9 / 25.1 | 29.6 / 27.8 | 33.0 / 29.9 | 13.1 | 21.7 |
| YOLOE-26m-seg | 640 | Testo/Visivo | 35.4 / 31.3 | 35.4 / 33.9 | 31.1 / 33.4 | 34.7 / 34.0 | 36.9 / 33.8 | 27.9 | 70.1 |
| YOLOE-26l-seg | 640 | Testo/Visivo | 36.8 / 33.7 | 37.8 / 36.3 | 35.1 / 37.6 | 37.6 / 36.2 | 38.5 / 36.1 | 32.3 | 88.3 |
| YOLOE-26x-seg | 640 | Testo/Visivo | 39.5 / 36.2 | 40.6 / 38.5 | 37.4 / 35.3 | 40.9 / 38.8 | 41.0 / 38.8 | 69.9 | 196.7 |
Esempio di utilizzo
YOLOE-26 supporta prompt sia basati su testo che visivi. Usare i prompt è semplice: ti basta passarli attraverso il metodo predict come mostrato di seguito:
I prompt di testo ti consentono di specificare le classi che desideri rilevare attraverso descrizioni testuali. Il seguente codice mostra come puoi usare YOLOE-26 per rilevare persone e autobus in un'immagine:
from ultralytics import YOLO
# Initialize model
model = YOLO("yoloe-26l-seg.pt") # or select yoloe-26s/m-seg.pt for different sizes
# Set text prompt to detect person and bus. You only need to do this once after you load the model.
model.set_classes(["person", "bus"])
# Run detection on the given image
results = model.predict("path/to/image.jpg")
# Show results
results[0].show()Per un approfondimento sulle tecniche di prompting, sull'addestramento da zero e su esempi di utilizzo completi, visita la Documentazione di YOLOE.
Citazioni e riconoscimenti
Ultralytics non ha pubblicato un documento di ricerca formale per YOLO26 a causa della natura in rapida evoluzione dei modelli. Al contrario, ci concentriamo sul fornire modelli all'avanguardia e sul renderli facili da usare. Per gli ultimi aggiornamenti su funzionalità, architetture e utilizzo di YOLO, visita il nostro repository GitHub e la nostra documentazione.
Se utilizzi YOLO26 o altro software Ultralytics nel tuo lavoro, ti preghiamo di citarlo come:
@software{yolo26_ultralytics,
author = {Glenn Jocher and Jing Qiu},
title = {Ultralytics YOLO26},
version = {26.0.0},
year = {2026},
url = {https://github.com/ultralytics/ultralytics},
orcid = {0000-0001-5950-6979, 0000-0003-3783-7069},
license = {AGPL-3.0}
}DOI in attesa. YOLO26 è disponibile con licenze AGPL-3.0 e Enterprise.
FAQ
Quali sono i miglioramenti chiave in YOLO26 rispetto a YOLO11?
- Rimozione DFL: Semplifica l'esportazione ed espande la compatibilità con i dispositivi edge
- Inferenza end-to-end senza NMS: Elimina NMS per un'implementazione più rapida e semplice
- ProgLoss + STAL: Aumenta la precisione, specialmente sugli oggetti piccoli
- Ottimizzatore MuSGD: Combina SGD e Muon (ispirato a Kimi K2 di Moonshot) per un addestramento più stabile ed efficiente
- Fino al 43% di inferenza CPU più rapida: Notevoli miglioramenti delle prestazioni per dispositivi che utilizzano solo CPU
Quali attività supporta YOLO26?
YOLO26 è una famiglia di modelli unificata, che fornisce supporto end-to-end per molteplici attività di visione artificiale:
- Rilevamento oggetti
- Segmentazione di istanza
- Segmentazione semantica
- Classificazione immagini
- Stima della posa
- Rilevamento oggetti orientati (OBB)
Ogni variante di dimensione (n, s, m, l, x) supporta tutte le attività, oltre a versioni a vocabolario aperto tramite YOLOE-26.
Perché YOLO26 è ottimizzato per l'implementazione edge?
YOLO26 offre prestazioni edge all'avanguardia con:
- Fino al 43% di inferenza CPU più rapida
- Dimensioni del modello e ingombro di memoria ridotti
- Architettura semplificata per la compatibilità (senza DFL, senza NMS)
- Formati di esportazione flessibili inclusi TensorRT, ONNX, CoreML, TFLite e OpenVINO
Come posso iniziare con YOLO26?
I modelli YOLO26 sono stati rilasciati il 14 gennaio 2026 e sono disponibili per il download. Installa o aggiorna il pacchetto ultralytics e carica un modello:
from ultralytics import YOLO
# Load a pretrained YOLO26 nano model
model = YOLO("yolo26n.pt")
# Run inference on an image
results = model("image.jpg")Consulta la sezione Usage Examples per le istruzioni su training, validazione ed esportazione.