Installer Ultralytics

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

# Install or upgrade the ultralytics package from PyPI
pip install -U 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.

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

# 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 Ultralytics Conda Docker sont également disponibles sur Docker Hub. 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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --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.

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

• 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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --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 --runtime=nvidia --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.

Si vous avez besoin de modifications personnalisées persistantes, vous pouvez créer une branche du 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 my-custom-branch
   

4. Apportez vos modifications à pyproject.toml ou d'autres fichiers si nécessaire.
5. Commit et push vos modifications :

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

6. Installer utilisation de pip avec git+https syntaxe, pointant vers votre branche :

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

Clonez le référentiel localement, modifiez les fichiers selon vos besoins et installez-le en mode éditable.

1. Cloner le dépôt Ultralytics :

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

2. Apportez vos modifications à pyproject.toml ou d'autres fichiers si nécessaire.
3. Installer le paquet en mode modifiable (-e). Pip utilisera votre fichier modifié. pyproject.toml pour résoudre les dépendances :

   pip install -e .
   

Cette approche est utile pour développer ou tester des modifications locales avant de les valider.

Spécifiez une Ultralytics personnalisée dans votre requirements.txt fichier afin de garantir la cohérence des installations au sein de votre équipe.

# Install ultralytics from a specific git branch
git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

# Other project dependencies
flask

Installez les dépendances à partir du fichier :

pip install -r requirements.txt

Ultralytics yolo les commandes utilisent la syntaxe suivante :

yolo TASK MODE ARGS

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 YOLO11n au format ONNX avec une taille d'image de 224x128 (aucune TASK 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

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

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