PyTorch ResNets 3D

ResNets 3D pour la reconnaissance des actions

Mise à jour (2020/4/13)

Nous avons publié un article sur arXiv.

Hirokatsu Kataoka, Tenga Wakamiya, Kensho Hara et Yutaka Satoh,
"Les ensembles de données à grande échelle amélioreraient-ils encore les CNN 3D spatio-temporels",
Préimpression arXiv, arXiv :2004.04968, 2020.

Nous avons téléchargé les modèles pré-entraînés décrits dans cet article, y compris ResNet-50 pré-entraîné sur l'ensemble de données combiné avec Kinetics-700 et Moments in Time.

Mise à jour (2020/4/10)

Nous avons considérablement mis à jour nos scripts. Si vous souhaitez utiliser des versions plus anciennes pour reproduire notre article CVPR2018, vous devez utiliser les scripts de la branche CVPR2018.

Cette mise à jour comprend les éléments suivants :

• Refactoriser l'ensemble du projet
• Prise en charge des versions les plus récentes de PyTorch
• Prise en charge de la formation distribuée
• Prise en charge de la formation et des tests sur l'ensemble de données Moments in Time.
• Ajout de modèles R(2+1)D
• Téléchargement de modèles ResNet 3D formés sur les ensembles de données Kinetics-700, Moments in Time et STAIR-Actions

Résumé

Il s'agit du code PyTorch pour les articles suivants :

Hirokatsu Kataoka, Tenga Wakamiya, Kensho Hara et Yutaka Satoh,
"Les ensembles de données à grande échelle amélioreraient-ils encore les CNN 3D spatio-temporels",
Préimpression arXiv, arXiv :2004.04968, 2020.

Kensho Hara, Hirokatsu Kataoka et Yutaka Satoh,
"Vers de bonnes pratiques pour la reconnaissance d'actions avec des convolutions spatio-temporelles 3D",
Actes de la Conférence internationale sur la reconnaissance de formes, pp. 2516-2521, 2018.

Kensho Hara, Hirokatsu Kataoka et Yutaka Satoh,
"Les CNN 3D spatio-temporels peuvent-ils retracer l'histoire des CNN 2D et d'ImageNet ?",
Actes de la conférence IEEE sur la vision par ordinateur et la reconnaissance de formes, pp. 6546-6555, 2018.

Kensho Hara, Hirokatsu Kataoka et Yutaka Satoh,
"Apprentissage des caractéristiques spatio-temporelles avec des réseaux résiduels 3D pour la reconnaissance d'actions",
Actes de l'atelier ICCV sur la reconnaissance de l'action, des gestes et des émotions, 2017.

Ce code comprend une formation, un réglage fin et des tests sur Kinetics, Moments in Time, ActivityNet, UCF-101 et HMDB-51.

Citation

Si vous utilisez ce code ou des modèles pré-entraînés, veuillez citer les éléments suivants :

 @inproceedings { hara3dcnns ,
  author = { Kensho Hara and Hirokatsu Kataoka and Yutaka Satoh } ,
  title = { Can Spatiotemporal 3D CNNs Retrace the History of 2D CNNs and ImageNet? } ,
  booktitle = { Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) } ,
  pages = { 6546--6555 } ,
  year = { 2018 } ,
}

Modèles pré-entraînés

Des modèles pré-entraînés sont disponibles ici.
Tous les modèles sont formés sur Kinetics-700 ( K ), Moments in Time ( M ), STAIR-Actions ( S ) ou sur des ensembles de données fusionnés ( KM , KS , MS , KMS ).
Si vous souhaitez affiner les modèles sur votre ensemble de données, vous devez spécifier les options suivantes.

 r3d18_K_200ep.pth: --model resnet --model_depth 18 --n_pretrain_classes 700
r3d18_KM_200ep.pth: --model resnet --model_depth 18 --n_pretrain_classes 1039
r3d34_K_200ep.pth: --model resnet --model_depth 34 --n_pretrain_classes 700
r3d34_KM_200ep.pth: --model resnet --model_depth 34 --n_pretrain_classes 1039
r3d50_K_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 700
r3d50_KM_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 1039
r3d50_KMS_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 1139
r3d50_KS_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 800
r3d50_M_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 339
r3d50_MS_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 439
r3d50_S_200ep.pth: --model resnet --model_depth 50 --n_pretrain_classes 100
r3d101_K_200ep.pth: --model resnet --model_depth 101 --n_pretrain_classes 700
r3d101_KM_200ep.pth: --model resnet --model_depth 101 --n_pretrain_classes 1039
r3d152_K_200ep.pth: --model resnet --model_depth 152 --n_pretrain_classes 700
r3d152_KM_200ep.pth: --model resnet --model_depth 152 --n_pretrain_classes 1039
r3d200_K_200ep.pth: --model resnet --model_depth 200 --n_pretrain_classes 700
r3d200_KM_200ep.pth: --model resnet --model_depth 200 --n_pretrain_classes 1039

Les anciens modèles pré-entraînés sont toujours disponibles ici.
Cependant, certaines modifications sont nécessaires pour utiliser les anciens modèles pré-entraînés dans les scripts actuels.

Exigences

• PyTorch (version 0.4+ requise)

