RF-DETR : un modèle open source pour la détection d'objets visuels en temps réel

Introduction générale

RF-DETR est un modèle de détection d'objets open source développé par l'équipe Roboflow. Il est basé sur Transformateur L'efficacité en temps réel est la principale caractéristique de l'architecture du modèle. Le modèle réalise la première détection en temps réel de plus de 60 points d'accès sur l'ensemble de données Microsoft COCO, et excelle également dans le test de référence RF100-VL, s'adaptant à un large éventail de scénarios du monde réel. Il est disponible en deux versions : RF-DETR-base (29 millions de paramètres) et RF-DETR-large (128 millions de paramètres). Le modèle est petit et convient au déploiement d'appareils périphériques. Le code et les poids pré-entraînés sont protégés par la licence Apache 2.0 et sont libres et ouverts à l'usage de la communauté. Les utilisateurs peuvent accéder aux ressources de GitHub pour faciliter la formation ou le déploiement.

Liste des fonctions

• Détection d'objets en temps réel : reconnaissance rapide d'objets dans des images ou des vidéos avec une faible latence.
• Entraînement à partir de données personnalisées : aide à la mise au point de modèles à l'aide de vos propres données.
• Fonctionnement sur des appareils périphériques : le modèle est léger et convient aux appareils à ressources limitées.
• Résolution réglable : les utilisateurs peuvent équilibrer la vitesse d'inspection et la précision.
• Support de modèle pré-entraîné : fournit des poids pré-entraînés basés sur l'ensemble de données COCO.
• Traitement des flux vidéo : permet d'analyser la vidéo en temps réel et de produire des résultats.
• Exportation ONNX : prend en charge la conversion au format ONNX pour faciliter le déploiement multiplateforme.
• Formation multi-GPU : plusieurs cartes graphiques peuvent être utilisées pour accélérer le processus de formation.

Utiliser l'aide

L'utilisation de RF-DETR se divise en trois parties : l'installation, l'inférence et la formation. Vous trouverez ci-dessous les étapes détaillées qui vous aideront à démarrer rapidement.

Processus d'installation

1. Préparation de l'environnement
   Nécessite Python 3.9 ou plus, et PyTorch 1.13.0 ou plus. Si vous utilisez un GPU, exécutez nvidia-smi Vérifier le lecteur.
   • Installer PyTorch :

     pip install torch>=1.13.0 torchvision>=0.14.0
     

   • Code de téléchargement :

     git clone https://github.com/roboflow/rf-detr.git
     cd rf-detr
     

   • Installer la dépendance :

     pip install rfdetr
     

     Cela installera automatiquement numpy,supervision et d'autres bibliothèques nécessaires.

2. Vérifier l'installation
   Exécutez le code suivant :

   from rfdetr import RFDETRBase
   print("安装成功")

Si aucune erreur n'est signalée, l'installation est terminée.

opération d'inférence

RF-DETR est livré avec un modèle pré-entraîné de l'ensemble de données COCO pour détecter directement des images ou des vidéos.

1. détection d'images
   • Exemple de code :

     import io
     import requests
     from PIL import Image
     from rfdetr import RFDETRBase
     import supervision as sv
     model = RFDETRBase()
     url = "https://media.roboflow.com/notebooks/examples/dog-2.jpeg"
     image = Image.open(io.BytesIO(requests.get(url).content))
     detections = model.predict(image, threshold=0.5)
     labels = [f"{class_id} {confidence:.2f}" for class_id, confidence in zip(detections.class_id, detections.confidence)]
     annotated_image = image.copy()
     annotated_image = sv.BoxAnnotator().annotate(annotated_image, detections)
     annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels)
     sv.plot_image(annotated_image)
     

   • Ce code détecte les objets dans l'image, étiquette la boîte englobante et le niveau de confiance, puis affiche les résultats.
2. Détection vidéo
   • Tout d'abord, installez opencv-python: :

     pip install opencv-python
     

   • Exemple de code :

     import cv2
     from rfdetr import RFDETRBase
     import supervision as sv
     model = RFDETRBase()
     cap = cv2.VideoCapture("video.mp4")  # 替换为你的视频路径
     while cap.isOpened():
     ret, frame = cap.read()
     if not ret:
     break
     image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
     detections = model.predict(image, threshold=0.5)
     annotated_frame = sv.BoxAnnotator().annotate(frame, detections)
     cv2.imshow("RF-DETR Detection", annotated_frame)
     if cv2.waitKey(1) & 0xFF == ord('q'):
     break
     cap.release()
     cv2.destroyAllWindows()
     

   • Il détecte les objets dans la vidéo image par image et les affiche en temps réel.
