Installer Ultralytics
Ultralytics propose différentes méthodes d'installation, notamment pip, conda et Docker. Vous pouvez installer YOLO via ultralytics
package pip pour la dernière version stable, ou en clonant le dépôt GitHub Ultralytics pour la version la plus récente. Docker est également une option pour exécuter le paquet dans un conteneur isolé, ce qui évite l'installation locale.
Regarder : Guide de démarrage rapide Ultralytics YOLO
Installer
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
Remarque
Si vous effectuez l'installation dans un environnement CUDA, il est préférable d'installer ultralytics
, pytorch
, et pytorch-cuda
dans la même commande. Cela permet au gestionnaire de paquets conda de résoudre les conflits. Alternativement, installez pytorch-cuda
dernier à remplacer le spécifique au CPU pytorch
si nécessaire.
# 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.
Consultez le fichier ultralytics
pyproject.toml pour une liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances requises.
Astuce
Les exigences de PyTorch varient selon le système d'exploitation et les exigences de CUDA. Installez donc d'abord PyTorch en suivant les instructions sur PyTorch.
Méthodes d'installation personnalisées
Bien que les méthodes d'installation standard couvrent la plupart des cas d'utilisation, vous pourriez avoir besoin d'une configuration plus personnalisée. Cela pourrait impliquer l'installation de versions spécifiques de paquets, l'omission de dépendances facultatives ou la substitution de paquets, comme le remplacement de opencv-python
avec l'interface graphique sans interface utilisateur opencv-python-headless
pour les environnements serveur.
Méthodes personnalisées
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.
-
Installer
ultralytics
core :pip install ultralytics --no-deps
-
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
Gestion des dépendances
Cette méthode offre un contrôle total, mais nécessite une gestion minutieuse des dépendances. Assurez-vous que tous les packages requis sont installés avec des versions compatibles en vous référant au ultralytics
pyproject.toml
.
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.
- Forkez le dépôt GitHub Ultralytics sur votre propre compte GitHub.
- Cloner votre fork localement :
git clone https://github.com/YOUR_USERNAME/ultralytics.git cd ultralytics
- Créer une nouvelle branche pour vos modifications :
git checkout -b custom-opencv
- Modifier
pyproject.toml
: Ouvrirpyproject.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). - Commit et push vos modifications :
git add pyproject.toml git commit -m "Switch to opencv-python-headless" git push origin custom-opencv
- 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.
- Cloner le dépôt Ultralytics :
git clone https://github.com/ultralytics/ultralytics cd ultralytics
- Modifier
pyproject.toml
: Modifiez le fichier pour apporter les modifications souhaitées. Par exemple, utilisezsed
(sur Linux/macOS) ou un éditeur de texte pour remplaceropencv-python
avecopencv-python-headless
. L'utilisation desed
(vérifiez la ligne exacte danspyproject.toml
première) :Ou modifier manuellement# 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
pyproject.toml
pour changer"opencv-python>=...
à"opencv-python-headless>=..."
. - Installer le paquet en mode modifiable (
-e
). Pip utilisera désormais votre version modifiéepyproject.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
).
- 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.txtRemarque : il n'est pas nécessaire de lister les dépendances déjà requises par votre custom# 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
ultralytics
fork (commeopencv-python-headless
) ici, car pip les installera en se basant sur le fork.pyproject.toml
. - 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.
Utiliser Ultralytics avec la CLI
L'interface de ligne de commande (CLI) Ultralytics permet d'utiliser des commandes simples sur une seule ligne sans avoir besoin d'un environnement Python. La CLI ne nécessite aucune personnalisation ni code Python ; exécutez toutes les tâches depuis le terminal avec la yolo
commande. Pour en savoir plus sur l'utilisation de YOLO à partir de la ligne de commande, consultez la Guide de la CLI.
Exemple
Ultralytics yolo
les commandes utilisent la syntaxe suivante :
yolo TASK MODE ARGS
TASK
(facultatif) est l'un de (detect, segment, classify, pose, obb)
- MODE
(obligatoire) est l'un de (train, val, predict, export, track, benchmark)
- ARGS
(facultatif) sont des paires arg=value
comme imgsz=640
qui remplacent les valeurs par défaut.
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
Avertissement
Les arguments doivent être passés par arg=value
paires, séparés par un signe égal =
signé et délimité par des espaces. Ne pas utiliser --
de préfixes d'argument ou de virgules ,
entre les arguments.
yolo predict model=yolo11n.pt imgsz=640 conf=0.25
✅yolo predict model yolo11n.pt imgsz 640 conf 0.25
❌ (manquant=
)yolo predict model=yolo11n.pt, imgsz=640, conf=0.25
❌ (ne pas utiliser,
)yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25
❌ (ne pas utiliser--
)yolo solution model=yolo11n.pt imgsz=640 conf=0.25
❌ (utilisersolutions
, passolution
)
Utiliser Ultralytics avec python
L'interface python Ultralytics YOLO offre une intégration transparente dans les projets python, facilitant le chargement, l'exécution et le traitement des sorties de modèles. Conçue pour la simplicité, l'interface python permet aux utilisateurs d'implémenter rapidement la détection d'objets, la segmentation et la classification. Cela fait de l'interface python YOLO un outil précieux pour intégrer ces fonctionnalités dans les projets python.
Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances et l'exporter au format ONNX avec seulement quelques lignes de code. Consultez le Guide Python pour en savoir plus sur l'utilisation de YOLO dans vos projets Python.
Exemple
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")
Paramètres Ultralytics
La bibliothèque Ultralytics comprend un SettingsManager
pour un contrôle précis des expériences, permettant aux utilisateurs d'accéder et de modifier facilement les paramètres. Stockés dans un fichier JSON dans le répertoire de configuration utilisateur de l'environnement, ces paramètres peuvent être consultés ou modifiés dans l'environnement python ou via l'interface de ligne de commande (CLI).
Inspection des paramètres
Pour afficher la configuration actuelle de vos paramètres :
Afficher les paramètres
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
Modification des paramètres
Ultralytics facilite la modification des paramètres des manières suivantes :
Mettre à jour les paramètres
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
Comprendre les paramètres
Le tableau ci-dessous donne un aperçu des paramètres réglables dans Ultralytics, y compris des exemples de valeurs, des types de données et des descriptions.
Nom | Exemple de valeur | Type de données | Description |
---|---|---|---|
settings_version |
'0.0.4' |
str |
Version des paramètres Ultralytics (distincte de la version pip Ultralytics) |
datasets_dir |
'/path/to/datasets' |
str |
Répertoire où les ensembles de données sont stockés |
weights_dir |
'/path/to/weights' |
str |
Répertoire où les poids du modèle sont stockés |
runs_dir |
'/path/to/runs' |
str |
Répertoire où les exécutions expérimentales sont stockées |
uuid |
'a1b2c3d4' |
str |
Identifiant unique pour les paramètres actuels |
sync |
True |
bool |
Possibilité de synchroniser les analyses et les plantages avec Ultralytics HUB |
api_key |
'' |
str |
Clé API Ultralytics HUB |
clearml |
True |
bool |
Possibilité d'utiliser la journalisation ClearML |
comet |
True |
bool |
Possibilité d'utiliser Comet ML pour le suivi et la visualisation des expériences |
dvc |
True |
bool |
Possibilité d'utiliser DVC pour le suivi des expériences et le contrôle de version |
hub |
True |
bool |
Possibilité d'utiliser l'intégration Ultralytics HUB |
mlflow |
True |
bool |
Possibilité d'utiliser MLFlow pour le suivi des expériences |
neptune |
True |
bool |
Possibilité d'utiliser Neptune pour le suivi des expériences |
raytune |
True |
bool |
Possibilité d'utiliser Ray Tune pour le réglage des hyperparamètres |
tensorboard |
True |
bool |
Possibilité d'utiliser TensorBoard pour la visualisation |
wandb |
True |
bool |
Possibilité d'utiliser la journalisation Weights & Biases |
vscode_msg |
True |
bool |
Lorsqu'un terminal VS Code est détecté, active une invite pour télécharger l'extension Ultralytics-Snippets. |
Revoyez ces paramètres au fur et à mesure de votre progression dans les projets ou les expériences afin de garantir une configuration optimale.
FAQ
Comment installer Ultralytics en utilisant pip ?
Installer Ultralytics avec pip en utilisant :
pip install ultralytics
Ceci installe la dernière version stable de ultralytics
package de PyPI. Pour installer la version de développement directement depuis GitHub :
pip install git+https://github.com/ultralytics/ultralytics.git
Assurez-vous que l'outil de ligne de commande Git est installé sur votre système.
Puis-je installer Ultralytics YOLO en utilisant conda ?
Oui, installez Ultralytics YOLO en utilisant conda avec :
conda install -c conda-forge ultralytics
Cette méthode est une excellente alternative à pip, assurant la compatibilité avec d'autres paquets. Pour les environnements CUDA, installez ultralytics
, pytorch
, et pytorch-cuda
ensemble pour résoudre les conflits :
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
Pour plus d'instructions, consultez le guide de démarrage rapide de Conda.
Quels sont les avantages de l'utilisation de Docker pour exécuter Ultralytics YOLO ?
Docker fournit un environnement isolé et cohérent pour Ultralytics YOLO, garantissant des performances fluides sur tous les systèmes et évitant les complexités d'installation locales. Les images Docker officielles sont disponibles sur Docker Hub, avec des variantes pour GPU, CPU, ARM64, NVIDIA Jetson et Conda. Pour extraire et exécuter la dernière image :
# 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
Pour des instructions Docker détaillées, consultez le guide de démarrage rapide Docker.
Comment cloner le dépôt Ultralytics pour le développement ?
Clonez le dépôt Ultralytics et configurez un environnement de développement avec :
# 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 .
Cela permet de contribuer au projet ou d'expérimenter avec le code source le plus récent. Pour plus de détails, consultez le dépôt GitHub Ultralytics.
Pourquoi devrais-je utiliser Ultralytics YOLO CLI ?
L'interface en ligne de commande (CLI) Ultralytics YOLO simplifie l'exécution des tâches de détection d'objets sans code python, permettant des commandes en une seule ligne pour l'entraînement, la validation et la prédiction directement depuis votre terminal. La syntaxe de base est la suivante :
yolo TASK MODE ARGS
Par exemple, pour entraîner un modèle de détection :
yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
Explorez d'autres commandes et exemples d'utilisation dans le Guide CLI complet.