SegAnyMo : un outil open source pour segmenter automatiquement des objets arbitraires en mouvement à partir d'une vidéo

Derniers outils d'IAPosté il y a 4 mois Sharenet.ai
723 0
吐司AI

Introduction générale

SegAnyMo est un projet open source développé par une équipe de chercheurs de l'UC Berkeley et de l'université de Pékin, comprenant des membres tels que Nan Huang. L'outil se concentre sur le traitement vidéo et peut automatiquement identifier et segmenter des objets arbitraires en mouvement dans une vidéo, tels que des personnes, des animaux ou des véhicules. Il combine des technologies telles que TAPNet, DINOv2 et SAM2, et prévoit de présenter ses résultats à la CVPR 2025. Le code du projet est entièrement public et gratuit pour les utilisateurs qui peuvent le télécharger, l'utiliser ou le modifier, et il convient aux développeurs, aux chercheurs et aux passionnés de traitement vidéo.L'objectif de SegAnyMo est de simplifier l'analyse des vidéos en mouvement et de fournir des solutions de segmentation efficaces.

SegAnyMo:从视频中自动分割任意运动物体的开源工具

 

Liste des fonctions

  • Détecte automatiquement les objets en mouvement dans la vidéo et génère des masques de segmentation précis.
  • Prise en charge des formats vidéo (par exemple MP4, AVI) ou de l'entrée de séquences d'images.
  • Fournit des modèles pré-entraînés pour permettre un déploiement et des tests rapides.
  • L'intégration avec TAPNet génère des traces de suivi en 2D et capture des informations sur les mouvements.
  • Utilisation de DINOv2 pour extraire des caractéristiques sémantiques afin d'améliorer la précision de la segmentation.
  • Segmentation au niveau du pixel à l'aide du masque de raffinement SAM2.
  • Prise en charge de la formation personnalisée des ensembles de données afin de s'adapter à différents scénarios.
  • Les résultats sont visualisés pour faciliter le contrôle et l'ajustement.

 

Utiliser l'aide

SegAnyMo nécessite une certaine base technique et s'adresse principalement aux utilisateurs ayant une expérience de la programmation. Vous trouverez ci-dessous un guide d'installation et d'utilisation détaillé.

Processus d'installation

  1. Préparer le matériel et les logiciels
    Le projet est développé sur Ubuntu 22.04, et une carte graphique NVIDIA RTX A6000 ou similaire avec CUDA est recommandée. Git et Anaconda doivent être préinstallés.

    • Cloner le dépôt de code :
      git clone --recurse-submodules https://github.com/nnanhuang/SegAnyMo
      
    • Accédez au catalogue de projets :
      cd SegAnyMo
      
  2. Créer un environnement virtuel
    Créez un environnement Python distinct avec Anaconda pour éviter les conflits de dépendances.

    • Créer un environnement :
      conda create -n seg python=3.12.4
      
    • Activer l'environnement :
      conda activate seg
      
  3. Installation des dépendances de base
    Installez PyTorch et les autres bibliothèques nécessaires.

    • Installez PyTorch (compatible avec CUDA 12.1) :
      conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.1 -c pytorch -c nvidia
      
    • Installer les autres dépendances :
      pip install -r requirements.txt
      
    • Installer xformers (raisonnement accéléré) :
      pip install -U xformers --index-url https://download.pytorch.org/whl/cu121
      
  4. Installation de DINOv2
    DINOv2 est utilisé pour l'extraction des caractéristiques.

    • Allez dans le catalogue de prétraitement et clonez :
      cd preproc && git clone https://github.com/facebookresearch/dinov2
      
  5. Installation de SAM2
    SAM2 est le noyau d'affinage des masques.

    • Accédez au catalogue SAM2 :
      cd sam2
      
    • Installation :
      pip install -e .
      
    • Télécharger le modèle pré-entraîné :
      cd checkpoints && ./download_ckpts.sh && cd ../..
      
  6. Installation de TAPNet
    TAPNet est utilisé pour générer des traces de suivi en 2D.

    • Accédez au catalogue TAPNet :
      cd preproc/tapnet
      
    • Installation :
      pip install .
      
    • Télécharger le modèle :
      cd ../checkpoints && wget https://storage.googleapis.com/dm-tapnet/bootstap/bootstapir_checkpoint_v2.pt
      
  7. Vérifier l'installation
    Vérifier que l'environnement est normal :
python -c "import torch; print(torch.cuda.is_available())"

exportations True Indique un succès.

Utilisation

Préparation des données

SegAnyMo prend en charge l'entrée de séquences vidéo ou d'images. Les données doivent être organisées selon la structure suivante :

data
├── images
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── bootstapir
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── dinos
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── depth_anything_v2
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
  • Si l'entrée est une vidéo, utilisez un outil (tel que FFmpeg) pour extraire les images vers le fichier images Dossier.
  • S'il s'agit d'une séquence d'images, placez-la directement dans le répertoire correspondant.