3. Ajustement de la résolution
   • La résolution peut être définie lors de l'initialisation (doit être un multiple de 56) :

     model = RFDETRBase(resolution=560)
     

   • Plus la résolution est élevée, meilleure est la précision, mais elle est plus lente.

Formation de modèles personnalisés

RF-DETR permet un réglage fin à l'aide de son propre ensemble de données, mais celui-ci doit être au format COCO et contenir les éléments suivants train,valid répondre en chantant test Trois sous-répertoires.

1. Préparation du jeu de données
   • Exemple de structure de catalogue :

     dataset/
     ├── train/
     │   ├── _annotations.coco.json
     │   ├── image1.jpg
     │   └── image2.jpg
     ├── valid/
     │   ├── _annotations.coco.json
     │   ├── image1.jpg
     │   └── image2.jpg
     └── test/
     ├── _annotations.coco.json
     ├── image1.jpg
     └── image2.jpg
     

   • Les ensembles de données au format COCO peuvent être générés à l'aide de la plateforme Roboflow :

     from roboflow import Roboflow
     rf = Roboflow(api_key="你的API密钥")
     project = rf.workspace("rf-100-vl").project("mahjong-vtacs-mexax-m4vyu-sjtd")
     dataset = project.version(2).download("coco")
     

2. Commencer la formation
   • Exemple de code :

     from rfdetr import RFDETRBase
     model = RFDETRBase()
     model.train(dataset_dir="./mahjong-vtacs-mexax-m4vyu-sjtd-2", epochs=10, batch_size=4, grad_accum_steps=4, lr=1e-4)
     

   • Pour la formation, la taille totale du lot recommandée (batch_size * grad_accum_stepsPar exemple, les GPU A100 utilisent l'option batch_size=16, grad_accum_steps=1GPU T4 batch_size=4, grad_accum_steps=4.
3. Formation multi-GPU
   • établir main.py Documentation :

     from rfdetr import RFDETRBase
     model = RFDETRBase()
     model.train(dataset_dir="./dataset", epochs=10, batch_size=4, grad_accum_steps=4, lr=1e-4)
     

   • S'exécute dans le terminal :

     python -m torch.distributed.launch --nproc_per_node=8 --use_env main.py
     

   • commandant en chef (militaire) 8 Remplacer par le nombre de GPU que vous utilisez. Notez l'ajustement batch_size pour que la taille totale du lot reste stable.
4. Résultats de l'entraînement au chargement
   • Deux fichiers de poids sont générés après l'entraînement : les poids normaux et les poids EMA (plus stables). Méthode de chargement :

     model = RFDETRBase(pretrain_weights="./output/model_ema.pt")
     detections = model.predict("image.jpg")
     

ONNX Export

• Exportation au format ONNX pour faciliter le déploiement sur d'autres plateformes :

  from rfdetr import RFDETRBase
  model = RFDETRBase()
  model.export()
  

• Le fichier exporté est enregistré dans le dossier output Catalogue pour l'inférence optimale pour les dispositifs de bord.

scénario d'application

1. conduite automatique
   RF-DETR détecte les véhicules et les piétons sur la route en temps réel. Sa faible latence et sa grande précision conviennent aux systèmes embarqués.
2. contrôle de la qualité industrielle
   RF-DETR identifie rapidement les défauts des pièces sur les lignes d'assemblage des usines. Le modèle est léger et peut être utilisé directement sur l'équipement.
3. vidéosurveillance
   Le RF-DETR traite les vidéos de surveillance pour détecter les objets ou les comportements anormaux en temps réel. Il prend en charge la diffusion vidéo en continu et convient pour une sécurité 24 heures sur 24 et 7 jours sur 7.

QA

1. Quels sont les formats de données pris en charge ?
   Seul le format COCO est pris en charge. L'ensemble de données doit contenir train,valid répondre en chantant test des sous-répertoires, chacun avec un fichier _annotations.coco.json Documentation.
2. Comment obtenir la clé API de Roboflow ?
   Connectez-vous à https://app.roboflow.com, trouvez la clé API dans les paramètres de votre compte, copiez-la et définissez-la dans la variable d'environnement ROBOFLOW_API_KEY.
3. Quelle est la durée de la formation ?
   Cela dépend du matériel et de la taille du jeu de données. Sur un GPU T4, 10 époques peuvent prendre quelques heures. Des ensembles de données plus petits peuvent être exécutés sur un processeur, mais c'est lent.