conda install pytorch torchvision cudatoolkit=10.1 -c soumith

• FFmpeg, FFprobe

• Python3

Préparation

ActivitéNet

• Téléchargez des vidéos à l'aide du robot d'exploration officiel.
• Convertir des fichiers avi en jpg à l'aide de util_scripts/generate_video_jpgs.py

python -m util_scripts.generate_video_jpgs mp4_video_dir_path jpg_video_dir_path activitynet

• Ajoutez des informations fps dans le fichier json util_scripts/add_fps_into_activitynet_json.py

python -m util_scripts.add_fps_into_activitynet_json mp4_video_dir_path json_file_path

Cinétique

• Téléchargez des vidéos à l'aide du robot d'exploration officiel.
  • Localisez l'ensemble de test dans video_directory/test .
• Convertir des fichiers avi en jpg à l'aide de util_scripts/generate_video_jpgs.py

python -m util_scripts.generate_video_jpgs mp4_video_dir_path jpg_video_dir_path kinetics

• Générez un fichier d'annotation au format json similaire à ActivityNet à l'aide de util_scripts/kinetics_json.py
  • Les fichiers CSV (kinétiques_{train, val, test}.csv) sont inclus dans le robot.

python -m util_scripts.kinetics_json csv_dir_path 700 jpg_video_dir_path jpg dst_json_path

UCF-101

• Téléchargez des vidéos et entraînez-vous/testez les fractionnements ici.
• Convertir des fichiers avi en jpg à l'aide de util_scripts/generate_video_jpgs.py

python -m util_scripts.generate_video_jpgs avi_video_dir_path jpg_video_dir_path ucf101

• Générez un fichier d'annotation au format json similaire à ActivityNet à l'aide de util_scripts/ucf101_json.py
  • annotation_dir_path inclut classInd.txt, trainlist0{1, 2, 3}.txt, testlist0{1, 2, 3}.txt

python -m util_scripts.ucf101_json annotation_dir_path jpg_video_dir_path dst_json_path

HMDB-51

• Téléchargez des vidéos et entraînez-vous/testez les fractionnements ici.
• Convertir des fichiers avi en jpg à l'aide de util_scripts/generate_video_jpgs.py

python -m util_scripts.generate_video_jpgs avi_video_dir_path jpg_video_dir_path hmdb51

• Générez un fichier d'annotation au format json similaire à ActivityNet à l'aide de util_scripts/hmdb51_json.py
  • annotation_dir_path inclut brush_hair_test_split1.txt, ...

python -m util_scripts.hmdb51_json annotation_dir_path jpg_video_dir_path dst_json_path

Exécuter le code

Supposons que la structure des répertoires de données est la suivante :

 ~/
  data/
    kinetics_videos/
      jpg/
        .../ (directories of class names)
          .../ (directories of video names)
            ... (jpg files)
    results/
      save_100.pth
    kinetics.json

Confirmez toutes les options.

python main.py -h

Entraînez ResNets-50 sur l'ensemble de données Kinetics-700 (700 classes) avec 4 threads CPU (pour le chargement des données).
La taille du lot est de 128.
Enregistrez les modèles toutes les 5 époques. Tous les GPU sont utilisés pour la formation. Si vous voulez une partie des GPU, utilisez CUDA_VISIBLE_DEVICES=... .

python main.py --root_path ~ /data --video_path kinetics_videos/jpg --annotation_path kinetics.json 
--result_path results --dataset kinetics --model resnet 
--model_depth 50 --n_classes 700 --batch_size 128 --n_threads 4 --checkpoint 5

Continuez la formation à partir de l'époque 101. (~/data/results/save_100.pth est chargé.)

python main.py --root_path ~ /data --video_path kinetics_videos/jpg --annotation_path kinetics.json 
--result_path results --dataset kinetics --resume_path results/save_100.pth 
--model_depth 50 --n_classes 700 --batch_size 128 --n_threads 4 --checkpoint 5

Calculez les 5 meilleures probabilités de classe de chaque vidéo à l'aide d'un modèle entraîné (~/data/results/save_200.pth.)
Notez que inference_batch_size doit être petit car la taille réelle du lot est calculée par inference_batch_size * (n_video_frames / inference_stride) .

python main.py --root_path ~ /data --video_path kinetics_videos/jpg --annotation_path kinetics.json 
--result_path results --dataset kinetics --resume_path results/save_200.pth 
--model_depth 50 --n_classes 700 --n_threads 4 --no_train --no_val --inference --output_topk 5 --inference_batch_size 1

Évaluez la précision vidéo la plus élevée d'un résultat de reconnaissance (~/data/results/val.json).

python -m util_scripts.eval_accuracy ~ /data/kinetics.json ~ /data/results/val.json --subset val -k 1 --ignore

Affinez les couches FC d'un modèle pré-entraîné (~/data/models/resnet-50-kinetics.pth) sur UCF-101.

python main.py --root_path ~ /data --video_path ucf101_videos/jpg --annotation_path ucf101_01.json 
--result_path results --dataset ucf101 --n_classes 101 --n_pretrain_classes 700 
--pretrain_path models/resnet-50-kinetics.pth --ft_begin_module fc 
--model resnet --model_depth 50 --batch_size 128 --n_threads 4 --checkpoint 5