Upload 15 files

accv2022/generate_testa_dataset_result/accv2022testadataset.py

@@ -0,0 +1,363 @@
+import os
+import cv2
+import json
+import numpy as np
+
+from PIL import Image
+
+from tqdm import tqdm
+
+from torch.utils.data import Dataset
+
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+
+
+class Opencv2PIL:
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        '''
+        sample must be a dict,contains 'image'、'label' keys.
+        '''
+        path, image = sample['path'], sample['image']
+
+        image = Image.fromarray(np.uint8(image))
+
+        return {
+            'path': path,
+            'image': image,
+        }
+
+
+class PIL2Opencv:
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        '''
+        sample must be a dict,contains 'image'、'label' keys.
+        '''
+        path, image = sample['path'], sample['image']
+
+        image = np.asarray(image).astype(np.float32)
+
+        return {
+            'path': path,
+            'image': image,
+        }
+
+
+class TorchResize:
+
+    def __init__(self, resize=224):
+        self.Resize = transforms.Resize(int(resize))
+
+    def __call__(self, sample):
+        '''
+        sample must be a dict,contains 'image'、'label' keys.
+        '''
+        path, image = sample['path'], sample['image']
+
+        image = self.Resize(image)
+
+        return {
+            'path': path,
+            'image': image,
+        }
+
+
+class TorchCenterCrop:
+
+    def __init__(self, resize=224):
+        self.CenterCrop = transforms.CenterCrop(int(resize))
+
+    def __call__(self, sample):
+        '''
+        sample must be a dict,contains 'image'、'label' keys.
+        '''
+        path, image = sample['path'], sample['image']
+
+        image = self.CenterCrop(image)
+
+        return {
+            'path': path,
+            'image': image,
+        }
+
+
+class TorchMeanStdNormalize:
+
+    def __init__(self, mean, std):
+        self.to_tensor = transforms.ToTensor()
+        self.Normalize = transforms.Normalize(mean=mean, std=std)
+
+    def __call__(self, sample):
+        '''
+        sample must be a dict,contains 'image'、'label' keys.
+        '''
+        path, image = sample['path'], sample['image']
+        image = self.to_tensor(image)
+        image = self.Normalize(image)
+        # 3 H W ->H W 3
+        image = image.permute(1, 2, 0)
+        image = image.numpy()
+
+        return {
+            'path': path,
+            'image': image,
+        }
+
+
+class ClassificationCollater:
+
+    def __init__(self):
+        pass
+
+    def __call__(self, data):
+        paths = [s['path'] for s in data]
+        images = [s['image'] for s in data]
+
+        images = np.array(images).astype(np.float32)
+
+        images = torch.from_numpy(images).float()
+        # B H W 3 ->B 3 H W
+        images = images.permute(0, 3, 1, 2)
+
+        return {
+            'path': paths,
+            'image': images,
+        }
+
+
+def load_state_dict(saved_model_path,
+                    model,
+                    excluded_layer_name=(),
+                    loading_new_input_size_position_encoding_weight=False):
+    '''
+    saved_model_path: a saved model.state_dict() .pth file path
+    model: a new defined model
+    excluded_layer_name: layer names that doesn't want to load parameters
+    loading_new_input_size_position_encoding_weight: default False, for vit net, loading a position encoding layer with new input size, set True
+    only load layer parameters which has same layer name and same layer weight shape
+    '''
+    if not saved_model_path:
+        print('No pretrained model file!')
+        return
+
+    saved_state_dict = torch.load(saved_model_path,
+                                  map_location=torch.device('cpu'))
+
+    not_loaded_save_state_dict = []
+    filtered_state_dict = {}
+    for name, weight in saved_state_dict.items():
+        if name in model.state_dict() and not any(
+                excluded_name in name for excluded_name in excluded_layer_name
+        ) and weight.shape == model.state_dict()[name].shape:
+            filtered_state_dict[name] = weight
+        else:
+            not_loaded_save_state_dict.append(name)
+
+    position_encoding_already_loaded = False
+    if 'position_encoding' in filtered_state_dict.keys():
+        position_encoding_already_loaded = True
+
+    # for vit net, loading a position encoding layer with new input size
+    if loading_new_input_size_position_encoding_weight and not position_encoding_already_loaded:
+        # assert position_encoding_layer name are unchanged for model and saved_model
+        # assert class_token num are unchanged for model and saved_model
+        # assert embedding_planes are unchanged for model and saved_model
+        model_num_cls_token = model.cls_token.shape[1]
+        model_embedding_planes = model.position_encoding.shape[2]
+        model_encoding_shape = int(
+            (model.position_encoding.shape[1] - model_num_cls_token)**0.5)
+        encoding_layer_name, encoding_layer_weight = None, None
+        for name, weight in saved_state_dict.items():
+            if 'position_encoding' in name:
+                encoding_layer_name = name
+                encoding_layer_weight = weight
+                break
+        save_model_encoding_shape = int(
+            (encoding_layer_weight.shape[1] - model_num_cls_token)**0.5)
+
+        save_model_cls_token_weight = encoding_layer_weight[:, 0:
+                                                            model_num_cls_token, :]
+        save_model_position_weight = encoding_layer_weight[:,
+                                                           model_num_cls_token:, :]
+        save_model_position_weight = save_model_position_weight.reshape(
+            -1, save_model_encoding_shape, save_model_encoding_shape,
+            model_embedding_planes).permute(0, 3, 1, 2)
+        save_model_position_weight = F.interpolate(save_model_position_weight,
+                                                   size=(model_encoding_shape,
+                                                         model_encoding_shape),
+                                                   mode='bicubic',
+                                                   align_corners=False)
+        save_model_position_weight = save_model_position_weight.permute(
+            0, 2, 3, 1).flatten(1, 2)
+        model_encoding_layer_weight = torch.cat(
+            (save_model_cls_token_weight, save_model_position_weight), dim=1)
+
+        filtered_state_dict[encoding_layer_name] = model_encoding_layer_weight
+        not_loaded_save_state_dict.remove('position_encoding')
+
+    if len(filtered_state_dict) == 0:
+        print('No pretrained parameters to load!')
+    else:
+        print(
+            f'load/model weight nums:{len(filtered_state_dict)}/{len(model.state_dict())}'
+        )
+        print(f'not loaded save layer weight:\n{not_loaded_save_state_dict}')
+        model.load_state_dict(filtered_state_dict, strict=False)
+
+    return
+
+
+class ACCV2022TestaDataset(Dataset):
+    '''
+    ACCV2022 Dataset:https://www.cvmart.net/race/10412/des
+    '''
+
+    def __init__(self,
+                 root_dir,
+                 set_name='testa',
+                 transform=None,
+                 broken_list_path=None):
+        assert set_name in ['testa'], 'Wrong set name!'
+        set_dir = os.path.join(root_dir, set_name)
+
+        broken_list = set()
+        if broken_list_path:
+            with open(broken_list_path, 'r') as load_f:
+                broken_list = json.load(load_f)
+                broken_list = set(broken_list)
+        print(f'Broken image num:{len(broken_list)}')
+
+        self.image_path_list = []
+        for per_image_name in tqdm(os.listdir(set_dir)):
+            per_image_path = os.path.join(set_dir, per_image_name)
+            if per_image_name in broken_list:
+                continue
+            self.image_path_list.append(per_image_path)
+
+        self.transform = transform
+
+        print(f'Dataset Size:{len(self.image_path_list)}')
+
+    def __len__(self):
+        return len(self.image_path_list)
+
+    def __getitem__(self, idx):
+        path = self.image_path_list[idx]
+        image = self.load_image(idx)
+
+        sample = {
+            'path': path,
+            'image': image,
+        }
+
+        if self.transform:
+            sample = self.transform(sample)
+
+        return sample
+
+    def load_image(self, idx):
+        image = cv2.imdecode(
+            np.fromfile(self.image_path_list[idx], dtype=np.uint8),
+            cv2.IMREAD_COLOR)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+        return image.astype(np.float32)
+
+
+if __name__ == '__main__':
+    import os
+    import random
+    import numpy as np
+    import torch
+    seed = 0
+    # for hash
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    # for python and numpy
+    random.seed(seed)
+    np.random.seed(seed)
+    # for cpu gpu
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+    import os
+    import sys
+
+    BASE_DIR = os.path.dirname(
+        os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    sys.path.append(BASE_DIR)
+
+    from tools.path import accv2022_dataset_path, accv2022_broken_list_path
+
+    import torchvision.transforms as transforms
+    from tqdm import tqdm
+
+    accv2022testadataset = ACCV2022TestaDataset(
+        root_dir=accv2022_dataset_path,
+        set_name='testa',
+        transform=transforms.Compose([
+            Opencv2PIL(),
+            TorchResize(resize=256),
+            TorchCenterCrop(resize=224),
+            PIL2Opencv(),
+            # TorchMeanStdNormalize(mean=[0.485, 0.456, 0.406],
+            #                       std=[0.229, 0.224, 0.225]),
+        ]),
+        broken_list_path=accv2022_broken_list_path)
+
+    count = 0
+    for per_sample in tqdm(accv2022testadataset):
+        print(per_sample['image'].shape, type(per_sample['image']),
+              per_sample['path'])
+
+        # temp_dir = './temp'
+        # if not os.path.exists(temp_dir):
+        #     os.makedirs(temp_dir)
+
+        # color = [random.randint(0, 255) for _ in range(3)]
+        # image = np.ascontiguousarray(per_sample['image'], dtype=np.uint8)
+        # image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        # image_name = per_sample['path'].split('/')[-1]
+        # text = f'image_name:{image_name}'
+        # cv2.putText(image,
+        #             text, (30, 30),
+        #             cv2.FONT_HERSHEY_PLAIN,
+        #             1.5,
+        #             color=color,
+        #             thickness=1)
+
+        # cv2.imencode('.jpg', image)[1].tofile(
+        #     os.path.join(temp_dir, f'idx_{count}.jpg'))
+
+        if count < 5:
+            count += 1
+        else:
+            break
+
+    from torch.utils.data import DataLoader
+    collater = ClassificationCollater()
+    train_loader = DataLoader(accv2022testadataset,
+                              batch_size=128,
+                              shuffle=True,
+                              num_workers=4,
+                              collate_fn=collater)
+
+    count = 0
+    for data in tqdm(train_loader):
+        paths, images = data['path'], data['image']
+        print(images.shape)
+        print(images.dtype)
+        if count < 5:
+            count += 1
+        else:
+            break

accv2022/generate_testa_dataset_result/test.py

@@ -0,0 +1,166 @@
+import os
+import sys
+import warnings
+
+BASE_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+sys.path.append(BASE_DIR)
+warnings.filterwarnings('ignore')
+
+import argparse
+import collections
+import numpy as np
+import os
+import random
+import csv
+
+from tqdm import tqdm
+from thop import profile
+from thop import clever_format
+import torch
+import torch.nn as nn
+import torch.backends.cudnn as cudnn
+
+from torch.utils.data import DataLoader
+
+
+def set_seed(seed):
+    # for hash
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    # for python and numpy
+    random.seed(seed)
+    np.random.seed(seed)
+    # for cpu gpu
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    # for cudnn
+    cudnn.benchmark = False
+    cudnn.deterministic = True
+
+
+def compute_macs_and_params(config, model):
+    assert isinstance(config.input_image_size, int) == True or isinstance(
+        config.input_image_size,
+        list) == True, 'Illegal input_image_size type!'
+
+    if isinstance(config.input_image_size, int):
+        macs_input = torch.randn(1, 3, config.input_image_size,
+                                 config.input_image_size).cpu()
+    elif isinstance(config.input_image_size, list):
+        macs_input = torch.randn(1, 3, config.input_image_size[0],
+                                 config.input_image_size[1]).cpu()
+
+    model = model.cpu()
+
+    macs, params = profile(model, inputs=(macs_input, ), verbose=False)
+    macs, params = clever_format([macs, params], '%.3f')
+
+    return macs, params
+
+
+def test_classification(test_loader, model, config):
+    if hasattr(config, 'use_ema_model') and config.use_ema_model:
+        model = config.ema_model.ema_model
+
+    # switch to evaluate mode
+    model.eval()
+
+    test_results = collections.OrderedDict()
+    with torch.no_grad():
+        model_on_cuda = next(model.parameters()).is_cuda
+        for _, data in tqdm(enumerate(test_loader)):
+            paths, images = data['path'], data['image']
+            if model_on_cuda:
+                images = images.cuda()
+
+            torch.cuda.synchronize()
+
+            outputs = model(images)
+            torch.cuda.synchronize()
+
+            _, topk_indexes = torch.topk(outputs,
+                                         k=1,
+                                         dim=1,
+                                         largest=True,
+                                         sorted=True)
+            topk_indexes = torch.squeeze(topk_indexes, dim=-1)
+
+            for per_image_path, per_image_pred_index in zip(
+                    paths, topk_indexes):
+                image_name = per_image_path.split('/')[-1]
+                written_index = f'{per_image_pred_index:0>4d}'
+                test_results[image_name] = written_index
+
+    return test_results
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='PyTorch Classification Testing')
+    parser.add_argument('--work-dir',
+                        type=str,
+                        help='path for get testing config')
+
+    return parser.parse_args()
+
+
+def main():
+    assert torch.cuda.is_available(), 'need gpu to train network!'
+    torch.cuda.empty_cache()
+
+    args = parse_args()
+    sys.path.append(args.work_dir)
+    from test_config import config
+    config.gpus_type = torch.cuda.get_device_name()
+    config.gpus_num = torch.cuda.device_count()
+
+    set_seed(config.seed)
+
+    local_rank = int(os.environ['LOCAL_RANK'])
+    # start init process
+    torch.distributed.init_process_group(backend='nccl', init_method='env://')
+    torch.cuda.set_device(local_rank)
+    config.group = torch.distributed.new_group(list(range(config.gpus_num)))
+
+    torch.distributed.barrier()
+
+    batch_size, num_workers = config.batch_size, config.num_workers
+    assert config.batch_size % config.gpus_num == 0, 'config.batch_size is not divisible by config.gpus_num!'
+    assert config.num_workers % config.gpus_num == 0, 'config.num_workers is not divisible by config.gpus_num!'
+    batch_size = int(config.batch_size // config.gpus_num)
+    num_workers = int(config.num_workers // config.gpus_num)
+
+    test_loader = DataLoader(config.test_dataset,
+                             batch_size=batch_size,
+                             shuffle=False,
+                             pin_memory=True,
+                             num_workers=num_workers,
+                             collate_fn=config.test_collater)
+
+    model = config.model
+
+    macs, params = compute_macs_and_params(config, model)
+    print(f'model: {config.network}, macs: {macs}, params: {params}')
+
+    model = model.cuda()
+
+    model = nn.parallel.DistributedDataParallel(model,
+                                                device_ids=[local_rank],
+                                                output_device=local_rank)
+
+    test_results = test_classification(test_loader, model, config)
+
+    if local_rank == 0:
+        with open(f"{config.set_name}_pred_results.csv", "w",
+                  encoding='utf-8') as csvfile:
+            writer = csv.writer(csvfile)
+            for per_image_name, per_image_pred in test_results.items():
+                writer.writerow([str(per_image_name), str(per_image_pred)])
+
+    return
+
+
+if __name__ == '__main__':
+    main()

accv2022/generate_testa_dataset_result/test.sh

@@ -0,0 +1 @@
+OMP_NUM_THREADS=1 CUDA_VISIBLE_DEVICES=0 python -m torch.distributed.run --nproc_per_node=1 --master_addr 127.0.1.11 --master_port 10011 test.py --work-dir ./

accv2022/generate_testa_dataset_result/test_config.py

@@ -0,0 +1,55 @@
+import os
+import sys
+
+BASE_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+sys.path.append(BASE_DIR)
+
+from tools.path import accv2022_dataset_path, accv2022_broken_list_path
+
+from simpleAICV.classification import backbones
+from accv2022testadataset import ACCV2022TestaDataset, Opencv2PIL, TorchResize, TorchCenterCrop, TorchMeanStdNormalize, ClassificationCollater, load_state_dict
+
+import torch
+import torchvision.transforms as transforms
+
+
+class config:
+    '''
+    for resnet,input_image_size = 224;for darknet,input_image_size = 256
+    '''
+    network = 'vit_large_patch16'
+    num_classes = 5000
+    input_image_size = 224
+    scale = 256 / 224
+    set_name = 'testa'
+
+    model = backbones.__dict__[network](**{
+        'image_size': 224,
+        'global_pool': True,
+        'num_classes': num_classes,
+    })
+
+    # load pretrained model or not
+    trained_model_path = '/root/code/SimpleAICV_pytorch_training_examples_on_ImageNet_COCO_ADE20K/pretrained_models/vit_finetune_on_accv2022_from_mae_pretrain/vit_large_patch16-acc90.693.pth'
+    load_state_dict(trained_model_path, model)
+
+    test_dataset = ACCV2022TestaDataset(
+        root_dir=accv2022_dataset_path,
+        set_name=set_name,
+        transform=transforms.Compose([
+            Opencv2PIL(),
+            TorchResize(resize=input_image_size * scale),
+            TorchCenterCrop(resize=input_image_size),
+            TorchMeanStdNormalize(mean=[0.485, 0.456, 0.406],
+                                  std=[0.229, 0.224, 0.225]),
+        ]),
+        broken_list_path=accv2022_broken_list_path)
+    test_collater = ClassificationCollater()
+
+    seed = 0
+    # batch_size is total size
+    batch_size = 16
+    # num_workers is total workers
+    num_workers = 20

accv2022/vit_large_patch16_lion_for_mae_pretrain/checkpoints/latest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d88acaa0c254898e6c1286b30797e32d325c3e8bddc61e84764d8a7a06154a92
+size 3677028335

accv2022/vit_large_patch16_lion_for_mae_pretrain/checkpoints/vit_large_patch16-acc90.693.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3705a212f69ca5a4c66bc7897eb50ea368aa475c27cd4ce0c07807518ab051c6
+size 1233796787

accv2022/vit_large_patch16_lion_for_mae_pretrain/test.sh

@@ -0,0 +1 @@
+OMP_NUM_THREADS=1 CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.run --nproc_per_node=2 --master_addr 127.0.1.0 --master_port 10000 ../../../tools/test_classification_model.py --work-dir ./

accv2022/vit_large_patch16_lion_for_mae_pretrain/test_config.py

@@ -0,0 +1,58 @@
+import os
+import sys
+
+BASE_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+sys.path.append(BASE_DIR)
+
+from tools.path import accv2022_dataset_path, accv2022_broken_list_path
+
+from simpleAICV.classification import backbones
+from simpleAICV.classification import losses
+from simpleAICV.classification.datasets.accv2022traindataset import ACCV2022TrainDataset
+from simpleAICV.classification.common import Opencv2PIL, TorchResize, TorchCenterCrop, TorchMeanStdNormalize, ClassificationCollater, load_state_dict
+
+import torch
+import torchvision.transforms as transforms
+
+
+class config:
+    '''
+    for resnet,input_image_size = 224;for darknet,input_image_size = 256
+    '''
+    network = 'vit_large_patch16'
+    num_classes = 5000
+    input_image_size = 224
+    scale = 256 / 224
+
+    model = backbones.__dict__[network](**{
+        'image_size': 224,
+        'global_pool': True,
+        'num_classes': num_classes,
+    })
+
+    # load pretrained model or not
+    trained_model_path = ''
+    load_state_dict(trained_model_path, model)
+
+    test_criterion = losses.__dict__['CELoss']()
+
+    test_dataset = ACCV2022TrainDataset(
+        root_dir=accv2022_dataset_path,
+        set_name='train',
+        transform=transforms.Compose([
+            Opencv2PIL(),
+            TorchResize(resize=input_image_size * scale),
+            TorchCenterCrop(resize=input_image_size),
+            TorchMeanStdNormalize(mean=[0.485, 0.456, 0.406],
+                                  std=[0.229, 0.224, 0.225]),
+        ]),
+        broken_list_path=accv2022_broken_list_path)
+    test_collater = ClassificationCollater()
+
+    seed = 0
+    # batch_size is total size
+    batch_size = 256
+    # num_workers is total workers
+    num_workers = 16

accv2022/vit_large_patch16_lion_for_mae_pretrain/train.sh

@@ -0,0 +1 @@
+OMP_NUM_THREADS=1 CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.run --nproc_per_node=2 --master_addr 127.0.1.0 --master_port 10000 ../../../tools/train_classification_model.py --work-dir ./

accv2022/vit_large_patch16_lion_for_mae_pretrain/train_config.py

@@ -0,0 +1,142 @@
+import os
+import sys
+
+BASE_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+sys.path.append(BASE_DIR)
+
+from tools.path import accv2022_dataset_path, accv2022_broken_list_path
+
+from simpleAICV.classification import backbones
+from simpleAICV.classification import losses
+from simpleAICV.classification.datasets.accv2022traindataset import ACCV2022TrainDataset
+from simpleAICV.classification.common import Opencv2PIL, TorchRandomResizedCrop, TorchRandomHorizontalFlip, RandAugment, TorchResize, TorchCenterCrop, TorchMeanStdNormalize, RandomErasing, ClassificationCollater, MixupCutmixClassificationCollater, load_state_dict
+
+import torch
+import torchvision.transforms as transforms
+
+
+class config:
+    network = 'vit_large_patch16'
+    num_classes = 5000
+    input_image_size = 224
+    scale = 256 / 224
+
+    model = backbones.__dict__[network](**{
+        'image_size': 224,
+        'drop_path_prob': 0.1,
+        'global_pool': True,
+        'num_classes': num_classes,
+    })
+
+    # load pretrained model or not
+    trained_model_path = '/root/code/SimpleAICV_pytorch_training_examples_on_ImageNet_COCO_ADE20K/pretrained_models/vit_mae_pretrain_on_accv2022_from_imagenet1k_pretrain/vit_large_patch16_224_mae_pretrain_model-loss0.424_encoder.pth'
+    load_state_dict(trained_model_path,
+                    model,
+                    loading_new_input_size_position_encoding_weight=True)
+
+    train_criterion = losses.__dict__['OneHotLabelCELoss']()
+    test_criterion = losses.__dict__['CELoss']()
+
+    train_dataset = ACCV2022TrainDataset(
+        root_dir=accv2022_dataset_path,
+        set_name='train',
+        transform=transforms.Compose([
+            Opencv2PIL(),
+            TorchRandomResizedCrop(resize=input_image_size),
+            TorchRandomHorizontalFlip(prob=0.5),
+            RandAugment(magnitude=9,
+                        num_layers=2,
+                        resize=input_image_size,
+                        mean=[0.485, 0.456, 0.406],
+                        integer=True,
+                        weight_idx=None,
+                        magnitude_std=0.5,
+                        magnitude_max=None),
+            TorchMeanStdNormalize(mean=[0.485, 0.456, 0.406],
+                                  std=[0.229, 0.224, 0.225]),
+            RandomErasing(prob=0.25, mode='pixel', max_count=1),
+        ]),
+        broken_list_path=accv2022_broken_list_path)
+
+    test_dataset = ACCV2022TrainDataset(
+        root_dir=accv2022_dataset_path,
+        set_name='train',
+        transform=transforms.Compose([
+            Opencv2PIL(),
+            TorchResize(resize=input_image_size * scale),
+            TorchCenterCrop(resize=input_image_size),
+            TorchMeanStdNormalize(mean=[0.485, 0.456, 0.406],
+                                  std=[0.229, 0.224, 0.225]),
+        ]),
+        broken_list_path=accv2022_broken_list_path)
+
+    train_collater = MixupCutmixClassificationCollater(
+        use_mixup=True,
+        mixup_alpha=0.8,
+        cutmix_alpha=1.0,
+        cutmix_minmax=None,
+        mixup_cutmix_prob=1.0,
+        switch_to_cutmix_prob=0.5,
+        mode='batch',
+        correct_lam=True,
+        label_smoothing=0.1,
+        num_classes=5000)
+    test_collater = ClassificationCollater()
+
+    seed = 0
+    # batch_size is total size
+    batch_size = 128
+    # num_workers is total workers
+    num_workers = 20
+    accumulation_steps = 32
+
+    optimizer = (
+        'Lion',
+        {
+            'lr':
+            4e-4,
+            'global_weight_decay':
+            False,
+            # if global_weight_decay = False
+            # all bias, bn and other 1d params weight set to 0 weight decay
+            'weight_decay':
+            5e-2,
+            # lr_layer_decay only support vit style model
+            'lr_layer_decay':
+            0.65,
+            'lr_layer_decay_block':
+            model.blocks,
+            'block_name':
+            'blocks',
+            'no_weight_decay_layer_name_list': [
+                'position_encoding',
+                'cls_token',
+            ],
+        },
+    )
+
+    scheduler = (
+        'CosineLR',
+        {
+            'warm_up_epochs': 5,
+            'min_lr': 1e-6,
+        },
+    )
+
+    epochs = 100
+    print_interval = 10
+
+    sync_bn = False
+    use_amp = True
+    use_compile = False
+    compile_params = {
+        # 'default': optimizes for large models, low compile-time and no extra memory usage.
+        # 'reduce-overhead': optimizes to reduce the framework overhead and uses some extra memory, helps speed up small models, model update may not correct.
+        # 'max-autotune': optimizes to produce the fastest model, but takes a very long time to compile and may failed.
+        'mode': 'default',
+    }
+
+    use_ema_model = False
+    ema_model_decay = 0.9999