Modèle YOLO-World

Le modèle YOLO-World introduit une approche avancée en temps réel basée sur Ultralytics YOLOv8 pour les tâches de détection à vocabulaire ouvert. Cette innovation permet de détecter tout objet dans une image à partir de textes descriptifs. En réduisant considérablement les besoins en calcul tout en préservant une performance compétitive, YOLO-World devient un outil polyvalent pour de nombreuses applications de vision.

Présentation

YOLO-World résout les défis rencontrés par les modèles de détection à vocabulaire ouvert traditionnels, qui s'appuient souvent sur des modèles Transformer lourds nécessitant d'importantes ressources de calcul. La dépendance de ces modèles à des catégories d'objets prédéfinies restreint également leur utilité dans des scénarios dynamiques. YOLO-World revitalise le framework YOLOv8 avec des capacités de détection à vocabulaire ouvert, en employant la modélisation du langage visuel et un pré-entraînement sur de vastes jeux de données pour exceller dans l'identification d'une large gamme d'objets dans des scénarios zero-shot avec une efficacité inégalée.

Fonctionnalités clés

1. Solution en temps réel : Exploitant la vitesse de calcul des CNN, YOLO-World offre une solution de détection à vocabulaire ouvert rapide, adaptée aux industries ayant besoin de résultats immédiats.

2. Efficacité et performance : YOLO-World réduit drastiquement les exigences en matière de calcul et de ressources sans sacrifier la performance, offrant une alternative robuste à des modèles comme SAM, mais à une fraction du coût de calcul, permettant des applications en temps réel.

3. Inférence avec vocabulaire hors ligne : YOLO-World introduit une stratégie de "prompt-then-detect", utilisant un vocabulaire hors ligne pour améliorer encore l'efficacité. Cette approche permet d'utiliser des prompts personnalisés calculés a priori, incluant des légendes ou des catégories, pour être encodés et stockés en tant qu'embeddings de vocabulaire hors ligne, simplifiant ainsi le processus de détection.

4. Propulsé par YOLOv8 : Construit sur Ultralytics YOLOv8, YOLO-World tire parti des dernières avancées en détection d'objets en temps réel pour faciliter la détection à vocabulaire ouvert avec une précision et une vitesse inégalées.

5. Excellence des benchmarks : YOLO-World surpasse les détecteurs à vocabulaire ouvert existants, y compris les séries MDETR et GLIP, en termes de vitesse et d'efficacité sur les benchmarks standard, démontrant la capacité supérieure de YOLOv8 sur un seul GPU NVIDIA V100.

6. Applications polyvalentes : L'approche innovante de YOLO-World ouvre de nouvelles possibilités pour une multitude de tâches de vision, offrant des gains de vitesse d'ordres de grandeur par rapport aux méthodes existantes.

Modèles disponibles, tâches prises en charge et modes de fonctionnement

Cette section détaille les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec divers modes opérationnels tels que Inférence, Validation, Entraînement et Exportation, notés par ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.

Transfert Zero-shot sur le jeu de données COCO

Exemples d'utilisation

Les modèles YOLO-World sont faciles à intégrer dans tes applications Python. Ultralytics fournit une API Python conviviale et des commandes CLI pour simplifier le développement.

Utilisation pour l'entraînement

La détection d'objets est simple avec la méthode train, comme illustré ci-dessous :

from ultralytics import YOLOWorld

# Load a pretrained YOLOv8s-worldv2 model
model = YOLOWorld("yolov8s-worldv2.pt")

# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Run inference with the YOLO-World model on the 'bus.jpg' image
results = model("path/to/bus.jpg")

Utilisation de la prédiction

La détection d'objets est simple avec la méthode predict, comme illustré ci-dessous :

from ultralytics import YOLOWorld

# Initialize a YOLO-World model
model = YOLOWorld("yolov8s-world.pt")  # or select yolov8m/l-world.pt for different sizes

# Execute inference with the YOLOv8s-world model on the specified image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Cet extrait démontre la simplicité de charger un modèle pré-entraîné et d'exécuter une prédiction sur une image.

Utilisation de la validation

La validation du modèle sur un jeu de données est simplifiée comme suit :

from ultralytics import YOLO

# Create a YOLO-World model
model = YOLO("yolov8s-world.pt")  # or select yolov8m/l-world.pt for different sizes

# Conduct model validation on the COCO8 example dataset
metrics = model.val(data="coco8.yaml")

Utilisation du suivi

Le suivi d'objets avec le modèle YOLO-World sur une vidéo/des images est simplifié comme suit :

from ultralytics import YOLO

# Create a YOLO-World model
model = YOLO("yolov8s-world.pt")  # or select yolov8m/l-world.pt for different sizes

