Démarrage rapide

Q: Can I install Ultralytics YOLO using conda?

Oui, tu peux installer Ultralytics YOLO à l'aide de conda en exécutant : Cette méthode est une excellente alternative à pip et garantit la compatibilité avec les autres paquets de ton environnement. Pour les environnements CUDA , il est préférable d'installer ultralytics, pytorch, et pytorch-cuda simultanément pour résoudre les conflits éventuels : Pour plus d'instructions, visite le guide de démarrage rapide de Conda.

Installer Ultralytics

Ultralytics propose différentes méthodes d'installation, notamment pip, conda et Docker. Installe YOLO via l'option ultralytics pip pour la dernière version stable ou en clonant le paquet Ultralytics Dépôt GitHub pour obtenir la version la plus récente. Docker peut être utilisé pour exécuter le paquet dans un conteneur isolé, évitant ainsi une installation locale.

Regarde : Ultralytics YOLO Guide de démarrage rapide

Installer

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

Installe le ultralytics à l'aide de pip, ou mettre à jour une installation existante en exécutant pip install -U ultralytics. Visite le site Python Package Index (PyPI) pour plus de détails sur le programme ultralytics paquet : https://pypi.org/project/ultralytics/.

# Install the ultralytics package from PyPI
pip install ultralytics

Tu peux aussi installer le ultralytics directement à partir du paquet GitHub dépôt. Cela peut être utile si tu veux la dernière version de développement. Assure-toi que l'outil de ligne de commande Git est installé sur ton système. L'outil @main La commande installe le main et peut être modifiée en une autre branche, c'est-à-dire @my-branchou supprimée complètement pour passer à la valeur par défaut main branche.

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

Conda est un gestionnaire de paquets alternatif à pip qui peut également être utilisé pour l'installation. Visite Anaconda pour plus de détails à https://anaconda.org/conda-forge/ultralytics. Ultralytics Le dépôt feedstock pour la mise à jour du paquet conda se trouve à https://github.com/conda-forge/ultralytics-feedstock/.

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

Note

Si tu l'installes 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 paquets conda de résoudre les conflits éventuels, ou bien pour installer pytorch-cuda dernier pour lui permettre d'annuler l'option CPU-specific 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 sont 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

Clone le ultralytics si tu souhaites contribuer au développement ou expérimenter le dernier code source. Après le clonage, navigue dans le répertoire et installe le paquet en mode modifiable -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 .

Utilise Docker pour exécuter sans effort l' ultralytics dans un conteneur isolé, ce qui garantit des performances constantes et fluides dans divers environnements. En choisissant l'une des versions officielles de ultralytics images de Hub Docker, tu évites non seulement la complexité de l'installation locale, mais tu bénéficies également de l'accès à un environnement de travail vérifié. Ultralytics propose 5 images Docker principales prises en charge, chacune étant conçue pour offrir une compatibilité et une efficacité élevées pour différentes plateformes et différents cas d'utilisation :

Dockerfile : GPU image recommandée pour la formation.
Dockerfile-arm64 : Optimisé pour l'architecture ARM64, permettant le déploiement sur des appareils comme le Raspberry Pi et d'autres plateformes basées sur ARM64.
Dockerfile-cpu: Version basée sur Ubuntu CPU-only adaptée à l'inférence et aux environnements sans GPU.
Dockerfile-jetson : Adapté aux appareils NVIDIA Jetson, intégrant la prise en charge de GPU optimisée pour ces plateformes.
Dockerfile-python: Image minimale avec juste 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 l'installation de conda du paquet ultralytics .

Tu trouveras ci-dessous 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. ultralytics image. Les -it attribue un pseudo-TTY et maintient stdin ouvert, ce qui te permet d'interagir avec le conteneur. Le drapeau --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. Le drapeau --gpus all flag permet d'accéder à tous les GPU disponibles à l'intérieur du conteneur, ce qui est crucial pour les tâches qui nécessitent des calculs sur GPU .

Remarque : pour travailler avec des fichiers sur ta machine locale dans le conteneur, utilise 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

Alter /path/on/host avec le chemin du répertoire sur ta machine locale, et /path/in/container avec le chemin souhaité à l'intérieur du conteneur Docker pour l'accessibilité.

Pour une utilisation avancée de Docker, n'hésite pas à explorer le guideUltralytics Docker.

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

Astuce

