Installer Ultralytics

Ultralytics propose plusieurs méthodes d'installation, notamment pip, conda et Docker. Tu peux installer YOLO via le package pip ultralytics pour la dernière version stable, ou en clonant le dépôt GitHub d'Ultralytics pour la version la plus récente. Docker est également une option pour exécuter le package dans un conteneur isolé, ce qui évite une installation locale.

Watch: Ultralytics YOLO Quick Start Guide

Installation

Installe ou mets à jour le package ultralytics via pip en exécutant pip install -U ultralytics. Pour plus de détails sur le package ultralytics, consulte le Python Package Index (PyPI).

# Install or upgrade the ultralytics package from PyPI
pip install -U ultralytics

Tu peux aussi installer ultralytics directement depuis le dépôt GitHub d'Ultralytics. Cela peut être utile si tu souhaites obtenir la dernière version de développement. Assure-toi d'avoir installé l'outil de ligne de commande Git, puis exécute :

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

See the ultralytics pyproject.toml file for a list of dependencies. Note that all examples above install all required dependencies.

Astuce

Les exigences de PyTorch varient selon le système d'exploitation et les besoins en CUDA. Installe donc PyTorch en premier en suivant les instructions sur PyTorch.

PyTorch installation selector for different platforms

Installation sur serveur sans interface graphique (Headless)

Pour les environnements serveurs sans écran (ex: VMs cloud, conteneurs Docker, pipelines CI/CD), utilise le package ultralytics-opencv-headless. Il est identique au package ultralytics standard mais dépend de opencv-python-headless au lieu de opencv-python, évitant ainsi les dépendances GUI inutiles et les erreurs libGL potentielles.

Installation Headless

pip install ultralytics-opencv-headless

Les deux packages offrent les mêmes fonctionnalités et API. La variante headless exclut simplement les composants GUI d'OpenCV qui nécessitent des bibliothèques d'affichage.

Installation avancée

Bien que les méthodes d'installation standard couvrent la plupart des cas d'utilisation, tu pourrais avoir besoin d'une configuration plus personnalisée pour le développement ou des réglages spécifiques.

Méthodes avancées

Si tu as besoin de modifications personnalisées persistantes, tu peux forker le dépôt Ultralytics, apporter des changements au pyproject.toml ou à d'autres codes, et installer depuis ton fork.

Forke le dépôt GitHub d'Ultralytics sur ton propre compte GitHub.

Clone ton fork localement :

git clone https://github.com/YOUR_USERNAME/ultralytics.git
cd ultralytics

Crée une nouvelle branche pour tes changements :
```
git checkout -b my-custom-branch
```
Apporte tes modifications au fichier pyproject.toml ou à d'autres fichiers selon tes besoins.

Valide et pousse (commit and push) tes changements :

git add .
git commit -m "My custom changes"
git push origin my-custom-branch

Installe via pip en utilisant la syntaxe git+https, en pointant vers ta branche :

pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

Utiliser Ultralytics avec la CLI

L'interface de ligne de commande (CLI) d'Ultralytics permet des commandes simples en une seule ligne sans avoir besoin d'un environnement Python. La CLI ne nécessite aucune personnalisation ni code Python ; exécute toutes tes tâches depuis le terminal avec la commande yolo. Pour plus d'informations sur l'utilisation de YOLO en ligne de commande, consulte le Guide CLI.

Exemple

Les commandes yolo d'Ultralytics utilisent la syntaxe suivante :

yolo TASK MODE ARGS

TASK (optionnel) est l'un des suivants (detect, segment, classify, pose, obb)
MODE (requis) est l'un des suivants (train, val, predict, export, track, benchmark)
ARGS (optionnel) sont des paires arg=value comme imgsz=640 qui remplacent les valeurs par défaut.

Consulte tous les ARGS dans le Guide de configuration complet ou via la commande CLI yolo cfg.

Avertissement

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