Prétraitement opérationnel

  1. Générer des cartes de profondeur, des caractéristiques et des trajectoires
    Utilisez les commandes suivantes pour traiter les données (environ 10 minutes, en fonction de la quantité de données) :

    • Pour les séquences d'images :
      python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --depths --tracks --dinos --e
      
    • Pour la vidéo :
      python core/utils/run_inference.py --video_path $VIDEO_PATH --gpus 0 --depths --tracks --dinos --e
      

    Paramètre Description :

    • --e Activez le mode efficace pour réduire la fréquence d'images et la résolution et accélérer le traitement.
    • --step 10 Indique qu'une image sur 10 est utilisée comme image d'interrogation, ce qui peut être ajusté à la baisse pour améliorer la précision.

Prévision des trajectoires de mouvement

  1. Télécharger le modèle de poids
    à travers (une brèche) Visage étreint peut-être Google Drive Téléchargez le modèle pré-entraîné. Écrire le chemin d'accès au fichier configs/example_train.yaml (utilisé comme expression nominale) resume_path Domaines.

    • Prédiction de la trajectoire de course :
      python core/utils/run_inference.py --data_dir $DATA_DIR --motin_seg_dir $OUTPUT_DIR --config_file configs/example_train.yaml --gpus 0 --motion_seg_infer --e
      

    La sortie est enregistrée dans le fichier $OUTPUT_DIR.

Générer un masque de segmentation

  1. Utilisation du masque de raffinement SAM2
    • Génération de masques d'exécution :
      python core/utils/run_inference.py --data_dir $DATA_DIR --sam2dir $RESULT_DIR --motin_seg_dir $OUTPUT_DIR --gpus 0 --sam2 --e
      

    Paramètre Description :

    • $DATA_DIR est le chemin de l'image originale.
    • $RESULT_DIR est le chemin de sauvegarde du masque.
    • $OUTPUT_DIR est la trajectoire du résultat de la prédiction de la trajectoire.
      Note : SAM2 supporte par défaut .jpg peut-être .jpeg le nom du fichier doit être un simple nombre. Si ce n'est pas le cas, modifiez le code ou renommez le fichier.

Résultats de l'évaluation

  1. Télécharger les résultats précalculés
    entité transférante Google Drive Télécharger le masque officiel pour comparaison.

    • Évaluation de l'ensemble de données DAVIS :
      CUDA_VISIBLE_DEVICES=0 python core/eval/eval_mask.py --res_dir $RES_DIR --eval_dir $GT_DIR --eval_seq_list core/utils/moving_val_sequences.txt
      
    • Évaluation affinée :
      cd core/eval/davis2017-evaluation && CUDA_VISIBLE_DEVICES=0 python evaluation_method.py --task unsupervised --results_path $MASK_PATH
      

Formation sur mesure

  1. Prétraitement des données
    Le jeu de données HOI4D est utilisé comme exemple :
python core/utils/process_HOI.py
python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --tracks --depths --dinos

Des images RVB et des masques dynamiques sont nécessaires pour les ensembles de données personnalisés.

  • Vérifier l'intégrité des données :
    python current-data-dir/dynamic_stereo/dynamic_replica_data/check_process.py
    
  • Le nettoyage des données permet d'économiser de l'espace :
    python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --clean
    
  1. formation au modèle
    modifications configs/$CONFIG.yaml formés avec des ensembles de données tels que Kubric, HOI4D, etc :
CUDA_VISIBLE_DEVICES=0 python train_seq.py ./configs/$CONFIG.yaml

 

scénario d'application

  1. Post-production vidéo
    Séparez les objets en mouvement (par exemple, les personnes qui courent) de la vidéo, générez des masques et utilisez-les pour la composition d'effets.
  2. Recherche en analyse comportementale
    Suivi des trajectoires de mouvements d'animaux ou d'êtres humains et analyse des schémas comportementaux.
  3. Développement de la conduite autonome
    Segmentation des objets en mouvement (véhicules, piétons, etc.) dans les vidéos de conduite pour optimiser le système de perception.
  4. Optimisation du système de surveillance
    Extraire les mouvements anormaux des vidéos de surveillance pour améliorer l'efficacité de la sécurité.

 

QA

  1. Besoin d'un GPU ?
    Oui, il est recommandé que les cartes NVIDIA prennent en charge CUDA, sinon elles fonctionnent de manière inefficace.
  2. Prend-il en charge le traitement en temps réel ?
    La version actuelle est adaptée au traitement hors ligne, les applications en temps réel devant être optimisées par elles-mêmes.
  3. De quel espace avez-vous besoin pour la formation ?
    Selon l'ensemble de données, un petit ensemble de données représente quelques gigaoctets et un grand ensemble de données peut représenter des centaines de gigaoctets.
  4. Comment améliorer la précision de la segmentation ?
    diminuer --step ou d'entraîner le modèle avec davantage de données étiquetées.
© déclaration de droits d'auteur
AiPPT

Articles connexes

Pas de commentaires

aucun
Pas de commentaires...