Installa Ultralytics

Ultralytics offre diversi metodi di installazione, tra cui pip, conda e Docker. Puoi installare YOLO tramite il pacchetto pip ultralytics per la versione stabile più recente, oppure clonando il repository GitHub di Ultralytics per la versione più attuale. Anche Docker è un'opzione per eseguire il pacchetto in un container isolato, evitando così l'installazione locale.

Watch: Ultralytics YOLO Quick Start Guide

Installa

Installa o aggiorna il pacchetto ultralytics usando pip eseguendo pip install -U ultralytics. Per maggiori dettagli sul pacchetto ultralytics, visita il Python Package Index (PyPI).

# Install or upgrade the ultralytics package from PyPI
pip install -U ultralytics

Puoi anche installare ultralytics direttamente dal repository GitHub di Ultralytics. Questo può essere utile se desideri la versione di sviluppo più recente. Assicurati di avere installato lo strumento da riga di comando Git, quindi esegui:

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

Consulta il file ultralytics pyproject.toml per un elenco delle dipendenze. Nota che tutti gli esempi sopra installano tutte le dipendenze richieste.

Suggerimento

I requisiti di PyTorch variano in base al sistema operativo e ai requisiti CUDA, quindi installa prima PyTorch seguendo le istruzioni su PyTorch.

PyTorch installation selector for different platforms

Installazione su server headless

Per ambienti server senza display (ad esempio, macchine virtuali cloud, container Docker, pipeline CI/CD), usa il pacchetto ultralytics-opencv-headless. Questo è identico al pacchetto ultralytics standard ma dipende da opencv-python-headless invece di opencv-python, evitando dipendenze GUI non necessarie e potenziali errori libGL.

Installazione Headless

pip install ultralytics-opencv-headless

Entrambi i pacchetti forniscono la stessa funzionalità e API. La variante headless esclude semplicemente i componenti GUI di OpenCV che richiedono librerie di visualizzazione.

Installazione avanzata

Sebbene i metodi di installazione standard coprano la maggior parte dei casi d'uso, potresti aver bisogno di una configurazione più su misura per lo sviluppo o configurazioni personalizzate.

Metodi avanzati

Se hai bisogno di modifiche personalizzate persistenti, puoi effettuare il fork del repository Ultralytics, apportare modifiche a pyproject.toml o ad altro codice e installare dal tuo fork.

Effettua il fork del repository GitHub di Ultralytics sul tuo account GitHub.

Clona il tuo fork localmente:

git clone https://github.com/YOUR_USERNAME/ultralytics.git
cd ultralytics

Crea un nuovo branch per le tue modifiche:
```
git checkout -b my-custom-branch
```
Apporta le tue modifiche a pyproject.toml o ad altri file come necessario.

Esegui commit e push delle tue modifiche:

git add .
git commit -m "My custom changes"
git push origin my-custom-branch

Installa usando pip con la sintassi git+https, puntando al tuo branch:

pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

Uso di Ultralytics con CLI

L'interfaccia a riga di comando (CLI) di Ultralytics consente semplici comandi su riga singola senza bisogno di un ambiente Python. La CLI non richiede alcuna personalizzazione o codice Python; esegui tutte le attività dal terminale con il comando yolo. Per saperne di più sull'uso di YOLO dalla riga di comando, consulta la Guida CLI.

Esempio

I comandi yolo di Ultralytics usano la seguente sintassi:

yolo TASK MODE ARGS

TASK (opzionale) è uno tra (detect, segment, classify, pose, obb)
MODE (obbligatorio) è uno tra (train, val, predict, export, track, benchmark)
ARGS (opzionali) sono coppie arg=value come imgsz=640 che sovrascrivono i valori predefiniti.

Vedi tutti gli ARGS nella Guida alla configurazione completa o con il comando CLI yolo cfg.

Avviso

Gli argomenti devono essere passati come coppie arg=value, separati da un segno uguale = e delimitati da spazi. Non usare prefissi di argomento -- o virgole , tra gli argomenti.

yolo predict model=yolo26n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolo26n.pt imgsz 640 conf 0.25 ❌ (segno = mancante)
yolo predict model=yolo26n.pt, imgsz=640, conf=0.25 ❌ (non usare ,)
yolo predict --model yolo26n.pt --imgsz 640 --conf 0.25 ❌ (non usare --)
yolo solution model=yolo26n.pt imgsz=640 conf=0.25 ❌ (usa solutions, non solution)

Guida CLI

Uso di Ultralytics con Python

L'interfaccia Python YOLO di Ultralytics offre un'integrazione perfetta nei progetti Python, rendendo facile caricare, eseguire ed elaborare gli output del modello. Progettata per la semplicità, l'interfaccia Python consente agli utenti di implementare rapidamente rilevamento oggetti, segmentazione e classificazione. Ciò rende l'interfaccia Python YOLO uno strumento prezioso per incorporare queste funzionalità nei progetti Python.

Ad esempio, gli utenti possono caricare un modello, addestrarlo, valutarne le prestazioni ed esportarlo in formato ONNX con solo poche righe di codice. Esplora la Guida Python per saperne di più sull'uso di YOLO all'interno dei tuoi progetti Python.

Esempio

from ultralytics import YOLO

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

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo26n.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")

Guida Python

Impostazioni Ultralytics

