Installer Ultralytics

Q: How do I install Ultralytics using pip?

Installez Ultralytics avec pip en utilisant : Ceci installe la dernière version stable du paquetage ultralytics depuis PyPI. Pour installer la version de développement directement depuis GitHub : Assurez-vous que l'outil de ligne de commande Git est installé sur votre système.

Ultralytics offre une variété de méthodes d'installation, y compris pip, conda, et Docker. Vous pouvez installer YOLO via la méthode ultralytics pip pour la dernière version stable, ou en clonant le paquetage Ultralytics Dépôt GitHub pour obtenir la version la plus récente. Docker est également une option pour exécuter le paquet dans un conteneur isolé, ce qui évite une installation locale.

Regarder : Ultralytics YOLO Guide de démarrage rapide

Installer

Installation de Pip (recommandée)Installation de CondaClone GitDocker

Installer ou mettre à jour le ultralytics à l'aide de pip en exécutant pip install -U ultralytics. Pour plus de détails sur les ultralytics visitez le site Index des paquets Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

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

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

Conda peut être utilisé comme gestionnaire de paquets alternatif à pip. Pour plus de détails, visitez Anaconda. Le dépôt Ultralytics feedstock pour la mise à jour du paquet conda est disponible sur GitHub.

# Install the ultralytics package using conda
conda install -c conda-forge ultralytics

Note

Si vous l'installez dans un environnement CUDA , il est préférable d'installer les éléments suivants ultralytics, pytorchet pytorch-cuda dans la même commande. Cela permet au gestionnaire de paquets conda de résoudre les conflits éventuels. Alternativement, installez pytorch-cuda pour remplacer la 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

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

Cloner le Ultralytics Dépôt GitHub si vous souhaitez contribuer au développement ou expérimenter le dernier code source. Après le clonage, naviguez dans le répertoire et installez le paquetage en mode éditable -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 fichier ultralytics dans un conteneur isolé, ce qui garantit des performances constantes dans divers environnements. En sélectionnant l'une des versions officielles de ultralytics images de Hub DockerAvec Ultralytics, vous évitez la complexité d'une installation locale et vous avez accès à un environnement de travail vérifié. Ultralytics propose cinq images Docker principales prises en charge, chacune conçue pour une compatibilité et une efficacité élevées :

Dockerfile : GPU image recommandée pour la formation.
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.
cpu: version CPU basée sur Ubuntu, adaptée à l'inférence et aux environnements sans GPU.
Dockerfile-jetson : Adapté aux appareils NVIDIA Jetson, intégrant le support GPU optimisé pour ces plateformes.
Dockerfile-python: Image minimale avec seulement 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 l'application ultralytics l'emballage.

Voici les commandes pour obtenir la dernière image 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 version du logiciel ultralytics l'image. L'image -it attribuent un pseudo-TTY et gardent stdin ouvert, permettant l'interaction avec le conteneur. Les drapeaux --ipc=host définit l'espace de noms IPC (Inter-Process Communication) pour l'hôte, ce qui est essentiel pour le partage de la mémoire entre les processus. L'indicateur --gpus all permet d'accéder à tous les GPU disponibles dans le conteneur, ce qui est crucial pour les tâches nécessitant des calculs sur GPU .

Note : Pour travailler avec des fichiers sur votre machine locale dans le conteneur, utilisez les 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

Remplacer /path/on/host avec le chemin d'accès au répertoire sur votre machine locale, et /path/in/container avec le chemin d'accès souhaité dans le conteneur Docker.

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

Voir le ultralytics pyproject.toml pour obtenir la liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances nécessaires.

Conseil

PyTorch varient en fonction du système d'exploitation et des exigences CUDA . Installez donc PyTorch en premier lieu en suivant les instructions à l'adresse suivante PyTorch.

Utiliser Ultralytics avec CLI

L'interface de ligne de commandeCLI d'Ultralytics permet d'effectuer des commandes simples sur une seule ligne sans avoir besoin d'un environnement Python . L'interface CLI commande ne nécessite aucune personnalisation ou code Python ; exécutez toutes les tâches à partir du terminal avec l'option yolo (ligne de commande). Pour plus d'informations sur l'utilisation de YOLO à partir de la ligne de commande, voir la section CLI Guide.

Exemple

SyntaxeTrainPrévoirValExportationCompterEntraînementFile d'attenteInférence avec StreamlitSpécial

Ultralytics yolo utilisent la syntaxe suivante :

yolo TASK MODE ARGS

