From 6eb3d6f48b1f1a07c8018037c16797c00c07e49a Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 3 Dec 2023 13:01:30 +0100 Subject: [PATCH 01/25] added vit-b weights --- weights.dvc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 From 6fdc892e6a9534141320c27b4a2cfeb3fcd1ddc9 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 3 Dec 2023 13:10:02 +0100 Subject: [PATCH 02/25] added experiment config --- ...ing_priority-labeling_paper-hyperparams.py | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.py 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 From 68001be32856c5f26cc0190a609ad1837e88b741 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 3 Dec 2023 13:12:35 +0100 Subject: [PATCH 03/25] added experiment job script --- ...n-sampling_priority-labeling_paper-hyperparams.sh | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh 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..57fa9f1 --- /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 \ No newline at end of file From 2e1847182be945c14f8d5e2c24297cf965ebd61b Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 3 Dec 2023 13:44:06 +0100 Subject: [PATCH 04/25] config for class weighted ce loss --- ...ling_paper-hyperparams_weighted-ce-loss.py | 38 +++++ notebooks/dataset_label_analysis.ipynb | 150 +++++++++++------- 2 files changed, 134 insertions(+), 54 deletions(-) create mode 100644 configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py 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..d1f8568 --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.py @@ -0,0 +1,38 @@ +_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 +# 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/notebooks/dataset_label_analysis.ipynb b/notebooks/dataset_label_analysis.ipynb index 63d7ab6..4457ee6 100644 --- a/notebooks/dataset_label_analysis.ipynb +++ b/notebooks/dataset_label_analysis.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -67,86 +67,93 @@ " \n", " \n", " 0\n", - " data/Fall_Simulation_Data/videos/ADL17_Cam1.avi\n", - " 2\n", - " (0.0, 10.0)\n", + " data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4\n", + " 0\n", + " (19.69, 29.69)\n", " 0\n", " RGB\n", " 0\n", - " Other\n", - " ADL\n", + " Fall\n", + " Fall\n", " \n", " \n", " 1\n", - " data/Fall_Simulation_Data/videos/ADL17_Cam1.avi\n", - " 2\n", - " (10.0, 20.0)\n", + " data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4\n", + " 1\n", + " (36.31, 46.31)\n", " 1\n", " RGB\n", " 0\n", - " Other\n", - " ADL\n", + " Lying\n", + " Fall\n", " \n", " \n", " 2\n", - " data/Fall_Simulation_Data/videos/ADL17_Cam1.avi\n", + " data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4\n", " 2\n", - " (20.0, 30.0)\n", + " (12.75, 22.75)\n", " 2\n", " RGB\n", " 0\n", " Other\n", - " ADL\n", + " Fall\n", " \n", " \n", " 3\n", - " data/Fall_Simulation_Data/videos/ADL17_Cam1.avi\n", - " 2\n", - " (30.0, 40.0)\n", + " data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4\n", + " 1\n", + " (39.11, 49.11)\n", " 3\n", " RGB\n", " 0\n", - " Other\n", - " ADL\n", + " Lying\n", + " Fall\n", " \n", " \n", " 4\n", - " data/Fall_Simulation_Data/videos/ADL17_Cam1.avi\n", + " data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4\n", " 2\n", - " (40.0, 50.0)\n", + " (13.149999999999999, 23.15)\n", " 4\n", " RGB\n", " 0\n", " Other\n", - " ADL\n", + " Fall\n", " \n", " \n", "\n", "" ], "text/plain": [ - " filename label interval \\\n", - "0 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (0.0, 10.0) \n", - "1 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (10.0, 20.0) \n", - "2 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (20.0, 30.0) \n", - "3 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (30.0, 40.0) \n", - "4 data/Fall_Simulation_Data/videos/ADL17_Cam1.avi 2 (40.0, 50.0) \n", + " filename label \\\n", + "0 data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4 0 \n", + "1 data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4 1 \n", + "2 data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4 2 \n", + "3 data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4 1 \n", + "4 data/Fall_Simulation_Data/videos/Fall7_Cam4.mp4 2 \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 " + " interval sample_idx modality start_index label_name \\\n", + "0 (19.69, 29.69) 0 RGB 0 Fall \n", + "1 (36.31, 46.31) 1 RGB 0 Lying \n", + "2 (12.75, 22.75) 2 RGB 0 Other \n", + "3 (39.11, 49.11) 3 RGB 0 Lying \n", + "4 (13.149999999999999, 23.15) 4 RGB 0 Other \n", + "\n", + " video_category \n", + "0 Fall \n", + "1 Fall \n", + "2 Fall \n", + "3 Fall \n", + "4 Fall " ] }, - "execution_count": 2, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ANN_FILE = \"data/Fall_Simulation_Data/annotations.csv\"\n", + "ANN_FILE = \"data/Fall_Simulation_Data/annotations_train.csv\"\n", "\n", "uniform_sampling = UniformSampling(clip_len=10, stride=0, overlap=False)\n", "gaussian_sampling = GaussianSampling(\n", @@ -185,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -217,9 +224,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.117428\n", - "Lying 0.079726\n", - "Other 0.802846\n", + "Fall 0.113712\n", + "Lying 0.079153\n", + "Other 0.807135\n", "Name: count, dtype: float64" ] }, @@ -239,9 +246,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1766\n", - "Lying 1199\n", - "Other 12074\n", + "Fall 1224\n", + "Lying 852\n", + "Other 8688\n", "Name: count, dtype: int64" ] }, @@ -250,7 +257,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -265,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -281,9 +288,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.402828\n", - "Lying 0.273495\n", - "Other 0.323677\n", + "Fall 0.391179\n", + "Lying 0.272291\n", + "Other 0.336529\n", "Name: count, dtype: float64" ] }, @@ -303,9 +310,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1766\n", - "Lying 1199\n", - "Other 1419\n", + "Fall 1224\n", + "Lying 852\n", + "Other 1053\n", "Name: count, dtype: int64" ] }, @@ -314,7 +321,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -326,6 +333,41 @@ "source": [ "plot_label_dist(df_hqfd[df_hqfd[\"video_category\"] == \"Fall\"])" ] + }, + { + "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": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[26.38235294117647, 37.901408450704224, 3.7168508287292816]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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": { From 544c23d67e4bc824ed7e84eaf46f721b21aa6392 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 3 Dec 2023 13:45:39 +0100 Subject: [PATCH 05/25] added job script and updated experiment name --- ...ty-labeling_paper-hyperparams_weighted-ce-loss.py | 4 +++- ...ty-labeling_paper-hyperparams_weighted-ce-loss.sh | 12 ++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams_weighted-ce-loss.sh 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 index d1f8568..e892cf2 100644 --- 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 @@ -2,7 +2,9 @@ "../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" +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}/") ) 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 From 99007837aaee09ef406bc39575cdcd227ce2ee11 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 20:32:34 +0100 Subject: [PATCH 06/25] added resume to job_script --- ...t-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 57fa9f1..ce03cdb 100644 --- a/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh +++ b/job_scripts/vit-b_gaussian-sampling_priority-labeling_paper-hyperparams.sh @@ -9,4 +9,4 @@ apptainer exec \ 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 \ No newline at end of file + --launcher pytorch --resume auto \ No newline at end of file From 43eef488bff984c01be395ec9f995ee0e49d3a6b Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 20:32:50 +0100 Subject: [PATCH 07/25] added new k400 hyperparams --- ...gh-quality-fall_runner_k400-hyperparams.py | 113 ++++++++++++++++++ configs/experiments/overfitting_run.py | 6 +- ...re_16x4x1_kinetics-400_k400-hyperparams.py | 102 ++++++++++++++++ 3 files changed, 218 insertions(+), 3 deletions(-) create mode 100644 configs/datasets/high-quality-fall_runner_k400-hyperparams.py create mode 100644 configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py 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..d1266cf --- /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=16, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=True, + 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=16, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=True, + 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=3, # From VideoMAEv2 repo + num_workers=8, + persistent_workers=True, + 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..cdb2933 100644 --- a/configs/experiments/overfitting_run.py +++ b/configs/experiments/overfitting_run.py @@ -12,7 +12,7 @@ train_dataloader = dict( sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( - indices=100, + indices=10, ), ) @@ -21,9 +21,9 @@ val_dataloader = dict( dataset=dict( ann_file=ann_file_val, - indices=100, + indices=10, ), ) 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/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..e6c0f76 --- /dev/null +++ b/configs/models/vit-s-p16_videomaev2-vit-g-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py @@ -0,0 +1,102 @@ +_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=3) + +# 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, + ), +] + +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 + ), + # 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") From 804b33fe8b274570bdabfaac2734b2c3248da7a8 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 20:34:54 +0100 Subject: [PATCH 08/25] added experiment results --- experiments.dvc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/experiments.dvc b/experiments.dvc index 98f6b2a..cc6d760 100644 --- a/experiments.dvc +++ b/experiments.dvc @@ -1,6 +1,6 @@ outs: -- md5: 004d25dfcdbec8b9a95e429079227b93.dir - size: 1022832432 - nfiles: 9 +- md5: c99fd58aef02c984c5f078634e666f3a.dir + size: 9316741750 + nfiles: 30 hash: md5 path: experiments From 20c9a3293d30139ed3bb6125086b2fa1d3c3e08f Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 22:36:43 +0100 Subject: [PATCH 09/25] added layer decay --- ...re_16x4x1_kinetics-400_k400-hyperparams.py | 312 ++++++ notebooks/custom_keys_optimizer.ipynb | 938 ++++++++++++++++++ 2 files changed, 1250 insertions(+) create mode 100644 notebooks/custom_keys_optimizer.ipynb 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 index e6c0f76..e10e973 100644 --- 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 @@ -65,6 +65,317 @@ ), ] +# 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( @@ -73,6 +384,7 @@ 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 ) 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 +} From 2e2f7b6227b1670bec819fb2bb19e47753259cb2 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 22:40:34 +0100 Subject: [PATCH 10/25] updated overfitting run --- configs/experiments/overfitting_run.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configs/experiments/overfitting_run.py b/configs/experiments/overfitting_run.py index cdb2933..b7e2110 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" From aabe62afea4e39531abbef510d32e144009b7e8b Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Mon, 4 Dec 2023 23:24:46 +0100 Subject: [PATCH 11/25] further refined configs --- ...gh-quality-fall_runner_k400-hyperparams.py | 4 +-- ...ling_priority-labeling_k400-hyperparams.py | 29 +++++++++++++++++++ ...re_16x4x1_kinetics-400_k400-hyperparams.py | 2 ++ ...ling_priority-labeling_k400-hyperparams.sh | 10 +++++++ 4 files changed, 43 insertions(+), 2 deletions(-) create mode 100644 configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py create mode 100644 job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh diff --git a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py index d1266cf..b38128b 100644 --- a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py +++ b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py @@ -35,7 +35,7 @@ ] train_dataloader = dict( - batch_size=16, # From VideoMAEv2 repo + batch_size=12, # From VideoMAEv2 repo num_workers=8, persistent_workers=True, sampler=dict(type="DefaultSampler", shuffle=True), @@ -68,7 +68,7 @@ # val_dataloader = train_dataloader val_dataloader = dict( - batch_size=16, # From VideoMAEv2 repo + batch_size=12, # From VideoMAEv2 repo num_workers=8, persistent_workers=True, sampler=dict(type="DefaultSampler", shuffle=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..ae2f85f --- /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=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/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 index e10e973..b859ebc 100644 --- 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 @@ -65,6 +65,8 @@ ), ] +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": { 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..17f348b --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling_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=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 \ No newline at end of file From e37fa4d9e637bbed68f4ccfe77e8342ae5aaf080 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 11:47:48 +0100 Subject: [PATCH 12/25] trying to fix memory issues --- .../datasets/high-quality-fall_runner_k400-hyperparams.py | 8 ++++---- ...aussian-sampling_priority-labeling_k400-hyperparams.py | 2 +- ...-dist-k710-pre_16x4x1_kinetics-400_k400-hyperparams.py | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py index b38128b..c7ac2a8 100644 --- a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py +++ b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py @@ -36,7 +36,7 @@ train_dataloader = dict( batch_size=12, # From VideoMAEv2 repo - num_workers=8, + num_workers=4, persistent_workers=True, sampler=dict(type="DefaultSampler", shuffle=True), dataset=dict( @@ -68,8 +68,8 @@ # val_dataloader = train_dataloader val_dataloader = dict( - batch_size=12, # From VideoMAEv2 repo - num_workers=8, + batch_size=1, # From VideoMAEv2 repo + num_workers=2, persistent_workers=True, sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( @@ -98,7 +98,7 @@ ] test_dataloader = dict( - batch_size=3, # From VideoMAEv2 repo + batch_size=1, # From VideoMAEv2 repo num_workers=8, persistent_workers=True, sampler=dict(type="DefaultSampler", shuffle=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 index ae2f85f..f3a095e 100644 --- a/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py @@ -12,7 +12,7 @@ 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=10)] +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=300)] # Use ViT-B/16 model = dict( 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 index b859ebc..cbcf715 100644 --- 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 @@ -42,7 +42,7 @@ 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=3) +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=90, val_interval=1) # TODO: Think about fine-tuning param scheduler param_scheduler = [ From 73aef25e3db3d8d94deecbedaded3fa61ad9429f Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 11:48:03 +0100 Subject: [PATCH 13/25] updated name for images in tensorboard --- visualization/visualization_hook.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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: From 00d478feb15581af80f8f11a3519cae08df9b3cb Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 11:49:03 +0100 Subject: [PATCH 14/25] added auto resume flag to training --- ...t-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 index 17f348b..fc47fdd 100644 --- a/job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh +++ b/job_scripts/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.sh @@ -7,4 +7,5 @@ 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 \ No newline at end of file + configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py \ + --resume auto \ No newline at end of file From fb5b69ef9bdb5f1ca25fa46c1a6fd81f52ad1d33 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 12:30:22 +0100 Subject: [PATCH 15/25] switched off persisting workers --- .../high-quality-fall_runner_k400-hyperparams.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py index c7ac2a8..bae936e 100644 --- a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py +++ b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py @@ -36,8 +36,8 @@ train_dataloader = dict( batch_size=12, # From VideoMAEv2 repo - num_workers=4, - persistent_workers=True, + num_workers=8, + persistent_workers=False, sampler=dict(type="DefaultSampler", shuffle=True), dataset=dict( type=dataset_type, @@ -69,8 +69,8 @@ # val_dataloader = train_dataloader val_dataloader = dict( batch_size=1, # From VideoMAEv2 repo - num_workers=2, - persistent_workers=True, + num_workers=8, + persistent_workers=False, sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( type=dataset_type, @@ -100,7 +100,7 @@ test_dataloader = dict( batch_size=1, # From VideoMAEv2 repo num_workers=8, - persistent_workers=True, + persistent_workers=False, sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( type=dataset_type, From 65d7b491e26cd3353ff41235f926ab8c54858d35 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 12:30:33 +0100 Subject: [PATCH 16/25] changed visualization interval --- ...it-b_gaussian-sampling_priority-labeling_k400-hyperparams.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index f3a095e..3cc96a5 100644 --- a/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py +++ b/configs/experiments/vit-b_gaussian-sampling_priority-labeling_k400-hyperparams.py @@ -12,7 +12,7 @@ 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)] +custom_hooks = [dict(type="CustomVisualizationHook", enable=True, interval=150)] # Use ViT-B/16 model = dict( From 89c3350b310c0493e381c34b2b6449d941829904 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Tue, 5 Dec 2023 12:31:54 +0100 Subject: [PATCH 17/25] changed val batch size --- configs/datasets/high-quality-fall_runner_k400-hyperparams.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py index bae936e..29bddfd 100644 --- a/configs/datasets/high-quality-fall_runner_k400-hyperparams.py +++ b/configs/datasets/high-quality-fall_runner_k400-hyperparams.py @@ -68,7 +68,7 @@ # val_dataloader = train_dataloader val_dataloader = dict( - batch_size=1, # From VideoMAEv2 repo + batch_size=12, # From VideoMAEv2 repo num_workers=8, persistent_workers=False, sampler=dict(type="DefaultSampler", shuffle=False), From 1ebad36384f3a712a0249d60aa19c69e93433669 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 14:13:56 +0100 Subject: [PATCH 18/25] created 5s clip experiment --- ...drop_priority-labeling_k400-hyperparams.py | 45 +++++++++++++++++++ ...drop_priority-labeling_k400-hyperparams.sh | 11 +++++ 2 files changed, 56 insertions(+) create mode 100644 configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py create mode 100644 job_scripts/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh 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..dbfa287 --- /dev/null +++ b/configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py @@ -0,0 +1,45 @@ +_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=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/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..2c6456d --- /dev/null +++ b/job_scripts/vit-b_gaussian-sampling-5s-clips-30-drop_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=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 \ + --resume auto \ No newline at end of file From 42b3e873f757e04e8396d1bc42b566894eec3dca Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 14:18:59 +0100 Subject: [PATCH 19/25] fixed typo --- ...ing-5s-clips-30-drop_priority-labeling_k400-hyperparams.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index dbfa287..3f6cbc4 100644 --- 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 @@ -30,8 +30,8 @@ fallback_sampler=dict( type="UniformSampling", clip_len=5, stride=5, overlap=False ), - drop_ratios=[0.0, 0.0, 0.30], - ) + ), + drop_ratios=[0.0, 0.0, 0.30], ) ) # We are not changing the val/test dataloaders since gaussian sampling requires labels From 021a513bea483840c40e87cacb34224bd3d46f32 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 18:25:59 +0100 Subject: [PATCH 20/25] added visualization to ds analysis --- notebooks/dataset_label_analysis.ipynb | 679 +++++++++++++++++++------ 1 file changed, 514 insertions(+), 165 deletions(-) diff --git a/notebooks/dataset_label_analysis.ipynb b/notebooks/dataset_label_analysis.ipynb index 9c86b64..8824ec3 100644 --- a/notebooks/dataset_label_analysis.ipynb +++ b/notebooks/dataset_label_analysis.ipynb @@ -11,13 +11,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "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", @@ -28,167 +30,92 @@ "from datasets.transforms.sampling_strategy import GaussianSampling, UniformSampling" ] }, + { + "cell_type": "code", + "execution_count": 11, + "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=9, 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": 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)0RGB0FallFall
1data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(50.0, 60.0)1RGB0LyingFall
2data/Fall_Simulation_Data/videos/Fall7_Cam4.mp42(60.0, 70.0)2RGB0OtherFall
3data/Fall_Simulation_Data/videos/ADL17_Cam1.avi2(90.0, 100.0)3RGB0LyingFall
4data/Fall_Simulation_Data/videos/Fall7_Cam4.mp42(160.0, 170.0)4RGB0OtherFall
\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", - " interval sample_idx modality start_index label_name \\\n", - "0 (19.69, 29.69) 0 RGB 0 Fall \n", - "1 (36.31, 46.31) 1 RGB 0 Lying \n", - "2 (12.75, 22.75) 2 RGB 0 Other \n", - "3 (39.11, 49.11) 3 RGB 0 Lying \n", - "4 (13.149999999999999, 23.15) 4 RGB 0 Other \n", - "\n", - " video_category \n", - "0 Fall \n", - "1 Fall \n", - "2 Fall \n", - "3 Fall \n", - "4 Fall " - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "ANN_FILE = \"data/Fall_Simulation_Data/annotations_train.csv\"\n", + "val_ann_file = \"data/Fall_Simulation_Data/annotations_val.csv\"\n", + "train_ann_file = \"data/Fall_Simulation_Data/annotations_train.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", + " 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.0,\n", + " threshold=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", + "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=[],\n", + " pipeline=val_pipeline,\n", " num_classes=3,\n", - " test_mode=False,\n", - " drop_ratios=[0.0, 0.0, 0.75],\n", + " test_mode=True,\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()" + "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", + ")" ] }, { @@ -197,7 +124,32 @@ "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", + " 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", @@ -207,11 +159,126 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train DS" + ] + }, { "cell_type": "code", "execution_count": 14, "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": [ + "10969" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'---- Label Distribution ----'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "label_name\n", + "Fall 0.149968\n", + "Lying 0.198104\n", + "Other 0.651928\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 1645\n", + "Lying 2173\n", + "Other 7151\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": [ + "5539" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "text/plain": [ @@ -225,9 +292,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.288679\n", - "Lying 0.204657\n", - "Other 0.506664\n", + "Fall 0.296985\n", + "Lying 0.392309\n", + "Other 0.310706\n", "Name: count, dtype: float64" ] }, @@ -247,9 +314,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1711\n", - "Lying 1213\n", - "Other 3003\n", + "Fall 1645\n", + "Lying 2173\n", + "Other 1721\n", "Name: count, dtype: int64" ] }, @@ -258,7 +325,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -268,7 +335,14 @@ } ], "source": [ - "plot_label_dist(df_hqfd)" + "analyse_dataset(train_hqfd)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Val DS" ] }, { @@ -276,6 +350,114 @@ "execution_count": 15, "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": [ @@ -289,9 +471,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.525330\n", - "Lying 0.372429\n", - "Other 0.102241\n", + "Fall 0.046948\n", + "Lying 0.552817\n", + "Other 0.400235\n", "Name: count, dtype: float64" ] }, @@ -311,9 +493,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1711\n", - "Lying 1213\n", - "Other 333\n", + "Fall 40\n", + "Lying 471\n", + "Other 341\n", "Name: count, dtype: int64" ] }, @@ -322,7 +504,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHKCAYAAAAdEHGNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAyBUlEQVR4nO3dfVhVdb7//9dGBBTdG9HYW64QnZOjaJqlRVQ2OTKiOY2OzClPHKPiaDdQo5wx9TvKlN1gZmo6pDUzpTV0e2Z01CaStKSSUHHQMjMrFMrZMBPCDhruZP/+6HL9ZieW2MbNB56P61rX1Vqf91rrvZrVxWvW3bZ5vV6vAAAADBIU6AYAAADaigADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADBOcKAbaC8tLS06duyYevfuLZvNFuh2AADAGfB6vfryyy8VHR2toKDTX2fptAHm2LFjiomJCXQbAADgLJSXl+v8888/7XinDTC9e/eW9PW/ALvdHuBuAADAmfB4PIqJibH+jp9Opw0wJ28b2e12AgwAAIb5rsc/eIgXAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDjBgW6gqxs4/5VAt9BpHFkyOdAtAADOEa7AAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHHaHGAKCgp03XXXKTo6WjabTRs3bjyl5uDBg/rZz34mh8Oh8PBwXXrppSorK7PG6+vrlZ6err59+6pXr15KTk5WRUWFzzbKyso0efJk9ezZU1FRUZo7d66am5vbfoQAAKDTaXOAqaur00UXXaScnJxWxz/55BNdddVVGjp0qN58803t379fixYtUlhYmFUzZ84cbd68WS+//LJ27NihY8eOadq0adb4iRMnNHnyZDU2Nmrnzp1av3691q1bp6ysrLM4RAAA0NnYvF6v96xXttm0YcMGTZ061Vo2ffp0de/eXc8++2yr69TU1Oi8887Tc889p1/84heSpA8//FBxcXEqLCzU5ZdfrldffVU//elPdezYMTmdTknS2rVrNW/ePP3jH/9QSEjId/bm8XjkcDhUU1Mju91+tofY7gbOfyXQLXQaR5ZMDnQLAIDv6Uz/fvv1GZiWlha98sor+uEPf6ikpCRFRUUpPj7e5zZTcXGxmpqalJiYaC0bOnSoBgwYoMLCQklSYWGhRowYYYUXSUpKSpLH49GBAwda3XdDQ4M8Ho/PBAAAOie/BpjKykrV1tZqyZIlmjhxorZu3aqf//znmjZtmnbs2CFJcrvdCgkJUUREhM+6TqdTbrfbqvn38HJy/ORYa7Kzs+VwOKwpJibGn4cGAAA6EL9fgZGkKVOmaM6cORo1apTmz5+vn/70p1q7dq0/d3WKBQsWqKamxprKy8vbdX8AACBw/Bpg+vXrp+DgYA0bNsxneVxcnPUWksvlUmNjo6qrq31qKioq5HK5rJpvvpV0cv5kzTeFhobKbrf7TAAAoHPya4AJCQnRpZdeqkOHDvks/+ijjxQbGytJGj16tLp3765t27ZZ44cOHVJZWZkSEhIkSQkJCXrvvfdUWVlp1eTn58tut58SjgAAQNcT3NYVamtr9fHHH1vzpaWlKikpUWRkpAYMGKC5c+fqhhtu0NVXX61x48YpLy9Pmzdv1ptvvilJcjgcSktLU2ZmpiIjI2W323XXXXcpISFBl19+uSRpwoQJGjZsmGbMmKGlS5fK7XZr4cKFSk9PV2hoqH+OHAAAGKvNAWbPnj0aN26cNZ+ZmSlJSk1N1bp16/Tzn/9ca9euVXZ2tu6++24NGTJEf/rTn3TVVVdZ66xYsUJBQUFKTk5WQ0ODkpKS9Pjjj1vj3bp105YtW3THHXcoISFB4eHhSk1N1eLFi7/PsQIAgE7ie30HpiPjOzBdD9+BAQDzBeQ7MAAAAOcCAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHHaHGAKCgp03XXXKTo6WjabTRs3bjxt7e233y6bzaaVK1f6LK+qqlJKSorsdrsiIiKUlpam2tpan5r9+/dr7NixCgsLU0xMjJYuXdrWVgEAQCfV5gBTV1eniy66SDk5Od9at2HDBr377ruKjo4+ZSwlJUUHDhxQfn6+tmzZooKCAs2aNcsa93g8mjBhgmJjY1VcXKxHHnlE9957r5588sm2tgsAADqh4LauMGnSJE2aNOlbaz7//HPdddddeu211zR58mSfsYMHDyovL0+7d+/WmDFjJEmrV6/Wtddeq2XLlik6Olq5ublqbGzUU089pZCQEA0fPlwlJSVavny5T9ABAABdk9+fgWlpadGMGTM0d+5cDR8+/JTxwsJCRUREWOFFkhITExUUFKSioiKr5uqrr1ZISIhVk5SUpEOHDun48eOt7rehoUEej8dnAgAAnZPfA8zDDz+s4OBg3X333a2Ou91uRUVF+SwLDg5WZGSk3G63VeN0On1qTs6frPmm7OxsORwOa4qJifm+hwIAADoovwaY4uJiPfbYY1q3bp1sNps/N/2dFixYoJqaGmsqLy8/p/sHAADnjl8DzFtvvaXKykoNGDBAwcHBCg4O1tGjR/W///u/GjhwoCTJ5XKpsrLSZ73m5mZVVVXJ5XJZNRUVFT41J+dP1nxTaGio7Ha7zwQAADonvwaYGTNmaP/+/SopKbGm6OhozZ07V6+99pokKSEhQdXV1SouLrbW2759u1paWhQfH2/VFBQUqKmpyarJz8/XkCFD1KdPH3+2DAAADNTmt5Bqa2v18ccfW/OlpaUqKSlRZGSkBgwYoL59+/rUd+/eXS6XS0OGDJEkxcXFaeLEiZo5c6bWrl2rpqYmZWRkaPr06dYr1zfeeKPuu+8+paWlad68eXr//ff12GOPacWKFd/nWAEAQCfR5gCzZ88ejRs3zprPzMyUJKWmpmrdunVntI3c3FxlZGRo/PjxCgoKUnJyslatWmWNOxwObd26Venp6Ro9erT69eunrKwsXqEGAACSJJvX6/UGuon24PF45HA4VFNT06Gfhxk4/5VAt9BpHFky+buLAAAd2pn+/ea3kAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjNPmAFNQUKDrrrtO0dHRstls2rhxozXW1NSkefPmacSIEQoPD1d0dLRuuukmHTt2zGcbVVVVSklJkd1uV0REhNLS0lRbW+tTs3//fo0dO1ZhYWGKiYnR0qVLz+4IAQBAp9PmAFNXV6eLLrpIOTk5p4x99dVX2rt3rxYtWqS9e/fqz3/+sw4dOqSf/exnPnUpKSk6cOCA8vPztWXLFhUUFGjWrFnWuMfj0YQJExQbG6vi4mI98sgjuvfee/Xkk0+exSECAIDOxub1er1nvbLNpg0bNmjq1Kmnrdm9e7cuu+wyHT16VAMGDNDBgwc1bNgw7d69W2PGjJEk5eXl6dprr9Vnn32m6OhorVmzRr/+9a/ldrsVEhIiSZo/f742btyoDz/88Ix683g8cjgcqqmpkd1uP9tDbHcD578S6BY6jSNLJge6hU6D89I/OCeBtjvTv9/t/gxMTU2NbDabIiIiJEmFhYWKiIiwwoskJSYmKigoSEVFRVbN1VdfbYUXSUpKStKhQ4d0/PjxVvfT0NAgj8fjMwEAgM6pXQNMfX295s2bp//6r/+yUpTb7VZUVJRPXXBwsCIjI+V2u60ap9PpU3Ny/mTNN2VnZ8vhcFhTTEyMvw8HAAB0EO0WYJqamnT99dfL6/VqzZo17bUby4IFC1RTU2NN5eXl7b5PAAAQGMHtsdGT4eXo0aPavn27zz0sl8ulyspKn/rm5mZVVVXJ5XJZNRUVFT41J+dP1nxTaGioQkND/XkYAACgg/L7FZiT4eXw4cN6/fXX1bdvX5/xhIQEVVdXq7i42Fq2fft2tbS0KD4+3qopKChQU1OTVZOfn68hQ4aoT58+/m4ZAAAYps0Bpra2ViUlJSopKZEklZaWqqSkRGVlZWpqatIvfvEL7dmzR7m5uTpx4oTcbrfcbrcaGxslSXFxcZo4caJmzpypXbt26Z133lFGRoamT5+u6OhoSdKNN96okJAQpaWl6cCBA3rxxRf12GOPKTMz039HDgAAjNXmW0h79uzRuHHjrPmToSI1NVX33nuvNm3aJEkaNWqUz3pvvPGGrrnmGklSbm6uMjIyNH78eAUFBSk5OVmrVq2yah0Oh7Zu3ar09HSNHj1a/fr1U1ZWls+3YgAAQNfV5gBzzTXX6Ns+HXMmn5WJjIzUc8899601I0eO1FtvvdXW9gAAQBfAbyEBAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABinzQGmoKBA1113naKjo2Wz2bRx40afca/Xq6ysLPXv3189evRQYmKiDh8+7FNTVVWllJQU2e12RUREKC0tTbW1tT41+/fv19ixYxUWFqaYmBgtXbq07UcHAAA6pTYHmLq6Ol100UXKyclpdXzp0qVatWqV1q5dq6KiIoWHhyspKUn19fVWTUpKig4cOKD8/Hxt2bJFBQUFmjVrljXu8Xg0YcIExcbGqri4WI888ojuvfdePfnkk2dxiAAAoLMJbusKkyZN0qRJk1od83q9WrlypRYuXKgpU6ZIkp555hk5nU5t3LhR06dP18GDB5WXl6fdu3drzJgxkqTVq1fr2muv1bJlyxQdHa3c3Fw1NjbqqaeeUkhIiIYPH66SkhItX77cJ+gAAICuya/PwJSWlsrtdisxMdFa5nA4FB8fr8LCQklSYWGhIiIirPAiSYmJiQoKClJRUZFVc/XVVyskJMSqSUpK0qFDh3T8+PFW993Q0CCPx+MzAQCAzsmvAcbtdkuSnE6nz3Kn02mNud1uRUVF+YwHBwcrMjLSp6a1bfz7Pr4pOztbDofDmmJiYr7/AQEAgA6p07yFtGDBAtXU1FhTeXl5oFsCAADtxK8BxuVySZIqKip8lldUVFhjLpdLlZWVPuPNzc2qqqryqWltG/++j28KDQ2V3W73mQAAQOfk1wAzaNAguVwubdu2zVrm8XhUVFSkhIQESVJCQoKqq6tVXFxs1Wzfvl0tLS2Kj4+3agoKCtTU1GTV5Ofna8iQIerTp48/WwYAAAZqc4Cpra1VSUmJSkpKJH394G5JSYnKyspks9k0e/ZsPfDAA9q0aZPee+893XTTTYqOjtbUqVMlSXFxcZo4caJmzpypXbt26Z133lFGRoamT5+u6OhoSdKNN96okJAQpaWl6cCBA3rxxRf12GOPKTMz028HDgAAzNXm16j37NmjcePGWfMnQ0VqaqrWrVune+65R3V1dZo1a5aqq6t11VVXKS8vT2FhYdY6ubm5ysjI0Pjx4xUUFKTk5GStWrXKGnc4HNq6davS09M1evRo9evXT1lZWbxCDQAAJEk2r9frDXQT7cHj8cjhcKimpqZDPw8zcP4rgW6h0ziyZHKgW+g0OC/9g3MSaLsz/fvdad5CAgAAXQcBBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOH4PMCdOnNCiRYs0aNAg9ejRQ//xH/+h+++/X16v16rxer3KyspS//791aNHDyUmJurw4cM+26mqqlJKSorsdrsiIiKUlpam2tpaf7cLAAAM5PcA8/DDD2vNmjX67W9/q4MHD+rhhx/W0qVLtXr1aqtm6dKlWrVqldauXauioiKFh4crKSlJ9fX1Vk1KSooOHDig/Px8bdmyRQUFBZo1a5a/2wUAAAYK9vcGd+7cqSlTpmjy5MmSpIEDB+r555/Xrl27JH199WXlypVauHChpkyZIkl65pln5HQ6tXHjRk2fPl0HDx5UXl6edu/erTFjxkiSVq9erWuvvVbLli1TdHS0v9sGAAAG8fsVmCuuuELbtm3TRx99JEnat2+f3n77bU2aNEmSVFpaKrfbrcTERGsdh8Oh+Ph4FRYWSpIKCwsVERFhhRdJSkxMVFBQkIqKilrdb0NDgzwej88EAAA6J79fgZk/f748Ho+GDh2qbt266cSJE3rwwQeVkpIiSXK73ZIkp9Pps57T6bTG3G63oqKifBsNDlZkZKRV803Z2dm67777/H04AACgA/L7FZiXXnpJubm5eu6557R3716tX79ey5Yt0/r16/29Kx8LFixQTU2NNZWXl7fr/gAAQOD4/QrM3LlzNX/+fE2fPl2SNGLECB09elTZ2dlKTU2Vy+WSJFVUVKh///7WehUVFRo1apQkyeVyqbKy0me7zc3Nqqqqstb/ptDQUIWGhvr7cAAAQAfk9yswX331lYKCfDfbrVs3tbS0SJIGDRokl8ulbdu2WeMej0dFRUVKSEiQJCUkJKi6ulrFxcVWzfbt29XS0qL4+Hh/twwAAAzj9ysw1113nR588EENGDBAw4cP19/+9jctX75ct956qyTJZrNp9uzZeuCBBzR48GANGjRIixYtUnR0tKZOnSpJiouL08SJEzVz5kytXbtWTU1NysjI0PTp03kDCQAA+D/ArF69WosWLdKdd96pyspKRUdH67bbblNWVpZVc88996iurk6zZs1SdXW1rrrqKuXl5SksLMyqyc3NVUZGhsaPH6+goCAlJydr1apV/m4XAAAYyOb990/kdiIej0cOh0M1NTWy2+2Bbue0Bs5/JdAtdBpHlkwOdAudBuelf3BOAm13pn+/+S0kAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjtEuA+fzzz/Xf//3f6tu3r3r06KERI0Zoz5491rjX61VWVpb69++vHj16KDExUYcPH/bZRlVVlVJSUmS32xUREaG0tDTV1ta2R7sAAMAwfg8wx48f15VXXqnu3bvr1Vdf1QcffKBHH31Uffr0sWqWLl2qVatWae3atSoqKlJ4eLiSkpJUX19v1aSkpOjAgQPKz8/Xli1bVFBQoFmzZvm7XQAAYKBgf2/w4YcfVkxMjJ5++mlr2aBBg6x/9nq9WrlypRYuXKgpU6ZIkp555hk5nU5t3LhR06dP18GDB5WXl6fdu3drzJgxkqTVq1fr2muv1bJlyxQdHe3vtgEAgEH8fgVm06ZNGjNmjP7zP/9TUVFRuvjii/W73/3OGi8tLZXb7VZiYqK1zOFwKD4+XoWFhZKkwsJCRUREWOFFkhITExUUFKSioqJW99vQ0CCPx+MzAQCAzsnvAebTTz/VmjVrNHjwYL322mu64447dPfdd2v9+vWSJLfbLUlyOp0+6zmdTmvM7XYrKirKZzw4OFiRkZFWzTdlZ2fL4XBYU0xMjL8PDQAAdBB+DzAtLS265JJL9NBDD+niiy/WrFmzNHPmTK1du9bfu/KxYMEC1dTUWFN5eXm77g8AAASO3wNM//79NWzYMJ9lcXFxKisrkyS5XC5JUkVFhU9NRUWFNeZyuVRZWekz3tzcrKqqKqvmm0JDQ2W3230mAADQOfk9wFx55ZU6dOiQz7KPPvpIsbGxkr5+oNflcmnbtm3WuMfjUVFRkRISEiRJCQkJqq6uVnFxsVWzfft2tbS0KD4+3t8tAwAAw/j9LaQ5c+boiiuu0EMPPaTrr79eu3bt0pNPPqknn3xSkmSz2TR79mw98MADGjx4sAYNGqRFixYpOjpaU6dOlfT1FZuJEydat56ampqUkZGh6dOn8wYSAADwf4C59NJLtWHDBi1YsECLFy/WoEGDtHLlSqWkpFg199xzj+rq6jRr1ixVV1frqquuUl5ensLCwqya3NxcZWRkaPz48QoKClJycrJWrVrl73YBAICBbF6v1xvoJtqDx+ORw+FQTU1Nh34eZuD8VwLdQqdxZMnkQLfQaXBe+gfnJNB2Z/r3m99CAgAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwTrsHmCVLlshms2n27NnWsvr6eqWnp6tv377q1auXkpOTVVFR4bNeWVmZJk+erJ49eyoqKkpz585Vc3Nze7cLAAAM0K4BZvfu3XriiSc0cuRIn+Vz5szR5s2b9fLLL2vHjh06duyYpk2bZo2fOHFCkydPVmNjo3bu3Kn169dr3bp1ysrKas92AQCAIdotwNTW1iolJUW/+93v1KdPH2t5TU2N/vCHP2j58uX68Y9/rNGjR+vpp5/Wzp079e6770qStm7dqg8++EB//OMfNWrUKE2aNEn333+/cnJy1NjY2F4tAwAAQ7RbgElPT9fkyZOVmJjos7y4uFhNTU0+y4cOHaoBAwaosLBQklRYWKgRI0bI6XRaNUlJSfJ4PDpw4ECr+2toaJDH4/GZAABA5xTcHht94YUXtHfvXu3evfuUMbfbrZCQEEVERPgsdzqdcrvdVs2/h5eT4yfHWpOdna377rvPD90DAICOzu9XYMrLy/XLX/5Subm5CgsL8/fmT2vBggWqqamxpvLy8nO2bwAAcG75PcAUFxersrJSl1xyiYKDgxUcHKwdO3Zo1apVCg4OltPpVGNjo6qrq33Wq6iokMvlkiS5XK5T3ko6OX+y5ptCQ0Nlt9t9JgAA0Dn5PcCMHz9e7733nkpKSqxpzJgxSklJsf65e/fu2rZtm7XOoUOHVFZWpoSEBElSQkKC3nvvPVVWVlo1+fn5stvtGjZsmL9bBgAAhvH7MzC9e/fWhRde6LMsPDxcffv2tZanpaUpMzNTkZGRstvtuuuuu5SQkKDLL79ckjRhwgQNGzZMM2bM0NKlS+V2u7Vw4UKlp6crNDTU3y0DAADDtMtDvN9lxYoVCgoKUnJyshoaGpSUlKTHH3/cGu/WrZu2bNmiO+64QwkJCQoPD1dqaqoWL14ciHYBAEAHc04CzJtvvukzHxYWppycHOXk5Jx2ndjYWP31r39t584AAICJ+C0kAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxAvIhOwAA2mLg/FcC3UKncWTJ5EC34BdcgQEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADCO3wNMdna2Lr30UvXu3VtRUVGaOnWqDh065FNTX1+v9PR09e3bV7169VJycrIqKip8asrKyjR58mT17NlTUVFRmjt3rpqbm/3dLgAAMJDfA8yOHTuUnp6ud999V/n5+WpqatKECRNUV1dn1cyZM0ebN2/Wyy+/rB07dujYsWOaNm2aNX7ixAlNnjxZjY2N2rlzp9avX69169YpKyvL3+0CAAADBft7g3l5eT7z69atU1RUlIqLi3X11VerpqZGf/jDH/Tcc8/pxz/+sSTp6aefVlxcnN59911dfvnl2rp1qz744AO9/vrrcjqdGjVqlO6//37NmzdP9957r0JCQvzdNgAAMEi7PwNTU1MjSYqMjJQkFRcXq6mpSYmJiVbN0KFDNWDAABUWFkqSCgsLNWLECDmdTqsmKSlJHo9HBw4caHU/DQ0N8ng8PhMAAOic2jXAtLS0aPbs2bryyit14YUXSpLcbrdCQkIUERHhU+t0OuV2u62afw8vJ8dPjrUmOztbDofDmmJiYvx8NAAAoKNo1wCTnp6u999/Xy+88EJ77kaStGDBAtXU1FhTeXl5u+8TAAAEht+fgTkpIyNDW7ZsUUFBgc4//3xrucvlUmNjo6qrq32uwlRUVMjlclk1u3bt8tneybeUTtZ8U2hoqEJDQ/18FAAAoCPy+xUYr9erjIwMbdiwQdu3b9egQYN8xkePHq3u3btr27Zt1rJDhw6prKxMCQkJkqSEhAS99957qqystGry8/Nlt9s1bNgwf7cMAAAM4/crMOnp6Xruuef0l7/8Rb1797aeWXE4HOrRo4ccDofS0tKUmZmpyMhI2e123XXXXUpISNDll18uSZowYYKGDRumGTNmaOnSpXK73Vq4cKHS09O5ygIAAPwfYNasWSNJuuaaa3yWP/3007r55pslSStWrFBQUJCSk5PV0NCgpKQkPf7441Ztt27dtGXLFt1xxx1KSEhQeHi4UlNTtXjxYn+3CwAADOT3AOP1er+zJiwsTDk5OcrJyTltTWxsrP7617/6szUAANBJ8FtIAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIxDgAEAAMYhwAAAAOMQYAAAgHEIMAAAwDgEGAAAYBwCDAAAMA4BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAACAcQgwAADAOAQYAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADG6dABJicnRwMHDlRYWJji4+O1a9euQLcEAAA6gA4bYF588UVlZmbqN7/5jfbu3auLLrpISUlJqqysDHRrAAAgwDpsgFm+fLlmzpypW265RcOGDdPatWvVs2dPPfXUU4FuDQAABFhwoBtoTWNjo4qLi7VgwQJrWVBQkBITE1VYWNjqOg0NDWpoaLDma2pqJEkej6d9m/2eWhq+CnQLnUZH/9/aJJyX/sE56T+ck/7T0c/Lk/15vd5vreuQAeaf//ynTpw4IafT6bPc6XTqww8/bHWd7Oxs3Xfffacsj4mJaZce0fE4Vga6A8AX5yQ6IlPOyy+//FIOh+O04x0ywJyNBQsWKDMz05pvaWlRVVWV+vbtK5vNFsDOzOfxeBQTE6Py8nLZ7fZAtwNwTqLD4Zz0H6/Xqy+//FLR0dHfWtchA0y/fv3UrVs3VVRU+CyvqKiQy+VqdZ3Q0FCFhob6LIuIiGivFrsku93Of5joUDgn0dFwTvrHt115OalDPsQbEhKi0aNHa9u2bdaylpYWbdu2TQkJCQHsDAAAdAQd8gqMJGVmZio1NVVjxozRZZddppUrV6qurk633HJLoFsDAAAB1mEDzA033KB//OMfysrKktvt1qhRo5SXl3fKg71of6GhofrNb35zyi06IFA4J9HRcE6eezbvd72nBAAA0MF0yGdgAAAAvg0BBgAAGIcAAwAAjEOAAQAAxiHAAAAA4xBgAABoo+bmZj3zzDOnfDEe5w6vUQMAcBZ69uypgwcPKjY2NtCtdEkd9kN2OPcuvvjiM/7hy71797ZzNwDQsV122WUqKSkhwAQIAQaWqVOnBroF4LT69OnTasC22WwKCwvTBRdcoJtvvpmfG8E5c+eddyozM1Pl5eUaPXq0wsPDfcZHjhwZoM66Bm4hATDCihUr9OCDD2rSpEm67LLLJEm7du1SXl6e5syZo9LSUj377LNavXq1Zs6cGeBu0RUEBZ36GKnNZpPX65XNZtOJEycC0FXXQYABYITk5GT95Cc/0e233+6z/IknntDWrVv1pz/9SatXr9aTTz6p9957L0Bdois5evTot45za6l9EWBgOd0l+tZUVVW1czeAr169eqmkpEQXXHCBz/KPP/5Yo0aNUm1trT755BONHDlSdXV1AeoSwLnCMzCwrFy5MtAtAKcVGRmpzZs3a86cOT7LN2/erMjISElSXV2devfuHYj20EU9++yzWrt2rUpLS1VYWKjY2FitXLlSgwYN0pQpUwLdXqdGgIElNTU10C0Ap7Vo0SLdcccdeuONN6xnYHbv3q2//vWvWrt2rSQpPz9fP/rRjwLZJrqQNWvWKCsrS7Nnz9aDDz5oPfMSERGhlStXEmDaGbeQ8J3q6+vV2Njos8xutweoG3Rl77zzjn7729/q0KFDkqQhQ4borrvu0hVXXBHgztAVDRs2TA899JCmTp2q3r17a9++ffrBD36g999/X9dcc43++c9/BrrFTo0rMGhVXV2d5s2bp5deeklffPHFKeM8XY9AuPLKK3XllVcGug1AklRaWqqLL774lOWhoaE8h3UOEGDQqnvuuUdvvPGG1qxZoxkzZignJ0eff/65nnjiCS1ZsiTQ7aGLamlp0ccff6zKykq1tLT4jF199dUB6gpd1aBBg1r9kF1eXp7i4uIC1FXXQYBBqzZv3qxnnnlG11xzjW655RaNHTtWF1xwgWJjY5Wbm6uUlJRAt4gu5t1339WNN96oo0eP6pt3vvnmBgIhMzNT6enpqq+vl9fr1a5du/T8888rOztbv//97wPdXqdHgEGrqqqq9IMf/EDS18+7nHxt+qqrrtIdd9wRyNbQRd1+++0aM2aMXnnlFfXv3/+MX/kH2sv//M//qEePHlq4cKG++uor3XjjjYqOjtZjjz2m6dOnB7q9To8Ag1b94Ac/UGlpqQYMGKChQ4fqpZde0mWXXabNmzcrIiIi0O2hCzp8+LD+7//+75TvwACBlJKSopSUFH311Veqra1VVFRUoFvqMk79DjK6tE8//VQtLS265ZZbtG/fPknS/PnzlZOTo7CwMM2ZM0dz584NcJfoiuLj4/Xxxx8Hug2gVT179iS8nGO8Rg0f3bp109///nfrP8QbbrhBq1atUn19vYqLi3XBBRfwA2UIiA0bNmjhwoWaO3euRowYoe7du/uMc17iXKuoqNCvfvUrbdu2TZWVlac8m8VzWe2LAAMfQUFBcrvdVoD5928bAIHED+eho5k0aZLKysqUkZHR6nNZfMiuffEMDAAjlJaWBroFwMfbb7+tt956S6NGjQp0K10SAQY+bDbbKf8vgrc90BHwy77oaGJiYk65bYRzh1tI8BEUFKRJkyYpNDRU0tffg/nxj3+s8PBwn7o///nPgWgPXcymTZs0adIkde/eXZs2bfrW2p/97GfnqCvga1u3btWjjz6qJ554QgMHDgx0O10OAQY+brnlljOqe/rpp9u5E8D3mazWnoE5iWdgcK706dPH56p0XV2dmpub1bNnz1MeLD/5/Sy0DwIMAABnaP369Wdcm5qa2o6dgAADwAiffvopb8MBsPAhOwBGuOCCCzRu3Dj98Y9/VH19faDbAdStWzdVVlaesvyLL75Qt27dAtBR10KAAWCEvXv3auTIkcrMzJTL5dJtt92mXbt2BbotdGGnu4HR0NCgkJCQc9xN18MtJABGaW5u1qZNm7Ru3Trl5eXphz/8oW699VbNmDFD5513XqDbQxewatUqSdKcOXN0//33q1evXtbYiRMnVFBQoCNHjuhvf/tboFrsEggwAIzU0NCgxx9/XAsWLFBjY6NCQkJ0/fXX6+GHH1b//v0D3R46sUGDBkmSjh49qvPPP9/ndlFISIgGDhyoxYsXKz4+PlAtdgkEGABG2bNnj5566im98MILCg8PV2pqqtLS0vTZZ5/pvvvuk8fj4dYSzolx48bpz3/+s5qbm2Wz2dSvX79At9Sl8AwMACMsX75cI0aM0BVXXKFjx47pmWee0dGjR3X77bcrOztbY8eO1bp167R3795At4ouoLq6WnFxcRo8eLBcLpecTqf69eunjIwMVVdXB7q9LoErMACMMHjwYN166626+eabfW4R7du3T5dccolOnDihxsZGPf/883x/A+2qqqpKCQkJ+vzzz5WSkqK4uDhJ0gcffKDnnntOMTEx2rlzp/r06RPgTjs3AgwAo/17gAHOhdmzZ2vbtm16/fXX5XQ6fcbcbrcmTJig8ePHa8WKFQHqsGvgFhIAAG2wceNGLVu27JTwIkkul0tLly7Vhg0bAtBZ10KAAQCgDf7+979r+PDhpx2/8MIL5Xa7z2FHXVNwoBsAgG8zbdq0bx3ngUmca/369dORI0d0/vnntzpeWlqqyMjIc9xV10OAAdChORyO7xy/6aabzlE3gJSUlKRf//rXys/PP+WLuw0NDVq0aJEmTpwYoO66Dh7iBQCgDT777DONGTNGoaGhSk9P19ChQ+X1enXw4EE9/vjjamho0J49exQTExPoVjs1AgwAAG1UWlqqO++8U1u3brV+E8lms+knP/mJfvvb3+qCCy4IcIedHwEGAICzdPz4cR0+fFjS17+YzrMv5w4BBgAAGIfXqAEAgHEIMAAAwDgEGAAAYBwCDIDTuuaaazR79uwzqn3zzTdls9m+94flBg4cqJUrV36vbQDo/AgwAADAOAQYAABgHAIMgDPy7LPPasyYMerdu7dcLpduvPFGVVZWnlL3zjvvaOTIkQoLC9Pll1+u999/32f87bff1tixY9WjRw/FxMTo7rvvVl1d3Vn1ZLPZ9Pvf/14///nP1bNnTw0ePFibNm2yxk+cOKG0tDQNGjRIPXr00JAhQ/TYY4/5bOPmm2/W1KlT9dBDD8npdCoiIkKLFy9Wc3Oz5s6dq8jISJ1//vl6+umnfdYrLy/X9ddfr4iICEVGRmrKlCk6cuTIWR0HgLYjwAA4I01NTbr//vu1b98+bdy4UUeOHNHNN998St3cuXP16KOPavfu3TrvvPN03XXXqampSZL0ySefaOLEiUpOTtb+/fv14osv6u2331ZGRsZZ93Xffffp+uuv1/79+3XttdcqJSVFVVVVkqSWlhadf/75evnll/XBBx8oKytL/+///T+99NJLPtvYvn27jh07poKCAi1fvly/+c1v9NOf/lR9+vRRUVGRbr/9dt1222367LPPrH8XSUlJ6t27t9566y2988476tWrlyZOnKjGxsazPhYAbeAFgNP40Y9+5P3lL3/Z6tju3bu9krxffvml1+v1et944w2vJO8LL7xg1XzxxRfeHj16eF988UWv1+v1pqWleWfNmuWznbfeessbFBTk/de//uX1er3e2NhY74oVK86oP0nehQsXWvO1tbVeSd5XX331tOukp6d7k5OTrfnU1FRvbGys98SJE9ayIUOGeMeOHWvNNzc3e8PDw73PP/+81+v1ep999lnvkCFDvC0tLVZNQ0ODt0ePHt7XXnvtjHoH8P3wa9QAzkhxcbHuvfde7du3T8ePH1dLS4skqaysTMOGDbPqEhISrH+OjIzUkCFDdPDgQUnSvn37tH//fuXm5lo1Xq9XLS0tKi0tVVxcXJv7GjlypPXP4eHhstvtPre2cnJy9NRTT6msrEz/+te/1NjYqFGjRvlsY/jw4QoK+v8vSDudTl144YXWfLdu3dS3b19ru/v27dPHH3+s3r17+2ynvr5en3zySZuPAUDbEWAAfKe6ujolJSUpKSlJubm5Ou+881RWVqakpKQ23TKpra3VbbfdprvvvvuUsQEDBpxVb927d/eZt9lsVrh64YUX9Ktf/UqPPvqoEhIS1Lt3bz3yyCMqKir6zm1823Zra2s1evRonyB20nnnnXdWxwGgbQgwAL7Thx9+qC+++EJLlixRTEyMJGnPnj2t1r777rtWGDl+/Lg++ugj68rKJZdcog8++OCc/VLvO++8oyuuuEJ33nmntcwfV0guueQSvfjii4qKipLdbv/e2wPQdjzEC+A7DRgwQCEhIVq9erU+/fRTbdq0Sffff3+rtYsXL9a2bdv0/vvv6+abb1a/fv00depUSdK8efO0c+dOZWRkqKSkRIcPH9Zf/vKX7/UQ77cZPHiw9uzZo9dee00fffSRFi1apN27d3/v7aakpKhfv36aMmWK3nrrLZWWlurNN9/U3XffbT3oC6B9EWAAfKfzzjtP69at08svv6xhw4ZpyZIlWrZsWau1S5Ys0S9/+UuNHj1abrdbmzdvVkhIiKSvn1fZsWOHPvroI40dO1YXX3yxsrKyFB0d3S5933bbbZo2bZpuuOEGxcfH64svvvC5GnO2evbsqYKCAg0YMEDTpk1TXFyc0tLSVF9fzxUZ4Byxeb1eb6CbAAAAaAuuwAAAAOMQYAB0SLm5uerVq1er0/DhwwPdHoAA4xYSgA7pyy+/VEVFRatj3bt3V2xs7DnuCEBHQoABAADG4RYSAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGCc/w91xk3dlplNrQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -332,33 +514,200 @@ } ], "source": [ - "plot_label_dist(df_hqfd[df_hqfd[\"video_category\"] == \"Fall\"])" + "analyse_dataset(val_hqfd)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Class weight calculation\n", + "# Visualization of Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from mmaction.visualization import ActionVisualizer\n", "\n", - "weight_for_class_i = total_samples / (num_samples_in_class_i * num_classes)" + "vis = ActionVisualizer()\n", + "\n", + "\n", + "def get_random_sample_from_class(ds: HighQualityFallDataset, label: int, n: int = 1):\n", + " dl = pd.DataFrame(val_hqfd.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": [ + "### Class 0 Samples in Val" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "86dd9be0cfd948a0ad4b5a04dd2446e5", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "[26.38235294117647, 37.901408450704224, 3.7168508287292816]" + "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": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f2dabc415963455bb02ba77e928b37aa", + "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": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ba16baab0b4a4e678010719099954a9c", + "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": [ + "# Class weight calculation\n", + "\n", + "weight_for_class_i = total_samples / (num_samples_in_class_i * num_classes)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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 15\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", @@ -392,4 +741,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From e11745baf3ac4c8ca3b824a02e87b425eff446fa Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 19:05:15 +0100 Subject: [PATCH 21/25] tinkered with visualization --- notebooks/dataset_label_analysis.ipynb | 159 ++++++++++++++++++++----- 1 file changed, 126 insertions(+), 33 deletions(-) diff --git a/notebooks/dataset_label_analysis.ipynb b/notebooks/dataset_label_analysis.ipynb index 8824ec3..d4d6287 100644 --- a/notebooks/dataset_label_analysis.ipynb +++ b/notebooks/dataset_label_analysis.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ "val_pipeline = [\n", " DecordInit(),\n", " ClipVideo(),\n", - " SampleFrames(clip_len=16, frame_interval=9, num_clips=1, test_mode=True),\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", @@ -77,13 +77,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "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", @@ -120,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -133,6 +135,7 @@ "\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", @@ -168,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -192,7 +195,7 @@ { "data": { "text/plain": [ - "10969" + "10876" ] }, "metadata": {}, @@ -211,9 +214,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.149968\n", - "Lying 0.198104\n", - "Other 0.651928\n", + "Fall 0.146837\n", + "Lying 0.194189\n", + "Other 0.658974\n", "Name: count, dtype: float64" ] }, @@ -233,9 +236,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1645\n", - "Lying 2173\n", - "Other 7151\n", + "Fall 1597\n", + "Lying 2112\n", + "Other 7167\n", "Name: count, dtype: int64" ] }, @@ -244,7 +247,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -273,7 +276,7 @@ { "data": { "text/plain": [ - "5539" + "5532" ] }, "metadata": {}, @@ -292,9 +295,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 0.296985\n", - "Lying 0.392309\n", - "Other 0.310706\n", + "Fall 0.288684\n", + "Lying 0.381779\n", + "Other 0.329537\n", "Name: count, dtype: float64" ] }, @@ -314,9 +317,9 @@ "data": { "text/plain": [ "label_name\n", - "Fall 1645\n", - "Lying 2173\n", - "Other 1721\n", + "Fall 1597\n", + "Lying 2112\n", + "Other 1823\n", "Name: count, dtype: int64" ] }, @@ -325,7 +328,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -347,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -526,7 +529,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -536,7 +539,8 @@ "\n", "\n", "def get_random_sample_from_class(ds: HighQualityFallDataset, label: int, n: int = 1):\n", - " dl = pd.DataFrame(val_hqfd.load_data_list())\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", @@ -586,6 +590,13 @@ " shutil.rmtree(\"tmp\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Validation Vis" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -595,13 +606,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "86dd9be0cfd948a0ad4b5a04dd2446e5", + "model_id": "ece263d38db14c2f996cc4766a5201d8", "version_major": 2, "version_minor": 0 }, @@ -627,13 +638,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f2dabc415963455bb02ba77e928b37aa", + "model_id": "9f65ac016a0447d1b751e327a0ae8305", "version_major": 2, "version_minor": 0 }, @@ -659,13 +670,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ba16baab0b4a4e678010719099954a9c", + "model_id": "cce622ef085647279b2cd1419a3168d8", "version_major": 2, "version_minor": 0 }, @@ -682,6 +693,88 @@ "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": {}, @@ -693,7 +786,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -703,7 +796,7 @@ "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 15\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[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" ] } From 48e42fc4485391b39f4ce04999305be6753a8292 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 19:13:07 +0100 Subject: [PATCH 22/25] fixed some upsies --- ...ing-5s-clips-30-drop_priority-labeling_k400-hyperparams.py | 4 +++- ...ing-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh | 3 +-- 2 files changed, 4 insertions(+), 3 deletions(-) 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 index 3f6cbc4..b1d81d7 100644 --- 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 @@ -2,7 +2,9 @@ "../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" +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}/") ) 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 index 2c6456d..0fafc47 100644 --- 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 @@ -7,5 +7,4 @@ 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 \ - --resume auto \ No newline at end of file + configs/experiments/vit-b_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py \ No newline at end of file From 13328340833d1351d7277ea51e1c75d57f30e2c7 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 19:13:18 +0100 Subject: [PATCH 23/25] changed overfitting run --- configs/experiments/overfitting_run.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/configs/experiments/overfitting_run.py b/configs/experiments/overfitting_run.py index b7e2110..06800f4 100644 --- a/configs/experiments/overfitting_run.py +++ b/configs/experiments/overfitting_run.py @@ -10,18 +10,22 @@ # Overrides train_dataloader = dict( + batch_size=1, sampler=dict(type="DefaultSampler", shuffle=False), dataset=dict( - indices=10, + indices=100, ), ) 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=10, + indices=100, ), ) From 3c44c2014b982f258f648c7b0d741c259ad00aac Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Wed, 6 Dec 2023 19:16:38 +0100 Subject: [PATCH 24/25] added frame interval 8 experiment --- ...drop_priority-labeling_k400-hyperparams.py | 78 +++++++++++++++++++ ...drop_priority-labeling_k400-hyperparams.sh | 10 +++ 2 files changed, 88 insertions(+) create mode 100644 configs/experiments/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.py create mode 100644 job_scripts/vit-b_frame-int-8_gaussian-sampling-5s-clips-30-drop_priority-labeling_k400-hyperparams.sh 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/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 From 0c9b189321de5faca42abdd249ff0501394db0b0 Mon Sep 17 00:00:00 2001 From: Till Grutschus Date: Sun, 10 Dec 2023 14:26:54 +0100 Subject: [PATCH 25/25] uploaded results to dvc --- experiments.dvc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/experiments.dvc b/experiments.dvc index cc6d760..ff1b824 100644 --- a/experiments.dvc +++ b/experiments.dvc @@ -1,6 +1,6 @@ outs: -- md5: c99fd58aef02c984c5f078634e666f3a.dir - size: 9316741750 - nfiles: 30 +- md5: 55075530cd6a7d51a35547b6eebafda0.dir + size: 21652483819 + nfiles: 97 hash: md5 path: experiments