first commit

configs/_base_/models/vgg19.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(type='VGG', depth=19, num_classes=1000),
+    neck=None,
+    head=dict(
+        type='ClsHead',
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/models/vgg19bn.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='VGG', depth=19, norm_cfg=dict(type='BN'), num_classes=1000),
+    neck=None,
+    head=dict(
+        type='ClsHead',
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/models/vig/pyramid_vig_base.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='PyramidVig',
+        arch='base',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_stochastic=False,
+        drop_path=0.1,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=1024,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/pyramid_vig_medium.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='PyramidVig',
+        arch='medium',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_stochastic=False,
+        drop_path=0.1,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=768,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/pyramid_vig_small.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='PyramidVig',
+        arch='small',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_stochastic=False,
+        drop_path=0.1,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=640,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/pyramid_vig_tiny.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='PyramidVig',
+        arch='tiny',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_stochastic=False,
+        drop_path=0.1,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=384,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/vig_base.py

+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='Vig',
+        arch='base',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_dilation=True,
+        use_stochastic=False,
+        drop_path=0.1,
+        relative_pos=False,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=640,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/vig_small.py

+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='Vig',
+        arch='small',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_dilation=True,
+        use_stochastic=False,
+        drop_path=0.1,
+        relative_pos=False,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=320,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vig/vig_tiny.py

+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='Vig',
+        arch='tiny',
+        k=9,
+        act_cfg=dict(type='GELU'),
+        norm_cfg=dict(type='BN'),
+        graph_conv_type='mr',
+        graph_conv_bias=True,
+        epsilon=0.2,
+        use_dilation=True,
+        use_stochastic=False,
+        drop_path=0.1,
+        relative_pos=False,
+        norm_eval=False,
+        frozen_stages=0),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='VigClsHead',
+        num_classes=1000,
+        in_channels=192,
+        hidden_dim=1024,
+        act_cfg=dict(type='GELU'),
+        dropout=0.,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ),
+    train_cfg=dict(augments=[
+        dict(type='Mixup', alpha=0.8),
+        dict(type='CutMix', alpha=1.0)
+    ]),
+)

configs/_base_/models/vit-base-p16.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='VisionTransformer',
+        arch='b',
+        img_size=224,
+        patch_size=16,
+        drop_rate=0.1,
+        init_cfg=[
+            dict(
+                type='Kaiming',
+                layer='Conv2d',
+                mode='fan_in',
+                nonlinearity='linear')
+        ]),
+    neck=None,
+    head=dict(
+        type='VisionTransformerClsHead',
+        num_classes=1000,
+        in_channels=768,
+        loss=dict(
+            type='LabelSmoothLoss', label_smooth_val=0.1,
+            mode='classy_vision'),
+    ))

configs/_base_/models/vit-base-p32.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='VisionTransformer',
+        arch='b',
+        img_size=224,
+        patch_size=32,
+        drop_rate=0.1,
+        init_cfg=[
+            dict(
+                type='Kaiming',
+                layer='Conv2d',
+                mode='fan_in',
+                nonlinearity='linear')
+        ]),
+    neck=None,
+    head=dict(
+        type='VisionTransformerClsHead',
+        num_classes=1000,
+        in_channels=768,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/models/vit-large-p16.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='VisionTransformer',
+        arch='l',
+        img_size=224,
+        patch_size=16,
+        drop_rate=0.1,
+        init_cfg=[
+            dict(
+                type='Kaiming',
+                layer='Conv2d',
+                mode='fan_in',
+                nonlinearity='linear')
+        ]),
+    neck=None,
+    head=dict(
+        type='VisionTransformerClsHead',
+        num_classes=1000,
+        in_channels=1024,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/models/vit-large-p32.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='VisionTransformer',
+        arch='l',
+        img_size=224,
+        patch_size=32,
+        drop_rate=0.1,
+        init_cfg=[
+            dict(
+                type='Kaiming',
+                layer='Conv2d',
+                mode='fan_in',
+                nonlinearity='linear')
+        ]),
+    neck=None,
+    head=dict(
+        type='VisionTransformerClsHead',
+        num_classes=1000,
+        in_channels=1024,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/models/wide-resnet50.py

+# model settings
+model = dict(
+    type='ImageClassifier',
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(3, ),
+        stem_channels=64,
+        base_channels=128,
+        expansion=2,
+        style='pytorch'),
+    neck=dict(type='GlobalAveragePooling'),
+    head=dict(
+        type='LinearClsHead',
+        num_classes=1000,
+        in_channels=2048,
+        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+        topk=(1, 5),
+    ))

configs/_base_/schedules/cifar10_bs128.py

+# optimizer
+optim_wrapper = dict(
+    optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001))
+# learning policy
+param_scheduler = dict(
+    type='MultiStepLR', by_epoch=True, milestones=[100, 150], gamma=0.1)
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=200, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=128)

configs/_base_/schedules/cub_bs64.py