yolo predict model=yolo26n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolo26n.pt imgsz 640 conf 0.25 ❌ (manque =)
yolo predict model=yolo26n.pt, imgsz=640, conf=0.25 ❌ (n'utilise pas ,)
yolo predict --model yolo26n.pt --imgsz 640 --conf 0.25 ❌ (n'utilise pas --)
yolo solution model=yolo26n.pt imgsz=640 conf=0.25 ❌ (utilise solutions, pas solution)

Guide CLI

Utiliser Ultralytics avec Python

L'interface Python de YOLO Ultralytics 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 de mettre en œuvre rapidement la détection d'objets, la segmentation et la classification. Cela fait de l'interface Python de YOLO un outil inestimable pour intégrer ces fonctionnalités dans tes 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. Explore le Guide Python pour en apprendre davantage sur l'utilisation de YOLO dans tes projets Python.

Exemple

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo26n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo26n.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 d'Ultralytics

La bibliothèque Ultralytics inclut un SettingsManager pour un contrôle précis 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 consultés ou modifiés dans l'environnement Python ou via l'interface de ligne de commande (CLI).

Inspection des paramètres

Pour voir la configuration actuelle de tes paramètres :

Voir les paramètres

Utilise Python pour voir tes paramètres en important l'objet settings depuis le module ultralytics. Affiche et renvoie les paramètres avec ces commandes :

from ultralytics import settings

# View all settings
print(settings)

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

Modification des paramètres

Ultralytics permet de modifier facilement les paramètres des manières suivantes :

Mettre à jour les paramètres

En Python, utilise la méthode update sur l'objet settings :

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

Comprendre les paramètres

Le tableau ci-dessous présente une vue d'ensemble des paramètres ajustables dans Ultralytics, incluant 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`	Ultralytics settings version (distinct from the Ultralytics pip version)
`datasets_dir`	`'/path/to/datasets'`	`str`	Répertoire où les jeux de données sont stockés
`weights_dir`	`'/path/to/weights'`	`str`	Répertoire où les poids des modèles sont stockés
`runs_dir`	`'/path/to/runs'`	`str`	Répertoire où les exécutions d'expériences sont stockées
`uuid`	`'a1b2c3d4'`	`str`	Identifiant unique pour les paramètres actuels
`sync`	`True`	`bool`	Option to sync analytics and crashes to Ultralytics Platform
`api_key`	`''`	`str`	Ultralytics Platform API Key
`clearml`	`True`	`bool`	Option to use ClearML logging
`comet`	`True`	`bool`	Option to use Comet ML for experiment tracking and visualization
`dvc`	`True`	`bool`	Option to use DVC for experiment tracking and version control
`hub`	`True`	`bool`	Option to use Ultralytics Platform integration
`mlflow`	`True`	`bool`	Option to use MLFlow for experiment tracking
`neptune`	`True`	`bool`	Option to use Neptune for experiment tracking
`raytune`	`True`	`bool`	Option to use Ray Tune for hyperparameter tuning
`tensorboard`	`True`	`bool`	Option to use TensorBoard for visualization
`wandb`	`True`	`bool`	Option to use Weights & Biases logging
`vscode_msg`	`True`	`bool`	When a VS Code terminal is detected, enables a prompt to download the Ultralytics-Snippets extension.

Revois ces paramètres au fur et à mesure de tes projets ou expériences pour assurer une configuration optimale.

FAQ

Comment installer Ultralytics avec pip ?

Installe Ultralytics avec pip en utilisant :

pip install -U ultralytics

Ceci installe la dernière version stable du package ultralytics depuis PyPI. Pour installer la 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 avec conda ?

Oui, installe Ultralytics YOLO avec conda en utilisant :

conda install -c conda-forge ultralytics

Cette méthode est une excellente alternative à pip, assurant la compatibilité avec d'autres packages. Pour les environnements CUDA, installe 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, consulte le Conda quickstart guide.

Quels sont les avantages d'utiliser 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 locale. 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 --runtime=nvidia --gpus all ultralytics/ultralytics:latest

Pour des instructions détaillées sur Docker, consulte le Docker quickstart guide.

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

Clone le dépôt Ultralytics et configure 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 .

Ceci permet de contribuer au projet ou d'expérimenter avec le code source le plus récent. Pour plus de détails, visite le Ultralytics GitHub repository.

Pourquoi devrais-je utiliser l'interface de ligne de commande (CLI) d'Ultralytics YOLO ?

L'interface de ligne de commande (CLI) d'Ultralytics YOLO simplifie l'exécution des tâches de détection d'objets sans code Python, permettant des commandes sur une seule ligne pour l'entraînement, la validation et la prédiction directement depuis ton terminal. La syntaxe de base est :

yolo TASK MODE ARGS

Par exemple, pour entraîner un modèle de détection :

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

Explore plus de commandes et d'exemples d'utilisation dans le CLI Guide complet.

Contributors

GLglenn-jocher²⁹ RIRizwanMunawar⁶ PDpderrenger³ BUBurhan-Q³ LALaughing-q² ONonuralpszr² JKjk4e² FCfcakyon¹ LAlakshanthad¹ PIpicsalex¹ LEleonnil¹ MAMatthewNoyce¹

Created 12 nov. 2023Updated la semaine dernière