# Track with a YOLO-World model on a video
results = model.track(source="path/to/video.mp4")

Définir des prompts

Le framework YOLO-World permet la spécification dynamique de classes via des prompts personnalisés, donnant aux utilisateurs le pouvoir d'adapter le modèle à leurs besoins spécifiques sans réentraînement. Cette fonctionnalité est particulièrement utile pour adapter le modèle à de nouveaux domaines ou à des tâches spécifiques qui ne faisaient pas partie à l'origine des données d'entraînement. En définissant des prompts personnalisés, les utilisateurs peuvent essentiellement guider l'attention du modèle vers les objets d'intérêt, améliorant ainsi la pertinence et la précision des résultats de détection.

Par exemple, si ton application nécessite uniquement de détecter les objets 'person' (personne) et 'bus' (bus), tu peux spécifier ces classes directement :

from ultralytics import YOLO

# Initialize a YOLO-World model
model = YOLO("yolov8s-world.pt")  # or choose yolov8m/l-world.pt

# Define custom classes
model.set_classes(["person", "bus"])

# Execute prediction for specified categories on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

model.set_classes(["person", "bus", ""])

Tu peux également sauvegarder un modèle après avoir défini des classes personnalisées. En faisant cela, tu crées une version du modèle YOLO-World spécialisée pour ton cas d'usage spécifique. Ce processus intègre tes définitions de classes personnalisées directement dans le fichier du modèle, rendant le modèle prêt à l'emploi avec tes classes spécifiées sans ajustements supplémentaires. Suis ces étapes pour sauvegarder et charger ton modèle YOLO-World personnalisé :

from ultralytics import YOLO

# Initialize a YOLO-World model
model = YOLO("yolov8s-world.pt")  # or select yolov8m/l-world.pt

# Define custom classes
model.set_classes(["person", "bus"])

# Save the model with the defined offline vocabulary
model.save("custom_yolov8s.pt")

from ultralytics import YOLO

# Load your custom model
model = YOLO("custom_yolov8s.pt")

# Run inference to detect your custom classes
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Avantages de la sauvegarde avec vocabulaire personnalisé

• Efficacité : Simplifie le processus de détection en se concentrant sur les objets pertinents, réduisant la charge de calcul et accélérant l'inférence.
• Flexibilité : Permet une adaptation facile du modèle à de nouvelles tâches de détection ou de niche sans besoin d'un réentraînement approfondi ou d'une collecte de données.
• Simplicité : Simplifie le déploiement en éliminant le besoin de spécifier à plusieurs reprises des classes personnalisées lors de l'exécution, rendant le modèle directement utilisable avec son vocabulaire intégré.
• Performance : Améliore la précision de la détection pour les classes spécifiées en focalisant l'attention et les ressources du modèle sur la reconnaissance des objets définis.

Cette approche offre un moyen puissant de personnaliser des modèles de détection d'objets de pointe pour des tâches spécifiques, rendant l'IA avancée plus accessible et applicable à un plus large éventail d'applications pratiques.

Reproduire les résultats officiels à partir de zéro (Expérimental)

Préparer les jeux de données

• Données d'entraînement

• Données de validation

Lance l'entraînement à partir de zéro

from ultralytics import YOLOWorld
from ultralytics.models.yolo.world.train_world import WorldTrainerFromScratch

