Avvio rapido

Q: How do I clone the Ultralytics repository for development?

Per clonare il repository Ultralytics e creare un ambiente di sviluppo, segui i seguenti passi: Questo approccio ti permette di contribuire al progetto o di sperimentare il codice sorgente più recente. Per maggiori dettagli, visita il repository GitHub di Ultralytics .

Installa Ultralytics

Ultralytics offre diversi metodi di installazione tra cui pip, conda e Docker. Installa YOLOv8 tramite la pagina ultralytics per l'ultima versione stabile o clonando il pacchetto Ultralytics Repository GitHub per la versione più aggiornata. Docker può essere utilizzato per eseguire il pacchetto in un contenitore isolato, evitando l'installazione locale.

Guarda: Ultralytics YOLO Guida rapida

Installa

Installa Pip (consigliato)Installazione di CondaClone GitDocker

Installa il programma ultralytics utilizzando pip, oppure aggiorna un'installazione esistente eseguendo pip install -U ultralytics. Visita il sito Python Package Index (PyPI) per maggiori dettagli sul programma. ultralytics pacchetto: https://pypi.org/project/ultralytics/.

# Install the ultralytics package from PyPI
pip install ultralytics

Puoi anche installare il programma ultralytics direttamente dal pacchetto GitHub deposito. Questo può essere utile se vuoi avere l'ultima versione di sviluppo. Assicurati di avere installato sul tuo sistema lo strumento a riga di comando Git. Il @main installa il file main e può essere modificato in un altro ramo, ad es. @my-brancho rimosso del tutto per passare all'impostazione predefinita di main ramo.

# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main

Conda è un gestore di pacchetti alternativo a pip che può essere utilizzato per l'installazione. Per maggiori dettagli visita Anaconda all'indirizzo https://anaconda.org/conda-forge/ultralytics. Ultralytics repository feedstock per l'aggiornamento del pacchetto conda si trova all'indirizzo https://github.com/conda-forge/ultralytics-feedstock/.

# Install the ultralytics package using conda
conda install -c conda-forge ultralytics

Nota

Se stai installando in un ambiente CUDA , la prassi migliore è quella di installare ultralytics, pytorch e pytorch-cuda nello stesso comando per consentire al gestore di pacchetti conda di risolvere eventuali conflitti, oppure per installare pytorch-cuda per ultimo per consentirgli di sovrascrivere le specifiche di CPU. pytorch se necessario.

# Install all packages together using conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Immagine Docker di Conda

Ultralytics Le immagini Docker di Conda sono disponibili anche su DockerHub. Queste immagini sono basate su Miniconda3 e sono un modo semplice per iniziare a usare ultralytics in un ambiente Conda.

# Set image name as a variable
t=ultralytics/ultralytics:latest-conda

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t  # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # specify GPUs

Clona il ultralytics se sei interessato a contribuire allo sviluppo o desideri sperimentare il codice sorgente più recente. Dopo la clonazione, naviga nella directory e installa il pacchetto in modalità modificabile -e utilizzando pip.

# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics

# Navigate to the cloned directory
cd ultralytics

# Install the package in editable mode for development
pip install -e .

Utilizza Docker per eseguire senza problemi il programma ultralytics in un contenitore isolato, assicurando prestazioni coerenti e fluide in vari ambienti. Scegliendo uno dei pacchetti ufficiali ultralytics immagini da Hub DockerUltralytics offre 5 immagini Docker principali supportate, ognuna delle quali è stata progettata per garantire un'elevata compatibilità ed efficienza per diverse piattaforme e casi d'uso:

Dockerfile: immagine di GPU consigliata per la formazione.
Dockerfile-arm64: Ottimizzato per l'architettura ARM64, consente la distribuzione su dispositivi come Raspberry Pi e altre piattaforme basate su ARM64.
Dockerfile-cpu: Versione basata su Ubuntu, CPU, adatta solo all'inferenza e agli ambienti senza GPU.
Dockerfile-jetson: Su misura per i dispositivi NVIDIA Jetson, integra il supporto di GPU ottimizzato per queste piattaforme.
Dockerfile-python: Immagine minimale con solo Python e le dipendenze necessarie, ideale per applicazioni leggere e di sviluppo.
Dockerfile-conda: basato su Miniconda3 con l'installazione di conda del pacchetto ultralytics .