- TASK (facultatif) est l'un des éléments suivants (détecter, segment, classer, poser, obb) - MODE (obligatoire) est l'un des éléments suivants (train, valeur, prévoir, l'exportation, piste, repère) - ARGS (facultatif) sont arg=value paires comme imgsz=640 qui remplacent les valeurs par défaut.

Voir tous ARGS dans l'ensemble Guide de configuration ou avec le yolo cfg CLI commandement.

Entraînez un modèle de détection pendant 10 époques 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 à l'aide d'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 (pas de TASK nécessaire) :

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

Comptez les objets dans une vidéo ou un flux en direct à l'aide de YOLO11:

yolo solutions count show=True

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

Contrôlez 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

Effectuez la détection d'objets, la segmentation d'instances ou l'estimation de la pose dans un navigateur Web à l'aide de 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 voir la version, afficher les paramètres, effectuer des vérifications, etc :

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

Avertissement

Les arguments doivent être transmis en tant que arg=value séparées par une équation = et délimité par des espaces. Ne pas utiliser -- préfixes ou virgules des arguments , 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)

CLI Guide

Utiliser Ultralytics avec Python

L'interface Ultralytics YOLO Python offre une intégration transparente dans les projets Python , ce qui facilite le chargement, l'exécution et le traitement des résultats du modèle. Conçue pour être simple, l'interface Python permet aux utilisateurs de mettre en œuvre rapidement la détection, la segmentation et la classification des objets. L'interface YOLO Python est donc un outil précieux pour incorporer 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 en quelques lignes de code seulement. Consultez le guidePython 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")

Python Guide

Ultralytics Paramètres

La bibliothèque Ultralytics comprend un module SettingsManager pour un contrôle fin des expériences, permettant aux utilisateurs d'accéder aux paramètres et de les modifier facilement. Stockés dans un fichier JSON dans le répertoire de configuration utilisateur de l'environnement, ces paramètres peuvent être visualisés ou modifiés dans l'environnement Python ou via l'interface en ligne de commandeCLI.

Inspection des paramètres

Pour afficher la configuration actuelle de vos paramètres :

Afficher les paramètres

PythonCLI

Utilisez Python pour visualiser vos paramètres en important le fichier settings de l'objet ultralytics module. Ces commandes permettent d'imprimer et de renvoyer les paramètres :

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 de la manière suivante :

Mise à jour des paramètres

PythonCLI

En Python, utilisez la fonction update sur la méthode 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 présente les paramètres ajustables 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 desparamètres d' Ultralytics (distincte de la version destuyaux d' Ultralytics )
`datasets_dir`	`'/path/to/datasets'`	`str`	Répertoire où sont stockés les ensembles de données
`weights_dir`	`'/path/to/weights'`	`str`	Répertoire où sont stockés les poids des modèles
`runs_dir`	`'/path/to/runs'`	`str`	Répertoire où sont stockées les expériences
`uuid`	`'a1b2c3d4'`	`str`	Identifiant unique pour les paramètres actuels
`sync`	`True`	`bool`	Option de synchronisation des analyses et des crashs avec Ultralytics HUB
`api_key`	`''`	`str`	Clé API Ultralytics HUB
`clearml`	`True`	`bool`	Possibilité d'utiliser ClearML journalisation
`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 des versions
`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 l'ajustement des hyperparamètres
`tensorboard`	`True`	`bool`	Possibilité d'utiliser TensorBoard pour la visualisation
`wandb`	`True`	`bool`	Option d'utilisation Weights & Biases la journalisation
`vscode_msg`	`True`	`bool`	Lorsqu'un terminal VS Code est détecté, active une invite à télécharger l'extension Ultralytics.

Revenez sur ces paramètres au fur et à mesure de l'avancement des projets ou des expériences afin de garantir une configuration optimale.

FAQ

Comment installer Ultralytics à l'aide de pip ?

Installer Ultralytics avec pip en utilisant :

pip install ultralytics

Cela permet d'installer la dernière version stable de l'application ultralytics paquet 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, car elle garantit la compatibilité avec d'autres paquets. Pour les environnements CUDA , installez ultralytics, pytorchet 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, voir 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 l'ensemble des systèmes et évitant les complexités de l'installation locale. Les images Docker officielles sont disponibles sur Docker Hub, avec des variantes pour GPU, CPU, ARM64, NVIDIA Jetson et Conda. Pour télécharger 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 détaillées sur Docker, voir le guide de démarrage rapide de Docker.

Comment cloner le dépôt Ultralytics pour le développement ?

Clonez le dépôt Ultralytics et mettez en place 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 le dernier code source. Pour plus de détails, visitez le dépôtUltralytics GitHub.

Pourquoi utiliser Ultralytics YOLO CLI ?

LeCLI YOLO CLI Ultralytics simplifie l'exécution des tâches de détection d'objets sans code Python , en permettant des commandes en une seule ligne pour l'entraînement, la validation et la prédiction directement à partir de votre terminal. La syntaxe de base est la suivante :

yolo TASK MODE ARGS

Par exemple, pour former un modèle de détection :

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

D'autres commandes et exemples d'utilisation sont présentés dans le GuideCLI complet.

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