Installer Ultralytics

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

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

Vous pouvez installer le ultralytics sans aucune dépendance à l'aide de la commande pip --no-deps . Cela vous oblige à installer manuellement toutes les dépendances nécessaires par la suite.

1. Installer ultralytics de base :

   pip install ultralytics --no-deps
   

2. Installer manuellement les dépendances : Vous devez installer tous les paquets nécessaires énumérés dans la section pyproject.toml en remplaçant ou en modifiant les versions selon les besoins. Pour l'exemple OpenCV sans tête :

   # Install other core dependencies
   pip install torch torchvision numpy matplotlib pandas pyyaml pillow psutil requests tqdm scipy seaborn ultralytics-thop
   
   # Install headless OpenCV instead of the default
   pip install opencv-python-headless
   

Si vous avez besoin de modifications personnalisées persistantes (comme l'utilisation systématique de opencv-python-headless), vous pouvez forker le dépôt Ultralytics , apporter des modifications à pyproject.toml ou d'autres codes, et installez-les à partir de votre fourche.

1. Créez un lien vers le dépôtUltralytics GitHub sur votre propre compte GitHub.
2. Clone votre fourchette localement :

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

3. Créer une nouvelle branche pour vos changements :

   git checkout -b custom-opencv
   

4. Modifier pyproject.toml: Ouvrir pyproject.toml dans un éditeur de texte et remplacez la ligne contenant "opencv-python>=4.6.0" avec "opencv-python-headless>=4.6.0" (ajuster la version si nécessaire).
5. Engager et pousser vos changements :

   git add pyproject.toml
   git commit -m "Switch to opencv-python-headless"
   git push origin custom-opencv
   

6. Installer en utilisant pip avec l'option git+https en pointant vers votre branche :

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

Cette méthode garantit que votre jeu de dépendances personnalisé est utilisé chaque fois que vous effectuez une installation à partir de cette URL spécifique. Voir la méthode 4 pour l'utiliser dans un requirements.txt fichier.

Similaire à la méthode standard "Git Clone" pour le développement, vous pouvez cloner le dépôt localement, modifier les fichiers de dépendance avant l' installation, puis installer en mode éditable.

1. Clone le référentiel Ultralytics :

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

2. Modifier pyproject.toml: Modifiez le fichier pour apporter les changements souhaités. Par exemple, utilisez sed (sous Linux/macOS) ou un éditeur de texte pour remplacer opencv-python avec opencv-python-headless. Utilisation sed (vérifier la ligne exacte dans pyproject.toml premier) :

   # Example: Replace the line starting with "opencv-python..."
   # Adapt the pattern carefully based on the current file content
   sed -i'' -e 's/^\s*"opencv-python>=.*",/"opencv-python-headless>=4.8.0",/' pyproject.toml
   

   Ou modifier manuellement pyproject.toml pour modifier "opencv-python>=... à "opencv-python-headless>=...".
3. Installer le paquet en mode éditable (-e). Pip va maintenant utiliser votre pyproject.toml pour résoudre et installer les dépendances :

   pip install -e .
   

Cette approche est utile pour tester les modifications locales apportées aux dépendances ou aux configurations de compilation avant de les valider, ou pour mettre en place des environnements de développement spécifiques.

Si vous gérez les dépendances de votre projet à l'aide d'un requirements.txt vous pouvez spécifier votre version personnalisée d'Ultralytics directement dans ce fichier. Cela garantit que toute personne mettant en place le projet obtiendra votre version spécifique avec ses dépendances modifiées (comme opencv-python-headless).

1. Créer ou modifier requirements.txt: Ajoutez une ligne pointant vers votre fork personnalisé et votre branche (comme préparé dans la méthode 2).
   exigences.txt

   # Core dependencies
   numpy
   matplotlib
   pandas
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   tqdm
   torch>=1.8.0 # Or specific version/variant
   torchvision>=0.9.0 # Or specific version/variant
   
   # Install ultralytics from a specific git commit or branch
   # Replace YOUR_USERNAME and custom-branch with your details
   git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-branch
   
   # Other project dependencies
   flask
   # ... etc
   

   Note : Vous n'avez pas besoin de lister les dépendances déjà requises par votre logiciel personnalisé. ultralytics fourchette (comme opencv-python-headless) ici, car pip les installera en se basant sur les paramètres de la fourche pyproject.toml.
2. Installer à partir du fichier :

   pip install -r requirements.txt
   

Cette méthode s'intègre parfaitement aux flux de travail standard de gestion des dépendances des projets Python , tout en vous permettant d'épingler ultralytics à votre source Git personnalisée.

Ultralytics yolo utilisent la syntaxe suivante :

yolo TASK MODE ARGS

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

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

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