Avvio rapido

Q: Can I install Ultralytics YOLO using conda?

Sì, è possibile installare Ultralytics YOLO utilizzando conda: Questo metodo è un'ottima alternativa a pip e garantisce la compatibilità con gli altri pacchetti presenti nell'ambiente. Per gli ambienti CUDA , è meglio installare contemporaneamente ultralytics, pytorch e pytorch-cuda per risolvere eventuali conflitti: Per ulteriori istruzioni, visitare la guida rapida di Conda.

Installare Ultralytics

Ultralytics fornisce vari metodi di installazione, tra cui pip, conda e Docker. Installare YOLO tramite il file ultralytics per l'ultima versione stabile o clonando il pacchetto Ultralytics Repository GitHub per la versione più aggiornata. Docker può essere usato per eseguire il pacchetto in un contenitore isolato, evitando l'installazione locale.

Guarda: Ultralytics YOLO Guida rapida

Installare

Installazione Pip (consigliata)Installazione di CondaClone GitDocker

Installare il ultralytics utilizzando pip, oppure aggiornare un'installazione esistente eseguendo pip install -U ultralytics. Visitare l'indice dei pacchetti Python (PyPI) per maggiori dettagli su ultralytics pacchetto: https://pypi.org/project/ultralytics/.

# Install the ultralytics package from PyPI
pip install ultralytics

È inoltre possibile installare il programma ultralytics direttamente dal pacchetto GitHub deposito. Questo può essere utile se si desidera l'ultima versione di sviluppo. Assicurarsi che lo strumento a riga di comando Git sia installato sul sistema. Il @main installa il file main e può essere modificato in un altro ramo, ad es. @my-brancho rimosso del tutto per passare al valore predefinito 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 usato anche per l'installazione. Per maggiori dettagli, visitare 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 si sta installando in un ambiente CUDA , la pratica migliore è quella di installare ultralytics, pytorch e pytorch-cuda nello stesso comando per permettere al gestore di pacchetti conda di risolvere eventuali conflitti, oppure per installare pytorch-cuda per ultimo, per consentire di sovrascrivere la specifica 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 da 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

Clonare il ultralytics se siete interessati a contribuire allo sviluppo o a sperimentare il codice sorgente più recente. Dopo la clonazione, navigare nella cartella e installare 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 .

Utilizzate 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 progettata per fornire un'elevata compatibilità ed efficienza per piattaforme e casi d'uso diversi:

Dockerfile: immagine 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- solo adatta 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 precedente inizializza un contenitore Docker con l'ultima versione di ultralytics immagine. Il -it assegna una pseudo-TTY e mantiene aperto lo stdin, consentendo di interagire con il contenitore. Il flag --ipc=host imposta il namespace IPC (Inter-Process Communication) all'host, essenziale per la condivisione della 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 computer locale all'interno del contenitore, usare 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 sulla macchina locale e /path/in/container con il percorso desiderato all'interno del contenitore Docker per l'accessibilità.

Per l'uso avanzato di Docker, si consiglia di esplorare la Guida a Docker diUltralytics .

Vedere il ultralytics progetto.toml per un elenco di dipendenze. Si noti 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 PyTorch prima seguendo le istruzioni riportate in https://pytorch.org/get-started/locally.

Utilizzare 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 . È sufficiente eseguire tutti i task dal terminale con il comando yolo comando. Controllare il comando CLI Guida per saperne di più sull'uso di YOLO dalla riga di comando.

Esempio

SintassiTrenoPrevedereValEsportazioneSpeciale

Ultralytics yolo I comandi utilizzano la seguente sintassi:

yolo TASK MODE ARGS

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

Vedi tutti ARGS nell'intero Guida alla configurazione o con il yolo cfg CLI comando.

Addestrare un modello di rilevamento per 10 epoche con un tasso_di_apprendimento iniziale di 0,01.

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

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

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

Val un modello di rilevamento pre-addestrato alla dimensione del batch 1 e alla dimensione dell'immagine 640:

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

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

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

Eseguite 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=yolo11n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolo11n.pt imgsz 640 conf 0.25 ❌ (mancante =)
yolo predict model=yolo11n.pt, imgsz=640, conf=0.25 ❌ (non utilizzare ,)
yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25 ❌ (non utilizzare --)

