def main():
parser = argparse.ArgumentParser(
description="easy2train for Change Detection")
parser.add_argument(
"-cfg",
"--config_file",
default="configs/h**o/default.yaml",
metavar="FILE",
help="Path to config file",
type=str,
)
parser.add_argument(
"-se",
"--skip_eval",
help="Do not eval the models(checkpoints)",
action="store_true",
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
run_train(cfg)
def main():
parser = argparse.ArgumentParser("Struct2vec training")
parser.add_argument(
"--config-file",
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
logger, log_path = create_logger(cfg)
logger.info(cfg)
graph = networkx.read_edgelist(cfg.DATA.GRAPH_PATH, create_using=networkx.DiGraph(), nodetype=None, data=[('weight', int)])
model = Struct2Vec(graph, cfg, logger)
model.train()
embedding = model.get_embedding()
eval_embedding(embedding, cfg.DATA.LABEL_PATH, logger)
vis_embedding(embedding, cfg.DATA.LABEL_PATH, log_path)
def main():
parser = argparse.ArgumentParser(
description="eval models from checkpoints.")
parser.add_argument(
"-cfg",
"--config_file",
default="configs/h**o/default.yaml",
metavar="FILE",
help="Path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
run_eval(cfg)
def main():
parser = argparse.ArgumentParser(description="PyTorch NDDR Training")
parser.add_argument(
"--config-file",
default="configs/vgg16_nddr_pret.yaml",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.EXPERIMENT_NAME = args.config_file.split('/')[-1][:-5]
cfg.merge_from_list(args.opts)
cfg.freeze()
# load the data
test_loader = torch.utils.data.DataLoader(
MultiTaskDataset(
data_dir=cfg.DATA_DIR,
data_list_1=cfg.TEST.DATA_LIST_1,
data_list_2=cfg.TEST.DATA_LIST_2,
output_size=cfg.TEST.OUTPUT_SIZE,
random_scale=cfg.TEST.RANDOM_SCALE,
random_mirror=cfg.TEST.RANDOM_MIRROR,
random_crop=cfg.TEST.RANDOM_CROP,
ignore_label=cfg.IGNORE_LABEL,
),
batch_size=cfg.TEST.BATCH_SIZE, shuffle=False)
net1 = DeepLabLargeFOVBN(3, cfg.MODEL.NET1_CLASSES, weights='')
net2 = DeepLabLargeFOVBN(3, cfg.MODEL.NET2_CLASSES, weights='')
model = NDDRNet(net1, net2,
shortcut=cfg.MODEL.SHORTCUT,
bn_before_relu=cfg.MODEL.BN_BEFORE_RELU)
ckpt_path = os.path.join(cfg.SAVE_DIR, cfg.EXPERIMENT_NAME, 'ckpt-%s.pth' % str(cfg.TEST.CKPT_ID).zfill(5))
print("Evaluating Checkpoint at %s" % ckpt_path)
ckpt = torch.load(ckpt_path)
model.load_state_dict(ckpt['model_state_dict'])
model.eval()
if cfg.CUDA:
model = model.cuda()
mIoU, pixel_acc, angle_metrics = evaluate(test_loader, model)
print('Mean IoU: {:.3f}'.format(mIoU))
print('Pixel Acc: {:.3f}'.format(pixel_acc))
for k, v in angle_metrics.items():
print('{}: {:.3f}'.format(k, v))
def main(device):
parser = argparse.ArgumentParser("SDNE training")
parser.add_argument(
"--config-file",
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
logger, log_path = create_logger(cfg)
logger.info(cfg)
graph = networkx.read_edgelist(cfg.DATA.GRAPH_PATH,
create_using=networkx.DiGraph(),
nodetype=None,
data=[('weight', int)])
model = SDNE(graph, cfg).to(device)
L_matrix, adj_matrix = model.get_matrix()
criterion = MixLoss(cfg, L_matrix, adj_matrix, device)
optimizer = torch.optim.Adam(model.parameters(),
lr=cfg.WORD2VEC.LR,
weight_decay=cfg.SDNE.L2)
train(adj_matrix, model, cfg, criterion, optimizer, device)
embedding = model.get_embedding(adj_matrix.to(device))
eval_embedding(embedding, cfg.DATA.LABEL_PATH, logger)
vis_embedding(embedding, cfg.DATA.LABEL_PATH, log_path)
def main(device):
parser = argparse.ArgumentParser("LINE training")
parser.add_argument(
"--config-file",
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
logger, log_path = create_logger(cfg)
logger.info(cfg)
graph = networkx.read_edgelist(cfg.DATA.GRAPH_PATH, create_using=networkx.DiGraph(), nodetype=None, data=[('weight', int)])
model = LINE(graph, cfg).to(device)
v2ind, ind2v = model.get_mapping()
sampler = Sampler(graph, v2ind, batch_size=cfg.SAMPLE.BATCHSIZE)
criterion = KLLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=cfg.WORD2VEC.LR)
train(sampler, model, cfg, criterion, optimizer, device)
embedding = model.get_embedding()
eval_embedding(embedding, cfg.DATA.LABEL_PATH, logger)
vis_embedding(embedding, cfg.DATA.LABEL_PATH, log_path)
def main():
parser = argparse.ArgumentParser(
description="PyTorch Object Detection Training")
parser.add_argument('--gpu', default='0', type=str)
parser.add_argument(
"--config_file",
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
# build model, optimizer and scheduler
model = make_model(cfg)
model = model.to(cfg.DEVICE)
optimizer = build_optimizer(cfg, model)
print('optimizer built!')
# NOTE: add separate optimizers to train single object predictor and interaction predictor
if cfg.USE_WANDB:
logger = Logger("FOL", cfg, project=cfg.PROJECT, viz_backend="wandb")
else:
logger = logging.Logger("FOL")
dataloader_params = {
"batch_size": cfg.SOLVER.BATCH_SIZE,
"shuffle": True,
"num_workers": cfg.DATALOADER.NUM_WORKERS
}
# get dataloaders
train_dataloader = make_dataloader(cfg, 'train')
val_dataloader = make_dataloader(cfg, 'val')
test_dataloader = make_dataloader(cfg, 'test')
print('Dataloader built!')
# get train_val_test engines
do_train, do_val, inference = build_engine(cfg)
print('Training engine built!')
if hasattr(logger, 'run_id'):
run_id = logger.run_id
else:
run_id = 'no_wandb'
save_checkpoint_dir = os.path.join(cfg.CKPT_DIR, run_id)
if not os.path.exists(save_checkpoint_dir):
os.makedirs(save_checkpoint_dir)
# NOTE: hyperparameter scheduler
model.param_scheduler = ParamScheduler()
model.param_scheduler.create_new_scheduler(name='kld_weight',
annealer=sigmoid_anneal,
annealer_kws={
'device': cfg.DEVICE,
'start': 0,
'finish': 100.0,
'center_step': 400.0,
'steps_lo_to_hi': 100.0,
})
model.param_scheduler.create_new_scheduler(name='z_logit_clip',
annealer=sigmoid_anneal,
annealer_kws={
'device': cfg.DEVICE,
'start': 0.05,
'finish': 5.0,
'center_step': 300.0,
'steps_lo_to_hi': 300.0 / 5.
})
if cfg.SOLVER.scheduler == 'exp':
# exponential schedule
lr_scheduler = optim.lr_scheduler.ExponentialLR(optimizer,
gamma=cfg.SOLVER.GAMMA)
elif cfg.SOLVER.scheduler == 'plateau':
# Plateau scheduler
lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.2,
patience=5,
min_lr=1e-07,
verbose=1)
else:
lr_scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[25, 40],
gamma=0.2)
print('Schedulers built!')
for epoch in range(cfg.SOLVER.MAX_EPOCH):
logger.info("Epoch:{}".format(epoch))
do_train(cfg,
epoch,
model,
optimizer,
train_dataloader,
cfg.DEVICE,
logger=logger,
lr_scheduler=lr_scheduler)
val_loss = do_val(cfg,
epoch,
model,
val_dataloader,
cfg.DEVICE,
logger=logger)
if (epoch + 1) % 1 == 0:
inference(cfg,
epoch,
model,
test_dataloader,
cfg.DEVICE,
logger=logger,
eval_kde_nll=False)
torch.save(
model.state_dict(),
os.path.join(save_checkpoint_dir,
'Epoch_{}.pth'.format(str(epoch).zfill(3))))
# update LR
if cfg.SOLVER.scheduler != 'exp':
lr_scheduler.step(val_loss)
def main():
parser = argparse.ArgumentParser(description="PyTorch NDDR Training")
parser.add_argument(
"--config-file",
default="configs/vgg16_nddr_pret.yaml",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.EXPERIMENT_NAME = args.config_file.split('/')[-1][:-5]
cfg.merge_from_list(args.opts)
cfg.freeze()
if not os.path.exists(os.path.join(cfg.SAVE_DIR, cfg.EXPERIMENT_NAME)):
os.makedirs(os.path.join(cfg.SAVE_DIR, cfg.EXPERIMENT_NAME))
# load the data
train_loader = torch.utils.data.DataLoader(
MultiTaskDataset(
data_dir=cfg.DATA_DIR,
data_list_1=cfg.TRAIN.DATA_LIST_1,
data_list_2=cfg.TRAIN.DATA_LIST_2,
output_size=cfg.TRAIN.OUTPUT_SIZE,
random_scale=cfg.TRAIN.RANDOM_SCALE,
random_mirror=cfg.TRAIN.RANDOM_MIRROR,
random_crop=cfg.TRAIN.RANDOM_CROP,
ignore_label=cfg.IGNORE_LABEL,
),
batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True)
# load the data
if cfg.TRAIN.EVAL_CKPT:
test_loader = torch.utils.data.DataLoader(
MultiTaskDataset(
data_dir=cfg.DATA_DIR,
data_list_1=cfg.TEST.DATA_LIST_1,
data_list_2=cfg.TEST.DATA_LIST_2,
output_size=cfg.TEST.OUTPUT_SIZE,
random_scale=cfg.TEST.RANDOM_SCALE,
random_mirror=cfg.TEST.RANDOM_MIRROR,
random_crop=cfg.TEST.RANDOM_CROP,
ignore_label=cfg.IGNORE_LABEL,
),
batch_size=cfg.TEST.BATCH_SIZE, shuffle=False)
timestamp = datetime.datetime.now().strftime("%Y-%m-%d~%H:%M:%S")
experiment_log_dir = os.path.join(cfg.LOG_DIR, cfg.EXPERIMENT_NAME, timestamp)
if not os.path.exists(experiment_log_dir):
os.makedirs(experiment_log_dir)
writer = SummaryWriter(logdir=experiment_log_dir)
net1 = DeepLabLargeFOVBN(3, cfg.MODEL.NET1_CLASSES, weights=cfg.TRAIN.WEIGHT_1)
net2 = DeepLabLargeFOVBN(3, cfg.MODEL.NET2_CLASSES, weights=cfg.TRAIN.WEIGHT_2)
model = NDDRNet(net1, net2,
shortcut=cfg.MODEL.SHORTCUT,
bn_before_relu=cfg.MODEL.BN_BEFORE_RELU)
if cfg.CUDA:
model = model.cuda()
model.train()
steps = 0
seg_loss = nn.CrossEntropyLoss(ignore_index=255)
# hacky way to pick params
nddr_params = []
fc8_weights = []
fc8_bias = []
base_params = []
for k, v in model.named_parameters():
if 'nddrs' in k:
nddr_params.append(v)
elif cfg.MODEL.FC8_ID in k:
if 'weight' in k:
fc8_weights.append(v)
else:
assert 'bias' in k
fc8_bias.append(v)
else:
base_params.append(v)
assert len(nddr_params) > 0 and len(fc8_weights) > 0 and len(fc8_bias) > 0
parameter_dict = [
{'params': base_params},
{'params': fc8_weights, 'lr': cfg.TRAIN.LR * cfg.TRAIN.FC8_WEIGHT_FACTOR},
{'params': fc8_bias, 'lr': cfg.TRAIN.LR * cfg.TRAIN.FC8_BIAS_FACTOR},
{'params': nddr_params, 'lr': cfg.TRAIN.LR * cfg.TRAIN.NDDR_FACTOR}
]
optimizer = optim.SGD(parameter_dict, lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM,
weight_decay=cfg.TRAIN.WEIGHT_DECAY)
if cfg.TRAIN.SCHEDULE == 'Poly':
scheduler = optim.lr_scheduler.LambdaLR(optimizer, lambda step: (1 - float(step) / cfg.TRAIN.STEPS)**cfg.TRAIN.POWER, last_epoch=-1)
elif cfg.TRAIN.SCHEDULE == 'Cosine':
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, cfg.TRAIN.STEPS)
else:
raise NotImplementedError
while steps < cfg.TRAIN.STEPS:
for batch_idx, (image, label_1, label_2) in enumerate(train_loader):
if cfg.CUDA:
image, label_1, label_2 = image.cuda(), label_1.cuda(), label_2.cuda()
optimizer.zero_grad()
out1, out2 = model(image)
# loss_seg = get_seg_loss(out1, label_1, 40, 255)
loss_seg = seg_loss(out1, label_1.squeeze(1))
loss_normal = get_normal_loss(out2, label_2, 255)
loss = loss_seg + cfg.TRAIN.NORMAL_FACTOR * loss_normal
loss.backward()
optimizer.step()
scheduler.step()
# Print out the loss periodically.
if steps % cfg.TRAIN.LOG_INTERVAL == 0:
print('Train Step: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tLoss1: {:.6f}\tLoss2: {:.6f}'.format(
steps, batch_idx * len(image), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.data.item(),
loss_seg.data.item(), loss_normal.data.item()))
# Log to tensorboard
writer.add_scalar('lr', scheduler.get_lr()[0], steps)
writer.add_scalar('loss/overall', loss.data.item(), steps)
writer.add_scalar('loss/seg', loss_seg.data.item(), steps)
writer.add_scalar('loss/normal', loss_normal.data.item(), steps)
writer.add_image('image', process_image(image[0]), steps)
seg_pred, seg_gt = process_seg_label(
out1.argmax(dim=1)[0].detach(),
label_1.squeeze(1)[0],
cfg.MODEL.NET1_CLASSES
)
writer.add_image('seg/pred', seg_pred, steps)
writer.add_image('seg/gt', seg_gt, steps)
normal_pred, normal_gt = process_normal_label(out2[0].detach(), label_2[0], 255)
writer.add_image('normal/pred', normal_pred, steps)
writer.add_image('normal/gt', normal_gt, steps)
if steps % cfg.TRAIN.SAVE_INTERVAL == 0:
checkpoint = {
'cfg': cfg,
'step': steps,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'scheduler_state_dict': scheduler.state_dict(),
'loss': loss,
'loss_seg': loss_seg,
'loss_normal': loss_normal,
'mIoU': None,
'PixelAcc': None,
'angle_metrics': None,
}
if cfg.TRAIN.EVAL_CKPT:
model.eval()
mIoU, pixel_acc, angle_metrics = evaluate(test_loader, model)
writer.add_scalar('eval/mIoU', mIoU, steps)
writer.add_scalar('eval/PixelAcc', pixel_acc, steps)
for k, v in angle_metrics.items():
writer.add_scalar('eval/{}'.format(k), v, steps)
checkpoint['mIoU'] = mIoU
checkpoint['PixelAcc'] = pixel_acc
checkpoint['angle_metrics'] = angle_metrics
model.train()
torch.save(checkpoint, os.path.join(cfg.SAVE_DIR, cfg.EXPERIMENT_NAME,
'ckpt-%s.pth' % str(steps).zfill(5)))
steps += 1
if steps >= cfg.TRAIN.STEPS:
break
description="PyTorch Object Detection Training")
parser.add_argument('--gpu', default='0', type=str)
parser.add_argument(
"--config_file",
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
main(cfg)
# NOTE: define all the ckpt we want to check
# all_ckpts = ['data/ETH_UCY_trajectron/checkpoints/goal_cvae_checkpoints/yh58kusd/Epoch_{}.pth'.format(str(i).zfill(3)) for i in range(1, 16)]
# for ckpt in all_ckpts:
# cfg.CKPT_DIR = ckpt
# for min_hist_len in [1, 8]:
# cfg.MODEL.MIN_HIST_LEN = min_hist_len
# main(cfg)
def main():
# Read config settings from yaml file
args = get_parser().parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
#create logger
output_dir = pathlib.Path(cfg.OUTPUT_DIR)
output_dir.mkdir(exist_ok=True, parents=True)
logger = setup_logger("U", "logs")
logger.info("Loaded configuration file {}".format(cfg))
lr = cfg.SOLVER.LEARN_RATE
bs = cfg.SOLVER.BATCH_SIZE
test_bs = cfg.SOLVER.TEST_BATCH_SIZE
epochs = cfg.TRAINING.EPOCHS
# sets the matplotlib display backend (most likely not needed)
# mp.use('TkAgg', force=True)
data = create_dataset()
tte_test_dataset, tee_test_dataset = load_test_data()
#split the training dataset and initialize the data loaders
print("Train Data length: {}".format(len(data)))
train_partition = int(cfg.TRAINING.TRAIN_PARTITION * len(data))
val_partition = len(data) - train_partition
# split the training dataset and initialize the data loaders
train_dataset, valid_dataset = torch.utils.data.random_split(
data, (train_partition, val_partition))
train_data = DataLoader(train_dataset, batch_size=bs, shuffle=True)
valid_data = DataLoader(valid_dataset, batch_size=bs, shuffle=True)
tte_test_data = DataLoader(tte_test_dataset,
batch_size=test_bs,
shuffle=True)
tee_test_data = DataLoader(tee_test_dataset,
batch_size=test_bs,
shuffle=True)
if cfg.TRAINING.VISUAL_DEBUG:
plotter.plot_image_and_mask(data, 1)
xb, yb = next(iter(train_data))
print(xb.shape, yb.shape)
# build the Unet2D with default input and output channels as given by config
unet = Unet2D()
# logger.info(unet)
#loss function and optimizer
loss_fn = nn.CrossEntropyLoss()
opt = torch.optim.Adam(unet.parameters(), lr=lr)
#do some training
if cfg.TESTING.TEST_ONLY:
run_test(unet, opt, tee_test_data)
evauate_and_log_results(logger, unet, tte_test_data, tee_test_data)
return
else:
train_loss, valid_loss, valid_dice, valid_dice_per_class, pixel_acc = start_train(
unet,
train_data,
valid_data,
loss_fn,
opt,
dice_multiclass,
acc_metric,
epochs=epochs)
# Evaluate network(f)
evauate_and_log_results(logger, unet, tte_test_data, tee_test_data)
if cfg.TRAINING.VISUAL_DEBUG:
# plot training and validation losses
plotter.plot_train_and_val_loss(train_loss, valid_loss)
# plot validation pixel accuracy
plotter.plot_avg_dice_history(valid_dice)
# plot validation dice
plotter.plot_dice_history(valid_dice_per_class)
# show the predicted segmentations
plotter.predict_on_batch_and_plot(tte_test_data, unet, test_bs)
plotter.predict_on_batch_and_plot(tee_test_data, unet, test_bs)
def main():
parser = argparse.ArgumentParser(
description="PyTorch Transfer Learning Task")
parser.add_argument("--config",
default="",
metavar="FILE",
help="path to config file",
type=str)
parser.add_argument("--load_ckpt",
default=None,
metavar="FILE",
help="path to the pretrained model to load ",
type=str)
parser.add_argument(
'--test_only',
action='store_true',
help="test the model (need to provide model path to --load_ckpt)")
parser.add_argument("opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER)
args = parser.parse_args()
if args.test_only:
assert os.path.exists(
args.load_ckpt
), "You need to provide the valid model path using --load_ckpt"
cfg.merge_from_file(args.config)
cfg.merge_from_list(args.opts)
cfg.freeze()
np.random.seed(1234)
torch.manual_seed(1234)
if 'cuda' in device:
torch.cuda.manual_seed_all(1234)
if not os.path.exists(cfg.OUTPUT_DIR):
print('creating output dir: {}'.format(cfg.OUTPUT_DIR))
os.makedirs(cfg.OUTPUT_DIR)
logger = setup_logger("fewshot", cfg.OUTPUT_DIR)
logger.info("Loaded configuration file {}".format(args.config))
with open(args.config, "r") as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
output_config_path = os.path.join(cfg.OUTPUT_DIR, 'config.yml')
logger.info("Saving config into: {}".format(output_config_path))
# save overloaded model config in the output directory
save_config(cfg, output_config_path)
model = architectures[cfg.MODEL.ARCHITECTURE](cfg, logger)
model.to(device)
meta_test_dataset = FashionProductImagesFewShot(cfg=cfg,
split='test',
k_way=cfg.TEST.K_WAY,
n_shot=cfg.TEST.N_SHOT,
logger=logger)
meta_test_dataset.params['shuffle'] = False
meta_test_dataset.params['batch_size'] = 1
meta_test_dataloader = DataLoader(meta_test_dataset,
**meta_test_dataset.params)
if args.test_only:
do_test(cfg, model, meta_test_dataloader, logger, 'test',
args.load_ckpt)
else:
meta_train_dataset = FashionProductImagesFewShot(
cfg=cfg,
split='train',
k_way=cfg.TRAIN.K_WAY,
n_shot=cfg.TRAIN.N_SHOT,
logger=logger)
meta_train_dataloader = DataLoader(meta_train_dataset,
**meta_train_dataset.params)
do_train(cfg, model, meta_train_dataloader, logger, args.load_ckpt)
do_test(cfg, model, meta_test_dataloader, logger, 'test', None)
'''for inner_iter, data in enumerate(meta_test_dataloader):
