def gather_options(self):
# initialize parser with basic options
if not self.initialized:
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser = self.initialize(parser)
# get the basic options
opt, unknown = parser.parse_known_args()
# modify model-related parser options
model_name = opt.model
model_option_setter = models.get_option_setter(model_name)
parser = model_option_setter(parser, self.isTrain)
# modify dataset-related parser options
dataset_mode = opt.dataset_mode
dataset_option_setter = data.get_option_setter(dataset_mode)
parser = dataset_option_setter(parser, self.isTrain)
opt, unknown = parser.parse_known_args()
# if there is opt_file, load it.
# The previous default options will be overwritten
if opt.load_from_opt_file:
parser = self.update_options_from_file(parser, opt)
update_parser_defaults_from_yaml(parser)
opt = parser.parse_args()
self.parser = parser
return opt
def main():
# parse command line and run
parser = utils.prepare_parser()
update_parser_defaults_from_yaml(parser)
config = vars(parser.parse_args())
print(config)
run(config)
def main():
# parse command line and run
parser = utils.prepare_parser()
update_parser_defaults_from_yaml(parser)
args = parser.parse_args()
args.base_root = os.path.join(args.tl_outdir, 'biggan')
config = EasyDict(vars(args))
config_str = get_dict_str(config)
logger = logging.getLogger('tl')
logger.info(config_str)
run(config)
def main():
logger = logging.getLogger('tl')
# parse command line
parser = utils.prepare_parser()
update_parser_defaults_from_yaml(parser)
args = parser.parse_args()
args.base_root = os.path.join(args.tl_outdir, 'biggan')
opt = EasyDict(vars(args))
logger.info(f"\nglobal_cfg: \n" + get_dict_str(global_cfg))
global_cfg.dump_to_file_with_command(
f"{opt.tl_outdir}/config_command.yaml", command=opt.tl_command)
run(opt)
def main():
parser = build_parser()
args, _ = parser.parse_known_args()
is_main_process = args.local_rank == 0
update_parser_defaults_from_yaml(parser, is_main_process=is_main_process)
if is_main_process:
modelarts_utils.setup_tl_outdir_obs(global_cfg)
modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True)
modelarts_utils.prepare_dataset(global_cfg.get('modelarts_download', {}), global_cfg=global_cfg)
args = parser.parse_args()
setup_runtime(seed=args.seed)
distributed = ddp_utils.is_distributed()
if distributed:
dist_utils.init_dist(args.launcher, backend='nccl')
# important: use different random seed for different process
torch.manual_seed(args.seed + dist.get_rank())
# dataset
dataset = torch_data_utils.ImageListDataset(meta_file=global_cfg.image_list_file, )
if distributed:
sampler = torch.utils.data.distributed.DistributedSampler(dataset, shuffle=False)
else:
sampler = None
train_loader = data_utils.DataLoader(
dataset,
batch_size=1,
shuffle=False,
sampler=sampler,
num_workers=args.num_workers,
pin_memory=False)
# test
data_iter = iter(train_loader)
data = next(data_iter)
if is_main_process:
modelarts_utils.prepare_dataset(global_cfg.get('modelarts_upload', {}), global_cfg=global_cfg, download=False)
modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True)
if distributed:
dist.barrier()
pass
def main():
update_parser_defaults_from_yaml(parser)
args = parser.parse_args()
global_cfg.merge_from_dict(vars(args))
modelarts_utils.setup_tl_outdir_obs(global_cfg)
modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True)
modelarts_utils.prepare_dataset(global_cfg.get('modelarts_download', {}),
global_cfg=global_cfg)
if args.seed is not None:
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
if args.gpu is not None:
warnings.warn('You have chosen a specific GPU. This will completely '
'disable data parallelism.')
if args.dist_url == "env://" and args.world_size == -1:
args.world_size = int(os.environ["WORLD_SIZE"])
args.distributed = args.world_size > 1 or args.multiprocessing_distributed
ngpus_per_node = torch.cuda.device_count()
if args.multiprocessing_distributed:
# Since we have ngpus_per_node processes per node, the total world_size
# needs to be adjusted accordingly
args.world_size = ngpus_per_node * args.world_size
# Use torch.multiprocessing.spawn to launch distributed processes: the
# main_worker process function
mp.spawn(main_worker,
nprocs=ngpus_per_node,
args=(ngpus_per_node, args))
else:
# Simply call main_worker function
main_worker(args.gpu, ngpus_per_node, args)
]
for v in sys.argv[1:]:
if '=' in v:
name, value = v.split('=')
if name == '--tl_opts':
argv.append(name)
argv.extend(value.split(' '))
else:
argv.extend([name, value])
else:
argv.append(v)
sys.argv.clear()
sys.argv.extend(argv)
sys.argv[
sys.argv.index('--tl_outdir') +
1] = f"{sys.argv[sys.argv.index('--tl_outdir') + 1]}-{time_str}_{tmp_args.number:02d}"
shutil.rmtree(sys.argv[sys.argv.index('--tl_outdir') + 1],
ignore_errors=True)
print(f"sys.argv processed: ")
pprint.pprint(sys.argv)
parser = update_parser_defaults_from_yaml(parser=parser,
use_cfg_as_args=True)
logger = logging.getLogger('tl')
args, _ = parser.parse_known_args()
global_cfg.merge_from_dict(vars(args))
print(get_dict_str(global_cfg))
main()
def run(argv_str=None):
parser = update_parser_defaults_from_yaml(parser=None,
use_cfg_as_args=True)
args = parser.parse_args()
main(args)
def main_worker(gpu, ngpus_per_node, args):
args.gpu = gpu
if args.gpu == 0:
update_parser_defaults_from_yaml(parser)
global_cfg.merge_from_dict(vars(args))
modelarts_utils.setup_tl_outdir_obs(global_cfg)
modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True)
logger = logging.getLogger('tl')
# suppress printing if not master
if args.multiprocessing_distributed and args.gpu != 0:
def print_pass(*args):
pass
builtins.print = print_pass
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank)
# create model
print("=> creating model '{}'".format(args.arch))
model = moco.builder.MoCo(models.__dict__[args.arch], args.moco_dim,
args.moco_k, args.moco_m, args.moco_t, args.mlp)
logger.info(model)
modelarts_utils.modelarts_sync_results_dir(global_cfg,
join=True,
is_main_process=(args.gpu == 0))
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(
(args.workers + ngpus_per_node - 1) / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
# comment out the following line for debugging
raise NotImplementedError("Only DistributedDataParallel is supported.")
else:
# AllGather implementation (batch shuffle, queue update, etc.) in
# this code only supports DistributedDataParallel.
raise NotImplementedError("Only DistributedDataParallel is supported.")
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
if args.gpu is None:
checkpoint = torch.load(args.resume)
else:
# Map model to be loaded to specified single gpu.
loc = 'cuda:{}'.format(args.gpu)
checkpoint = torch.load(args.resume, map_location=loc)
args.start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.aug_plus:
# MoCo v2's aug: similar to SimCLR https://arxiv.org/abs/2002.05709
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4,
0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply([moco.loader.GaussianBlur([.1, 2.])],
p=0.5),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize
]
else:
# MoCo v1's aug: the same as InstDisc https://arxiv.org/abs/1805.01978
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomGrayscale(p=0.2),
transforms.ColorJitter(0.4, 0.4, 0.4, 0.4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]
train_dataset = datasets.ImageFolder(
traindir,
moco.loader.TwoCropsTransform(transforms.Compose(augmentation)))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler,
drop_last=True)
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
if not args.multiprocessing_distributed or (
args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
},
is_best=False,
filename=f'{args.tl_ckptdir}/checkpoint_{epoch:04d}.pth.tar')
modelarts_utils.modelarts_sync_results_dir(
global_cfg, join=False, is_main_process=(args.gpu == 0))
def main_worker(gpu, ngpus_per_node, args):
global best_acc1
args.gpu = gpu
update_parser_defaults_from_yaml(parser, is_main_process=(gpu == 0))
logger = logging.getLogger('tl')
if args.gpu == 0:
modelarts_utils.setup_tl_outdir_obs(global_cfg)
modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True)
# suppress printing if not master
if args.multiprocessing_distributed and args.gpu != 0:
def print_pass(*args):
pass
builtins.print = print_pass
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank)
# create model
logger.info("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
# freeze all layers but the last fc
for name, param in model.named_parameters():
if name not in ['fc.weight', 'fc.bias']:
param.requires_grad = False
# init the fc layer
model.fc.weight.data.normal_(mean=0.0, std=0.01)
model.fc.bias.data.zero_()
logger.info(model)
# load from pre-trained, before DistributedDataParallel constructor
if args.pretrained:
if os.path.isfile(args.pretrained):
logger.info("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained, map_location="cpu")
# rename moco pre-trained keys
state_dict = checkpoint['state_dict']
for k in list(state_dict.keys()):
# retain only encoder_q up to before the embedding layer
if k.startswith('module.encoder_q'
) and not k.startswith('module.encoder_q.fc'):
# remove prefix
state_dict[k[len("module.encoder_q."):]] = state_dict[k]
# delete renamed or unused k
del state_dict[k]
args.start_epoch = 0
msg = model.load_state_dict(state_dict, strict=False)
assert set(msg.missing_keys) == {"fc.weight", "fc.bias"}
logger.info("=> loaded pre-trained model '{}'".format(
args.pretrained))
else:
print("=> no checkpoint found at '{}'".format(args.pretrained))
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(
(args.workers + ngpus_per_node - 1) / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size to all available GPUs
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
# optimize only the linear classifier
parameters = list(filter(lambda p: p.requires_grad, model.parameters()))
assert len(parameters) == 2 # fc.weight, fc.bias
optimizer = torch.optim.SGD(parameters,
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
if args.gpu is None:
checkpoint = torch.load(args.resume)
else:
# Map model to be loaded to specified single gpu.
loc = 'cuda:{}'.format(args.gpu)
checkpoint = torch.load(args.resume, map_location=loc)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
if args.gpu is not None:
# best_acc1 may be from a checkpoint from a different GPU
best_acc1 = best_acc1.to(args.gpu)
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler)
# val_loader = torch.utils.data.DataLoader(
# datasets.ImageFolder(valdir, transforms.Compose([
# transforms.Resize(256),
# transforms.CenterCrop(224),
# transforms.ToTensor(),
# normalize,
# ])),
# batch_size=args.batch_size, shuffle=False,
# num_workers=args.workers, pin_memory=True)
evaldir = os.path.join(args.data, 'val')
eval_imagenet = EvalImageNet(valdir=evaldir, gpu_id=gpu)
if args.evaluate:
eval_imagenet.validate(model=model, epoch=0)
return
# print("=> loading checkpoint '{}'".format(args.pretrained))
# checkpoint = torch.load(args.pretrained, map_location="cpu")
#
# # rename moco pre-trained keys
# state_dict = checkpoint['state_dict']
# for k in list(state_dict.keys()):
# # retain only encoder_q up to before the embedding layer
# if k.startswith('module.encoder_q'):
# # remove prefix
# state_dict['module.' + k[len("module.encoder_q."):]] = state_dict[k]
# # delete renamed or unused k
# del state_dict[k]
#
# msg = model.load_state_dict(state_dict, strict=False)
# validate(val_loader, model, criterion, args)
# return
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on validation set
# acc1 = validate(val_loader, model, criterion, args)
# summary_dict2txtfig({'top1': acc1.item()}, prefix='eval', step=epoch,
# textlogger=global_textlogger, is_main_process=(args.gpu == 0))
acc1 = eval_imagenet.validate(model=model, epoch=epoch)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
if not args.multiprocessing_distributed or (
args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
},
is_best,
filename=f"{args.tl_ckptdir}/checkpoint.pth.tar")
modelarts_utils.modelarts_sync_results_dir(
global_cfg, join=False, is_main_process=(args.gpu == 0))
if epoch == args.start_epoch:
sanity_check(model.state_dict(), args.pretrained)
modelarts_utils.modelarts_sync_results_dir(global_cfg,
join=True,
is_main_process=(args.gpu == 0))
def main():
parser = ArgumentParser(add_help=False)
parser.add_argument('-c',
'--config_path',
type=str,
default='./src/configs/CIFAR10/ContraGAN.json')
parser.add_argument('--checkpoint_folder', type=str, default=None)
parser.add_argument('-current',
'--load_current',
action='store_true',
help='whether you load the current or best checkpoint')
parser.add_argument('--log_output_path', type=str, default=None)
parser.add_argument('-DDP',
'--distributed_data_parallel',
action='store_true')
parser.add_argument('-n', '--nodes', default=1, type=int, metavar='N')
parser.add_argument('-nr',
'--nr',
default=0,
type=int,
help='ranking within the nodes')
parser.add_argument('--seed',
type=int,
default=-1,
help='seed for generating random numbers')
parser.add_argument('--num_workers', type=int, default=8, help='')
parser.add_argument('-sync_bn',
'--synchronized_bn',
action='store_true',
help='whether turn on synchronized batchnorm')
parser.add_argument('-mpc',
'--mixed_precision',
action='store_true',
help='whether turn on mixed precision training')
parser.add_argument('-LARS',
'--LARS_optimizer',
action='store_true',
help='whether turn on LARS optimizer')
parser.add_argument('-rm_API',
'--disable_debugging_API',
action='store_true',
help='whether disable pytorch autograd debugging mode')
parser.add_argument('--reduce_train_dataset',
type=float,
default=1.0,
help='control the number of train dataset')
parser.add_argument('--truncated_factor',
type=float,
default=-1.0,
help='factor for truncation trick')
parser.add_argument('-stat_otf',
'--bn_stat_OnTheFly',
action='store_true',
help='when evaluating, use the statistics of a batch')
parser.add_argument('-std_stat',
'--standing_statistics',
action='store_true')
parser.add_argument('--standing_step',
type=int,
default=-1,
help='# of steps for accumulation batchnorm')
parser.add_argument('--freeze_layers',
type=int,
default=-1,
help='# of layers for freezing discriminator')
parser.add_argument('-l', '--load_all_data_in_memory', action='store_true')
parser.add_argument('-t', '--train', action='store_true')
parser.add_argument('-e', '--eval', action='store_true')
parser.add_argument('-s', '--save_images', action='store_true')
parser.add_argument('-iv',
'--image_visualization',
action='store_true',
help='select whether conduct image visualization')
parser.add_argument(
'-knn',
'--k_nearest_neighbor',
action='store_true',
help='select whether conduct k-nearest neighbor analysis')
parser.add_argument('-itp',
'--interpolation',
action='store_true',
help='whether conduct interpolation analysis')
parser.add_argument('-fa',
'--frequency_analysis',
action='store_true',
help='whether conduct frequency analysis')
parser.add_argument('-tsne',
'--tsne_analysis',
action='store_true',
help='whether conduct tsne analysis')
parser.add_argument('--nrow',
type=int,
default=10,
help='number of rows to plot image canvas')
parser.add_argument('--ncol',
type=int,
default=8,
help='number of cols to plot image canvas')
parser.add_argument('--print_every',
type=int,
default=100,
help='control log interval')
parser.add_argument('--save_every',
type=int,
default=2000,
help='control evaluation and save interval')
parser.add_argument('--eval_type',
type=str,
default='test',
help='[train/valid/test]')
from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg
update_parser_defaults_from_yaml(parser=parser)
args = parser.parse_args()
if not args.train and \
not args.eval and \
not args.save_images and \
not args.image_visualization and \
not args.k_nearest_neighbor and \
not args.interpolation and \
not args.frequency_analysis and \
not args.tsne_analysis:
parser.print_help(sys.stderr)
sys.exit(1)
if args.config_path is not None:
with open(args.config_path) as f:
model_configs = json.load(f)
train_configs = vars(args)
else:
raise NotImplementedError
hdf5_path_train = make_hdf5(model_configs['data_processing'], train_configs, mode="train") \
if train_configs['load_all_data_in_memory'] else None
if train_configs['seed'] == -1:
train_configs['seed'] = random.randint(1, 4096)
cudnn.benchmark, cudnn.deterministic = True, False
else:
cudnn.benchmark, cudnn.deterministic = False, True
fix_all_seed(train_configs['seed'])
gpus_per_node, rank = torch.cuda.device_count(), torch.cuda.current_device(
)
world_size = gpus_per_node * train_configs['nodes']
if world_size == 1:
warnings.warn(
'You have chosen a specific GPU. This will completely disable data parallelism.'
)
run_name = make_run_name(
RUN_NAME_FORMAT,
framework=train_configs['config_path'].split('/')[-1][:-5],
phase='train')
if train_configs['disable_debugging_API']:
torch.autograd.set_detect_anomaly(False)
check_flags(train_configs, model_configs, world_size)
if train_configs['distributed_data_parallel'] and world_size > 1:
print("Train the models through DistributedDataParallel (DDP) mode.")
mp.spawn(prepare_train_eval,
nprocs=gpus_per_node,
args=(gpus_per_node, world_size, run_name, train_configs,
model_configs, hdf5_path_train))
else:
prepare_train_eval(rank,
gpus_per_node,
world_size,
run_name,
train_configs,
model_configs,
hdf5_path_train=hdf5_path_train)
weights = np.mean(grads, axis=(1, 2)) #
for i, w in enumerate(weights):
cam += w * feature_map[i, :, :]
cam = np.maximum(cam, 0)
cam = cv2.resize(cam, (32, 32))
cam -= np.min(cam)
cam /= np.max(cam)
return cam
if __name__ == '__main__':
from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg
update_parser_defaults_from_yaml(parser=None)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
path_img = os.path.join(BASE_DIR, "cam_img", "test_img_8.png")
path_net = os.path.join(BASE_DIR, "cam_img", "net_params_72p.pkl")
output_dir = global_cfg.tl_outdir
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 图片读取；网络加载
img = cv2.imread(path_img, 1) # H*W*C
img_input = img_preprocess(img)
net = Net()
ret = net.load_state_dict(torch.load(path_net))
