text: log_level = 'INFO'
  load_from = None
  resume_from = None
  dist_params = dict(backend='nccl')
  workflow = [('train', 1)]
  checkpoint_config = dict(interval=50)
  evaluation = dict(interval=50, metric='mAP', save_best='AP')
  
  optimizer = dict(
      type='Adam',
      lr=0.0015,
  )
  optimizer_config = dict(grad_clip=None)
  # learning policy
  lr_config = dict(
      policy='step',
      warmup='linear',
      warmup_iters=500,
      warmup_ratio=0.001,
      step=[200, 260])
  total_epochs = 300
  log_config = dict(
      interval=50,
      hooks=[
          dict(type='TextLoggerHook'),
          # dict(type='TensorboardLoggerHook')
      ])
  
  channel_cfg = dict(
      dataset_joints=17,
      dataset_channel=[
          [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
      ],
      inference_channel=[
          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
      ])
  
  data_cfg = dict(
      image_size=640,
      base_size=320,
      base_sigma=2,
      heatmap_size=[160],
      num_joints=channel_cfg['dataset_joints'],
      dataset_channel=channel_cfg['dataset_channel'],
      inference_channel=channel_cfg['inference_channel'],
      num_scales=1,
      scale_aware_sigma=False,
  )
  
  # model settings
  model = dict(
      type='AssociativeEmbedding',
      pretrained='https://download.openmmlab.com/mmpose/'
      'pretrain_models/hrnet_w48-8ef0771d.pth',
      backbone=dict(
          type='HRNet',
          in_channels=3,
          extra=dict(
              stage1=dict(
                  num_modules=1,
                  num_branches=1,
                  block='BOTTLENECK',
                  num_blocks=(4, ),
                  num_channels=(64, )),
              stage2=dict(
                  num_modules=1,
                  num_branches=2,
                  block='BASIC',
                  num_blocks=(4, 4),
                  num_channels=(48, 96)),
              stage3=dict(
                  num_modules=4,
                  num_branches=3,
                  block='BASIC',
                  num_blocks=(4, 4, 4),
                  num_channels=(48, 96, 192)),
              stage4=dict(
                  num_modules=3,
                  num_branches=4,
                  block='BASIC',
                  num_blocks=(4, 4, 4, 4),
                  num_channels=(48, 96, 192, 384))),
      ),
      keypoint_head=dict(
          type='AESimpleHead',
          in_channels=48,
          num_joints=17,
          num_deconv_layers=0,
          tag_per_joint=True,
          with_ae_loss=[True],
          extra=dict(final_conv_kernel=1, ),
          loss_keypoint=dict(
              type='MultiLossFactory',
              num_joints=17,
              num_stages=1,
              ae_loss_type='exp',
              with_ae_loss=[True],
              push_loss_factor=[0.001],
              pull_loss_factor=[0.001],
              with_heatmaps_loss=[True],
              heatmaps_loss_factor=[1.0])),
      train_cfg=dict(
          num_joints=channel_cfg['dataset_joints'],
          img_size=data_cfg['image_size']),
      test_cfg=dict(
          num_joints=channel_cfg['dataset_joints'],
          max_num_people=30,
          scale_factor=[1],
          with_heatmaps=[True],
          with_ae=[True],
          project2image=False,
          nms_kernel=5,
          nms_padding=2,
          tag_per_joint=True,
          detection_threshold=0.1,
          tag_threshold=1,
          use_detection_val=True,
          ignore_too_much=False,
          adjust=True,
          refine=True,
          flip_test=True,
          use_udp=True))
  
  train_pipeline = [
      dict(type='LoadImageFromFile'),
      dict(
          type='BottomUpRandomAffine',
          rot_factor=30,
          scale_factor=[0.75, 1.5],
          scale_type='short',
          trans_factor=40,
          use_udp=True),
      dict(type='BottomUpRandomFlip', flip_prob=0.5),
      dict(type='ToTensor'),
      dict(
          type='NormalizeTensor',
          mean=[0.485, 0.456, 0.406],
          std=[0.229, 0.224, 0.225]),
      dict(
          type='BottomUpGenerateTarget',
          sigma=2,
          max_num_people=30,
          use_udp=True,
      ),
      dict(
          type='Collect',
          keys=['img', 'joints', 'targets', 'masks'],
          meta_keys=[]),
  ]
  
  val_pipeline = [
      dict(type='LoadImageFromFile'),
      dict(type='BottomUpGetImgSize', test_scale_factor=[1], use_udp=True),
      dict(
          type='BottomUpResizeAlign',
          transforms=[
              dict(type='ToTensor'),
              dict(
                  type='NormalizeTensor',
                  mean=[0.485, 0.456, 0.406],
                  std=[0.229, 0.224, 0.225])
          ],
          use_udp=True),
      dict(
          type='Collect',
          keys=['img'],
          meta_keys=[
              'image_file', 'aug_data', 'test_scale_factor', 'base_size',
              'center', 'scale', 'flip_index'
          ]),
  ]
  
  test_pipeline = val_pipeline
  
  data_root = 'data/coco'
  data = dict(
      samples_per_gpu=8,
      workers_per_gpu=2,
      train=dict(
          type='BottomUpCocoDataset',
          ann_file=f'{data_root}/annotations/person_keypoints_train2017.json',
          img_prefix=f'{data_root}/train2017/',
          data_cfg=data_cfg,
          pipeline=train_pipeline),
      val=dict(
          type='BottomUpCocoDataset',
          ann_file=f'{data_root}/annotations/person_keypoints_val2017.json',
          img_prefix=f'{data_root}/val2017/',
          data_cfg=data_cfg,
          pipeline=val_pipeline),
      test=dict(
          type='BottomUpCocoDataset',
          ann_file=f'{data_root}/annotations/person_keypoints_val2017.json',
          img_prefix=f'{data_root}/val2017/',
          data_cfg=data_cfg,
          pipeline=val_pipeline),
  )
  