PyTorch La configuration requise varie selon le système d'exploitation et CUDA . Il est donc recommandé d'installer d'abord PyTorch en suivant les instructions à https://pytorch.org/get-started/locally.

Utilise Ultralytics avec CLI

L'interface de ligne de commande Ultralytics (CLI) permet d'effectuer des commandes simples sur une seule ligne sans avoir besoin d'un environnement Python . CLI ne nécessite aucune personnalisation ni aucun code Python . Tu peux simplement exécuter toutes les tâches à partir du terminal avec la commande yolo commande. Jette un coup d'œil à la CLI Guide pour en savoir plus sur l'utilisation de YOLO à partir de la ligne de commande.

Exemple

SyntaxeTrainPrévoirValExporterSpécial

Ultralytics yolo Les commandes utilisent la syntaxe suivante :

yolo TASK MODE ARGS

TASK (facultatif) est l'un des éléments suivants (détecter, segment, classer, pose, obb)
MODE (obligatoire) est l'un des éléments suivants (train, val, prédire, exporter, 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 commande.

Entraîne 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édis une vidéo YouTube à l'aide d'un modèle de segmentation pré-entraîné à la taille d'image 320 :

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

Val un modèle de détection pré-entraîné à la taille de lot 1 et à la taille d'image 640 :

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

Exporte un modèle de classification Yolo11n au format ONNX avec une taille d'image de 224 par 128 (aucune TÂCHE requise).

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

Exécute 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 en tant que arg=val paires, séparées par une équation = et délimitées par des espaces entre les paires. 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 --)

CLI Guide

Utilise Ultralytics avec Python

YOLOL'interface Python permet une intégration transparente dans tes projets Python , facilitant le chargement, l'exécution et le traitement des résultats du modèle. Conçue dans un souci de simplicité et de facilité d'utilisation, l'interface Python permet aux utilisateurs de mettre rapidement en œuvre la détection, la segmentation et la classification des objets dans leurs projets. Cela fait de l'interface YOLO's Python un outil inestimable pour tous ceux qui cherchent à incorporer ces fonctionnalités dans leurs projets Python .

Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un ensemble de validation et même l'exporter au format ONNX avec seulement quelques lignes de code. Consulte le guidePython pour en savoir plus sur l'utilisation de YOLO dans tes 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 Réglages

La bibliothèque Ultralytics offre un puissant système de gestion des paramètres qui permet de contrôler finement tes expériences. En utilisant la bibliothèque SettingsManager hébergé au sein du ultralytics.utils les utilisateurs peuvent facilement accéder à leurs paramètres et les modifier. Ceux-ci sont stockés dans un fichier JSON dans le répertoire de configuration de l'utilisateur de l'environnement, et peuvent être consultés ou modifiés directement dans l'environnement Python ou via l'interface de ligne de commande (CLI).

Inspecter les paramètres

Pour avoir un aperçu de la configuration actuelle de tes paramètres, tu peux les consulter directement :

Afficher les paramètres

PythonCLI

Tu peux utiliser Python pour visualiser tes paramètres. Commence par importer le fichier settings de l'objet ultralytics module. Imprime et renvoie les paramètres à l'aide des commandes suivantes :

from ultralytics import settings

# View all settings
print(settings)

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

Sinon, l'interface de ligne de commande te permet de vérifier tes paramètres à l'aide d'une simple commande :

yolo settings

Modifier les paramètres

Ultralytics permet aux utilisateurs de modifier facilement leurs paramètres. Les modifications peuvent être effectuées de la manière suivante :

Mettre à jour les paramètres

PythonCLI

Dans l'environnement Python , appelle la fonction update sur la méthode settings pour modifier tes paramètres :

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

Si tu préfères utiliser l'interface de ligne de commande, les commandes suivantes te permettront de modifier tes paramètres :

# 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 réglages

Le tableau ci-dessous donne un aperçu des paramètres pouvant être ajustés sur le site Ultralytics. Chaque paramètre est présenté avec un exemple de valeur, le type de données et une brève description.

