Passer au contenu

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

PyPI - Version Python

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

PyPI - Version Téléchargements

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

Version Conda Téléchargements Conda Recette Conda Plateformes Conda

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

Dernier commit GitHub Activité des commits GitHub

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

Version de l'image Docker Pull Docker

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

Instructions d'installation de 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.

  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
    

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.

  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.

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 ❌ (utiliser solutions, pas solution)

Guide de la CLI

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

Guide Python

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.



📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 jours

Commentaires