Aller au contenu

Démarrage rapide

Installer Ultralytics

Ultralytics propose diverses méthodes d'installation, y compris pip, conda et Docker. Installez YOLOv8 via le package ultralytics avec pip pour obtenir la dernière version stable ou en clonant le répertoire GitHub d'Ultralytics pour la version la plus récente. Docker peut être utilisé pour exécuter le package dans un conteneur isolé, évitant l'installation locale.

Installer

Installez le package ultralytics en utilisant pip, ou mettez à jour une installation existante en exécutant pip install -U ultralytics. Visitez l'Index des Packages Python (PyPI) pour plus de détails sur le package ultralytics : https://pypi.org/project/ultralytics/.

Version PyPI Téléchargements

# Installer le package ultralytics depuis PyPI
pip install ultralytics

Vous pouvez également installer le package ultralytics directement depuis le répertoire GitHub. Cela peut être utile si vous voulez la version de développement la plus récente. Assurez-vous d'avoir l'outil en ligne de commande Git installé sur votre système. La commande @main installe la branche main et peut être modifiée pour une autre branche, p. ex. @my-branch, ou supprimée entièrement pour revenir par défaut à la branche main.

# Installer le package ultralytics depuis GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main

Conda est un gestionnaire de packages alternatif à pip qui peut également être utilisé pour l'installation. Visitez Anaconda pour plus de détails à https://anaconda.org/conda-forge/ultralytics. Le répertoire feedstock d'Ultralytics pour la mise à jour du package conda est sur https://github.com/conda-forge/ultralytics-feedstock/.

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

# Installer le package ultralytics en utilisant conda
conda install -c conda-forge ultralytics

Note

Si vous installez dans un environnement CUDA, la meilleure pratique est d'installer ultralytics, pytorch et pytorch-cuda dans la même commande pour permettre au gestionnaire de package conda de résoudre les conflits, ou bien d'installer pytorch-cuda en dernier pour lui permettre de remplacer le package pytorch spécifique aux CPU si nécessaire.

# Installer tous les packages ensemble en utilisant 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 constituent un moyen simple de commencer à utiliser ultralytics dans un environnement Conda.

# Définir le nom de l'image comme variable
t=ultralytics/ultralytics:latest-conda

# Télécharger la dernière image ultralytics de Docker Hub
sudo docker pull $t

# Exécuter l'image ultralytics dans un conteneur avec support GPU
sudo docker run -it --ipc=host --gpus all $t  # tous les GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # spécifier les GPUs

Clonez le répertoire ultralytics si vous êtes intéressé par la contribution au développement ou si vous souhaitez expérimenter avec le dernier code source. Après le clonage, naviguez dans le répertoire et installez le package en mode éditable -e en utilisant pip.

# Cloner le répertoire ultralytics
git clone https://github.com/ultralytics/ultralytics

# Naviguer vers le répertoire cloné
cd ultralytics

# Installer le package en mode éditable pour le développement
pip install -e .

Voir le fichier requirements.txt d'ultralytics pour une liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances requises.



Watch: Ultralytics YOLO Quick Start Guide

Conseil

Les prérequis de PyTorch varient selon le système d'exploitation et les exigences CUDA, donc il est recommandé d'installer PyTorch en premier en suivant les instructions sur https://pytorch.org/get-started/locally.

Instructions d'installation de PyTorch

Utiliser Ultralytics avec CLI

L'interface en ligne de commande (CLI) d'Ultralytics permet l'utilisation de commandes simples en une seule ligne sans nécessiter d'environnement Python. La CLI ne requiert pas de personnalisation ou de code Python. Vous pouvez simplement exécuter toutes les tâches depuis le terminal avec la commande yolo. Consultez le Guide CLI pour en savoir plus sur l'utilisation de YOLOv8 depuis la ligne de commande.

Exemple

Les commandes yolo d'Ultralytics utilisent la syntaxe suivante :

yolo TÂCHE MODE ARGS

   TÂCHE (facultatif) est l'une de [detect, segment, classify]
     MODE (obligatoire) est l'un de [train, val, predict, export, track]
     ARGS (facultatif) sont n'importe quel nombre de paires personnalisées 'arg=valeur' comme 'imgsz=320' qui remplacent les valeurs par défaut.
Voyez tous les ARGS dans le Guide de Configuration complet ou avec yolo cfg

Entraînez un modèle de détection pour 10 epochs avec un learning_rate initial de 0.01

yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01

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

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

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

yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640

Exportez un modèle de classification YOLOv8n au format ONNX à une taille d'image de 224 par 128 (pas de TÂCHE requise)

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

Exécutez des commandes spéciales pour voir la version, afficher les paramètres, effectuer des vérifications et plus encore :

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

Avertissement

Les arguments doivent être passés sous forme de paires arg=val, séparés par un signe égal = et délimités par des espaces entre les paires. N'utilisez pas de préfixes d'arguments -- ou de virgules , entre les arguments.

  • yolo predict model=yolov8n.pt imgsz=640 conf=0.25   ✅
  • yolo predict model yolov8n.pt imgsz 640 conf 0.25   ❌
  • yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25   ❌

Guide CLI

Utiliser Ultralytics avec Python

L'interface Python de YOLOv8 permet une intégration transparente dans vos projets Python, facilitant le chargement, l'exécution et le traitement de la sortie du modèle. Conçue avec simplicité et facilité d'utilisation à l'esprit, l'interface Python permet aux utilisateurs de mettre en œuvre rapidement la détection d'objets, la segmentation et la classification dans leurs projets. Cela fait de l'interface Python de YOLOv8 un outil inestimable pour quiconque cherche à intégrer ces fonctionnalités dans ses projets Python.

Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un set de validation, et même l'exporter au format ONNX avec seulement quelques lignes de code. Consultez le Guide Python pour en savoir plus sur l'utilisation de YOLOv8 au sein de vos projets Python.

Exemple

from ultralytics import YOLO

# Créer un nouveau modèle YOLO à partir de zéro
model = YOLO('yolov8n.yaml')

# Charger un modèle YOLO pré-entraîné (recommandé pour l'entraînement)
model = YOLO('yolov8n.pt')

# Entraîner le modèle en utilisant le jeu de données 'coco128.yaml' pour 3 epochs
résultats = model.train(data='coco128.yaml', epochs=3)

# Évaluer la performance du modèle sur le set de validation
résultats = model.val()

# Effectuer la détection d'objets sur une image en utilisant le modèle
résultats = model('https://ultralytics.com/images/bus.jpg')

# Exporter le modèle au format ONNX
succès = model.export(format='onnx')

Guide Python


Created 2023-11-13, Updated 2023-11-25
Authors: glenn-jocher (5), chr043416@gmail.com (1)

Commentaires