Installare Ultralytics

Installare o aggiornare il programma ultralytics utilizzando pip, eseguendo pip install -U ultralytics. Per maggiori dettagli sul ultralytics visitare il sito Indice dei pacchetti Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

È inoltre possibile installare ultralytics direttamente dal Ultralytics Repository GitHub. Questo può essere utile se si desidera l'ultima versione di sviluppo. Assicurarsi di avere installato lo strumento a riga di comando Git ed eseguirlo:

# 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, visitate Anaconda. Il repository 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 di Conda

Ultralytics Le immagini Docker di Conda sono disponibili anche da DockerHub. Queste immagini sono basate su Miniconda3 e fornire un modo semplice per iniziare ad 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 Repository GitHub se siete interessati a contribuire allo sviluppo o desiderate 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 .

Utilizzare Docker per eseguire il file ultralytics in un contenitore isolato, assicurando prestazioni coerenti in vari ambienti. Selezionando uno dei pacchetti ufficiali ultralytics immagini da Hub DockerSi 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 garantire un'elevata compatibilità ed efficienza:

• Dockerfile: immagine GPU consigliata per la formazione.
• Dockerfile-arm64: Ottimizzato per l'architettura ARM64, adatto per la distribuzione su dispositivi come Raspberry Pi e altre piattaforme basate su ARM64.
• cpu: versione CPU basata su Ubuntu, adatta all'inferenza e agli ambienti senza GPU.
• Dockerfile-jetson: Personalizzato per i dispositivi NVIDIA Jetson, integra il supporto 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 un'installazione di conda ultralytics pacchetto.

Ecco 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 stdin, consentendo l'interazione con il contenitore. I 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 consente l'accesso a tutte le GPU disponibili all'interno del contenitore, fondamentale per le attività che richiedono il calcolo 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

Sostituire /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 un utilizzo avanzato di Docker, esplorare la Guida DockerUltralytics .

È possibile installare il programma ultralytics senza alcuna dipendenza, utilizzando il pacchetto pip --no-deps flag. Ciò richiede l'installazione manuale di tutte le dipendenze necessarie.

1. Installare ultralytics nucleo:

   pip install ultralytics --no-deps
   

2. Installare manualmente le dipendenze: È necessario installare tutti i pacchetti necessari elencati nel file pyproject.toml sostituendo o modificando le versioni secondo necessità. Per l'esempio di OpenCV senza testa:

   # Install other core dependencies
   pip install torch torchvision numpy matplotlib pandas pyyaml pillow psutil requests tqdm scipy seaborn ultralytics-thop
   
   # Install headless OpenCV instead of the default
   pip install opencv-python-headless
   

Se si ha bisogno di modifiche personalizzate persistenti (come usare sempre il metodo opencv-python-headless), è possibile creare un fork del repository Ultralytics , apportare modifiche a pyproject.toml o altro codice, e installare dal proprio fork.

1. Fare il fork del repository GitHub di Ultralytics sul proprio account GitHub.
2. Clone la vostra forchetta in loco:

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

3. Creare un nuovo ramo per le modifiche apportate:

   git checkout -b custom-opencv
   

4. Modificare pyproject.toml: Aperto pyproject.toml in un editor di testo e sostituire la riga contenente "opencv-python>=4.6.0" con "opencv-python-headless>=4.6.0" (modificare la versione in base alle esigenze).
5. Impegnarsi e spingere le vostre modifiche:

   git add pyproject.toml
   git commit -m "Switch to opencv-python-headless"
   git push origin custom-opencv
   

6. Installare utilizzando pip con l'opzione git+https che punta al vostro ramo:

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

Questo metodo assicura che il set di dipendenze personalizzato venga usato ogni volta che si installa da questo URL specifico. Vedere il metodo 4 per l'utilizzo di questo metodo in un file requirements.txt file.

Analogamente al metodo standard "Git Clone" per lo sviluppo, è possibile clonare il repository localmente, modificare i file di dipendenza prima dell' installazione e quindi installare in modalità modificabile.

1. Clone il repository Ultralytics :

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

2. Modificare pyproject.toml: Modificare il file per apportare le modifiche desiderate. Ad esempio, utilizzare sed (su Linux/macOS) o un editor di testo per sostituire opencv-python con opencv-python-headless. Utilizzo sed (verificare la riga esatta in pyproject.toml prima):

   # Example: Replace the line starting with "opencv-python..."
   # Adapt the pattern carefully based on the current file content
   sed -i'' -e 's/^\s*"opencv-python>=.*",/"opencv-python-headless>=4.8.0",/' pyproject.toml
   

   Oppure modificare manualmente pyproject.toml per cambiare "opencv-python>=... a "opencv-python-headless>=...".
3. Installare il pacchetto in modalità modificabile (-e). Pip utilizzerà ora il vostro file modificato pyproject.toml per risolvere e installare le dipendenze:

   pip install -e .
   

Questo approccio è utile per testare le modifiche locali alle dipendenze o alle configurazioni di build prima di eseguire il commit o per impostare ambienti di sviluppo specifici.

Se si gestiscono le dipendenze del progetto utilizzando un file requirements.txt è possibile specificare il proprio fork personalizzato di Ultralytics direttamente al suo interno. Questo assicura che chiunque configuri il progetto riceva la vostra versione specifica con le sue dipendenze modificate (come ad esempio opencv-python-headless).

1. Creare o modificare requirements.txt: Aggiungete una riga che punta al vostro fork e ramo personalizzato (come preparato nel Metodo 2).
   requisiti.txt

   # Core dependencies
   numpy
   matplotlib
   pandas
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   tqdm
   torch>=1.8.0 # Or specific version/variant
   torchvision>=0.9.0 # Or specific version/variant
   
   # Install ultralytics from a specific git commit or branch
   # Replace YOUR_USERNAME and custom-branch with your details
   git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-branch
   
   # Other project dependencies
   flask
   # ... etc
   

   Nota: non è necessario elencare le dipendenze già richieste dalla propria applicazione personalizzata. ultralytics forcella (come opencv-python-headless) qui, in quanto pip li installerà in base alla versione del fork pyproject.toml.
2. Installare dipendenze dal file:

   pip install -r requirements.txt
   

Questo metodo si integra perfettamente con i flussi di lavoro standard di gestione delle dipendenze di un progetto Python , consentendo di appuntare ultralytics alla vostra fonte Git personalizzata.

Ultralytics yolo I comandi utilizzano la seguente sintassi:

yolo TASK MODE ARGS

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

Addestrare un modello di rilevamento per 10 epoche con una velocità 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

Convalidare un modello di rilevamento preaddestrato con una dimensione del lotto di 1 e una dimensione dell'immagine di 640:

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

Esportare un modello di classificazione YOLOv11n in formato ONNX con un'immagine di dimensioni 224x128 (non è richiesto alcun TASK):

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

Contate gli oggetti in un video o in un flusso live con 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

Utilizzare YOLO11 per contare gli oggetti in una coda o in una 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

Eseguire 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

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
yolo solutions help

Utilizzate Python per visualizzare le impostazioni importando il file settings dall'oggetto ultralytics modulo. Stampare e restituire 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, utilizzare l'opzione update sul metodo settings oggetto:

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 utilizzando 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