diff --git a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py new file mode 100644 index 0000000..29bddfd --- /dev/null +++ b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py @@ -0,0 +1,113 @@ +"""Base `Runner` config for high-quality-fall dataset.""" + +dataset_type = "HighQualityFallDataset" + +label_strategy = dict( + type="PriorityLabel", + label_description=dict( + names=["fall", "lying", "other"], + start_timestamp_names=["fall_start", "lying_start"], + end_timestamp_names=["fall_end", "lying_end"], + visible_names=["fall_visible", "lying_visible"], + other_class=2, + ), +) + +sampling_strategy = dict(type="UniformSampling", clip_len=10) + + +# TRAIN +ann_file_train = "data/Fall_Simulation_Data/annotations_train.csv" + +# TODO: Add shape comments +# TODO: Think about augmentation steps +train_pipeline = [ + dict(type="DecordInit"), + dict(type="ClipVideo"), + dict(type="SampleFrames", clip_len=16, frame_interval=4, num_clips=1), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(224, 224), keep_ratio=False), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] + +train_dataloader = dict( + batch_size=12, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=False, + sampler=dict(type="DefaultSampler", shuffle=True), + dataset=dict( + type=dataset_type, + sampling_strategy=sampling_strategy, + label_strategy=label_strategy, + ann_file=ann_file_train, + pipeline=train_pipeline, + num_classes=3, + # indices=100, + ), +) + +# VALIDATION +ann_file_val = "data/Fall_Simulation_Data/annotations_val.csv" + +val_pipeline = [ + dict(type="DecordInit"), + dict(type="ClipVideo"), + dict( + type="SampleFrames", clip_len=16, frame_interval=4, num_clips=1, test_mode=True + ), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="CenterCrop", crop_size=224), # From VideoMAEv2 repo + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] + +# val_dataloader = train_dataloader +val_dataloader = dict( + batch_size=12, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=False, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + sampling_strategy=sampling_strategy, + label_strategy=label_strategy, + ann_file=ann_file_val, + pipeline=val_pipeline, + num_classes=3, + ), +) + +# TEST +ann_file_test = "data/Fall_Simulation_Data/annotations_test.csv" + +test_pipeline = [ + dict(type="DecordInit"), + dict( + type="SampleFrames", clip_len=16, frame_interval=4, num_clips=5, test_mode=True + ), # From VideoMAEv2 repo + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="ThreeCrop", crop_size=224), # From VideoMAEv2 repo + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] + +test_dataloader = dict( + batch_size=1, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=False, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + sampling_strategy=sampling_strategy, + label_strategy=label_strategy, + ann_file=ann_file_test, + pipeline=test_pipeline, + num_classes=3, + ), +) diff --git a/configs/experiments/overfitting_run.py b/configs/experiments/overfitting_run.py index 06c3afc..06800f4 100644 --- a/configs/experiments/overfitting_run.py +++ b/configs/experiments/overfitting_run.py @@ -1,5 +1,5 @@ _base_ = [ - "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_base.py" + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py" ] EXPERIMENT_NAME = "overfitting_run" @@ -10,6 +10,7 @@ # Overrides train_dataloader = dict( + batch_size=1, sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( indices=100, @@ -19,6 +20,9 @@ ann_file_val = "data/Fall_Simulation_Data/annotations_train.csv" val_dataloader = dict( + num_workers=0, + persistent_workers=False, + batch_size=1, dataset=dict( ann_file=ann_file_val, indices=100, @@ -26,4 +30,4 @@ ) default_hooks = dict(checkpoint=dict(interval=0)) -custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=10)] +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=1)] diff --git a/configs/experiments/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py b/configs/experiments/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py new file mode 100644 index 0000000..a1bf91a --- /dev/null +++ b/configs/experiments/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py @@ -0,0 +1,78 @@ +_base_ = [ + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py" +] + +EXPERIMENT_NAME = "vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams" +visualizer = dict( + vis_backends=dict(save_dir=f"experiments/tensorboard/{EXPERIMENT_NAME}/") +) +work_dir = f"experiments/{EXPERIMENT_NAME}" + +# Overrides +default_hooks = dict(checkpoint=dict(interval=1)) + +# 1487 samples in val -> 92 batches per node -> We want around 10 images +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=300)] + +# Use ViT-B/16 +model = dict( + backbone=dict(embed_dims=768, depth=12, num_heads=12), + cls_head=dict(in_channels=768), +) +load_from = "weights/vit-base-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-3e7f93b2.pth" + +# Use frame_interval 8 +train_pipeline = [ + dict(type="DecordInit"), + dict(type="ClipVideo"), + dict( + type="SampleFrames", clip_len=16, frame_interval=8, num_clips=1 + ), # This has changed + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(224, 224), keep_ratio=False), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] + + +# Use Gaussian sampling +train_dataloader = dict( + dataset=dict( + sampling_strategy=dict( + type="GaussianSampling", + clip_len=5, + fallback_sampler=dict( + type="UniformSampling", clip_len=5, stride=5, overlap=False + ), + ), + drop_ratios=[0.0, 0.0, 0.30], + pipeline=train_pipeline, + ) +) +# We are not changing the val/test dataloaders since gaussian sampling requires labels +# and we cannot have a valid validation if we use labels in the preprocessing + +val_pipeline = [ + dict(type="DecordInit"), + dict(type="ClipVideo"), + dict( + type="SampleFrames", clip_len=16, frame_interval=8, num_clips=1, test_mode=True + ), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="CenterCrop", crop_size=224), # From VideoMAEv2 repo + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] + +val_dataloader = dict( + dataset=dict( + sampling_strategy=dict( + type="UniformSampling", clip_len=5, stride=0, overlap=False + ), + pipeline=val_pipeline, + ), +) diff --git a/configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py b/configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py new file mode 100644 index 0000000..b1d81d7 --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py @@ -0,0 +1,47 @@ +_base_ = [ + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py" +] + +EXPERIMENT_NAME = ( + "vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams" +) +visualizer = dict( + vis_backends=dict(save_dir=f"experiments/tensorboard/{EXPERIMENT_NAME}/") +) +work_dir = f"experiments/{EXPERIMENT_NAME}" + +# Overrides +default_hooks = dict(checkpoint=dict(interval=1)) + +# 1487 samples in val -> 92 batches per node -> We want around 10 images +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=300)] + +# Use ViT-B/16 +model = dict( + backbone=dict(embed_dims=768, depth=12, num_heads=12), + cls_head=dict(in_channels=768), +) +load_from = "weights/vit-base-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-3e7f93b2.pth" + +# Use Gaussian sampling +train_dataloader = dict( + dataset=dict( + sampling_strategy=dict( + type="GaussianSampling", + clip_len=5, + fallback_sampler=dict( + type="UniformSampling", clip_len=5, stride=5, overlap=False + ), + ), + drop_ratios=[0.0, 0.0, 0.30], + ) +) +# We are not changing the val/test dataloaders since gaussian sampling requires labels +# and we cannot have a valid validation if we use labels in the preprocessing +val_dataloader = dict( + dataset=dict( + sampling_strategy=dict( + type="UniformSampling", clip_len=5, stride=0, overlap=False + ), + ), +) diff --git a/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py new file mode 100644 index 0000000..3cc96a5 --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py @@ -0,0 +1,29 @@ +_base_ = [ + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py" +] + +EXPERIMENT_NAME = "vit-b_gaussian-sampling_priority-labeling_k400-hyperparams" +visualizer = dict( + vis_backends=dict(save_dir=f"experiments/tensorboard/{EXPERIMENT_NAME}/") +) +work_dir = f"experiments/{EXPERIMENT_NAME}" + +# Overrides +default_hooks = dict(checkpoint=dict(interval=1)) + +# 1487 samples in val -> 92 batches per node -> We want around 10 images +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=150)] + +# Use ViT-B/16 +model = dict( + backbone=dict(embed_dims=768, depth=12, num_heads=12), + cls_head=dict(in_channels=768), +) +load_from = "weights/vit-base-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-3e7f93b2.pth" + +# Use Gaussian sampling +train_dataloader = dict( + dataset=dict(sampling_strategy=dict(type="GaussianSampling", clip_len=10)) +) +# We are not changing the val/test dataloaders since gaussian sampling requires labels +# and we cannot have a valid validation if we use labels in the preprocessing diff --git a/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.py b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.py new file mode 100644 index 0000000..03352ac --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.py @@ -0,0 +1,30 @@ +_base_ = [ + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_base.py" +] + +EXPERIMENT_NAME = "vit-b_gaussian-sampling_priority-labeling_paper-hyperparams" +visualizer = dict( + vis_backends=dict(save_dir=f"experiments/tensorboard/{EXPERIMENT_NAME}/") +) +work_dir = f"experiments/{EXPERIMENT_NAME}" + +# Overrides +default_hooks = dict(checkpoint=dict(interval=3)) + +# 1487 samples in val -> 372 per node -> 124 batches per node -> We want around 10 images +# -> Interval = 124 / 10 = 12 +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=10)] + +# Use ViT-B/16 +model = dict( + backbone=dict(embed_dims=768, depth=12, num_heads=12), + cls_head=dict(in_channels=768), +) +load_from = "weights/vit-base-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-3e7f93b2.pth" + +# Use Gaussian sampling +train_dataloader = dict( + dataset=dict(sampling_strategy=dict(type="GaussianSampling", clip_len=10)) +) +# We are not changing the val/test dataloaders since gaussian sampling requires labels +# and we cannot have a valid validation if we use labels in the preprocessing diff --git a/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py new file mode 100644 index 0000000..e892cf2 --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py @@ -0,0 +1,40 @@ +_base_ = [ + "../models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_base.py" +] + +EXPERIMENT_NAME = ( + "vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss" +) +visualizer = dict( + vis_backends=dict(save_dir=f"experiments/tensorboard/{EXPERIMENT_NAME}/") +) +work_dir = f"experiments/{EXPERIMENT_NAME}" + +# Overrides +default_hooks = dict(checkpoint=dict(interval=3)) + +# 1487 samples in val -> 372 per node -> 124 batches per node -> We want around 10 images +# -> Interval = 124 / 10 = 12 +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=10)] + +# Use ViT-B/16 +# Add weighted CE loss +# weight_for_class_i = total_samples / (num_samples_in_class_i * num_classes) +model = dict( + backbone=dict(embed_dims=768, depth=12, num_heads=12), + cls_head=dict( + in_channels=768, + loss_cls=dict( + type="CrossEntropyLoss", + class_weight=[26.38235294117647, 37.901408450704224, 3.7168508287292816], + ), + ), +) +load_from = "weights/vit-base-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-3e7f93b2.pth" + +# Use Gaussian sampling +train_dataloader = dict( + dataset=dict(sampling_strategy=dict(type="GaussianSampling", clip_len=10)) +) +# We are not changing the val/test dataloaders since gaussian sampling requires labels +# and we cannot have a valid validation if we use labels in the preprocessing diff --git a/configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py b/configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py new file mode 100644 index 0000000..cbcf715 --- /dev/null +++ b/configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py @@ -0,0 +1,416 @@ +_base_ = [ + "../default_runtime.py", + "../datasets/high-quality-fall_runner_k400-hyperparams.py", +] + +# Finetuning parameters are from VideoMAEv2 repo +# https://github.com/OpenGVLab/VideoMAEv2/blob/master/scripts/finetune/vit_b_k400_ft.sh + + +# ViT-S-P16 +model = dict( + type="Recognizer3D", + backbone=dict( + type="VisionTransformer", + img_size=224, + patch_size=16, + embed_dims=384, + depth=12, + num_heads=6, + mlp_ratio=4, + qkv_bias=True, + num_frames=16, + norm_cfg=dict(type="LN", eps=1e-6), + drop_path_rate=0.3, # From VideoMAEv2 repo + ), + cls_head=dict( + type="TimeSformerHead", + num_classes=3, + in_channels=384, + average_clips="prob", + topk=(1,), + ), + data_preprocessor=dict( + type="ActionDataPreprocessor", + mean=[102.17311096191406, 98.78225708007812, 92.68714141845703], + std=[58.04566192626953, 57.004024505615234, 57.3704948425293], + format_shape="NCTHW", + ), +) + +# Loading weights +load_from = "weights/vit-small-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-25c748fd.pth" + +# TRAINING CONFIG +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=90, val_interval=1) + +# TODO: Think about fine-tuning param scheduler +param_scheduler = [ + dict( + type="LinearLR", + by_epoch=True, + convert_to_iter_based=True, + start_factor=1e-3, + end_factor=1, + begin=0, + end=5, + ), # From VideoMAEv2 repo - Warmup + dict( + type="CosineAnnealingLR", + by_epoch=True, + convert_to_iter_based=True, + eta_min=1e-6, + begin=5, + end=35, + ), +] + +auto_scale_lr = dict(enable=True, base_batch_size=256) + +# Layer Decay and Weight Decay module configs +vit_b_layer_decay_75_custom_keys = { + "backbone.patch_embed.projection.weight": { + "lr_mult": 0.023757264018058777, + "decay_mult": 1, + }, + "backbone.patch_embed.projection.bias": { + "lr_mult": 0.023757264018058777, + "decay_mult": 0, + }, + "backbone.blocks.0.norm1.weight": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.norm1.bias": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.attn.q_bias": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.attn.v_bias": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.attn.proj.bias": { + "lr_mult": 0.03167635202407837, + "decay_mult": 0, + }, + "backbone.blocks.0.norm2.weight": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.norm2.bias": {"lr_mult": 0.03167635202407837, "decay_mult": 0}, + "backbone.blocks.0.mlp.layers.0.0.bias": { + "lr_mult": 0.03167635202407837, + "decay_mult": 0, + }, + "backbone.blocks.0.mlp.layers.1.bias": { + "lr_mult": 0.03167635202407837, + "decay_mult": 0, + }, + "backbone.blocks.0.attn.qkv.weight": { + "lr_mult": 0.03167635202407837, + "decay_mult": 1, + }, + "backbone.blocks.0.attn.proj.weight": { + "lr_mult": 0.03167635202407837, + "decay_mult": 1, + }, + "backbone.blocks.0.mlp.layers.0.0.weight": { + "lr_mult": 0.03167635202407837, + "decay_mult": 1, + }, + "backbone.blocks.0.mlp.layers.1.weight": { + "lr_mult": 0.03167635202407837, + "decay_mult": 1, + }, + "backbone.blocks.1.norm1.weight": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.norm1.bias": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.attn.q_bias": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.attn.v_bias": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.attn.proj.bias": { + "lr_mult": 0.04223513603210449, + "decay_mult": 0, + }, + "backbone.blocks.1.norm2.weight": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.norm2.bias": {"lr_mult": 0.04223513603210449, "decay_mult": 0}, + "backbone.blocks.1.mlp.layers.0.0.bias": { + "lr_mult": 0.04223513603210449, + "decay_mult": 0, + }, + "backbone.blocks.1.mlp.layers.1.bias": { + "lr_mult": 0.04223513603210449, + "decay_mult": 0, + }, + "backbone.blocks.1.attn.qkv.weight": { + "lr_mult": 0.04223513603210449, + "decay_mult": 1, + }, + "backbone.blocks.1.attn.proj.weight": { + "lr_mult": 0.04223513603210449, + "decay_mult": 1, + }, + "backbone.blocks.1.mlp.layers.0.0.weight": { + "lr_mult": 0.04223513603210449, + "decay_mult": 1, + }, + "backbone.blocks.1.mlp.layers.1.weight": { + "lr_mult": 0.04223513603210449, + "decay_mult": 1, + }, + "backbone.blocks.2.norm1.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 0, + }, + "backbone.blocks.2.norm1.bias": {"lr_mult": 0.056313514709472656, "decay_mult": 0}, + "backbone.blocks.2.attn.q_bias": {"lr_mult": 0.056313514709472656, "decay_mult": 0}, + "backbone.blocks.2.attn.v_bias": {"lr_mult": 0.056313514709472656, "decay_mult": 0}, + "backbone.blocks.2.attn.proj.bias": { + "lr_mult": 0.056313514709472656, + "decay_mult": 0, + }, + "backbone.blocks.2.norm2.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 0, + }, + "backbone.blocks.2.norm2.bias": {"lr_mult": 0.056313514709472656, "decay_mult": 0}, + "backbone.blocks.2.mlp.layers.0.0.bias": { + "lr_mult": 0.056313514709472656, + "decay_mult": 0, + }, + "backbone.blocks.2.mlp.layers.1.bias": { + "lr_mult": 0.056313514709472656, + "decay_mult": 0, + }, + "backbone.blocks.2.attn.qkv.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 1, + }, + "backbone.blocks.2.attn.proj.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 1, + }, + "backbone.blocks.2.mlp.layers.0.0.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 1, + }, + "backbone.blocks.2.mlp.layers.1.weight": { + "lr_mult": 0.056313514709472656, + "decay_mult": 1, + }, + "backbone.blocks.3.norm1.weight": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.norm1.bias": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.attn.q_bias": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.attn.v_bias": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.attn.proj.bias": { + "lr_mult": 0.07508468627929688, + "decay_mult": 0, + }, + "backbone.blocks.3.norm2.weight": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.norm2.bias": {"lr_mult": 0.07508468627929688, "decay_mult": 0}, + "backbone.blocks.3.mlp.layers.0.0.bias": { + "lr_mult": 0.07508468627929688, + "decay_mult": 0, + }, + "backbone.blocks.3.mlp.layers.1.bias": { + "lr_mult": 0.07508468627929688, + "decay_mult": 0, + }, + "backbone.blocks.3.attn.qkv.weight": { + "lr_mult": 0.07508468627929688, + "decay_mult": 1, + }, + "backbone.blocks.3.attn.proj.weight": { + "lr_mult": 0.07508468627929688, + "decay_mult": 1, + }, + "backbone.blocks.3.mlp.layers.0.0.weight": { + "lr_mult": 0.07508468627929688, + "decay_mult": 1, + }, + "backbone.blocks.3.mlp.layers.1.weight": { + "lr_mult": 0.07508468627929688, + "decay_mult": 1, + }, + "backbone.blocks.4.norm1.weight": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.norm1.bias": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.attn.q_bias": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.attn.v_bias": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.attn.proj.bias": { + "lr_mult": 0.1001129150390625, + "decay_mult": 0, + }, + "backbone.blocks.4.norm2.weight": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.norm2.bias": {"lr_mult": 0.1001129150390625, "decay_mult": 0}, + "backbone.blocks.4.mlp.layers.0.0.bias": { + "lr_mult": 0.1001129150390625, + "decay_mult": 0, + }, + "backbone.blocks.4.mlp.layers.1.bias": { + "lr_mult": 0.1001129150390625, + "decay_mult": 0, + }, + "backbone.blocks.4.attn.qkv.weight": { + "lr_mult": 0.1001129150390625, + "decay_mult": 1, + }, + "backbone.blocks.4.attn.proj.weight": { + "lr_mult": 0.1001129150390625, + "decay_mult": 1, + }, + "backbone.blocks.4.mlp.layers.0.0.weight": { + "lr_mult": 0.1001129150390625, + "decay_mult": 1, + }, + "backbone.blocks.4.mlp.layers.1.weight": { + "lr_mult": 0.1001129150390625, + "decay_mult": 1, + }, + "backbone.blocks.5.norm1.weight": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.norm1.bias": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.attn.q_bias": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.attn.v_bias": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.attn.proj.bias": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.norm2.weight": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.norm2.bias": {"lr_mult": 0.13348388671875, "decay_mult": 0}, + "backbone.blocks.5.mlp.layers.0.0.bias": { + "lr_mult": 0.13348388671875, + "decay_mult": 0, + }, + "backbone.blocks.5.mlp.layers.1.bias": { + "lr_mult": 0.13348388671875, + "decay_mult": 0, + }, + "backbone.blocks.5.attn.qkv.weight": {"lr_mult": 0.13348388671875, "decay_mult": 1}, + "backbone.blocks.5.attn.proj.weight": { + "lr_mult": 0.13348388671875, + "decay_mult": 1, + }, + "backbone.blocks.5.mlp.layers.0.0.weight": { + "lr_mult": 0.13348388671875, + "decay_mult": 1, + }, + "backbone.blocks.5.mlp.layers.1.weight": { + "lr_mult": 0.13348388671875, + "decay_mult": 1, + }, + "backbone.blocks.6.norm1.weight": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.norm1.bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.attn.q_bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.attn.v_bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.attn.proj.bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.norm2.weight": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.norm2.bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.mlp.layers.0.0.bias": { + "lr_mult": 0.177978515625, + "decay_mult": 0, + }, + "backbone.blocks.6.mlp.layers.1.bias": {"lr_mult": 0.177978515625, "decay_mult": 0}, + "backbone.blocks.6.attn.qkv.weight": {"lr_mult": 0.177978515625, "decay_mult": 1}, + "backbone.blocks.6.attn.proj.weight": {"lr_mult": 0.177978515625, "decay_mult": 1}, + "backbone.blocks.6.mlp.layers.0.0.weight": { + "lr_mult": 0.177978515625, + "decay_mult": 1, + }, + "backbone.blocks.6.mlp.layers.1.weight": { + "lr_mult": 0.177978515625, + "decay_mult": 1, + }, + "backbone.blocks.7.norm1.weight": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.norm1.bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.attn.q_bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.attn.v_bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.attn.proj.bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.norm2.weight": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.norm2.bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.mlp.layers.0.0.bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.mlp.layers.1.bias": {"lr_mult": 0.2373046875, "decay_mult": 0}, + "backbone.blocks.7.attn.qkv.weight": {"lr_mult": 0.2373046875, "decay_mult": 1}, + "backbone.blocks.7.attn.proj.weight": {"lr_mult": 0.2373046875, "decay_mult": 1}, + "backbone.blocks.7.mlp.layers.0.0.weight": { + "lr_mult": 0.2373046875, + "decay_mult": 1, + }, + "backbone.blocks.7.mlp.layers.1.weight": {"lr_mult": 0.2373046875, "decay_mult": 1}, + "backbone.blocks.8.norm1.weight": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.norm1.bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.attn.q_bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.attn.v_bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.attn.proj.bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.norm2.weight": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.norm2.bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.mlp.layers.0.0.bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.mlp.layers.1.bias": {"lr_mult": 0.31640625, "decay_mult": 0}, + "backbone.blocks.8.attn.qkv.weight": {"lr_mult": 0.31640625, "decay_mult": 1}, + "backbone.blocks.8.attn.proj.weight": {"lr_mult": 0.31640625, "decay_mult": 1}, + "backbone.blocks.8.mlp.layers.0.0.weight": {"lr_mult": 0.31640625, "decay_mult": 1}, + "backbone.blocks.8.mlp.layers.1.weight": {"lr_mult": 0.31640625, "decay_mult": 1}, + "backbone.blocks.9.norm1.weight": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.norm1.bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.attn.q_bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.attn.v_bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.attn.proj.bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.norm2.weight": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.norm2.bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.mlp.layers.0.0.bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.mlp.layers.1.bias": {"lr_mult": 0.421875, "decay_mult": 0}, + "backbone.blocks.9.attn.qkv.weight": {"lr_mult": 0.421875, "decay_mult": 1}, + "backbone.blocks.9.attn.proj.weight": {"lr_mult": 0.421875, "decay_mult": 1}, + "backbone.blocks.9.mlp.layers.0.0.weight": {"lr_mult": 0.421875, "decay_mult": 1}, + "backbone.blocks.9.mlp.layers.1.weight": {"lr_mult": 0.421875, "decay_mult": 1}, + "backbone.blocks.10.norm1.weight": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.norm1.bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.attn.q_bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.attn.v_bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.attn.proj.bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.norm2.weight": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.norm2.bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.mlp.layers.0.0.bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.mlp.layers.1.bias": {"lr_mult": 0.5625, "decay_mult": 0}, + "backbone.blocks.10.attn.qkv.weight": {"lr_mult": 0.5625, "decay_mult": 1}, + "backbone.blocks.10.attn.proj.weight": {"lr_mult": 0.5625, "decay_mult": 1}, + "backbone.blocks.10.mlp.layers.0.0.weight": {"lr_mult": 0.5625, "decay_mult": 1}, + "backbone.blocks.10.mlp.layers.1.weight": {"lr_mult": 0.5625, "decay_mult": 1}, + "backbone.blocks.11.norm1.weight": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.norm1.bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.attn.q_bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.attn.v_bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.attn.proj.bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.norm2.weight": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.norm2.bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.mlp.layers.0.0.bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.mlp.layers.1.bias": {"lr_mult": 0.75, "decay_mult": 0}, + "backbone.blocks.11.attn.qkv.weight": {"lr_mult": 0.75, "decay_mult": 1}, + "backbone.blocks.11.attn.proj.weight": {"lr_mult": 0.75, "decay_mult": 1}, + "backbone.blocks.11.mlp.layers.0.0.weight": {"lr_mult": 0.75, "decay_mult": 1}, + "backbone.blocks.11.mlp.layers.1.weight": {"lr_mult": 0.75, "decay_mult": 1}, + "backbone.fc_norm.weight": {"lr_mult": 1.0, "decay_mult": 0}, + "backbone.fc_norm.bias": {"lr_mult": 1.0, "decay_mult": 0}, + "cls_head.fc_cls.bias": {"lr_mult": 1.0, "decay_mult": 0}, + "cls_head.fc_cls.weight": {"lr_mult": 1.0, "decay_mult": 1}, +} + + +optim_wrapper = dict( + type="AmpOptimWrapper", # Automatic Mixed Precision may speed up trainig + optimizer=dict( + type="AdamW", # From VideoMAEv2 repo + lr=7e-4, # From VideoMAEv2 repo + weight_decay=0.05, # From VideoMAEv2 repo + betas=(0.9, 0.999), # From VideoMAEv2 repo + ), + paramwise_cfg=dict(custom_keys=vit_b_layer_decay_75_custom_keys), + # clip_grad=dict(max_norm=5, norm_type=2), # From VideoMAEv2 repo +) + +# VALIDATION CONFIG +val_evaluator = dict( + type="AddAccMetric", + metric_list=( + "unweighted_average_f1", + "per_class_f1", + "per_class_precision", + "per_class_recall", + ), +) +val_cfg = dict(type="ValLoop") + + +# TEST CONFIG +test_evaluator = dict( + type="AddAccMetric", + metric_list=( + "unweighted_average_f1", + "per_class_f1", + "per_class_precision", + "per_class_recall", + ), +) +test_cfg = dict(type="TestLoop") diff --git a/experiments.dvc b/experiments.dvc index 98f6b2a..ff1b824 100644 --- a/experiments.dvc +++ b/experiments.dvc @@ -1,6 +1,6 @@ outs: -- md5: 004d25dfcdbec8b9a95e429079227b93.dir - size: 1022832432 - nfiles: 9 +- md5: 55075530cd6a7d51a35547b6eebafda0.dir + size: 21652483819 + nfiles: 97 hash: md5 path: experiments diff --git a/job_scripts/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh b/job_scripts/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh new file mode 100644 index 0000000..07c096e --- /dev/null +++ b/job_scripts/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash +#SBATCH -A NAISS2023-22-1160 -p alvis +#SBATCH -N 1 --gpus-per-node=A40:1 +#SBATCH --time=48:00:00 + +apptainer exec \ + --env PYTHONPATH=$(pwd) \ + containers/c3se_job_container.sif \ + python mmaction2/tools/train.py \ + configs/experiments/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py \ No newline at end of file diff --git a/job_scripts/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh b/job_scripts/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh new file mode 100644 index 0000000..0fafc47 --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash +#SBATCH -A NAISS2023-22-1160 -p alvis +#SBATCH -N 1 --gpus-per-node=A40:1 +#SBATCH --time=48:00:00 + +apptainer exec \ + --env PYTHONPATH=$(pwd) \ + containers/c3se_job_container.sif \ + python mmaction2/tools/train.py \ + configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py \ No newline at end of file diff --git a/job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh b/job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh new file mode 100644 index 0000000..fc47fdd --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash +#SBATCH -A NAISS2023-22-1160 -p alvis +#SBATCH -N 1 --gpus-per-node=A40:1 +#SBATCH --time=24:00:00 + +apptainer exec \ + --env PYTHONPATH=$(pwd) \ + containers/c3se_job_container.sif \ + python mmaction2/tools/train.py \ + configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py \ + --resume auto \ No newline at end of file diff --git a/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh b/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh new file mode 100644 index 0000000..ce03cdb --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +#SBATCH -A NAISS2023-22-1160 -p alvis +#SBATCH -N 1 --gpus-per-node=A40:4 +#SBATCH --time=24:00:00 + +apptainer exec \ + --env PYTHONPATH=$(pwd) \ + containers/c3se_job_container.sif \ + python -m torch.distributed.launch --nproc_per_node=4 \ + mmaction2/tools/train.py \ + configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.py \ + --launcher pytorch --resume auto \ No newline at end of file diff --git a/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.sh b/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.sh new file mode 100644 index 0000000..0603a02 --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +#SBATCH -A NAISS2023-22-1160 -p alvis +#SBATCH -N 1 --gpus-per-node=A40:4 +#SBATCH --time=24:00:00 + +apptainer exec \ + --env PYTHONPATH=$(pwd) \ + containers/c3se_job_container.sif \ + python -m torch.distributed.launch --nproc_per_node=4 \ + mmaction2/tools/train.py \ + configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py \ + --launcher pytorch \ No newline at end of file diff --git a/notebooks/custom_keys_optimizer.ipynb b/notebooks/custom_keys_optimizer.ipynb new file mode 100644 index 0000000..31557cb --- /dev/null +++ b/notebooks/custom_keys_optimizer.ipynb @@ -0,0 +1,938 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Custom Keys Optimizer\n", + "\n", + "Here we create the custom keys dictionary for the runner config.\n", + "It is necessary to get layer decay." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "LAYER_DECAY = 0.75\n", + "MODEL_DEPTH = 12\n", + "BASE_WEIGHT_DECAY = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12/04 22:32:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - \n", + "------------------------------------------------------------\n", + "System environment:\n", + " sys.platform: darwin\n", + " Python: 3.10.13 | packaged by conda-forge | (main, Oct 26 2023, 18:09:17) [Clang 16.0.6 ]\n", + " CUDA available: False\n", + " numpy_random_seed: 104644062\n", + " GCC: Apple clang version 15.0.0 (clang-1500.0.40.1)\n", + " PyTorch: 2.1.1\n", + " PyTorch compiling details: PyTorch built with:\n", + " - GCC 4.2\n", + " - C++ Version: 201703\n", + " - clang 13.1.6\n", + " - LAPACK is enabled (usually provided by MKL)\n", + " - NNPACK is enabled\n", + " - CPU capability usage: NO AVX\n", + " - Build settings: BLAS_INFO=accelerate, BUILD_TYPE=Release, CXX_COMPILER=/Applications/Xcode_13.3.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOCUPTI -DLIBKINETO_NOROCTRACER -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_PYTORCH_METAL_EXPORT -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DUSE_COREML_DELEGATE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=braced-scalar-init -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wvla-extension -Wnewline-eof -Winconsistent-missing-override -Winconsistent-missing-destructor-override -Wno-range-loop-analysis -Wno-pass-failed -Wsuggest-override -Wno-error=pedantic -Wno-error=old-style-cast -Wno-error=inconsistent-missing-override -Wno-error=inconsistent-missing-destructor-override -Wconstant-conversion -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-missing-braces -Wunused-lambda-capture -Qunused-arguments -fcolor-diagnostics -faligned-new -Wno-unused-but-set-variable -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -DUSE_MPS -Wno-unused-private-field -Wno-missing-braces, LAPACK_INFO=accelerate, TORCH_DISABLE_GPU_ASSERTS=OFF, TORCH_VERSION=2.1.1, USE_CUDA=0, USE_CUDNN=OFF, USE_EIGEN_FOR_BLAS=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=OFF, USE_MKLDNN=OFF, USE_MPI=OFF, USE_NCCL=OFF, USE_NNPACK=ON, USE_OPENMP=OFF, USE_ROCM=OFF, \n", + "\n", + " TorchVision: 0.16.1\n", + " OpenCV: 4.8.1\n", + " MMEngine: 0.10.1\n", + "\n", + "Runtime environment:\n", + " cudnn_benchmark: False\n", + " mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}\n", + " dist_cfg: {'backend': 'nccl'}\n", + " seed: 104644062\n", + " Distributed launcher: none\n", + " Distributed training: False\n", + " GPU number: 1\n", + "------------------------------------------------------------\n", + "\n", + "12/04 22:32:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Config:\n", + "ann_file_test = 'data/Fall_Simulation_Data/annotations_test.csv'\n", + "ann_file_train = 'data/Fall_Simulation_Data/annotations_train.csv'\n", + "ann_file_val = 'data/Fall_Simulation_Data/annotations_val.csv'\n", + "custom_hooks = [\n", + " dict(enable=True, type='CustomVisualizationHook'),\n", + "]\n", + "custom_imports = dict(\n", + " allow_failed_imports=False,\n", + " imports=[\n", + " 'datasets',\n", + " 'evaluation',\n", + " 'visualization',\n", + " ])\n", + "dataset_type = 'HighQualityFallDataset'\n", + "default_hooks = dict(\n", + " checkpoint=dict(\n", + " by_epoch=True,\n", + " interval=3,\n", + " max_keep_ckpts=3,\n", + " save_best='auto',\n", + " type='CheckpointHook'),\n", + " logger=dict(type='LoggerHook'),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " runtime_info=dict(type='RuntimeInfoHook'),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " sync_buffers=dict(type='SyncBuffersHook'),\n", + " timer=dict(type='IterTimerHook'))\n", + "default_scope = 'mmaction'\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " dist_cfg=dict(backend='nccl'),\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))\n", + "label_strategy = dict(\n", + " label_description=dict(\n", + " end_timestamp_names=[\n", + " 'fall_end',\n", + " 'lying_end',\n", + " ],\n", + " names=[\n", + " 'fall',\n", + " 'lying',\n", + " 'other',\n", + " ],\n", + " other_class=2,\n", + " start_timestamp_names=[\n", + " 'fall_start',\n", + " 'lying_start',\n", + " ],\n", + " visible_names=[\n", + " 'fall_visible',\n", + " 'lying_visible',\n", + " ]),\n", + " type='PriorityLabel')\n", + "launcher = 'none'\n", + "load_from = 'weights/vit-small-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_20230510-25c748fd.pth'\n", + "log_level = 'INFO'\n", + "log_processor = dict(by_epoch=True, type='LogProcessor', window_size=10)\n", + "model = dict(\n", + " backbone=dict(\n", + " depth=12,\n", + " drop_path_rate=0.3,\n", + " embed_dims=384,\n", + " img_size=224,\n", + " mlp_ratio=4,\n", + " norm_cfg=dict(eps=1e-06, type='LN'),\n", + " num_frames=16,\n", + " num_heads=6,\n", + " patch_size=16,\n", + " qkv_bias=True,\n", + " type='VisionTransformer'),\n", + " cls_head=dict(\n", + " average_clips='prob',\n", + " in_channels=384,\n", + " num_classes=3,\n", + " topk=(1, ),\n", + " type='TimeSformerHead'),\n", + " data_preprocessor=dict(\n", + " format_shape='NCTHW',\n", + " mean=[\n", + " 102.17311096191406,\n", + " 98.78225708007812,\n", + " 92.68714141845703,\n", + " ],\n", + " std=[\n", + " 58.04566192626953,\n", + " 57.004024505615234,\n", + " 57.3704948425293,\n", + " ],\n", + " type='ActionDataPreprocessor'),\n", + " type='Recognizer3D')\n", + "optim_wrapper = dict(\n", + " clip_grad=dict(max_norm=5, norm_type=2),\n", + " optimizer=dict(\n", + " betas=(\n", + " 0.9,\n", + " 0.999,\n", + " ), lr=0.001, type='AdamW', weight_decay=0.1),\n", + " type='AmpOptimWrapper')\n", + "param_scheduler = [\n", + " dict(\n", + " begin=0,\n", + " by_epoch=True,\n", + " convert_to_iter_based=True,\n", + " end=5,\n", + " end_factor=1,\n", + " start_factor=0.001,\n", + " type='LinearLR'),\n", + " dict(\n", + " begin=5,\n", + " by_epoch=True,\n", + " convert_to_iter_based=True,\n", + " end=35,\n", + " eta_min=1e-06,\n", + " type='CosineAnnealingLR'),\n", + "]\n", + "resume = False\n", + "sampling_strategy = dict(clip_len=10, type='UniformSampling')\n", + "test_cfg = dict(type='TestLoop')\n", + "test_dataloader = dict(\n", + " batch_size=3,\n", + " dataset=dict(\n", + " ann_file='data/Fall_Simulation_Data/annotations_test.csv',\n", + " label_strategy=dict(\n", + " label_description=dict(\n", + " end_timestamp_names=[\n", + " 'fall_end',\n", + " 'lying_end',\n", + " ],\n", + " names=[\n", + " 'fall',\n", + " 'lying',\n", + " 'other',\n", + " ],\n", + " other_class=2,\n", + " start_timestamp_names=[\n", + " 'fall_start',\n", + " 'lying_start',\n", + " ],\n", + " visible_names=[\n", + " 'fall_visible',\n", + " 'lying_visible',\n", + " ]),\n", + " type='PriorityLabel'),\n", + " num_classes=3,\n", + " pipeline=[\n", + " dict(type='DecordInit'),\n", + " dict(\n", + " clip_len=16,\n", + " frame_interval=4,\n", + " num_clips=5,\n", + " test_mode=True,\n", + " type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(crop_size=224, type='ThreeCrop'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + " ],\n", + " sampling_strategy=dict(clip_len=10, type='UniformSampling'),\n", + " type='HighQualityFallDataset'),\n", + " num_workers=8,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "test_evaluator = dict(\n", + " metric_list=(\n", + " 'unweighted_average_f1',\n", + " 'per_class_f1',\n", + " 'per_class_precision',\n", + " 'per_class_recall',\n", + " ),\n", + " type='AddAccMetric')\n", + "test_pipeline = [\n", + " dict(type='DecordInit'),\n", + " dict(\n", + " clip_len=16,\n", + " frame_interval=4,\n", + " num_clips=5,\n", + " test_mode=True,\n", + " type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(crop_size=224, type='ThreeCrop'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + "]\n", + "train_cfg = dict(max_epochs=35, type='EpochBasedTrainLoop', val_interval=1)\n", + "train_dataloader = dict(\n", + " batch_size=3,\n", + " dataset=dict(\n", + " ann_file='data/Fall_Simulation_Data/annotations_train.csv',\n", + " label_strategy=dict(\n", + " label_description=dict(\n", + " end_timestamp_names=[\n", + " 'fall_end',\n", + " 'lying_end',\n", + " ],\n", + " names=[\n", + " 'fall',\n", + " 'lying',\n", + " 'other',\n", + " ],\n", + " other_class=2,\n", + " start_timestamp_names=[\n", + " 'fall_start',\n", + " 'lying_start',\n", + " ],\n", + " visible_names=[\n", + " 'fall_visible',\n", + " 'lying_visible',\n", + " ]),\n", + " type='PriorityLabel'),\n", + " num_classes=3,\n", + " pipeline=[\n", + " dict(type='DecordInit'),\n", + " dict(type='ClipVideo'),\n", + " dict(\n", + " clip_len=16,\n", + " frame_interval=4,\n", + " num_clips=1,\n", + " type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(size=224, type='RandomCrop'),\n", + " dict(keep_ratio=False, scale=(\n", + " 224,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(flip_ratio=0.5, type='Flip'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + " ],\n", + " sampling_strategy=dict(clip_len=10, type='UniformSampling'),\n", + " type='HighQualityFallDataset'),\n", + " num_workers=8,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=True, type='DefaultSampler'))\n", + "train_pipeline = [\n", + " dict(type='DecordInit'),\n", + " dict(type='ClipVideo'),\n", + " dict(clip_len=16, frame_interval=4, num_clips=1, type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(size=224, type='RandomCrop'),\n", + " dict(keep_ratio=False, scale=(\n", + " 224,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(flip_ratio=0.5, type='Flip'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + "]\n", + "val_cfg = dict(type='ValLoop')\n", + "val_dataloader = dict(\n", + " batch_size=3,\n", + " dataset=dict(\n", + " ann_file='data/Fall_Simulation_Data/annotations_val.csv',\n", + " label_strategy=dict(\n", + " label_description=dict(\n", + " end_timestamp_names=[\n", + " 'fall_end',\n", + " 'lying_end',\n", + " ],\n", + " names=[\n", + " 'fall',\n", + " 'lying',\n", + " 'other',\n", + " ],\n", + " other_class=2,\n", + " start_timestamp_names=[\n", + " 'fall_start',\n", + " 'lying_start',\n", + " ],\n", + " visible_names=[\n", + " 'fall_visible',\n", + " 'lying_visible',\n", + " ]),\n", + " type='PriorityLabel'),\n", + " num_classes=3,\n", + " pipeline=[\n", + " dict(type='DecordInit'),\n", + " dict(type='ClipVideo'),\n", + " dict(\n", + " clip_len=16,\n", + " frame_interval=4,\n", + " num_clips=1,\n", + " test_mode=True,\n", + " type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(crop_size=224, type='CenterCrop'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + " ],\n", + " sampling_strategy=dict(clip_len=10, type='UniformSampling'),\n", + " type='HighQualityFallDataset'),\n", + " num_workers=8,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "val_evaluator = dict(\n", + " metric_list=(\n", + " 'unweighted_average_f1',\n", + " 'per_class_f1',\n", + " 'per_class_precision',\n", + " 'per_class_recall',\n", + " ),\n", + " type='AddAccMetric')\n", + "val_pipeline = [\n", + " dict(type='DecordInit'),\n", + " dict(type='ClipVideo'),\n", + " dict(\n", + " clip_len=16,\n", + " frame_interval=4,\n", + " num_clips=1,\n", + " test_mode=True,\n", + " type='SampleFrames'),\n", + " dict(type='DecordDecode'),\n", + " dict(scale=(\n", + " -1,\n", + " 224,\n", + " ), type='Resize'),\n", + " dict(crop_size=224, type='CenterCrop'),\n", + " dict(input_format='NCTHW', type='FormatShape'),\n", + " dict(type='PackActionInputs'),\n", + "]\n", + "vis_backends = dict(\n", + " save_dir='experiments/tensorboard', type='TensorboardVisBackend')\n", + "visualizer = dict(\n", + " type='ActionVisualizer',\n", + " vis_backends=dict(\n", + " save_dir='experiments/tensorboard', type='TensorboardVisBackend'))\n", + "work_dir = 'experiments'\n", + "\n", + "12/04 22:32:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n", + "12/04 22:32:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Hooks will be executed in the following order:\n", + "before_run:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "before_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_train_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DistSamplerSeedHook \n", + " -------------------- \n", + "before_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_train_epoch:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) SyncBuffersHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_val_epoch:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) SyncBuffersHook \n", + " -------------------- \n", + "before_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) CustomVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_val_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_test_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) CustomVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_run:\n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n" + ] + } + ], + "source": [ + "from mmengine.runner import Runner\n", + "from mmengine.config import Config\n", + "\n", + "runner_cfg = Config.fromfile(\n", + " \"configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_base.py\"\n", + ")\n", + "runner = Runner.from_cfg(runner_cfg)\n", + "model = runner.model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Functions from the VideoMAE repo\n", + "\n", + "\n", + "def get_num_layer_for_vit(var_name, num_max_layer):\n", + " if var_name in (\"backbone.cls_token\", \"backbone.mask_token\", \"backbone.pos_embed\"):\n", + " return 0\n", + " elif var_name.startswith(\"backbone.patch_embed\"):\n", + " return 0\n", + " elif var_name.startswith(\"backbone.rel_pos_bias\"):\n", + " return num_max_layer - 1\n", + " elif var_name.startswith(\"backbone.blocks\"):\n", + " layer_id = int(var_name.split(\".\")[2])\n", + " return layer_id + 1\n", + " else:\n", + " return num_max_layer - 1\n", + "\n", + "\n", + "class LayerDecayValueAssigner(object):\n", + " def __init__(self, values):\n", + " self.values = values\n", + "\n", + " def get_scale(self, layer_id):\n", + " return self.values[layer_id]\n", + "\n", + " def get_layer_id(self, var_name):\n", + " return get_num_layer_for_vit(var_name, len(self.values))\n", + "\n", + "\n", + "def get_parameter_groups(\n", + " model, weight_decay=1e-5, skip_list=(), get_num_layer=None, get_layer_scale=None\n", + "):\n", + " parameter_group_names = {}\n", + " parameter_group_vars = {}\n", + "\n", + " for name, param in model.named_parameters():\n", + " if not param.requires_grad:\n", + " continue # frozen weights\n", + " if (\n", + " len(param.shape) == 1\n", + " or name.endswith(\".bias\")\n", + " or name.endswith(\".scale\")\n", + " or name in skip_list\n", + " ):\n", + " group_name = \"no_decay\"\n", + " this_weight_decay = 0.0\n", + " else:\n", + " group_name = \"decay\"\n", + " this_weight_decay = weight_decay\n", + " if get_num_layer is not None:\n", + " layer_id = get_num_layer(name)\n", + " group_name = \"layer_%d_%s\" % (layer_id, group_name)\n", + " else:\n", + " layer_id = None\n", + "\n", + " if group_name not in parameter_group_names:\n", + " if get_layer_scale is not None:\n", + " scale = get_layer_scale(layer_id)\n", + " else:\n", + " scale = 1.0\n", + "\n", + " parameter_group_names[group_name] = {\n", + " \"weight_decay\": this_weight_decay,\n", + " \"params\": [],\n", + " \"lr_scale\": scale,\n", + " }\n", + " parameter_group_vars[group_name] = {\n", + " \"weight_decay\": this_weight_decay,\n", + " \"params\": [],\n", + " \"lr_scale\": scale,\n", + " }\n", + "\n", + " parameter_group_vars[group_name][\"params\"].append(param)\n", + " parameter_group_names[group_name][\"params\"].append(name)\n", + "\n", + " return parameter_group_names" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the parameter groups from VideoMAE\n", + "\n", + "assigner = LayerDecayValueAssigner(\n", + " list(LAYER_DECAY ** (MODEL_DEPTH + 1 - i) for i in range(MODEL_DEPTH + 2))\n", + ")\n", + "\n", + "groups = get_parameter_groups(\n", + " model,\n", + " BASE_WEIGHT_DECAY,\n", + " get_num_layer=assigner.get_layer_id,\n", + " get_layer_scale=assigner.get_scale,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'backbone.patch_embed.projection.weight': {'lr_mult': 0.023757264018058777,\n", + " 'decay_mult': 1},\n", + " 'backbone.patch_embed.projection.bias': {'lr_mult': 0.023757264018058777,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.norm1.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.norm1.bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.attn.q_bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.attn.v_bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.attn.proj.bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.norm2.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.norm2.bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.mlp.layers.0.0.bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.mlp.layers.1.bias': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.0.attn.qkv.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.0.attn.proj.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.0.mlp.layers.0.0.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.0.mlp.layers.1.weight': {'lr_mult': 0.03167635202407837,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.1.norm1.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.norm1.bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.attn.q_bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.attn.v_bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.attn.proj.bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.norm2.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.norm2.bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.mlp.layers.0.0.bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.mlp.layers.1.bias': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.1.attn.qkv.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.1.attn.proj.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.1.mlp.layers.0.0.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.1.mlp.layers.1.weight': {'lr_mult': 0.04223513603210449,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.2.norm1.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.norm1.bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.attn.q_bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.attn.v_bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.attn.proj.bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.norm2.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.norm2.bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.mlp.layers.0.0.bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.mlp.layers.1.bias': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.2.attn.qkv.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.2.attn.proj.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.2.mlp.layers.0.0.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.2.mlp.layers.1.weight': {'lr_mult': 0.056313514709472656,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.3.norm1.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.norm1.bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.attn.q_bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.attn.v_bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.attn.proj.bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.norm2.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.norm2.bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.mlp.layers.0.0.bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.mlp.layers.1.bias': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.3.attn.qkv.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.3.attn.proj.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.3.mlp.layers.0.0.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.3.mlp.layers.1.weight': {'lr_mult': 0.07508468627929688,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.4.norm1.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.norm1.bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.attn.q_bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.attn.v_bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.attn.proj.bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.norm2.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.norm2.bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.mlp.layers.0.0.bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.mlp.layers.1.bias': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.4.attn.qkv.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.4.attn.proj.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.4.mlp.layers.0.0.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.4.mlp.layers.1.weight': {'lr_mult': 0.1001129150390625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.5.norm1.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.norm1.bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.attn.q_bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.attn.v_bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.attn.proj.bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.norm2.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.norm2.bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.mlp.layers.0.0.bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.mlp.layers.1.bias': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.5.attn.qkv.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.5.attn.proj.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.5.mlp.layers.0.0.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.5.mlp.layers.1.weight': {'lr_mult': 0.13348388671875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.6.norm1.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.6.norm1.bias': {'lr_mult': 0.177978515625, 'decay_mult': 0},\n", + " 'backbone.blocks.6.attn.q_bias': {'lr_mult': 0.177978515625, 'decay_mult': 0},\n", + " 'backbone.blocks.6.attn.v_bias': {'lr_mult': 0.177978515625, 'decay_mult': 0},\n", + " 'backbone.blocks.6.attn.proj.bias': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.6.norm2.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.6.norm2.bias': {'lr_mult': 0.177978515625, 'decay_mult': 0},\n", + " 'backbone.blocks.6.mlp.layers.0.0.bias': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.6.mlp.layers.1.bias': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.6.attn.qkv.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.6.attn.proj.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.6.mlp.layers.0.0.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.6.mlp.layers.1.weight': {'lr_mult': 0.177978515625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.7.norm1.weight': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.norm1.bias': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.attn.q_bias': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.attn.v_bias': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.attn.proj.bias': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.7.norm2.weight': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.norm2.bias': {'lr_mult': 0.2373046875, 'decay_mult': 0},\n", + " 'backbone.blocks.7.mlp.layers.0.0.bias': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.7.mlp.layers.1.bias': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.7.attn.qkv.weight': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.7.attn.proj.weight': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.7.mlp.layers.0.0.weight': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.7.mlp.layers.1.weight': {'lr_mult': 0.2373046875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.8.norm1.weight': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.norm1.bias': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.attn.q_bias': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.attn.v_bias': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.attn.proj.bias': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.norm2.weight': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.norm2.bias': {'lr_mult': 0.31640625, 'decay_mult': 0},\n", + " 'backbone.blocks.8.mlp.layers.0.0.bias': {'lr_mult': 0.31640625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.8.mlp.layers.1.bias': {'lr_mult': 0.31640625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.8.attn.qkv.weight': {'lr_mult': 0.31640625, 'decay_mult': 1},\n", + " 'backbone.blocks.8.attn.proj.weight': {'lr_mult': 0.31640625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.8.mlp.layers.0.0.weight': {'lr_mult': 0.31640625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.8.mlp.layers.1.weight': {'lr_mult': 0.31640625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.9.norm1.weight': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.norm1.bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.attn.q_bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.attn.v_bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.attn.proj.bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.norm2.weight': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.norm2.bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.mlp.layers.0.0.bias': {'lr_mult': 0.421875,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.9.mlp.layers.1.bias': {'lr_mult': 0.421875, 'decay_mult': 0},\n", + " 'backbone.blocks.9.attn.qkv.weight': {'lr_mult': 0.421875, 'decay_mult': 1},\n", + " 'backbone.blocks.9.attn.proj.weight': {'lr_mult': 0.421875, 'decay_mult': 1},\n", + " 'backbone.blocks.9.mlp.layers.0.0.weight': {'lr_mult': 0.421875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.9.mlp.layers.1.weight': {'lr_mult': 0.421875,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.10.norm1.weight': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.norm1.bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.attn.q_bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.attn.v_bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.attn.proj.bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.norm2.weight': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.norm2.bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.mlp.layers.0.0.bias': {'lr_mult': 0.5625,\n", + " 'decay_mult': 0},\n", + " 'backbone.blocks.10.mlp.layers.1.bias': {'lr_mult': 0.5625, 'decay_mult': 0},\n", + " 'backbone.blocks.10.attn.qkv.weight': {'lr_mult': 0.5625, 'decay_mult': 1},\n", + " 'backbone.blocks.10.attn.proj.weight': {'lr_mult': 0.5625, 'decay_mult': 1},\n", + " 'backbone.blocks.10.mlp.layers.0.0.weight': {'lr_mult': 0.5625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.10.mlp.layers.1.weight': {'lr_mult': 0.5625,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.11.norm1.weight': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.norm1.bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.attn.q_bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.attn.v_bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.attn.proj.bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.norm2.weight': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.norm2.bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.mlp.layers.0.0.bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.mlp.layers.1.bias': {'lr_mult': 0.75, 'decay_mult': 0},\n", + " 'backbone.blocks.11.attn.qkv.weight': {'lr_mult': 0.75, 'decay_mult': 1},\n", + " 'backbone.blocks.11.attn.proj.weight': {'lr_mult': 0.75, 'decay_mult': 1},\n", + " 'backbone.blocks.11.mlp.layers.0.0.weight': {'lr_mult': 0.75,\n", + " 'decay_mult': 1},\n", + " 'backbone.blocks.11.mlp.layers.1.weight': {'lr_mult': 0.75, 'decay_mult': 1},\n", + " 'backbone.fc_norm.weight': {'lr_mult': 1.0, 'decay_mult': 0},\n", + " 'backbone.fc_norm.bias': {'lr_mult': 1.0, 'decay_mult': 0},\n", + " 'cls_head.fc_cls.bias': {'lr_mult': 1.0, 'decay_mult': 0},\n", + " 'cls_head.fc_cls.weight': {'lr_mult': 1.0, 'decay_mult': 1}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert the parameter groups to the format used by mmaction\n", + "\n", + "custom_keys = {}\n", + "for _, group in groups.items():\n", + " decay_mult = 0 if group[\"weight_decay\"] == 0 else 1\n", + " params = group[\"params\"]\n", + " lr_mult = group[\"lr_scale\"]\n", + " for param in params:\n", + " custom_keys[param] = {\"lr_mult\": lr_mult, \"decay_mult\": decay_mult}\n", + "\n", + "custom_keys" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "human-fall-detection", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/dataset_label_analysis.ipynb b/notebooks/dataset_label_analysis.ipynb index dbc73a3..d4d6287 100644 --- a/notebooks/dataset_label_analysis.ipynb +++ b/notebooks/dataset_label_analysis.ipynb @@ -1,353 +1,837 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Label Analysis\n", - "\n", - "In this notebook we analyse the datsets and label distributions we get for different settings for sampling and labeling strategy." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "%reload_ext autoreload\n", - "%autoreload 2\n", - "import re\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "from datasets import HighQualityFallDataset\n", - "from datasets.transforms.label_strategy import HQFD_LABEL_DESCRIPTION, PriorityLabel\n", - "from datasets.transforms.sampling_strategy import GaussianSampling, UniformSampling" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
filenamelabelintervalsample_idxmodalitystart_indexlabel_namevideo_category
0data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(30.0, 40.0)0RGB0OtherADL
1data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(50.0, 60.0)1RGB0OtherADL
2data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(60.0, 70.0)2RGB0OtherADL
3data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(90.0, 100.0)3RGB0OtherADL
4data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(160.0, 170.0)4RGB0OtherADL
\n", - "
" - ], - "text/plain": [ - " filename label interval \\\n", - "0 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (30.0, 40.0) \n", - "1 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (50.0, 60.0) \n", - "2 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (60.0, 70.0) \n", - "3 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (90.0, 100.0) \n", - "4 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (160.0, 170.0) \n", - "\n", - " sample_idx modality start_index label_name video_category \n", - "0 0 RGB 0 Other ADL \n", - "1 1 RGB 0 Other ADL \n", - "2 2 RGB 0 Other ADL \n", - "3 3 RGB 0 Other ADL \n", - "4 4 RGB 0 Other ADL " - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ANN_FILE = \"data/Fall_Simulation_Data/annotations.csv\"\n", - "\n", - "uniform_sampling = UniformSampling(clip_len=10, stride=0, overlap=False)\n", - "gaussian_sampling = GaussianSampling(\n", - " clip_len=10, n_samples_per_sec=None, fallback_sampler=None, std=None\n", - ")\n", - "label_strategy = PriorityLabel(\n", - " label_description=HQFD_LABEL_DESCRIPTION,\n", - " threshold=0.0,\n", - " absolute_threshold=False,\n", - " priority=[0, 1, 2],\n", - ")\n", - "\n", - "hqfd = HighQualityFallDataset(\n", - " ann_file=ANN_FILE,\n", - " sampling_strategy=gaussian_sampling,\n", - " label_strategy=label_strategy,\n", - " pipeline=[],\n", - " num_classes=3,\n", - " test_mode=False,\n", - " drop_ratios=[0.0, 0.0, 0.75],\n", - ")\n", - "\n", - "df_hqfd = pd.DataFrame(list(hqfd))\n", - "class_names = [\"Fall\", \"Lying\", \"Other\"]\n", - "df_hqfd[\"label_name\"] = df_hqfd[\"label\"].apply(lambda x: class_names[x])\n", - "\n", - "\n", - "def extract_category(filename):\n", - " match = re.search(r\"(ADL|Fall)\", filename.split(\"/\")[-1])\n", - " return match.group(1) if match else None\n", - "\n", - "\n", - "df_hqfd[\"video_category\"] = df_hqfd[\"filename\"].apply(extract_category)\n", - "\n", - "df_hqfd.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_label_dist(df_hqfd):\n", - " display(\"---- Label Distribution ----\")\n", - " display(df_hqfd[\"label_name\"].value_counts().sort_index() / len(df_hqfd))\n", - "\n", - " display(\"---- Label Counts ----\")\n", - " display(df_hqfd[\"label_name\"].value_counts().sort_index())\n", - " df_hqfd[\"label_name\"].value_counts().sort_index().plot(kind=\"bar\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'---- Label Distribution ----'" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "label_name\n", - "Fall 0.288679\n", - "Lying 0.204657\n", - "Other 0.506664\n", - "Name: count, dtype: float64" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "'---- Label Counts ----'" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "label_name\n", - "Fall 1711\n", - "Lying 1213\n", - "Other 3003\n", - "Name: count, dtype: int64" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_label_dist(df_hqfd)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'---- Label Distribution ----'" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "label_name\n", - "Fall 0.525330\n", - "Lying 0.372429\n", - "Other 0.102241\n", - "Name: count, dtype: float64" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "'---- Label Counts ----'" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "label_name\n", - "Fall 1711\n", - "Lying 1213\n", - "Other 333\n", - "Name: count, dtype: int64" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_label_dist(df_hqfd[df_hqfd[\"video_category\"] == \"Fall\"])" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "human-fall-detection", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Label Analysis\n", + "\n", + "In this notebook we analyse the datsets and label distributions we get for different settings for sampling and labeling strategy." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "import re\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from datasets import HighQualityFallDataset\n", + "from datasets.transforms.label_strategy import HQFD_LABEL_DESCRIPTION, PriorityLabel\n", + "from datasets.transforms.sampling_strategy import GaussianSampling, UniformSampling" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from mmaction.datasets.transforms import (\n", + " DecordInit,\n", + " DecordDecode,\n", + " SampleFrames,\n", + " Resize,\n", + " RandomCrop,\n", + " Flip,\n", + " FormatShape,\n", + " PackActionInputs,\n", + " CenterCrop,\n", + ")\n", + "from datasets.transforms import ClipVideo\n", + "\n", + "# Train pipeline\n", + "train_pipeline = [\n", + " DecordInit(),\n", + " ClipVideo(),\n", + " SampleFrames(clip_len=16, frame_interval=8, num_clips=1),\n", + " DecordDecode(),\n", + " Resize(scale=(-1, 224)),\n", + " RandomCrop(size=224),\n", + " Resize(scale=(224, 224), keep_ratio=False),\n", + " Flip(flip_ratio=0.5),\n", + " FormatShape(input_format=\"NCTHW\"),\n", + " PackActionInputs(),\n", + "]\n", + "\n", + "val_pipeline = [\n", + " DecordInit(),\n", + " ClipVideo(),\n", + " SampleFrames(clip_len=16, frame_interval=8, num_clips=1, test_mode=True),\n", + " DecordDecode(),\n", + " Resize(scale=(-1, 224)),\n", + " CenterCrop(crop_size=224),\n", + " FormatShape(input_format=\"NCTHW\"),\n", + " PackActionInputs(),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "val_ann_file = \"data/Fall_Simulation_Data/annotations_val.csv\"\n", + "train_ann_file = \"data/Fall_Simulation_Data/annotations_train.csv\"\n", + "\n", + "np.random.seed(42)\n", + "\n", + "gaussian_sampling = GaussianSampling(\n", + " clip_len=5,\n", + " n_samples_per_sec=None,\n", + " fallback_sampler=UniformSampling(clip_len=5, stride=5, overlap=False),\n", + " std=None,\n", + ")\n", + "label_strategy = PriorityLabel(\n", + " label_description=HQFD_LABEL_DESCRIPTION,\n", + " threshold=0,\n", + " absolute_threshold=False,\n", + " priority=[0, 1, 2],\n", + ")\n", + "\n", + "uniform_sampling = UniformSampling(clip_len=5, stride=0, overlap=False)\n", + "val_hqfd = HighQualityFallDataset(\n", + " ann_file=val_ann_file,\n", + " sampling_strategy=uniform_sampling,\n", + " label_strategy=label_strategy,\n", + " pipeline=val_pipeline,\n", + " num_classes=3,\n", + " test_mode=True,\n", + ")\n", + "\n", + "train_hqfd = HighQualityFallDataset(\n", + " ann_file=train_ann_file,\n", + " sampling_strategy=gaussian_sampling,\n", + " label_strategy=label_strategy,\n", + " pipeline=train_pipeline,\n", + " num_classes=3,\n", + " test_mode=False,\n", + " drop_ratios=[0.0, 0.0, 0.30],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def analyse_dataset(ds):\n", + " df_hqfd = convert_ds_to_df(ds)\n", + " display(\"------- Full Dataset -------\")\n", + " plot_label_dist(df_hqfd)\n", + " display(\"------- Only Fall videos -------\")\n", + " plot_label_dist(df_hqfd[df_hqfd[\"video_category\"] == \"Fall\"])\n", + "\n", + "\n", + "def convert_ds_to_df(ds: HighQualityFallDataset):\n", + " np.random.seed(42)\n", + " df_hqfd = pd.DataFrame(ds.load_data_list())\n", + " class_names = [\"Fall\", \"Lying\", \"Other\"]\n", + " df_hqfd[\"label_name\"] = df_hqfd[\"label\"].apply(lambda x: class_names[x])\n", + "\n", + " def extract_category(filename):\n", + " match = re.search(r\"(ADL|Fall)\", filename.split(\"/\")[-1])\n", + " return match.group(1) if match else None\n", + "\n", + " df_hqfd[\"video_category\"] = df_hqfd[\"filename\"].apply(extract_category)\n", + "\n", + " return df_hqfd\n", + "\n", + "\n", + "def plot_label_dist(df_hqfd):\n", + " display(\"---- Dataset Size ----\")\n", + " display(len(df_hqfd))\n", + "\n", + " display(\"---- Label Distribution ----\")\n", + " display(df_hqfd[\"label_name\"].value_counts().sort_index() / len(df_hqfd))\n", + "\n", + " display(\"---- Label Counts ----\")\n", + " display(df_hqfd[\"label_name\"].value_counts().sort_index())\n", + " df_hqfd[\"label_name\"].value_counts().sort_index().plot(kind=\"bar\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train DS" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'------- Full Dataset -------'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Dataset Size ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "10876" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Distribution ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 0.146837\n", + "Lying 0.194189\n", + "Other 0.658974\n", + "Name: count, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Counts ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 1597\n", + "Lying 2112\n", + "Other 7167\n", + "Name: count, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'------- Only Fall videos -------'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Dataset Size ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "5532" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Distribution ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 0.288684\n", + "Lying 0.381779\n", + "Other 0.329537\n", + "Name: count, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Counts ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 1597\n", + "Lying 2112\n", + "Other 1823\n", + "Name: count, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "analyse_dataset(train_hqfd)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Val DS" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'------- Full Dataset -------'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Dataset Size ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "2985" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Distribution ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 0.013400\n", + "Lying 0.157789\n", + "Other 0.828811\n", + "Name: count, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Counts ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 40\n", + "Lying 471\n", + "Other 2474\n", + "Name: count, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'------- Only Fall videos -------'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Dataset Size ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "852" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Distribution ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 0.046948\n", + "Lying 0.552817\n", + "Other 0.400235\n", + "Name: count, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Counts ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 40\n", + "Lying 471\n", + "Other 341\n", + "Name: count, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAHKCAYAAAApabCRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAke0lEQVR4nO3dfVSUdf7/8ReooCAD4g3kEdSOrkpqpq46lWVlolGrK53sxDE0t9TQUk5m7qqt+i1ZKzXNu90279I0d9PU8m6p1BTvcDXv00KhaMA0QSlA4Pr90Tq/JqwEkesD83ycM+fIdX1meE9dHZ9dc82Mj2VZlgAAAAzia/cAAAAAP0egAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADBOTbsHKI+SkhJlZmYqKChIPj4+do8DAACugWVZunjxoho3bixf318/R1IlAyUzM1MRERF2jwEAAMohIyNDTZo0+dU1VTJQgoKCJP34BB0Oh83TAACAa5Gbm6uIiAj33+O/pkoGypWXdRwOB4ECAEAVcy2XZ3CRLAAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjFPT7gEAVK5mL3xg9wjVwumkGLtHAKo1zqAAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMc12BkpSUJB8fH40aNcq9LT8/XwkJCapfv77q1q2r2NhYZWVledwvPT1dMTExCggIUKNGjTRmzBgVFRVdzygAAKAaKXeg7N27VwsWLFD79u09to8ePVrr1q3TqlWrtHXrVmVmZqp///7u/cXFxYqJiVFhYaF27typxYsXa9GiRZo4cWL5nwUAAKhWyhUoly5dUlxcnP7xj3+oXr167u05OTn65z//qenTp+vee+9Vp06dtHDhQu3cuVO7du2SJG3evFlHjx7V22+/rQ4dOqhPnz6aMmWK5syZo8LCwop5VgAAoEorV6AkJCQoJiZGPXv29Niempqqy5cve2xv3bq1IiMjlZKSIklKSUlRu3btFBYW5l4THR2t3NxcHTly5Kq/r6CgQLm5uR43AABQfdUs6x1WrFih/fv3a+/evaX2uVwu+fn5KSQkxGN7WFiYXC6Xe81P4+TK/iv7rmbq1KmaNGlSWUcFAABVVJnOoGRkZOjZZ5/VsmXLVLt27Rs1Uynjxo1TTk6O+5aRkVFpvxsAAFS+MgVKamqqsrOz1bFjR9WsWVM1a9bU1q1bNWvWLNWsWVNhYWEqLCzUhQsXPO6XlZWl8PBwSVJ4eHipd/Vc+fnKmp/z9/eXw+HwuAEAgOqrTIFy33336dChQzpw4ID71rlzZ8XFxbn/XKtWLSUnJ7vvc+LECaWnp8vpdEqSnE6nDh06pOzsbPeaLVu2yOFwKCoqqoKeFgAAqMrKdA1KUFCQ2rZt67EtMDBQ9evXd28fMmSIEhMTFRoaKofDoZEjR8rpdKpbt26SpF69eikqKkoDBw7UtGnT5HK5NH78eCUkJMjf37+CnhYAAKjKynyR7G+ZMWOGfH19FRsbq4KCAkVHR2vu3Lnu/TVq1ND69es1fPhwOZ1OBQYGKj4+XpMnT67oUQAAQBXlY1mWZfcQZZWbm6vg4GDl5ORwPQpQRs1e+MDuEaqF00kxdo8AVDll+fub7+IBAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGqWn3AAAA79bshQ/sHqHaOJ0UY/cIFYYzKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAME6ZAmXevHlq3769HA6HHA6HnE6nNmzY4N6fn5+vhIQE1a9fX3Xr1lVsbKyysrI8HiM9PV0xMTEKCAhQo0aNNGbMGBUVFVXMswEAANVCmQKlSZMmSkpKUmpqqvbt26d7771Xffv21ZEjRyRJo0eP1rp167Rq1Spt3bpVmZmZ6t+/v/v+xcXFiomJUWFhoXbu3KnFixdr0aJFmjhxYsU+KwAAUKX5WJZlXc8DhIaG6pVXXtHDDz+shg0bavny5Xr44YclScePH1ebNm2UkpKibt26acOGDXrwwQeVmZmpsLAwSdL8+fM1duxYnT17Vn5+ftf0O3NzcxUcHKycnBw5HI7rGR/wOs1e+MDuEaqF00kxdo9QbXBMVhzTj8uy/P1d7mtQiouLtWLFCuXl5cnpdCo1NVWXL19Wz5493Wtat26tyMhIpaSkSJJSUlLUrl07d5xIUnR0tHJzc91nYa6moKBAubm5HjcAAFB9lTlQDh06pLp168rf31/Dhg3T6tWrFRUVJZfLJT8/P4WEhHisDwsLk8vlkiS5XC6POLmy/8q+XzJ16lQFBwe7bxEREWUdGwAAVCFlDpRWrVrpwIED2r17t4YPH674+HgdPXr0RszmNm7cOOXk5LhvGRkZN/T3AQAAe9Us6x38/PzUokULSVKnTp20d+9evf766xowYIAKCwt14cIFj7MoWVlZCg8PlySFh4drz549Ho935V0+V9Zcjb+/v/z9/cs6KgAAqKKu+3NQSkpKVFBQoE6dOqlWrVpKTk527ztx4oTS09PldDolSU6nU4cOHVJ2drZ7zZYtW+RwOBQVFXW9owAAgGqiTGdQxo0bpz59+igyMlIXL17U8uXL9cknn2jTpk0KDg7WkCFDlJiYqNDQUDkcDo0cOVJOp1PdunWTJPXq1UtRUVEaOHCgpk2bJpfLpfHjxyshIYEzJAAAwK1MgZKdna3HH39c33zzjYKDg9W+fXtt2rRJ999/vyRpxowZ8vX1VWxsrAoKChQdHa25c+e671+jRg2tX79ew4cPl9PpVGBgoOLj4zV58uSKfVYAAKBKu+7PQbEDn4MClB+fOVExTP+8iaqEY7LimH5cVsrnoAAAANwoBAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOOUKVCmTp2q3//+9woKClKjRo3Ur18/nThxwmNNfn6+EhISVL9+fdWtW1exsbHKysryWJOenq6YmBgFBASoUaNGGjNmjIqKiq7/2QAAgGqhTIGydetWJSQkaNeuXdqyZYsuX76sXr16KS8vz71m9OjRWrdunVatWqWtW7cqMzNT/fv3d+8vLi5WTEyMCgsLtXPnTi1evFiLFi3SxIkTK+5ZAQCAKs3HsiyrvHc+e/asGjVqpK1bt+quu+5STk6OGjZsqOXLl+vhhx+WJB0/flxt2rRRSkqKunXrpg0bNujBBx9UZmamwsLCJEnz58/X2LFjdfbsWfn5+f3m783NzVVwcLBycnLkcDjKOz7glZq98IHdI1QLp5Ni7B6h2uCYrDimH5dl+fv7uq5BycnJkSSFhoZKklJTU3X58mX17NnTvaZ169aKjIxUSkqKJCklJUXt2rVzx4kkRUdHKzc3V0eOHLnq7ykoKFBubq7HDQAAVF/lDpSSkhKNGjVKd9xxh9q2bStJcrlc8vPzU0hIiMfasLAwuVwu95qfxsmV/Vf2Xc3UqVMVHBzsvkVERJR3bAAAUAWUO1ASEhJ0+PBhrVixoiLnuapx48YpJyfHfcvIyLjhvxMAANinZnnuNGLECK1fv17btm1TkyZN3NvDw8NVWFioCxcueJxFycrKUnh4uHvNnj17PB7vyrt8rqz5OX9/f/n7+5dnVAAAUAWV6QyKZVkaMWKEVq9erY8++kjNmzf32N+pUyfVqlVLycnJ7m0nTpxQenq6nE6nJMnpdOrQoUPKzs52r9myZYscDoeioqKu57kAAIBqokxnUBISErR8+XK9//77CgoKcl8zEhwcrDp16ig4OFhDhgxRYmKiQkND5XA4NHLkSDmdTnXr1k2S1KtXL0VFRWngwIGaNm2aXC6Xxo8fr4SEBM6SAAAASWUMlHnz5kmSevTo4bF94cKFGjRokCRpxowZ8vX1VWxsrAoKChQdHa25c+e619aoUUPr16/X8OHD5XQ6FRgYqPj4eE2ePPn6ngkAAKg2yhQo1/KRKbVr19acOXM0Z86cX1zTtGlTffjhh2X51QAAwIvwXTwAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxT5kDZtm2bHnroITVu3Fg+Pj5as2aNx37LsjRx4kTddNNNqlOnjnr27KmTJ096rDl//rzi4uLkcDgUEhKiIUOG6NKlS9f1RAAAQPVR5kDJy8vTrbfeqjlz5lx1/7Rp0zRr1izNnz9fu3fvVmBgoKKjo5Wfn+9eExcXpyNHjmjLli1av369tm3bpqeeeqr8zwIAAFQrNct6hz59+qhPnz5X3WdZlmbOnKnx48erb9++kqQlS5YoLCxMa9as0aOPPqpjx45p48aN2rt3rzp37ixJmj17th544AG9+uqraty48XU8HQAAUB1U6DUoaWlpcrlc6tmzp3tbcHCwunbtqpSUFElSSkqKQkJC3HEiST179pSvr69279591cctKChQbm6uxw0AAFRfFRooLpdLkhQWFuaxPSwszL3P5XKpUaNGHvtr1qyp0NBQ95qfmzp1qoKDg923iIiIihwbAAAYpkq8i2fcuHHKyclx3zIyMuweCQAA3EAVGijh4eGSpKysLI/tWVlZ7n3h4eHKzs722F9UVKTz58+71/ycv7+/HA6Hxw0AAFRfFRoozZs3V3h4uJKTk93bcnNztXv3bjmdTkmS0+nUhQsXlJqa6l7z0UcfqaSkRF27dq3IcQAAQBVV5nfxXLp0SadOnXL/nJaWpgMHDig0NFSRkZEaNWqU/u///k8tW7ZU8+bNNWHCBDVu3Fj9+vWTJLVp00a9e/fWk08+qfnz5+vy5csaMWKEHn30Ud7BAwAAJJUjUPbt26d77rnH/XNiYqIkKT4+XosWLdLzzz+vvLw8PfXUU7pw4YLuvPNObdy4UbVr13bfZ9myZRoxYoTuu+8++fr6KjY2VrNmzaqApwMAAKoDH8uyLLuHKKvc3FwFBwcrJyeH61GAMmr2wgd2j1AtnE6KsXuEaoNjsuKYflyW5e/vKvEuHgAA4F0IFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYJyadg9QnTV74QO7R6g2TifF2D0CAKAScQYFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYx9ZAmTNnjpo1a6batWura9eu2rNnj53jAAAAQ9gWKCtXrlRiYqJefPFF7d+/X7feequio6OVnZ1t10gAAMAQtgXK9OnT9eSTT2rw4MGKiorS/PnzFRAQoLfeesuukQAAgCFq2vFLCwsLlZqaqnHjxrm3+fr6qmfPnkpJSSm1vqCgQAUFBe6fc3JyJEm5ubk3ftjrUFLwvd0jVBum/7uuSjguKwbHZMXhmKw4ph+XV+azLOs319oSKN9++62Ki4sVFhbmsT0sLEzHjx8vtX7q1KmaNGlSqe0RERE3bEaYJXim3RMAnjgmYaKqclxevHhRwcHBv7rGlkApq3HjxikxMdH9c0lJic6fP6/69evLx8fHxsmqvtzcXEVERCgjI0MOh8PucQCOSRiHY7LiWJalixcvqnHjxr+51pZAadCggWrUqKGsrCyP7VlZWQoPDy+13t/fX/7+/h7bQkJCbuSIXsfhcPAfHozCMQnTcExWjN86c3KFLRfJ+vn5qVOnTkpOTnZvKykpUXJyspxOpx0jAQAAg9j2Ek9iYqLi4+PVuXNndenSRTNnzlReXp4GDx5s10gAAMAQtgXKgAEDdPbsWU2cOFEul0sdOnTQxo0bS104ixvL399fL774YqmX0AC7cEzCNByT9vCxruW9PgAAAJWI7+IBAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAA+ImioiItWbKk1Kedo3LxNmMAAH4mICBAx44dU9OmTe0exWtViS8LxPW77bbbrvmLFffv33+DpwEAs3Xp0kUHDhwgUGxEoHiJfv362T0C8Ivq1at31YD28fFR7dq11aJFCw0aNIivwkClefrpp5WYmKiMjAx16tRJgYGBHvvbt29v02Teg5d4ANhuxowZeumll9SnTx916dJFkrRnzx5t3LhRo0ePVlpampYuXarZs2frySeftHlaeANf39KXaPr4+MiyLPn4+Ki4uNiGqbwLgQLAdrGxsbr//vs1bNgwj+0LFizQ5s2b9e9//1uzZ8/W3//+dx06dMimKeFNzpw586v7eennxiNQvMQvnUK/mvPnz9/gaQBPdevW1YEDB9SiRQuP7adOnVKHDh106dIlffHFF2rfvr3y8vJsmhJAZeIaFC8xc+ZMu0cAflFoaKjWrVun0aNHe2xft26dQkNDJUl5eXkKCgqyYzx4qaVLl2r+/PlKS0tTSkqKmjZtqpkzZ6p58+bq27ev3eNVewSKl4iPj7d7BOAXTZgwQcOHD9fHH3/svgZl7969+vDDDzV//nxJ0pYtW3T33XfbOSa8yLx58zRx4kSNGjVKL730kvuak5CQEM2cOZNAqQS8xOPl8vPzVVhY6LHN4XDYNA282Y4dO/TGG2/oxIkTkqRWrVpp5MiRuv32222eDN4oKipKL7/8svr166egoCAdPHhQN998sw4fPqwePXro22+/tXvEao8zKF4oLy9PY8eO1bvvvqtz586V2s/V6bDDHXfcoTvuuMPuMQBJUlpamm677bZS2/39/bkOqpIQKF7o+eef18cff6x58+Zp4MCBmjNnjr7++mstWLBASUlJdo8HL1VSUqJTp04pOztbJSUlHvvuuusum6aCt2revPlVP6ht48aNatOmjU1TeRcCxQutW7dOS5YsUY8ePTR48GB1795dLVq0UNOmTbVs2TLFxcXZPSK8zK5du/TYY4/pzJkz+vmrznzmBOyQmJiohIQE5efny7Is7dmzR++8846mTp2qN9980+7xvAKB4oXOnz+vm2++WdKP15tceVvxnXfeqeHDh9s5GrzUsGHD1LlzZ33wwQe66aabrvkt8cCN8qc//Ul16tTR+PHj9f333+uxxx5T48aN9frrr+vRRx+1ezyvQKB4oZtvvllpaWmKjIxU69at9e6776pLly5at26dQkJC7B4PXujkyZP617/+VepzUAA7xcXFKS4uTt9//70uXbqkRo0a2T2SVyn9Wb6otr788kuVlJRo8ODBOnjwoCTphRde0Jw5c1S7dm2NHj1aY8aMsXlKeKOuXbvq1KlTdo8BXFVAQABxYgPeZuxFatSooW+++cb9H9qAAQM0a9Ys5efnKzU1VS1atOALsGCL1atXa/z48RozZozatWunWrVqeeznuERly8rK0nPPPafk5GRlZ2eXujaK66JuPALFi/j6+srlcrkD5afv7QfsxBezwTR9+vRRenq6RowYcdXrovigthuPa1AA2C4tLc3uEQAPn376qbZv364OHTrYPYrXIlC8iI+PT6n/C+DdEjAB3wwL00RERJR6WQeVi5d4vIivr6/69Okjf39/ST9+Hsq9996rwMBAj3XvvfeeHePBy6xdu1Z9+vRRrVq1tHbt2l9d+4c//KGSpgJ+tHnzZr322mtasGCBmjVrZvc4XolA8SKDBw++pnULFy68wZMAntdEXe0alCu4BgWVpV69eh5nlfPy8lRUVKSAgIBSF25f+fwo3DgECgAAkhYvXnzNa/mG+BuPQAFguy+//JJ3kwHwwAe1AbBdixYtdM899+jtt99Wfn6+3eMAqlGjhrKzs0ttP3funGrUqGHDRN6HQAFgu/3796t9+/ZKTExUeHi4hg4dqj179tg9FrzYL724UFBQID8/v0qexjvxEg8AYxQVFWnt2rVatGiRNm7cqN/97nd64oknNHDgQDVs2NDu8eAFZs2aJUkaPXq0pkyZorp167r3FRcXa9u2bTp9+rT++9//2jWi1yBQABinoKBAc+fO1bhx41RYWCg/Pz898sgj+tvf/qabbrrJ7vFQjTVv3lySdObMGTVp0sTj5Rw/Pz81a9ZMkydPVteuXe0a0WsQKACMsW/fPr311ltasWKFAgMDFR8fryFDhuirr77SpEmTlJuby0s/qBT33HOP3nvvPRUVFcnHx0cNGjSweySvwzUoAGw3ffp0tWvXTrfffrsyMzO1ZMkSnTlzRsOGDdPUqVPVvXt3LVq0SPv377d7VHiBCxcuqE2bNmrZsqXCw8MVFhamBg0aaMSIEbpw4YLd43kNzqAAsF3Lli31xBNPaNCgQR4v4Rw8eFAdO3ZUcXGxCgsL9c477/D5E7ihzp8/L6fTqa+//lpxcXFq06aNJOno0aNavny5IiIitHPnTtWrV8/mSas/AgWAsX4aKEBlGDVqlJKTk/Wf//xHYWFhHvtcLpd69eql++67TzNmzLBpQu/BSzwAAPzPmjVr9Oqrr5aKE0kKDw/XtGnTtHr1ahsm8z4ECgAA//PNN9/olltu+cX9bdu2lcvlqsSJvFdNuwcA4L369+//q/u5IBGVrUGDBjp9+rSaNGly1f1paWkKDQ2t5Km8E4ECwDbBwcG/uf/xxx+vpGkAKTo6Wn/5y1+0ZcuWUp8YW1BQoAkTJqh37942TedduEgWAID/+eqrr9S5c2f5+/srISFBrVu3lmVZOnbsmObOnauCggLt27dPERERdo9a7REoAAD8RFpamp5++mlt3rzZ/Z08Pj4+uv/++/XGG2+oRYsWNk/oHQgUAACu4rvvvtPJkycl/fiN21x7UrkIFAAAYBzeZgwAAIxDoAAAAOMQKAAAwDgECuClevTooVGjRl3T2k8++UQ+Pj7X/cFpzZo108yZM6/rMQB4BwIFAAAYh0ABAADGIVAAaOnSpercubOCgoIUHh6uxx57TNnZ2aXW7dixQ+3bt1ft2rXVrVs3HT582GP/p59+qu7du6tOnTqKiIjQM888o7y8vHLN5OPjozfffFN//OMfFRAQoJYtW2rt2rXu/cXFxRoyZIiaN2+uOnXqqFWrVnr99dc9HmPQoEHq16+fXn75ZYWFhSkkJESTJ09WUVGRxowZo9DQUDVp0kQLFy70uF9GRoYeeeQRhYSEKDQ0VH379tXp06fL9TwAlA+BAkCXL1/WlClTdPDgQa1Zs0anT5/WoEGDSq0bM2aMXnvtNe3du1cNGzbUQw89pMuXL0uSvvjiC/Xu3VuxsbH67LPPtHLlSn366acaMWJEueeaNGmSHnnkEX322Wd64IEHFBcXp/Pnz0uSSkpK1KRJE61atUpHjx7VxIkT9ec//1nvvvuux2N89NFHyszM1LZt2zR9+nS9+OKLevDBB1WvXj3t3r1bw4YN09ChQ/XVV1+5/1lER0crKChI27dv144dO1S3bl317t1bhYWF5X4uAMrIAuCV7r77buvZZ5+96r69e/dakqyLFy9almVZH3/8sSXJWrFihXvNuXPnrDp16lgrV660LMuyhgwZYj311FMej7N9+3bL19fX+uGHHyzLsqymTZtaM2bMuKb5JFnjx493/3zp0iVLkrVhw4ZfvE9CQoIVGxvr/jk+Pt5q2rSpVVxc7N7WqlUrq3v37u6fi4qKrMDAQOudd96xLMuyli5darVq1coqKSlxrykoKLDq1Kljbdq06ZpmB3D9+DZjAEpNTdVf//pXHTx4UN99951KSkokSenp6YqKinKvczqd7j+HhoaqVatWOnbsmCTp4MGD+uyzz7Rs2TL3GsuyVFJSorS0NLVp06bMc7Vv397958DAQDkcDo+XnubMmaO33npL6enp+uGHH1RYWKgOHTp4PMYtt9wiX9//f7I4LCxMbdu2df9co0YN1a9f3/24Bw8e1KlTpxQUFOTxOPn5+friiy/K/BwAlA+BAni5vLw8RUdHKzo6WsuWLVPDhg2Vnp6u6OjoMr2kcenSJQ0dOlTPPPNMqX2RkZHlmq1WrVoeP/v4+LjjacWKFXruuef02muvyel0KigoSK+88op27979m4/xa4976dIlderUySO0rmjYsGG5ngeAsiNQAC93/PhxnTt3TklJSe6vkN+3b99V1+7atcsdG999950+//xz95mRjh076ujRo5X2Ta87duzQ7bffrqefftq9rSLOcHTs2FErV65Uo0aN5HA4rvvxAJQPF8kCXi4yMlJ+fn6aPXu2vvzyS61du1ZTpky56trJkycrOTlZhw8f1qBBg9SgQQP169dPkjR27Fjt3LlTI0aM0IEDB3Ty5Em9//7713WR7K9p2bKl9u3bp02bNunzzz/XhAkTtHfv3ut+3Li4ODVo0EB9+/bV9u3blZaWpk8++UTPPPOM+0JaADcegQJ4uYYNG2rRokVatWqVoqKilJSUpFdfffWqa5OSkvTss8+qU6dOcrlcWrdunfz8/CT9eL3I1q1b9fnnn6t79+667bbbNHHiRDVu3PiGzD106FD1799fAwYMUNeuXXXu3DmPsynlFRAQoG3btikyMlL9+/dXmzZtNGTIEOXn53NGBahEPpZlWXYPAQAA8FOcQQEAAMYhUABUumXLlqlu3bpXvd1yyy12jwfAALzEA6DSXbx4UVlZWVfdV6tWLTVt2rSSJwJgGgIFAAAYh5d4AACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMb5f1wA+4Zhz4hPAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "analyse_dataset(val_hqfd)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualization of Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from mmaction.visualization import ActionVisualizer\n", + "\n", + "vis = ActionVisualizer()\n", + "\n", + "\n", + "def get_random_sample_from_class(ds: HighQualityFallDataset, label: int, n: int = 1):\n", + " np.random.seed(42)\n", + " dl = pd.DataFrame(ds.load_data_list())\n", + " idx = dl[dl[\"label\"] == label].index.to_list()\n", + " idx = np.random.choice(idx, size=n, replace=False)\n", + " return idx\n", + "\n", + "\n", + "def render_sample_videos(path: str = \"tmp\"):\n", + " from ipywidgets import Output, GridspecLayout\n", + " from IPython import display\n", + "\n", + " videos = sorted(Path(path).glob(\"*.gif\"))\n", + " grid = GridspecLayout((len(videos) // 4) + 1, 4)\n", + "\n", + " for i, video in enumerate(videos):\n", + " out = Output()\n", + " with out:\n", + " display.display(display.Image(video))\n", + " grid[i // 4, i % 4] = out\n", + "\n", + " display.display(grid)\n", + "\n", + "\n", + "def generate_sample_videos(\n", + " ds: HighQualityFallDataset,\n", + " idx: int | list[int],\n", + " out_path: str | None = None,\n", + " render: bool = True,\n", + "):\n", + " if isinstance(idx, int):\n", + " idx = [idx]\n", + " vis = ActionVisualizer()\n", + " for i in idx:\n", + " # video [B, C, T, H, W] -> [T, H, W, C]\n", + " video = ds[i][\"inputs\"].squeeze(0).permute(1, 2, 3, 0).numpy().astype(np.uint8)\n", + " # Convert to RGB\n", + " video = video[..., ::-1]\n", + " vis.add_datasample(\n", + " name=i,\n", + " video=video,\n", + " data_sample=ds[i][\"data_samples\"],\n", + " draw_gt=True,\n", + " show_frames=True,\n", + " out_type=\"gif\",\n", + " out_path=f\"tmp/{i}.gif\" if out_path is None else out_path + f\"/{i}.gif\",\n", + " )\n", + " if render:\n", + " render_sample_videos()\n", + " shutil.rmtree(\"tmp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Validation Vis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Class 0 Samples in Val" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ece263d38db14c2f996cc4766a5201d8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(val_hqfd, 0, 20)\n", + "generate_sample_videos(val_hqfd, idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Class 1 Val Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f65ac016a0447d1b751e327a0ae8305", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(val_hqfd, 1, 20)\n", + "generate_sample_videos(val_hqfd, idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Class 2 Val" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cce622ef085647279b2cd1419a3168d8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(val_hqfd, 2, 20)\n", + "generate_sample_videos(val_hqfd, idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train Vis" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1a841bc7b69f4fb9baa6fda4dec06068", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(train_hqfd, 0, 20)\n", + "generate_sample_videos(train_hqfd, idx)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c0d9d8651a6e4a8295d90dd4599e9813", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(train_hqfd, 1, 20)\n", + "generate_sample_videos(train_hqfd, idx)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7bdcf6b03db04a5bbe6aada25554ae4f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GridspecLayout(children=(Output(layout=Layout(grid_area='widget001')), Output(layout=Layout(grid_area='widget0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = get_random_sample_from_class(train_hqfd, 2, 20)\n", + "generate_sample_videos(train_hqfd, idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Class weight calculation\n", + "\n", + "weight_for_class_i = total_samples / (num_samples_in_class_i * num_classes)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'df_hqfd' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/tillgrutschus/Library/CloudStorage/OneDrive-Personal/Documents/Arbeit und Beruf/Uppsala/Project in Data Science/human-fall-detection/notebooks/dataset_label_analysis.ipynb Cell 24\u001b[0m line \u001b[0;36m4\n\u001b[1;32m 2\u001b[0m num_classes \u001b[39m=\u001b[39m \u001b[39m3\u001b[39m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(num_classes):\n\u001b[0;32m----> 4\u001b[0m total_samples \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(df_hqfd)\n\u001b[1;32m 5\u001b[0m num_samples_in_class_i \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(df_hqfd[df_hqfd[\u001b[39m\"\u001b[39m\u001b[39mlabel\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m==\u001b[39m i])\n\u001b[1;32m 6\u001b[0m weights\u001b[39m.\u001b[39mappend(total_samples \u001b[39m/\u001b[39m num_samples_in_class_i \u001b[39m*\u001b[39m num_classes)\n", + "\u001b[0;31mNameError\u001b[0m: name 'df_hqfd' is not defined" + ] + } + ], + "source": [ + "weights = []\n", + "num_classes = 3\n", + "for i in range(num_classes):\n", + " total_samples = len(df_hqfd)\n", + " num_samples_in_class_i = len(df_hqfd[df_hqfd[\"label\"] == i])\n", + " weights.append(total_samples / num_samples_in_class_i * num_classes)\n", + "\n", + "display(weights)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "human-fall-detection", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/visualization/visualization_hook.py b/visualization/visualization_hook.py index e5be66e..257e2e6 100644 --- a/visualization/visualization_hook.py +++ b/visualization/visualization_hook.py @@ -53,7 +53,7 @@ def _draw_samples( elif "frame_dir" in data_sample: sample_name = osp.basename(data_sample.get("frame_dir")) else: - sample_name = str(sample_id) + sample_name = f"visualization/{str(sample_id)}" draw_args = self.draw_args if self.out_dir is not None: diff --git a/weights.dvc b/weights.dvc index 7bd26e2..1e03786 100644 --- a/weights.dvc +++ b/weights.dvc @@ -1,6 +1,6 @@ outs: -- md5: 48821704004601bbd361b199c730da94.dir - size: 394932752 - nfiles: 2 +- md5: 0ca76cf4d3f1320299c140bb8713267c.dir + size: 568033822 + nfiles: 3 hash: md5 path: weights