+# optimizer
+optim_wrapper = dict(
+    optimizer=dict(
+        type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005, nesterov=True))
+
+# learning policy
+param_scheduler = [
+    # warm up learning rate scheduler
+    dict(
+        type='LinearLR',
+        start_factor=0.01,
+        by_epoch=True,
+        begin=0,
+        end=5,
+        # update by iter
+        convert_to_iter_based=True),
+    # main learning rate scheduler
+    dict(
+        type='CosineAnnealingLR',
+        T_max=95,
+        by_epoch=True,
+        begin=5,
+        end=100,
+    )
+]
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=100, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=64)

configs/_base_/schedules/imagenet_bs1024_adamw_conformer.py

+optim_wrapper = dict(
+    optimizer=dict(
+        type='AdamW',
+        # for batch in each gpu is 128, 8 gpu
+        # lr = 5e-4 * 128 * 8 / 512 = 0.001
+        lr=5e-4 * 128 * 8 / 512,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+    paramwise_cfg=dict(
+        norm_decay_mult=0.0,
+        bias_decay_mult=0.0,
+        custom_keys={
+            '.cls_token': dict(decay_mult=0.0),
+        }),
+)
+
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=1e-3,
+        by_epoch=True,
+        begin=0,
+        end=5,
+        convert_to_iter_based=True),
+    dict(
+        type='CosineAnnealingLR',
+        T_max=295,
+        eta_min=1e-5,
+        by_epoch=True,
+        begin=5,
+        end=300)
+]
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=300, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=1024)

configs/_base_/schedules/imagenet_bs1024_adamw_hivit.py

+# for batch in each gpu is 128, 8 gpu
+# lr = 5e-4 * 128 * 8 / 512 = 0.001
+optim_wrapper = dict(
+    optimizer=dict(
+        type='AdamW',
+        lr=5e-4 * 1024 / 512,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+    paramwise_cfg=dict(
+        norm_decay_mult=0.0,
+        bias_decay_mult=0.0,
+        flat_decay_mult=0.0,
+        custom_keys={
+            '.pos_embed': dict(decay_mult=0.0),
+            '.relative_position_bias_table': dict(decay_mult=0.0)
+        }),
+)
+
+# learning policy
+param_scheduler = [
+    # warm up learning rate scheduler
+    dict(
+        type='LinearLR',
+        start_factor=1e-3,
+        by_epoch=True,
+        end=20,
+        # update by iter
+        convert_to_iter_based=True),
+    # main learning rate scheduler
+    dict(type='CosineAnnealingLR', eta_min=1e-5, by_epoch=True, begin=20)
+]
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=300, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=1024)

configs/_base_/schedules/imagenet_bs1024_adamw_revvit.py

+# for batch in each gpu is 128, 8 gpu
+# lr = 5e-4 * 128 * 8 / 512 = 0.001
+# schedule settings
+optim_wrapper = dict(
+    optimizer=dict(
+        type='AdamW',
+        lr=5e-4 * 2048 / 512,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+    paramwise_cfg=dict(
+        norm_decay_mult=0.0,
+        bias_decay_mult=0.0,
+        custom_keys={
+            '.cls_token': dict(decay_mult=0.0),
+            '.pos_embed': dict(decay_mult=0.0)
+        }),
+    clip_grad=dict(max_norm=1.0),
+)
+# learning policy
+param_scheduler = [
+    # warm up learning rate scheduler
+    dict(
+        type='LinearLR',
+        start_factor=1e-8 / 2e-3,
+        by_epoch=True,
+        end=70,
+        # update by iter
+        convert_to_iter_based=True),
+    # main learning rate scheduler
+    dict(type='CosineAnnealingLR', eta_min=1e-5, by_epoch=True, begin=70)
+]
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=300, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=1024)

configs/_base_/schedules/imagenet_bs1024_adamw_swin.py

+# for batch in each gpu is 128, 8 gpu
+# lr = 5e-4 * 128 * 8 / 512 = 0.001
+optim_wrapper = dict(
+    optimizer=dict(
+        type='AdamW',
+        lr=5e-4 * 1024 / 512,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+    paramwise_cfg=dict(
+        norm_decay_mult=0.0,
+        bias_decay_mult=0.0,
+        flat_decay_mult=0.0,
+        custom_keys={
+            '.absolute_pos_embed': dict(decay_mult=0.0),
+            '.relative_position_bias_table': dict(decay_mult=0.0)
+        }),
+)
+
+# learning policy
+param_scheduler = [
+    # warm up learning rate scheduler
+    dict(
+        type='LinearLR',
+        start_factor=1e-3,
+        by_epoch=True,
+        end=20,
+        # update by iter
+        convert_to_iter_based=True),
+    # main learning rate scheduler
+    dict(type='CosineAnnealingLR', eta_min=1e-5, by_epoch=True, begin=20)
+]
+
+# train, val, test setting
+train_cfg = dict(by_epoch=True, max_epochs=300, val_interval=1)
+val_cfg = dict()
+test_cfg = dict()
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=1024)