# Option 1: Use Python dictionary
data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr30k/images",
                json_file="flickr30k/final_flickr_separateGT_train.json",
            ),
            dict(
                img_path="GQA/images",
                json_file="GQA/final_mixed_train_no_coco.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

# Option 2: Use YAML file (yolo_world_data.yaml)
# train:
#   yolo_data:
#     - Objects365.yaml
#   grounding_data:
#     - img_path: flickr/full_images/
#       json_file: flickr/annotations/final_flickr_separateGT_train_segm.json
#     - img_path: mixed_grounding/gqa/images
#       json_file: mixed_grounding/annotations/final_mixed_train_no_coco_segm.json
# val:
#   yolo_data:
#     - lvis.yaml

model = YOLOWorld("yolov8s-worldv2.yaml")
model.train(
    data=data,  # or data="yolo_world_data.yaml" if using YAML file
    batch=128,
    epochs=100,
    trainer=WorldTrainerFromScratch,
)

Citations et remerciements

Nous exprimons notre gratitude au Tencent AILab Computer Vision Center pour leur travail pionnier dans la détection d'objets en temps réel à vocabulaire ouvert avec YOLO-World :

@article{cheng2024yolow,
title={YOLO-World: Real-Time Open-Vocabulary Object Detection},
author={Cheng, Tianheng and Song, Lin and Ge, Yixiao and Liu, Wenyu and Wang, Xinggang and Shan, Ying},
journal={arXiv preprint arXiv:2401.17270},
year={2024}
}

Pour aller plus loin, l'article original sur YOLO-World est disponible sur arXiv. Le code source du projet et des ressources supplémentaires sont accessibles via leur dépôt GitHub. Nous apprécions leur engagement à faire progresser le domaine et à partager leurs précieuses connaissances avec la communauté.

FAQ

Qu'est-ce que le modèle YOLO-World et comment fonctionne-t-il ?

Le modèle YOLO-World est une approche avancée de détection d'objets en temps réel basée sur le framework Ultralytics YOLOv8. Il excelle dans les tâches de détection à vocabulaire ouvert (Open-Vocabulary Detection) en identifiant des objets au sein d'une image à partir de textes descriptifs. En utilisant la modélisation vision-langage et le pré-entraînement sur de grands jeux de données, YOLO-World atteint une efficacité et des performances élevées avec des exigences de calcul considérablement réduites, ce qui le rend idéal pour les applications en temps réel dans diverses industries.

Comment YOLO-World gère-t-il l'inférence avec des prompts personnalisés ?

YOLO-World prend en charge une stratégie de "prompt-then-detect" (prompt suivi de détection), qui utilise un vocabulaire hors ligne pour améliorer l'efficacité. Les prompts personnalisés tels que des légendes ou des catégories d'objets spécifiques sont pré-encodés et stockés en tant qu'embeddings (plongements) de vocabulaire hors ligne. Cette approche rationalise le processus de détection sans avoir besoin de réentraînement. Tu peux définir dynamiquement ces prompts au sein du modèle pour l'adapter à des tâches de détection spécifiques, comme illustré ci-dessous :

from ultralytics import YOLOWorld

# Initialize a YOLO-World model
model = YOLOWorld("yolov8s-world.pt")

# Define custom classes
model.set_classes(["person", "bus"])

# Execute prediction on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Pourquoi devrais-je choisir YOLO-World plutôt que des modèles de détection à vocabulaire ouvert traditionnels ?

YOLO-World offre plusieurs avantages par rapport aux modèles de détection à vocabulaire ouvert traditionnels :

• Performances en temps réel : Il tire parti de la vitesse de calcul des CNN pour offrir une détection rapide et efficace.
• Efficacité et faibles besoins en ressources : YOLO-World maintient des performances élevées tout en réduisant considérablement les exigences en matière de calcul et de ressources.
• Prompts personnalisables : Le modèle prend en charge la définition dynamique de prompts, permettant aux utilisateurs de spécifier des classes de détection personnalisées sans réentraînement.
• Excellence en matière de benchmark : Il surpasse d'autres détecteurs à vocabulaire ouvert comme MDETR et GLIP en termes de vitesse et d'efficacité sur les benchmarks standard.

Comment entraîner un modèle YOLO-World sur mon propre jeu de données ?

L'entraînement d'un modèle YOLO-World sur ton jeu de données est simple grâce à l'API Python ou aux commandes CLI fournies. Voici comment commencer l'entraînement en utilisant Python :

from ultralytics import YOLOWorld

# Load a pretrained YOLOv8s-worldv2 model
model = YOLOWorld("yolov8s-worldv2.pt")

# Train the model on the COCO8 dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Ou en utilisant la CLI :

yolo train model=yolov8s-worldv2.yaml data=coco8.yaml epochs=100 imgsz=640

Quels sont les modèles YOLO-World pré-entraînés disponibles et leurs tâches prises en charge ?

Ultralytics propose plusieurs modèles YOLO-World pré-entraînés prenant en charge diverses tâches et modes de fonctionnement :

Comment reproduire les résultats officiels de YOLO-World à partir de zéro ?

Pour reproduire les résultats officiels à partir de zéro, tu dois préparer les jeux de données et lancer l'entraînement à l'aide du code fourni. La procédure d'entraînement implique la création d'un dictionnaire de données et l'exécution de la méthode train avec un entraîneur personnalisé :

from ultralytics import YOLOWorld
from ultralytics.models.yolo.world.train_world import WorldTrainerFromScratch

data = {
    "train": {
        "yolo_data": ["Objects365.yaml"],
        "grounding_data": [
            {
                "img_path": "flickr30k/images",
                "json_file": "flickr30k/final_flickr_separateGT_train.json",
            },
            {
                "img_path": "GQA/images",
                "json_file": "GQA/final_mixed_train_no_coco.json",
            },
        ],
    },
    "val": {"yolo_data": ["lvis.yaml"]},
}

model = YOLOWorld("yolov8s-worldv2.yaml")
model.train(data=data, batch=128, epochs=100, trainer=WorldTrainerFromScratch)