La libreria Ultralytics include un SettingsManager per un controllo granulare sugli esperimenti, consentendo agli utenti di accedere e modificare facilmente le impostazioni. Memorizzate in un file JSON all'interno della directory di configurazione utente dell'ambiente, queste impostazioni possono essere visualizzate o modificate nell'ambiente Python o tramite l'interfaccia a riga di comando (CLI).

Ispezione delle impostazioni

Per visualizzare la configurazione corrente delle tue impostazioni:

Visualizza impostazioni

Usa Python per visualizzare le tue impostazioni importando l'oggetto settings dal modulo ultralytics. Stampa e restituisci le impostazioni con questi comandi:

from ultralytics import settings

# View all settings
print(settings)

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

Modifica delle impostazioni

Ultralytics semplifica la modifica delle impostazioni nei seguenti modi:

Aggiorna impostazioni

In Python, usa il metodo update sull'oggetto settings:

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()

Comprendere le impostazioni

La tabella seguente fornisce una panoramica delle impostazioni regolabili in Ultralytics, inclusi valori di esempio, tipi di dati e descrizioni.

Nome	Valore di esempio	Tipo di dati	Descrizione
`settings_version`	`'0.0.4'`	`str`	Ultralytics settings version (distinct from the Ultralytics pip version)
`datasets_dir`	`'/path/to/datasets'`	`str`	Directory in cui vengono archiviati i set di dati
`weights_dir`	`'/path/to/weights'`	`str`	Directory in cui vengono archiviati i pesi del modello
`runs_dir`	`'/path/to/runs'`	`str`	Directory in cui vengono archiviate le esecuzioni degli esperimenti
`uuid`	`'a1b2c3d4'`	`str`	Identificatore univoco per le impostazioni correnti
`sync`	`True`	`bool`	Option to sync analytics and crashes to Ultralytics Platform
`api_key`	`''`	`str`	Ultralytics Platform API Key
`clearml`	`True`	`bool`	Option to use ClearML logging
`comet`	`True`	`bool`	Option to use Comet ML for experiment tracking and visualization
`dvc`	`True`	`bool`	Option to use DVC for experiment tracking and version control
`hub`	`True`	`bool`	Option to use Ultralytics Platform integration
`mlflow`	`True`	`bool`	Option to use MLFlow for experiment tracking
`neptune`	`True`	`bool`	Option to use Neptune for experiment tracking
`raytune`	`True`	`bool`	Option to use Ray Tune for hyperparameter tuning
`tensorboard`	`True`	`bool`	Option to use TensorBoard for visualization
`wandb`	`True`	`bool`	Option to use Weights & Biases logging
`vscode_msg`	`True`	`bool`	When a VS Code terminal is detected, enables a prompt to download the Ultralytics-Snippets extension.

Rivedi queste impostazioni man mano che procedi con progetti o esperimenti per garantire una configurazione ottimale.

FAQ

Come installo Ultralytics usando pip?

Installa Ultralytics con pip usando:

pip install -U ultralytics

Questo installa l'ultima release stabile del pacchetto ultralytics da PyPI. Per installare la versione di sviluppo direttamente da GitHub:

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

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

Posso installare Ultralytics YOLO usando conda?

Sì, installa Ultralytics YOLO usando conda con:

conda install -c conda-forge ultralytics

Questo metodo è un'ottima alternativa a pip, garantendo la compatibilità con altri pacchetti. Per ambienti CUDA, installa ultralytics, pytorch e pytorch-cuda insieme per risolvere i conflitti:

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

Per ulteriori istruzioni, consulta la Conda quickstart guide.

Quali sono i vantaggi dell'utilizzo di Docker per eseguire Ultralytics YOLO?

Docker fornisce un ambiente isolato e coerente per Ultralytics YOLO, garantendo prestazioni fluide tra i sistemi ed evitando le complessità dell'installazione locale. Le immagini Docker ufficiali sono disponibili su Docker Hub, con varianti per GPU, CPU, ARM64, NVIDIA Jetson e Conda. Per scaricare ed eseguire l'ultima immagine:

# 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 --runtime=nvidia --gpus all ultralytics/ultralytics:latest

Per istruzioni dettagliate su Docker, consulta la Docker quickstart guide.

Come clono il repository Ultralytics per lo sviluppo?

Clona il repository Ultralytics e imposta un ambiente di sviluppo con:

# 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 .

Ciò consente contributi al progetto o sperimentazioni con il codice sorgente più recente. Per i dettagli, visita il Ultralytics GitHub repository.

Perché dovrei usare l'interfaccia a riga di comando (CLI) di Ultralytics YOLO?

La CLI di Ultralytics YOLO semplifica l'esecuzione di attività di rilevamento oggetti senza codice Python, consentendo comandi su riga singola per addestramento, validazione e previsione direttamente dal tuo terminale. La sintassi di base è:

yolo TASK MODE ARGS

Ad esempio, per addestrare un modello di rilevamento:

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

Esplora altri comandi ed esempi di utilizzo nella CLI Guide completa.

Contributors

GLglenn-jocher²⁹ RIRizwanMunawar⁶ PDpderrenger³ BUBurhan-Q³ LALaughing-q² ONonuralpszr² JKjk4e² FCfcakyon¹ LAlakshanthad¹ PIpicsalex¹ LEleonnil¹ MAMatthewNoyce¹

Created 12 nov 2023Updated settimana scorsa