Installer Ultralytics

Installer ou mettre à jour le ultralytics package en utilisant pip en exécutant pip install -U ultralytics. Pour plus de détails sur le ultralytics package, consultez le Index des packages Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

Vous pouvez également installer ultralytics directement à partir du dépôt GitHub Ultralytics. Cela peut être utile si vous souhaitez la dernière version de développement. Assurez-vous d'avoir installé l'outil de ligne de commande Git, puis exécutez :

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

Conda peut être utilisé comme alternative à pip pour la gestion des paquets. Pour plus de détails, consultez Anaconda. Le référentiel Ultralytics pour la mise à jour du paquet conda est disponible sur 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

Image Docker Conda

Les images Docker Conda d'Ultralytics sont également disponibles sur DockerHub. Ces images sont basées sur Miniconda3 et fournissent un moyen simple de commencer à utiliser ultralytics dans un environnement 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

Clonez le dépôt GitHub Ultralytics si vous souhaitez contribuer au développement ou expérimenter avec le code source le plus récent. Après le clonage, naviguez dans le répertoire et installez le paquet en mode editable -e en utilisant 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 .

Utilisez Docker pour exécuter le ultralytics package dans un conteneur isolé, garantissant des performances constantes dans divers environnements. En sélectionnant l'un des ultralytics d'Ultralytics depuis Docker Hub, vous évitez la complexité de l'installation locale et vous accédez à un environnement de travail vérifié. Ultralytics propose cinq images Docker principales prises en charge, chacune étant conçue pour une compatibilité et une efficacité élevées :

• Dockerfile : Image GPU recommandée pour l'entraînement.
• Dockerfile-arm64 : Optimisé pour l'architecture ARM64, adapté au déploiement sur des appareils tels que Raspberry Pi et d'autres plateformes basées sur ARM64.
• Dockerfile-cpu : Version Ubuntu basée sur le CPU uniquement, adaptée à l'inférence et aux environnements sans GPU.
• Dockerfile-jetson : Conçu sur mesure pour les appareils NVIDIA Jetson, intégrant un support GPU optimisé pour ces plateformes.
• Dockerfile-python : Image minimale avec uniquement python et les dépendances nécessaires, idéale pour les applications légères et le développement.
• Dockerfile-conda : Basé sur Miniconda3 avec une installation conda de ultralytics package.

Voici les commandes pour obtenir l'image la plus récente et l'exécuter :

# 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

La commande ci-dessus initialise un conteneur Docker avec la dernière ultralytics image. L'option -it Les drapeaux assignent un pseudo-TTY et maintiennent stdin ouvert, permettant l'interaction avec le conteneur. Le --ipc=host définit l'espace de noms IPC (Inter-Process Communication) sur l'hôte, ce qui est essentiel pour le partage de mémoire entre les processus. L'option --gpus all flag permet d'accéder à tous les GPU disponibles dans le conteneur, ce qui est essentiel pour les tâches nécessitant un calcul GPU.

Remarque : pour travailler avec des fichiers sur votre machine locale dans le conteneur, utilisez des volumes Docker pour monter un répertoire local dans le conteneur :

# 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

Remplacez /path/on/host par le chemin d'accès au répertoire sur votre machine locale, et /path/in/container par le chemin d'accès souhaité à l'intérieur du conteneur Docker.

Pour une utilisation avancée de Docker, explorez le Guide Docker Ultralytics.

Vous pouvez installer le ultralytics package core sans aucune dépendance en utilisant --no-deps l'indicateur. Cela vous oblige à installer manuellement toutes les dépendances nécessaires par la suite.

1. Installer ultralytics core :

   pip install ultralytics --no-deps
   

2. Installer manuellement les dépendances : Vous devez installer tous les packages requis listés dans le pyproject.toml fichier, en remplaçant ou en modifiant les versions si nécessaire. Pour l'exemple OpenCV sans interface graphique :

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