Di seguito sono riportati i comandi per ottenere l'ultima immagine ed eseguirla:

# Set image name as a variable
t=ultralytics/ultralytics:latest

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t  # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # specify GPUs

Il comando di cui sopra inizializza un contenitore Docker con l'ultima versione di ultralytics immagine. Il -it assegna una pseudo-TTY e mantiene aperto lo stdin, permettendoti di interagire con il contenitore. Il flag --ipc=host imposta lo spazio dei nomi IPC (Inter-Process Communication) all'host, essenziale per condividere la memoria tra i processi. Il flag --gpus all permette di accedere a tutte le GPU disponibili all'interno del contenitore, il che è fondamentale per le attività che richiedono il calcolo di GPU .

Nota: per lavorare con i file sul tuo computer locale all'interno del contenitore, usa i volumi Docker per montare una directory locale nel contenitore:

# Mount local directory to a directory inside the container
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t

Alter /path/on/host con il percorso della directory sul tuo computer locale e /path/in/container con il percorso desiderato all'interno del contenitore Docker per l'accessibilità.

Per un utilizzo avanzato di Docker, non esitare a consultare la Guida Docker di Ultralytics .

Vedi il ultralytics pyproject.toml per un elenco delle dipendenze. Nota che tutti gli esempi precedenti installano tutte le dipendenze richieste.

Suggerimento

PyTorch I requisiti variano a seconda del sistema operativo e dei CUDA requisiti, quindi si consiglia di installare prima PyTorch seguendo le istruzioni riportate in https://pytorch.org/get-started/locally.

Usa Ultralytics con CLI

L'interfaccia a riga di comando Ultralytics (CLI) consente di eseguire semplici comandi a riga singola senza la necessità di un ambiente Python . CLI non richiede alcuna personalizzazione o codice Python . Puoi semplicemente eseguire tutte le attività dal terminale con il comando yolo comando. Controlla la sezione CLI Guida per saperne di più sull'uso di YOLOv8 dalla linea di comando.

Esempio

SintassiTrenoPrevedereValEsportazioneSpeciale

Ultralytics yolo utilizza la seguente sintassi:

yolo TASK MODE ARGS

TASK (opzionale) è uno dei seguenti (rilevare, segmento, classificare, posa, obb)
MODE (richiesto) è uno dei seguenti (treno, valore, Prevedere, esportazione, binario, punto di riferimento)
ARGS (opzionale) sono arg=value coppie come imgsz=640 che sovrascrivono le impostazioni predefinite.

Vedi tutti ARGS nella versione completa Guida alla configurazione o con l'opzione yolo cfg CLI comando.

Addestra un modello di rilevamento per 10 epoche con un tasso di apprendimento iniziale di 0,01.

yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01

Prevedere un video di YouTube utilizzando un modello di segmentazione preaddestrato con dimensioni dell'immagine pari a 320:

yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320

Val un modello di rilevamento preaddestrato alla dimensione del lotto 1 e alla dimensione dell'immagine 640:

yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640

Esporta un modello di classificazione YOLOv8n in formato ONNX con dimensioni dell'immagine 224 per 128 (non è richiesto alcun TASK)

yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128

Esegui comandi speciali per vedere la versione, visualizzare le impostazioni, eseguire controlli e altro ancora:

yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg

Avvertenze

Gli argomenti devono essere passati come arg=val coppie, divise da un uguale = e delimitati da spazi tra le coppie. Non utilizzare -- prefissi o virgole degli argomenti , tra gli argomenti.

yolo predict model=yolov8n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolov8n.pt imgsz 640 conf 0.25 ❌ (mancante =)
yolo predict model=yolov8n.pt, imgsz=640, conf=0.25 ❌ (non usare ,)
yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25 ❌ (non usare --)

CLI Guida

Usa Ultralytics con Python

