Installa Ultralytics

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

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

È anche possibile installare ultralytics direttamente dalla repository GitHub di Ultralytics. Questo può essere utile se desideri l'ultima versione di sviluppo. Assicurati di avere lo strumento da riga di comando Git installato, quindi esegui:

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

Conda può essere utilizzato come gestore di pacchetti alternativo a pip. Per maggiori dettagli, visita Anaconda. Il repository di feedstock di Ultralytics per l'aggiornamento del pacchetto conda è disponibile su GitHub.

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

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

Immagine Docker Conda

Le immagini Docker di Ultralytics Conda sono disponibili anche su Docker Hub. Queste immagini sono basate su Miniconda3 e forniscono un modo semplice per iniziare a utilizzare 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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --gpus '"device=2,3"' $t # specify GPUs

Clona il repository repository GitHub di Ultralytics se sei interessato a contribuire allo sviluppo o desideri sperimentare con il codice sorgente più recente. Dopo aver clonato, accedi alla 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 il ultralytics package in un container isolato, garantendo prestazioni coerenti in vari ambienti. Selezionando uno degli ufficiali ultralytics da Docker Hub, si evita la complessità dell'installazione locale e si ottiene l'accesso a un ambiente di lavoro verificato. Ultralytics offre cinque immagini Docker principali supportate, ciascuna progettata per un'elevata compatibilità ed efficienza:

• Dockerfile: Immagine GPU consigliata per l'addestramento.
• Dockerfile-arm64: Ottimizzato per l'architettura ARM64, adatto per la distribuzione su dispositivi come Raspberry Pi e altre piattaforme basate su ARM64.
• Dockerfile-cpu: Versione basata su Ubuntu solo CPU, adatta per l'inferenza e ambienti senza GPU.
• Dockerfile-jetson: Realizzato su misura per i dispositivi NVIDIA Jetson, integrando il supporto GPU ottimizzato per queste piattaforme.
• Dockerfile-python: Immagine minima con solo python e le dipendenze necessarie, ideale per applicazioni leggere e sviluppo.
• Dockerfile-conda: Basato su Miniconda3 con un'installazione conda di ultralytics package.

Ecco i comandi per ottenere l'immagine più recente 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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --gpus '"device=2,3"' $t # specify GPUs

Il comando sopra riportato inizializza un container Docker con l'ultima ultralytics immagine. Il flag -it flags assegnano uno pseudo-TTY e mantengono aperto stdin, consentendo l'interazione con il container. Il --ipc=host imposta il namespace IPC (Inter-Process Communication) sull'host, essenziale per la condivisione della memoria tra i processi. Il flag --gpus all flag abilita l'accesso a tutte le GPU disponibili all'interno del container, fondamentale per le attività che richiedono calcolo tramite GPU.

Nota: Per lavorare con i file sulla tua macchina locale all'interno del container, usa i volumi Docker per montare una directory locale nel container:

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

Sostituisci /path/on/host con il percorso della directory sulla macchina locale e /path/in/container con il percorso desiderato all'interno del container Docker.

Per un utilizzo avanzato di Docker, esplora la Guida a Docker di Ultralytics.

Se hai bisogno di modifiche personalizzate permanenti, puoi eseguire il fork del Ultralytics , apportare modifiche a pyproject.toml o altro codice, e installa dal tuo fork.

1. Fork del repository GitHub di Ultralytics sul tuo account GitHub.
2. Clona il tuo fork localmente:

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

3. Crea un nuovo ramo per le tue modifiche:

   git checkout -b my-custom-branch
   

4. Apporta le tue modifiche a pyproject.toml o altri file, se necessario.
5. Commit e push le tue modifiche:

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

6. Installa utilizzando pip con il git+https sintassi, che punta al tuo branch:

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

Clona il repository localmente, modifica i file secondo necessità e installa in modalità modificabile.

1. Clona il repository Ultralytics:

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

2. Apporta le tue modifiche a pyproject.toml o altri file, se necessario.
3. Installa il pacchetto in modalità modificabile (-e). Pip utilizzerà il tuo modificato pyproject.toml per risolvere le dipendenze:

   pip install -e .
   

Questo approccio è utile per lo sviluppo o il test di modifiche locali prima del commit.

Specificare un Ultralytics personalizzato nel proprio requirements.txt file per garantire installazioni coerenti all'interno del tuo team.

# Install ultralytics from a specific git branch
git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

# Other project dependencies
flask

Installa le dipendenze dal file:

pip install -r requirements.txt

Ultralytics yolo i comandi utilizzano la seguente sintassi:

yolo TASK MODE ARGS

Vedi tutti i ARGS nel completo Guida alla Configurazione o con il comando yolo cfg CLI.

Addestra 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

Esegui una prediction su un video di YouTube utilizzando un modello di segmentazione pre-addestrato con una dimensione dell'immagine di 320:

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

Convalida di un modello di rilevamento pre-addestrato con una dimensione del batch di 1 e una dimensione dell'immagine di 640:

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

Esporta un modello di classificazione YOLO11n in formato ONNX con una dimensione dell'immagine di 224x128 (nessuna TASK richiesta):

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

Conta gli oggetti in un video o in uno streaming live utilizzando YOLO11:

yolo solutions count show=True

yolo solutions count source="path/to/video.mp4" # specify video file path

Monitorare gli esercizi di allenamento utilizzando un modello di posa YOLO11:

yolo solutions workout show=True

yolo solutions workout source="path/to/video.mp4" # specify video file path

# Use keypoints for ab-workouts
yolo solutions workout kpts="[5, 11, 13]" # left side
yolo solutions workout kpts="[6, 12, 14]" # right side

Utilizza YOLO11 per contare gli oggetti in una coda o regione designata:

yolo solutions queue show=True

yolo solutions queue source="path/to/video.mp4" # specify video file path

yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure queue coordinates

Esegui il rilevamento di oggetti, la segmentazione di istanze o la stima della posa in un browser web utilizzando Streamlit:

yolo solutions inference

yolo solutions inference model="path/to/model.pt" # use model fine-tuned with Ultralytics Python package

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

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

Utilizza python per visualizzare le tue impostazioni importando il settings oggetto dal ultralytics modulo. 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"]

L'interfaccia a riga di comando consente di verificare le impostazioni con:

yolo settings

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

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

Per modificare le impostazioni usando l'interfaccia a riga di comando:

# 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