Nom	Exemple de valeur	Type de données	Description
`settings_version`	`'0.0.4'`	`str`	Ultralytics version desparamètres (différente de la version de Ultralytics pip )
`datasets_dir`	`'/path/to/datasets'`	`str`	Le répertoire où sont stockés les ensembles de données
`weights_dir`	`'/path/to/weights'`	`str`	Le répertoire où les poids du modèle sont stockés
`runs_dir`	`'/path/to/runs'`	`str`	Le répertoire dans lequel les expériences sont stockées
`uuid`	`'a1b2c3d4'`	`str`	L'identifiant unique des paramètres actuels
`sync`	`True`	`bool`	Si tu veux synchroniser les analyses et les crashs avec le HUB.
`api_key`	`''`	`str`	Ultralytics Clé API HUB
`clearml`	`True`	`bool`	S'il faut utiliser ClearML l'exploitation forestière
`comet`	`True`	`bool`	S'il faut utiliser Comet ML pour le suivi et la visualisation des expériences.
`dvc`	`True`	`bool`	Faut-il utiliser DVC pour le suivi des expériences et le contrôle des versions ?
`hub`	`True`	`bool`	Utiliser ou non l'intégration de Ultralytics HUB
`mlflow`	`True`	`bool`	Utiliser ou non MLFlow pour le suivi des expériences
`neptune`	`True`	`bool`	Utiliser ou non Neptune pour le suivi des expériences
`raytune`	`True`	`bool`	Utiliser ou non Ray Tune pour l'ajustement des hyperparamètres
`tensorboard`	`True`	`bool`	Si tu veux utiliser TensorBoard pour la visualisation
`wandb`	`True`	`bool`	S'il faut utiliser Weights & Biases l'exploitation forestière
`vscode_msg`	`True`	`bool`	Lorsque le terminal VS Code est détecté, l'invite à télécharger l'extension Ultralytics-Snippets est activée.

Au fur et à mesure que tu navigues dans tes projets ou tes expériences, n'oublie pas de revenir sur ces paramètres pour t'assurer qu'ils sont configurés de façon optimale pour tes besoins.

FAQ

Comment installer Ultralytics à l'aide de pip ?

Pour installer Ultralytics avec pip, exécute la commande suivante :

pip install ultralytics

Pour la dernière version stable, cela installera le fichier ultralytics directement à partir de Python Package Index (PyPI). Pour plus de détails, visite le site ultralytics sur PyPI.

Sinon, tu peux installer la dernière version de développement directement depuis GitHub :

pip install git+https://github.com/ultralytics/ultralytics.git

Assure-toi que l'outil de ligne de commande Git est installé sur ton système.

Puis-je installer Ultralytics YOLO en utilisant conda ?

Oui, tu peux installer Ultralytics YOLO en utilisant conda :

conda install -c conda-forge ultralytics

Cette méthode est une excellente alternative à pip et garantit la compatibilité avec les autres paquets de ton environnement. Pour les environnements CUDA , il est préférable d'installer ultralytics, pytorchet pytorch-cuda simultanément pour résoudre les conflits éventuels :

conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Pour plus d'instructions, visite le guide de démarrage rapide de Conda.

Quels sont les avantages de l'utilisation de Docker pour exécuter Ultralytics YOLO ?

L'utilisation de Docker pour exécuter Ultralytics YOLO permet d'obtenir un environnement isolé et cohérent, garantissant des performances fluides sur différents systèmes. Il élimine également la complexité de l'installation locale. Les images Docker officielles de Ultralytics sont disponibles sur Docker Hub, avec différentes variantes adaptées aux environnements GPU, CPU, ARM64, NVIDIA Jetson et Conda. Tu trouveras ci-dessous les commandes pour tirer 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 plus détaillées sur Docker, consulte le guide de démarrage rapide de Docker.

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

Pour cloner le dépôt Ultralytics et mettre en place un environnement de développement, suis les étapes suivantes :

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

Cette approche te permet de contribuer au projet ou d'expérimenter le dernier code source. Pour plus de détails, visite le dépôt GitHub Ultralytics .

Pourquoi utiliser Ultralytics YOLO CLI ?

L'interface de ligne de commande Ultralytics YOLO (CLI) simplifie l'exécution des tâches de détection d'objets sans nécessiter de code Python . Tu peux exécuter des commandes d'une seule ligne pour des tâches telles que l'entraînement, la validation et la prédiction directement à partir de ton terminal. La syntaxe de base pour yolo Les commandes sont :

yolo TASK MODE ARGS

Par exemple, pour former un modèle de détection avec des paramètres spécifiés :

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

Consulte le guide complet CLI pour découvrir d'autres commandes et exemples d'utilisation.

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