YOLOv8L'interfaccia di Python consente una perfetta integrazione nei progetti Python , facilitando il caricamento, l'esecuzione e l'elaborazione dei risultati del modello. Progettata all'insegna della semplicità e della facilità d'uso, l'interfaccia di Python consente agli utenti di implementare rapidamente il rilevamento, la segmentazione e la classificazione degli oggetti nei loro progetti. Questo rende l'interfaccia di YOLOv8's Python uno strumento prezioso per chiunque voglia incorporare queste funzionalità nei propri progetti Python .

Ad esempio, gli utenti possono caricare un modello, addestrarlo, valutarne le prestazioni su un set di validazione e persino esportarlo in formato ONNX con poche righe di codice. Dai un'occhiata alla Guida diPython per saperne di più sull'uso di YOLOv8 nei tuoi progetti Python .

Esempio

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolov8n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolov8n.pt")

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")

# Export the model to ONNX format
success = model.export(format="onnx")

Python Guida

Ultralytics Impostazioni

La libreria Ultralytics fornisce un potente sistema di gestione delle impostazioni per consentire un controllo a grana fine dei tuoi esperimenti. Utilizzando la libreria SettingsManager ospitato all'interno del ultralytics.utils gli utenti possono accedere facilmente alle loro impostazioni e modificarle. Queste sono memorizzate in un file YAML e possono essere visualizzate o modificate direttamente nell'ambiente Python o tramite l'interfaccia a riga di comando (CLI).

Ispezione delle impostazioni

Per conoscere la configurazione attuale delle tue impostazioni, puoi visualizzarle direttamente:

Visualizza le impostazioni

PythonCLI

Puoi utilizzare Python per visualizzare le tue impostazioni. Inizia importando il file settings dall'oggetto ultralytics modulo. Stampa e restituisci le impostazioni utilizzando i seguenti comandi:

from ultralytics import settings

# View all settings
print(settings)

# Return a specific setting
value = settings["runs_dir"]

In alternativa, l'interfaccia a riga di comando ti permette di verificare le tue impostazioni con un semplice comando:

yolo settings

Modifica delle impostazioni

Ultralytics permette agli utenti di modificare facilmente le proprie impostazioni. Le modifiche possono essere effettuate nei seguenti modi:

Aggiorna le impostazioni

PythonCLI

All'interno dell'ambiente Python , chiama il metodo update sul metodo settings per modificare le impostazioni:

from ultralytics import settings

# Update a setting
settings.update({"runs_dir": "/path/to/runs"})

# Update multiple settings
settings.update({"runs_dir": "/path/to/runs", "tensorboard": False})

# Reset settings to default values
settings.reset()

Se preferisci utilizzare l'interfaccia a riga di comando, i seguenti comandi ti permetteranno di modificare le impostazioni:

# Update a setting
yolo settings runs_dir='/path/to/runs'

# Update multiple settings
yolo settings runs_dir='/path/to/runs' tensorboard=False

# Reset settings to default values
yolo settings reset

Capire le impostazioni

La tabella seguente fornisce una panoramica delle impostazioni disponibili per la regolazione all'interno di Ultralytics. Ogni impostazione è descritta con un valore di esempio, il tipo di dati e una breve descrizione.

Nome	Esempio di valore	Tipo di dati	Descrizione
`settings_version`	`'0.0.4'`	`str`	Ultralytics versionedelle impostazioni (diversa dalla versione di Ultralytics pip )
`datasets_dir`	`'/path/to/datasets'`	`str`	La directory in cui sono memorizzati i set di dati
`weights_dir`	`'/path/to/weights'`	`str`	La directory in cui sono memorizzati i pesi del modello
`runs_dir`	`'/path/to/runs'`	`str`	La directory in cui sono memorizzate le esecuzioni dell'esperimento
`uuid`	`'a1b2c3d4'`	`str`	L'identificativo univoco delle impostazioni correnti
`sync`	`True`	`bool`	Se sincronizzare le analisi e i crash con HUB
`api_key`	`''`	`str`	Ultralytics Chiave API HUB
`clearml`	`True`	`bool`	Whether to use ClearML logging
`comet`	`True`	`bool`	Se utilizzare Comet ML per il tracciamento e la visualizzazione degli esperimenti
`dvc`	`True`	`bool`	Se utilizzare il DVC per il tracciamento degli esperimenti e il controllo delle versioni
`hub`	`True`	`bool`	Se utilizzare l'integrazione di Ultralytics HUB
`mlflow`	`True`	`bool`	Whether to use MLFlow for experiment tracking
`neptune`	`True`	`bool`	Whether to use Neptune for experiment tracking
`raytune`	`True`	`bool`	Whether to use Ray Tune for hyperparameter tuning
`tensorboard`	`True`	`bool`	Whether to use TensorBoard for visualization
`wandb`	`True`	`bool`	Whether to use Weights & Biases logging
`vscode_msg`	`True`	`bool`	When VS Code terminal detected, enables prompt to download Ultralytics-Snippets extension.