Si vous avez besoin de modifications personnalisées persistantes (comme l'utilisation systématique de opencv-python-headless), vous pouvez forker le dépôt Ultralytics, apporter des modifications à pyproject.toml ou autre code, et effectuez l'installation à partir de votre fork.

1. Forkez le dépôt GitHub Ultralytics sur votre propre compte GitHub.
2. Cloner votre fork localement :

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

3. Créer une nouvelle branche pour vos modifications :

   git checkout -b custom-opencv
   

4. Modifier pyproject.toml: Ouvrir pyproject.toml dans un éditeur de texte et remplacez la ligne contenant "opencv-python>=4.6.0" avec "opencv-python-headless>=4.6.0" (ajuster la version si nécessaire).
5. Commit et push vos modifications :

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

6. Installer utilisation de pip avec git+https syntaxe, pointant vers votre branche :

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

Cette méthode garantit que votre ensemble de dépendances personnalisé est utilisé chaque fois que vous installez à partir de cette URL spécifique. Voir la méthode 4 pour l'utiliser dans un requirements.txt .

Similaire à la méthode standard "Git Clone" pour le développement, vous pouvez cloner le référentiel localement, modifier les fichiers de dépendance avant l'installation, puis installer en mode modifiable.

1. Cloner le dépôt Ultralytics :

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

2. Modifier pyproject.toml: Modifiez le fichier pour apporter les modifications souhaitées. Par exemple, utilisez sed (sur Linux/macOS) ou un éditeur de texte pour remplacer opencv-python avec opencv-python-headless. L'utilisation de sed (vérifiez la ligne exacte dans pyproject.toml première) :

   # 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
   

   Ou modifier manuellement pyproject.toml pour changer "opencv-python>=... à "opencv-python-headless>=...".
3. Installer le paquet en mode modifiable (-e). Pip utilisera désormais votre version modifiée pyproject.toml pour résoudre et installer les dépendances :

   pip install -e .
   

Cette approche est utile pour tester les modifications locales apportées aux dépendances ou aux configurations de build avant de les valider, ou pour configurer des environnements de développement spécifiques.

Si vous gérez les dépendances de votre projet à l'aide d'un requirements.txt fichier, vous pouvez spécifier votre fork Ultralytics personnalisé directement à l'intérieur. Cela garantit que toute personne configurant le projet obtient votre version spécifique avec ses dépendances modifiées (comme opencv-python-headless).

1. Créer ou modifier requirements.txt: Ajoutez une ligne pointant vers votre fork et branche personnalisés (tel que préparé dans la méthode 2).
   requirements.txt

   # Core dependencies
   numpy
   matplotlib
   polars
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   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
   

   Remarque : il n'est pas nécessaire de lister les dépendances déjà requises par votre custom ultralytics fork (comme opencv-python-headless) ici, car pip les installera en se basant sur le fork. pyproject.toml.
2. Installer dépendances du fichier :

   pip install -r requirements.txt
   

Cette méthode s'intègre parfaitement aux flux de travail standard de gestion des dépendances des projets Python tout en vous permettant d'épingler ultralytics à votre source Git personnalisée.

Ultralytics yolo les commandes utilisent la syntaxe suivante :

yolo TASK MODE ARGS

Voir tout ARGS dans l'ensemble du Guide de configuration ou avec la yolo cfg commande CLI.

Entraîner un modèle de détection pendant 10 epochs avec un taux d'apprentissage initial de 0,01 :

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

Prédire une vidéo YouTube en utilisant un modèle de segmentation pré-entraîné à une taille d'image de 320 :

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

Valider un modèle de détection pré-entraîné avec une taille de lot de 1 et une taille d'image de 640:

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

Exporter un modèle de classification YOLOv11n au format ONNX avec une taille d'image de 224x128 (aucune TÂCHE requise) :

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

Compter les objets dans une vidéo ou un flux en direct en utilisant YOLO11 :

yolo solutions count show=True

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

Surveiller les exercices d'entraînement à l'aide d'un modèle de pose 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

Utilisez YOLO11 pour compter les objets dans une file d'attente ou une région désignée :

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

Effectuer la détection d'objets, la segmentation d'instances ou l'estimation de pose dans un navigateur web en utilisant Streamlit :

yolo solutions inference

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

Exécutez des commandes spéciales pour afficher la version, consulter les paramètres, exécuter des vérifications, et bien plus :

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

Utilisez Python pour afficher vos paramètres en important le settings objet à partir du ultralytics module. Affichez et renvoyez les paramètres avec ces commandes :

from ultralytics import settings

# View all settings
print(settings)

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

L'interface de ligne de commande vous permet de vérifier vos paramètres avec :

yolo settings

Dans python, utilisez le update méthode sur le settings objet :

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

Pour modifier les paramètres à l'aide de l'interface de ligne de commande :

# 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