CLI Guida

Utilizzare Ultralytics con Python

YOLOL'interfaccia 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 Python consente agli utenti di implementare rapidamente il rilevamento, la segmentazione e la classificazione degli oggetti nei loro progetti. Questo rende l'interfaccia YOLO di 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. Consultate la guidaPython per saperne di più sull'uso di YOLO nei vostri progetti Python .

Esempio

from ultralytics import YOLO

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

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.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 degli 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 JSON nella directory di configurazione dell'utente dell'ambiente 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 impostazioni, è possibile visualizzarle direttamente:

Visualizza le impostazioni

PythonCLI

È possibile utilizzare Python per visualizzare le impostazioni. Iniziare importando il file settings dall'oggetto ultralytics modulo. Stampare e restituire 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 consente di verificare le impostazioni con un semplice comando:

yolo settings

Modifica delle impostazioni

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

Aggiornamento delle impostazioni

PythonCLI

Nell'ambiente Python , richiamare 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 si preferisce utilizzare l'interfaccia a riga di comando, i seguenti comandi consentono 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

Comprensione delle impostazioni

La tabella seguente fornisce una panoramica delle impostazioni disponibili per la regolazione all'interno di Ultralytics. Ciascuna 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'identificatore univoco delle impostazioni correnti
`sync`	`True`	`bool`	Se sincronizzare le analisi e gli arresti anomali con l'HUB
`api_key`	`''`	`str`	Ultralytics Chiave API HUB
`clearml`	`True`	`bool`	Se utilizzare ClearML registrazione
`comet`	`True`	`bool`	Se utilizzare Comet ML per il tracciamento e la visualizzazione degli esperimenti
`dvc`	`True`	`bool`	Se utilizzare DVC per il tracciamento degli esperimenti e il controllo delle versioni
`hub`	`True`	`bool`	Se utilizzare l'integrazione di Ultralytics HUB
`mlflow`	`True`	`bool`	Se utilizzare MLFlow per il tracciamento degli esperimenti
`neptune`	`True`	`bool`	Se utilizzare Neptune per il tracciamento degli esperimenti
`raytune`	`True`	`bool`	Se utilizzare Ray Tune per la regolazione dell'iperparametro
`tensorboard`	`True`	`bool`	Se utilizzare o meno TensorBoard per la visualizzazione
`wandb`	`True`	`bool`	Se utilizzare Weights & Biases registrazione
`vscode_msg`	`True`	`bool`	Quando viene rilevato il terminale VS Code, attiva la richiesta di scaricare l'estensione Ultralytics-Snippets.

Man mano che si procede con i progetti o gli esperimenti, è bene rivedere queste impostazioni per assicurarsi che siano configurate in modo ottimale per le proprie esigenze.

FAQ

Come si installa Ultralytics usando pip?

Per installare Ultralytics con pip, eseguire 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, visitare il sito ultralytics su PyPI.

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

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

Assicuratevi di avere installato lo strumento a riga di comando Git sul vostro sistema.

Posso installare Ultralytics YOLO usando conda?

Sì, è possibile installare Ultralytics YOLO usando conda, eseguendo il comando

conda install -c conda-forge ultralytics

Questo metodo è un'ottima alternativa a pip e garantisce la compatibilità con gli altri pacchetti presenti nell'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, visitate la guida rapida di Conda.

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

L'uso di Docker per l'esecuzione di Ultralytics YOLO fornisce un ambiente isolato e coerente, garantendo prestazioni uniformi 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, consultate la guida rapida a Docker.

Come si clona il repository Ultralytics per lo sviluppo?

Per clonare il repository Ultralytics e configurare un ambiente di sviluppo, procedere come segue:

# 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 consente di contribuire al progetto o di sperimentare il codice sorgente più recente. Per maggiori dettagli, visitate il repository GitHub di Ultralytics .

Perché dovrei usare Ultralytics YOLO CLI ?

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

yolo TASK MODE ARGS

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

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

Consultate la Guida completa di CLI per esplorare altri comandi ed esempi di utilizzo.

📅C reato 1 anno fa ✏️ Aggiornato 1 mese fa