Man mano che navighi nei tuoi progetti o esperimenti, assicurati di rivedere queste impostazioni per assicurarti che siano configurate in modo ottimale per le tue esigenze.

DOMANDE FREQUENTI

Come posso installare Ultralytics YOLOv8 utilizzando pip?

Per installare Ultralytics YOLOv8 con pip, esegui il seguente comando:

pip install ultralytics

Per l'ultima versione stabile, questo installerà il file ultralytics direttamente dal Python Package Index (PyPI). Per maggiori dettagli, visita il sito ultralytics su PyPI.

In alternativa, puoi installare l'ultima versione di sviluppo direttamente da GitHub:

pip install git+https://github.com/ultralytics/ultralytics.git

Assicurati di aver installato lo strumento a riga di comando Git sul tuo sistema.

Posso installare Ultralytics YOLOv8 utilizzando conda?

Sì, puoi installare Ultralytics YOLOv8 utilizzando conda:

conda install -c conda-forge ultralytics

Questo metodo è un'ottima alternativa a pip e garantisce la compatibilità con gli altri pacchetti presenti nel tuo ambiente. Per gli ambienti CUDA , è meglio installare ultralytics, pytorch, e pytorch-cuda contemporaneamente per risolvere eventuali conflitti:

conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Per ulteriori istruzioni, visita la guida rapida di Conda.

Quali sono i vantaggi di utilizzare Docker per eseguire Ultralytics YOLOv8 ?

L'utilizzo di Docker per l'esecuzione di Ultralytics YOLOv8 offre un ambiente isolato e coerente, garantendo prestazioni ottimali su sistemi diversi. Inoltre, elimina la complessità dell'installazione locale. Le immagini Docker ufficiali di Ultralytics sono disponibili su Docker Hub, con diverse varianti adatte agli ambienti GPU, CPU, ARM64, NVIDIA Jetson e Conda. Di seguito sono riportati i comandi per prelevare ed eseguire l'immagine più recente:

# Pull the latest ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all ultralytics/ultralytics:latest

Per istruzioni più dettagliate su Docker, consulta la guida rapida di Docker.

Come faccio a clonare il repository Ultralytics per lo sviluppo?

Per clonare il repository Ultralytics e configurare un ambiente di sviluppo, usa i seguenti passaggi:

# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics

# Navigate to the cloned directory
cd ultralytics

# Install the package in editable mode for development
pip install -e .

Questo approccio ti permette di contribuire al progetto o di sperimentare il codice sorgente più recente. Per maggiori dettagli, visita il repository GitHub di Ultralytics .

Perché dovrei usare Ultralytics YOLOv8 CLI ?

L'interfaccia a riga di comando Ultralytics YOLOv8 (CLI) semplifica l'esecuzione delle attività di rilevamento degli oggetti senza richiedere codice Python . Puoi eseguire comandi a riga singola per attività come l'addestramento, la convalida e la predizione direttamente dal tuo terminale. La sintassi di base per yolo I comandi sono:

yolo TASK MODE ARGS

Ad esempio, per addestrare un modello di rilevamento con parametri specifici:

yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01

Dai un'occhiata alla guida completa di CLI per scoprire altri comandi ed esempi di utilizzo.

📅 Created 10 months ago ✏️ Updated 6 days ago