| |
|
| | import gorilla
|
| | from tqdm import tqdm
|
| | import argparse
|
| | import os
|
| | import sys
|
| | import os.path as osp
|
| | import time
|
| | import logging
|
| | import numpy as np
|
| | import random
|
| | import importlib
|
| |
|
| | import torch
|
| | from torch.autograd import Variable
|
| | import torch.optim as optim
|
| |
|
| | BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
| | sys.path.append(os.path.join(BASE_DIR, 'provider'))
|
| | sys.path.append(os.path.join(BASE_DIR, 'utils'))
|
| | sys.path.append(os.path.join(BASE_DIR, 'model'))
|
| | sys.path.append(os.path.join(BASE_DIR, 'model', 'pointnet2'))
|
| |
|
| | from solver import Solver, get_logger
|
| | from loss_utils import Loss
|
| |
|
| | def get_parser():
|
| | parser = argparse.ArgumentParser(
|
| | description="Pose Estimation")
|
| |
|
| | parser.add_argument("--gpus",
|
| | type=str,
|
| | default="0",
|
| | help="index of gpu")
|
| | parser.add_argument("--model",
|
| | type=str,
|
| | default="pose_estimation_model",
|
| | help="name of model")
|
| | parser.add_argument("--config",
|
| | type=str,
|
| | default="config/base.yaml",
|
| | help="path to config file")
|
| | parser.add_argument("--exp_id",
|
| | type=int,
|
| | default=0,
|
| | help="experiment id")
|
| | parser.add_argument("--checkpoint_iter",
|
| | type=int,
|
| | default=-1,
|
| | help="iter num. of checkpoint")
|
| | args_cfg = parser.parse_args()
|
| |
|
| | return args_cfg
|
| |
|
| |
|
| | def init():
|
| | args = get_parser()
|
| | exp_name = args.model + '_' + \
|
| | osp.splitext(args.config.split("/")[-1])[0] + '_id' + str(args.exp_id)
|
| | log_dir = osp.join("log", exp_name)
|
| |
|
| | cfg = gorilla.Config.fromfile(args.config)
|
| | cfg.exp_name = exp_name
|
| | cfg.gpus = args.gpus
|
| | cfg.model_name = args.model
|
| | cfg.log_dir = log_dir
|
| | cfg.checkpoint_iter = args.checkpoint_iter
|
| |
|
| | if not os.path.isdir(log_dir):
|
| | os.makedirs(log_dir)
|
| | logger = get_logger(
|
| | level_print=logging.INFO, level_save=logging.WARNING, path_file=log_dir+"/training_logger.log")
|
| | gorilla.utils.set_cuda_visible_devices(gpu_ids=cfg.gpus)
|
| |
|
| | return logger, cfg
|
| |
|
| |
|
| | if __name__ == "__main__":
|
| | logger, cfg = init()
|
| |
|
| | logger.warning(
|
| | "************************ Start Logging ************************")
|
| | logger.info(cfg)
|
| | logger.info("using gpu: {}".format(cfg.gpus))
|
| |
|
| | random.seed(cfg.rd_seed)
|
| | torch.manual_seed(cfg.rd_seed)
|
| |
|
| |
|
| | logger.info("=> creating model ...")
|
| | MODEL = importlib.import_module(cfg.model_name)
|
| | model = MODEL.Net(cfg.model)
|
| | if hasattr(cfg, 'pretrain_dir') and cfg.pretrain_dir is not None:
|
| | logger.info('loading pretrained backbone from {}'.format(cfg.pretrain_dir))
|
| | key1, key2 = model.load_state_dict(torch.load(cfg.pretrain_dir)['model'], strict=False)
|
| | if len(cfg.gpus) > 1:
|
| | model = torch.nn.DataParallel(model, range(len(cfg.gpus.split(","))))
|
| | model = model.cuda()
|
| |
|
| | loss = Loss().cuda()
|
| | count_parameters = sum(gorilla.parameter_count(model).values())
|
| | logger.warning("#Total parameters : {}".format(count_parameters))
|
| |
|
| |
|
| | batchsize = cfg.train_dataloader.bs
|
| | num_epoch = cfg.training_epoch
|
| |
|
| | if cfg.lr_scheduler.type == 'WarmupCosineLR':
|
| | num_iter = cfg.lr_scheduler.max_iters
|
| | if hasattr(cfg, 'warmup_iter') and cfg.warmup_iter >0:
|
| | num_iter = num_iter + cfg.warmup_iter
|
| | iters_per_epoch = int(np.floor(num_iter / num_epoch))
|
| | elif cfg.lr_scheduler.type == 'CyclicLR':
|
| | iters_per_epoch = cfg.lr_scheduler.step_size_up+cfg.lr_scheduler.step_size_down
|
| | train_dataset = importlib.import_module(cfg.train_dataset.name)
|
| | train_dataset = train_dataset.Dataset(cfg.train_dataset, iters_per_epoch*batchsize)
|
| |
|
| |
|
| | train_dataloader = torch.utils.data.DataLoader(
|
| | train_dataset,
|
| | batch_size=cfg.train_dataloader.bs,
|
| | num_workers=cfg.train_dataloader.num_workers,
|
| | shuffle=cfg.train_dataloader.shuffle,
|
| | sampler=None,
|
| | drop_last=cfg.train_dataloader.drop_last,
|
| | pin_memory=cfg.train_dataloader.pin_memory,
|
| | )
|
| |
|
| | dataloaders = {
|
| | "train": train_dataloader,
|
| | }
|
| |
|
| |
|
| | Trainer = Solver(model=model, loss=loss,
|
| | dataloaders=dataloaders,
|
| | logger=logger,
|
| | cfg=cfg)
|
| | Trainer.solve()
|
| |
|
| | logger.info('\nFinish!\n')
|
| |
|
