def train(args):
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
shutil.copy(args.config_file, cfg.OUTPUT_DIR)
num_gpus = torch.cuda.device_count()
logger = setup_logger('reid_baseline', output_dir, 0)
logger.info('Using {} GPUS'.format(num_gpus))
logger.info(args)
logger.info('Running with config:\n{}'.format(cfg))
train_dl, val_dl, num_query, num_classes = make_dataloader(cfg, num_gpus)
model = build_model(cfg, num_classes)
# print(model)
loss_func = make_loss(cfg, num_classes)
trainer = BaseTrainer(cfg, model, train_dl, val_dl, loss_func, num_query,
num_gpus)
for epoch in range(trainer.epochs):
for batch in trainer.train_dl:
trainer.step(batch)
trainer.handle_new_batch()
trainer.handle_new_epoch()
def main():
args = parse_args()
update_config(cfg, args)
cfg.defrost()
cfg.RANK = args.rank
cfg.freeze()
logger, final_output_dir, tb_log_dir = create_logger(
cfg, args.cfg, 'train')
logger.info(pprint.pformat(args))
#logger.info(cfg)
if cfg.WITHOUT_EVAL:
input(
"[WARNING] According to the configuration, there will be no evaluation. If evaluation is necessary, please terminate this process. [press Enter to continue]"
)
logger.info("=> Training without evaluation")
ngpus_per_node = len(cfg.GPUS)
if ngpus_per_node == 1:
warnings.warn(
'You have chosen a specific GPU. This will completely disable data parallelism.'
)
# Simply call main_worker function
main_worker(','.join([str(i) for i in cfg.GPUS]), ngpus_per_node, args,
final_output_dir, tb_log_dir)
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
print("Creating generator object ...")
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
# gen.load_state_dict(torch.load(args.generator_file))
gen.load(args.generator_file)
draw_truncation_trick_figure('figure08-truncation-trick.png',
gen,
out_depth=5,
seeds=[1, 32, 44, 86, 91, 388],
psis=[1, 0.7, 0.5, 0, -0.5, -1])
print('Done.')
def main():
setup_seed(1)
parser = argparse.ArgumentParser(description="ReID Baseline Training")
parser.add_argument(
"--config_file", default="", 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()
# num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
logger = setup_logger("reid_baseline", output_dir, 0)
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
cudnn.benchmark = True
train(cfg)
def test_cross_dataset(config_file,test_dataset, **kwargs):
cfg.merge_from_file(config_file)
if kwargs:
opts = []
for k,v in kwargs.items():
opts.append(k)
opts.append(v)
cfg.merge_from_list(opts)
cfg.freeze()
PersonReID_Dataset_Downloader('./datasets',cfg.DATASETS.NAMES)
_, _, _, num_classes = data_loader(cfg,cfg.DATASETS.NAMES)
PersonReID_Dataset_Downloader('./datasets',test_dataset)
_, val_loader, num_query, _ = data_loader(cfg,test_dataset)
re_ranking=cfg.RE_RANKING
if not re_ranking:
logger = make_logger("Reid_Baseline", cfg.OUTPUT_DIR,
cfg.DATASETS.NAMES+'->'+test_dataset)
logger.info("Test Results:")
else:
logger = make_logger("Reid_Baseline", cfg.OUTPUT_DIR,
cfg.DATASETS.NAMES+'->'+test_dataset+'_re-ranking')
logger.info("Re-Ranking Test Results:")
device = torch.device(cfg.DEVICE)
model = getattr(models, cfg.MODEL.NAME)(num_classes)
model.load(cfg.OUTPUT_DIR,cfg.TEST.LOAD_EPOCH)
model = model.eval()
all_feats = []
all_pids = []
all_camids = []
since = time.time()
for data in tqdm(val_loader, desc='Feature Extraction', leave=False):
model.eval()
with torch.no_grad():
images, pids, camids = data
if device:
model.to(device)
images = images.to(device)
feats = model(images)
all_feats.append(feats)
all_pids.extend(np.asarray(pids))
all_camids.extend(np.asarray(camids))
cmc, mAP = evaluation(all_feats,all_pids,all_camids,num_query,re_ranking)
logger.info("mAP: {:.1%}".format(mAP))
for r in [1, 5, 10]:
logger.info("CMC curve, Rank-{:<3}:{:.1%}".format(r, cmc[r - 1]))
test_time = time.time() - since
logger.info('Testing complete in {:.0f}m {:.0f}s'.format(test_time // 60, test_time % 60))
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Training")
parser.add_argument(
"--config_file", default="", 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()
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
logger = setup_logger(name="merlin.baseline", output=output_dir)
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
# logger.info("Using {} GPUS".format(num_gpus))
train(cfg)
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Training")
parser.add_argument('-cfg',
"--config_file",
default="",
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()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
if not os.path.exists(cfg.OUTPUT_DIR): os.makedirs(cfg.OUTPUT_DIR)
logger = setup_logger("reid_baseline", cfg.OUTPUT_DIR, 0)
logger.info("Using {} GPUs.".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
logger.info("Running with config:\n{}".format(cfg))
cudnn.benchmark = True
train(cfg)
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
print("Creating generator object ...")
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
# gen.load_state_dict(torch.load(args.generator_file))
gen = load(gen, args.generator_file)
# path for saving the files:
# generate the images:
# src_seeds = [639, 701, 687, 615, 1999], dst_seeds = [888, 888, 888],
draw_style_mixing_figure(os.path.join('figure03-style-mixing.png'),
gen,
out_depth=4,
src_seeds=[639, 1995, 687, 615, 1999],
dst_seeds=[888, 888, 888],
style_ranges=[range(0, 2)] * 1 +
[range(2, 8)] * 1 + [range(8, 14)] * 1)
print('Done.')
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
save_path = args.output_dir
os.makedirs(save_path, exist_ok=True)
print("Creating generator object ...")
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
gen.load_state_dict(torch.load(args.generator_file))
build_truncation_trick_seq(save_path,
gen,
out_depth=5,
num_samles=args.num_samples)
print('Done.')
def main():
args = parse_args()
update_config(cfg, args)
cfg.defrost()
cfg.TEST.MODEL_FILE = HRNET_PATH + '/models/pytorch/pose_coco/pose_hrnet_w32_256x192.pth'
cfg.TEST.USE_GT_BBOX = False
cfg.GPUS = (0, )
cfg.freeze()
logger, final_output_dir, tb_log_dir = create_logger(
cfg, args.cfg, 'valid')
logger.info(pprint.pformat(args))
logger.info(cfg)
# cudnn related setting
cudnn.benchmark = cfg.CUDNN.BENCHMARK
torch.backends.cudnn.deterministic = cfg.CUDNN.DETERMINISTIC
torch.backends.cudnn.enabled = cfg.CUDNN.ENABLED
logger.info('=> loading model from {}'.format(cfg.TEST.MODEL_FILE))
model = eval('models.' + cfg.MODEL.NAME + '.get_pose_net')(cfg,
is_train=False)
model.load_state_dict(torch.load(cfg.TEST.MODEL_FILE), strict=False)
model = torch.nn.DataParallel(model, device_ids=cfg.GPUS).cuda()
# Data loading code
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
normalize = transforms.Compose([transforms.ToTensor(), normalize])
predict_imgs(model, args.imgs, args.bbox, args.out, normalize, 0.85)
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Training")
parser.add_argument("--config_file",
default="",
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()
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train(cfg)
def main():
parser = argparse.ArgumentParser(description="PyTorch Template MNIST Training")
parser.add_argument(
"--config_file", default="", 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()
num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
mkdir(output_dir)
logger = setup_logger("wheatdetection", output_dir, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
train(cfg, logger)
def main(args):
if args.use_cpu or not torch.cuda.is_available():
device = torch.device("cpu")
pin_memory = False
else:
device = torch.device("cuda")
pin_memory = True
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
logger = setup_logger(cfg, args.config_file, "test")
cfg.freeze()
test_dataset = MVORDatasetTest(ann_file=cfg.DATASET.TEST.ANNO_FILE,
root=cfg.DATASET.TEST.ROOT_DIR)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=cfg.DATASET.TEST.BATCH_SIZE,
shuffle=cfg.DATASET.TEST.SHUFFLE,
num_workers=cfg.DATASET.TEST.WORKERS,
pin_memory=pin_memory,
)
logger.info(pprint.pformat(cfg))
logger.info(pprint.pformat(args))
model = get_model()
model.load_state_dict(torch.load(cfg.TEST.MODEL_FILE), strict=True)
model.to(device)
eval_on_lowres_mvor(cfg=cfg,
test_loader=test_loader,
model=model,
logger=logger,
device=device)
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
print("Creating generator object ...")
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
# gen.load_state_dict(torch.load(args.generator_file))
gen.load(args.generator_file)
src_seeds=[1,32, 44, 86]
dst_seeds=[231,415,1515,16]
draw_interp_figure(args.output, gen, out_depth=5,
src_seeds=src_seeds, dst_seeds=dst_seeds, psis=[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7,0.8, 0.9,1])
print('Done.')
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument("--config_file",
default="",
help="path to config file",
type=str)
parser.add_argument("flag",
action='store_false',
help="whether to test multiple models")
parser.add_argument("opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER)
args = parser.parse_args()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
mkdir(output_dir)
logger = setup_logger("reid_baseline", output_dir, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train_loader, val_loader, num_query, num_classes = make_data_loader(cfg)
model = build_model(cfg, num_classes)
if args.flag:
path, _ = os.path.split(cfg.TEST.WEIGHT)
model_list = []
for root, dirs, files in os.walk(path):
for i in files:
if i.startswith('resnet50_model'):
model_list.append(i)
for i in model_list:
print(i)
model.load_param(os.path.join(path, i))
inference(cfg, model, val_loader, num_query)
else:
model.load_param(cfg.TEST.WEIGHT)
inference(cfg, model, val_loader, num_query)
def __prepare_fine_tune(self):
cfg.defrost()
cfg.TRAIN.ANNO_FILE = cfg.FINE_TUNE.ANNO_FILE
cfg.TRAIN.YOLO_EPOCHS = cfg.FINE_TUNE.YOLO_EPOCHS
cfg.TRAIN.LR_INIT = cfg.FINE_TUNE.LR_INIT
cfg.TRAIN.LR_END = cfg.FINE_TUNE.LR_END
cfg.TRAIN.WARMUP_EPOCHS = cfg.FINE_TUNE.WARMUP_EPOCHS
cfg.freeze()
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument(
"--config_file", default="", 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()
num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
mkdir(output_dir)
logger = setup_logger("reid_baseline", output_dir, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train_loader, val_loader, num_query, num_classes = make_data_loader(cfg)
model = build_mt_model(
num_features=cfg.mt.num_features,
last_stride=cfg.mt.last_conv_stride,
num_classes=1, #not used since clf is not loaded
num_classes_seg=cfg.mt.num_classes_seg,
global_branch=cfg.mt.global_branch,
mask_branch=cfg.mt.mask_branch,
part_branch=cfg.mt.part_branch,
mask_dim=cfg.mt.mask_dim,
part_dim=cfg.mt.part_dim,
part_info=cfg.mt.part_info,
attr_mask_weight=cfg.mt.attr_mask_weight,
use_attr=cfg.mt.use_attr,
part_layer=cfg.mt.part_layer,
part_abla=cfg.mt.part_abla
)
print(cfg.TEST.WEIGHT)
model.load_param(cfg.TEST.WEIGHT)
inference(cfg, model, val_loader, num_query)
def train(train_loader, num_classes):
parser = argparse.ArgumentParser(description="ReID Baseline Training")
parser.add_argument(
"--config_file", default="", 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()
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
set_seed(cfg.SOLVER.SEED)
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
logger = setup_logger("reid_baseline", output_dir, if_train=True)
logger.info("Saving model in the path :{}".format(cfg.OUTPUT_DIR))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
if cfg.MODEL.PRETRAIN_CHOICE == 'finetune':
model = make_model(cfg, num_class=num_classes)
model.load_param_finetune(cfg.MODEL.PRETRAIN_PATH)
print('Loading pretrained model for finetuning......')
else:
model = make_model(cfg, num_class=num_classes)
loss_func = make_loss(cfg, num_classes=num_classes)
optimizer = make_optimizer(cfg, model)
scheduler = WarmupCosineAnnealingLR(optimizer, cfg.SOLVER.MAX_EPOCHS, cfg.SOLVER.DELAY_ITERS, cfg.SOLVER.ETA_MIN_LR,
cfg.SOLVER.WARMUP_FACTOR, cfg.SOLVER.WARMUP_EPOCHS, cfg.SOLVER.WARMUP_METHOD)
logger.info("use WarmupCosineAnnealingLR, delay_step:{}".format(cfg.SOLVER.DELAY_ITERS))
do_train(
cfg,
model,
train_loader,
optimizer,
scheduler, # modify for using self trained model
loss_func
)
def main():
#解析命令行参数,详见argparse模块
parser = argparse.ArgumentParser(
description="Classification Baseline Training")
parser.add_argument("--config_file",
default="",
help="path to config file",
type=str)
parser.add_argument("opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER
) #nargs=argparse.REMAINDER是指所有剩余的参数均转化为一个列表赋值给此项
args = parser.parse_args()
#os.environ()是python用来获取系统相关信息的。如environ[‘HOME’]就代表了当前这个用户的主目录
## WORLD_SIZE 由torch.distributed.launch.py产生 具体数值为 nproc_per_node*node(主机数，这里为1)
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
#此处是指如果有类似yaml重新赋值参数的文件在的话会把它读进来。这也是rbgirshick/yacs模块的优势所在——参数与代码分离
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.TRAIN.DATALOADER.IMS_PER_BATCH = cfg.TRAIN.DATALOADER.CATEGORIES_PER_BATCH * cfg.TRAIN.DATALOADER.INSTANCES_PER_CATEGORY_IN_BATCH
cfg.VAL.DATALOADER.IMS_PER_BATCH = cfg.VAL.DATALOADER.CATEGORIES_PER_BATCH * cfg.VAL.DATALOADER.INSTANCES_PER_CATEGORY_IN_BATCH
cfg.TEST.DATALOADER.IMS_PER_BATCH = cfg.TEST.DATALOADER.CATEGORIES_PER_BATCH * cfg.TEST.DATALOADER.INSTANCES_PER_CATEGORY_IN_BATCH
cfg.freeze(
) #最终要freeze一下，prevent further modification，也就是参数设置在这一步就完成了，后面都不能再改变了
output_dir = cfg.SOLVER.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
#logger主要用于输出运行日志，相比print有一定优势。
logger = setup_logger("classification", output_dir, "training", 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
# print the configuration file
'''
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
#'''
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = ",".join(
"%s" % i for i in
cfg.MODEL.DEVICE_ID) # int tuple -> str # cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train(cfg)
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
print("Creating generator object ...")
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
# gen.load_state_dict(torch.load(args.generator_file))
gen.load(args.generator_file)
# path for saving the files:
save_path = args.output_dir
os.makedirs(save_path, exist_ok=True)
latent_size = opt.model.gen.latent_size
out_depth = int(np.log2(opt.dataset.resolution)) - 2
print("Generating scale synchronized images ...")
# generate the images:
# with torch.no_grad():
with jt.no_grad():
# point = torch.randn(args.n_row * args.n_col, latent_size)
np.random.seed(1000)
point = np.random.randn(args.n_row * args.n_col, latent_size)
# point = (point / point.norm()) * (latent_size ** 0.5)
point = (point / np.linalg.norm(point)) * (latent_size**0.5)
point = jt.array(point, dtype='float32')
ss_image = gen(point, depth=out_depth, alpha=1)
# color adjust the generated image:
ss_image = adjust_dynamic_range(ss_image)
print("gen done")
# save the ss_image in the directory
# ss_image = torch.from_numpy(ss_image.data)
# save_image(ss_image, os.path.join(save_path, "grid.png"), nrow=args.n_row,
# normalize=True, scale_each=True, pad_value=128, padding=1)
jt.save_image_my(ss_image,
os.path.join(save_path, "grid.png"),
nrow=args.n_row,
normalize=True,
scale_each=True,
pad_value=128,
padding=1)
print('Done.')
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument('-cfg',
"--config_file", default="", 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()
num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
# set pretrian = False to avoid loading weight repeatedly
cfg.MODEL.PRETRAIN = False
cfg.freeze()
logger = setup_logger("reid_baseline", False, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
logger.info("Running with config:\n{}".format(cfg))
test_dataloader, num_query, _ = get_test_dataloader(cfg, test_phase=False)
distmat_paths = [cfg.TEST.DISTMAT1, cfg.TEST.DISTMAT2, cfg.TEST.DISTMAT3,
cfg.TEST.DISTMAT4, cfg.TEST.DISTMAT5, cfg.TEST.DISTMAT6]
# 加载dist_mats
dist_mats = []
cnt = 0
thresh = 3
for distmat_path in distmat_paths:
if os.path.isfile(distmat_path):
f = h5py.File(distmat_path, 'r')
#mat = f['dist_mat'][()]
if cnt < thresh:
mat = f['dist_mat1'][()]
else:
mat = f['dist_mat1'][()]
mat = mat[np.newaxis, ...]
dist_mats.append(mat)
f.close()
cnt += 1
logger.info(f'Average {cnt} results')
dist_mat = np.concatenate(dist_mats, axis=0).mean(axis=0)
inference_with_distmat(cfg, test_dataloader, num_query, dist_mat)
def main():
parser = argparse.ArgumentParser(
description="Image Classification Training")
parser.add_argument("--config_file",
default="",
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()
num_gpu = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
experiment_name = 'no_config'
if args.config_file != "":
cfg.merge_from_file(args.config_file)
experiment_name = args.config_file.split('/')[-1].split('.')[0]
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = os.path.join(cfg.MODEL.OUTPUT_PATH, experiment_name)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
logger, log_path = setup_logger('{}'.format(cfg.PROJECT.NAME), output_dir,
experiment_name)
logger.info("Running with config:\n{}".format(cfg.PROJECT.NAME))
logger.info("Using {} GPU".format(num_gpu))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train(cfg, experiment_name=experiment_name)
try:
logger.info("Drawing curve ......")
plot_curve(log_path=log_path,
experiment_name=experiment_name,
output=output_dir)
logger.info("The curve is saved in {}".format(output_dir))
except Exception as e:
print(e)
def main():
parser = argparse.ArgumentParser(description="AGW Re-ID Baseline")
parser.add_argument("--config_file",
default="",
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()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
logger = setup_logger("reid_baseline", output_dir, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
if cfg.MODEL.DEVICE == "cuda":
os.environ[
'CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID # new add by gu
cudnn.benchmark = True
data_loader, num_query, num_classes = make_data_loader(cfg)
model = build_model(cfg, num_classes)
if 'cpu' not in cfg.MODEL.DEVICE:
if torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
model.to(device=cfg.MODEL.DEVICE)
if cfg.TEST.EVALUATE_ONLY == 'on':
logger.info("Evaluate Only")
model.load_param(cfg.TEST.WEIGHT)
do_test(cfg, model, data_loader, num_query)
return
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument("--config_file",
default="",
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()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
mkdir(output_dir)
if cfg.MODEL.DEVICE == "cuda":
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID
cudnn.benchmark = True
train_loader, val_loader, num_query, num_classes = make_data_loader(cfg)
model = build_model_pre(cfg, num_classes)
model.load_param(cfg.TEST.WEIGHT)
# inference(cfg, model, val_loader, num_query)
device = cfg.MODEL.DEVICE
evaluator = create_supervised_evaluator(
model,
metrics={
'pre_selection_index':
pre_selection_index(num_query,
max_rank=100,
feat_norm=cfg.TEST.FEAT_NORM)
},
device=device)
evaluator.run(val_loader)
index = evaluator.state.metrics['pre_selection_index']
with open(cfg.Pre_Index_DIR, 'w+') as f:
json.dump(index.tolist(), f)
print("Pre_Selection_Done")
def main():
config.load_cfg_fom_args("Train a cls model.")
cfg.freeze()
global args
global min_loss
global step
args = parser.parse_args()
cuda_gpu = torch.cuda.is_available()
mytraindata = generalclsDataset(args.data_dir, cfg)
mytrainloader = DataLoaderX(mytraindata,
batch_size=args.batch_size,
shuffle=True,
num_workers=0)
mymodel = builGraph.getModel(args.backbone,
args.classnum,
args.gpu,
'retrieval',
cuda_gpu=cuda_gpu,
pretrained=True)
#mymodel=models.resnet50(pretrained=True).cuda()
if args.optimizer == 'gd':
optimizer = torch.optim.SGD(mymodel.parameters(), lr=args.LR)
else:
optimizer = torch.optim.Adam(mymodel.parameters(), lr=args.LR)
Arcloss = torch.nn.DataParallel(ArcMarginLoss(
args.classnum, in_features=OUTPUT_DIM[args.backbone]),
device_ids=args.gpu).cuda()
thisloss = nn.CrossEntropyLoss()
startepoch = 0
if os.path.exists(args.train_dir):
print(args.train_dir, flush=True)
checkpoint = torch.load(args.train_dir, map_location='cpu')
print(mymodel.named_parameters(), flush=True)
mymodel.load_state_dict(checkpoint['model_state_dict'])
Arcloss.load_state_dict(checkpoint['arcface_state_dict'])
print(mymodel.named_parameters(), flush=True)
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
startepoch = checkpoint['epoch'] + 1
min_loss = checkpoint['loss']
if 'step' in checkpoint:
step = checkpoint['step']
for epoch in range(startepoch, args.maxepoch):
_learning_rate_schedule(optimizer, epoch, args.maxepoch, args.LR)
trainclassification(mymodel, epoch, optimizer, thisloss, mytrainloader,
Arcloss)
#_learning_rate_schedule(optimizer,epoch,args.maxepoch,args.LR)
#test(mymodel,mytrainloader)
writer.close()
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument('-cfg',
"--config_file",
default="",
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()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
# set pretrian = False to avoid loading weight repeatedly
cfg.MODEL.PRETRAIN = False
cfg.DATASETS.PRELOAD_IMAGE = False
cfg.freeze()
logger = setup_logger("reid_baseline", False, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
logger.info("Running with config:\n{}".format(cfg))
cudnn.benchmark = True
model = build_model(cfg, 0)
#print('model', model)
model = model.cuda()
model.load_params_wo_fc(torch.load(cfg.TEST.WEIGHT))
test_dataloader, num_query, _ = get_test_dataloader(cfg, test_phase=False)
#inference_no_rerank(cfg, model, test_dataloader, num_query)
#inference(cfg, model, test_dataloader, num_query)
#inference_aligned(cfg, model, test_dataloader, num_query) # using flipped image
inference_aligned_flipped(cfg,
model,
test_dataloader,
num_query,
use_local_feature=False,
use_rerank=True,
use_cross_feature=True)
def main(args):
"""
Main function for the script
:param args: parsed command line arguments
:return: None
"""
from config import cfg as opt
opt.merge_from_file(args.config)
opt.freeze()
print("Creating generator object ...")
print(opt.model.gen)
# create the generator object
gen = Generator(resolution=opt.dataset.resolution,
num_channels=opt.dataset.channels,
structure=opt.structure,
**opt.model.gen)
print("Loading the generator weights from:", args.generator_file)
# load the weights into it
# gen.load_state_dict(torch.load(args.generator_file))
gen = load(gen, args.generator_file)
# path for saving the files:
save_path = args.output_dir
os.makedirs(save_path, exist_ok=True)
latent_size = opt.model.gen.latent_size
out_depth = int(np.log2(opt.dataset.resolution)) - 2
if args.input is None:
print("Generating scale synchronized images ...")
for img_num in tqdm(range(1, args.num_samples + 1)):
# generate the images:
with torch.no_grad():
point = torch.randn(1, latent_size)
point = (point / point.norm()) * (latent_size ** 0.5)
ss_image = gen(point, depth=out_depth, alpha=1)
# color adjust the generated image:
ss_image = adjust_dynamic_range(ss_image)
# save the ss_image in the directory
save_image(ss_image, os.path.join(save_path, str(img_num) + ".png"))
print("Generated %d images at %s" % (args.num_samples, save_path))
else:
code = np.load(args.input)
dlatent_in = torch.unsqueeze(torch.from_numpy(code), 0)
ss_image = gen.g_synthesis(dlatent_in, depth=out_depth, alpha=1)
# color adjust the generated image:
ss_image = adjust_dynamic_range(ss_image)
save_image(ss_image, args.output)
def main():
parser = argparse.ArgumentParser(description="ReID Model Training")
parser.add_argument('-cfg',
"--config_file",
default="",
metavar="FILE",
help="path to config file",
type=str)
# parser.add_argument("--local_rank", type=int, default=0)
parser.add_argument("opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER)
args = parser.parse_args()
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
gpus = os.environ[
"CUDA_VISIBLE_DEVICES"] if "CUDA_VISIBLE_DEVICES" in os.environ else '0'
gpus = [int(i) for i in gpus.split(',')]
num_gpus = len(gpus)
# cfg.SOLVER.DIST = num_gpus > 1
# if cfg.SOLVER.DIST:
# torch.cuda.set_device(args.local_rank)
# torch.distributed.init_process_group(
# backend="nccl", init_method="env://"
# )
# torch.cuda.synchronize()
cfg.freeze()
log_save_dir = os.path.join(cfg.OUTPUT_DIR,
'-'.join(cfg.DATASETS.TEST_NAMES),
cfg.MODEL.VERSION)
if not os.path.exists(log_save_dir): os.makedirs(log_save_dir)
logger = setup_logger("reid_baseline.train", log_save_dir, 0)
logger.info("Using {} GPUs.".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
logger.info("Running with config:\n{}".format(cfg))
logger.info('start training')
cudnn.benchmark = True
writer = SummaryWriter(os.path.join(log_save_dir, 'tf'))
reid_system = ReidSystem(cfg, logger, writer)
reid_system.train()
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument("--config_file",
default="",
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()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
output_dir = cfg.OUTPUT_DIR
if output_dir and not os.path.exists(output_dir):
mkdir(output_dir)
logger = setup_logger("reid_baseline", output_dir, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
with open(args.config_file, 'r') as cf:
config_str = "\n" + cf.read()
logger.info(config_str)
logger.info("Running with config:\n{}".format(cfg))
cudnn.benchmark = True
train_loader, val_loader, num_query, num_classes = make_data_loader(cfg)
model = build_model(cfg, num_classes)
model.load_state_dict(torch.load(cfg.TEST.WEIGHT))
model = model.cuda()
model = model.eval()
logger = logging.getLogger("reid_baseline.inference")
logger.info("Start inferencing")
with torch.no_grad():
qf, gf = extract_feature(model, val_loader, num_query)
# save feature
np.save('../data/feature_expansion/' + cfg.TEST.QF_NAME, qf.cpu().numpy())
np.save('../data/feature_expansion/' + cfg.TEST.GF_NAME, gf.cpu().numpy())
'''
def main():
parser = argparse.ArgumentParser(description="ReID Baseline Inference")
parser.add_argument('-cfg',
"--config_file",
default="",
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()
gpus = os.environ[
"CUDA_VISIBLE_DEVICES"] if "CUDA_VISIBLE_DEVICES" in os.environ else '0'
gpus = [int(i) for i in gpus.split(',')]
num_gpus = len(gpus)
if args.config_file != "":
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
# set pretrian = False to avoid loading weight repeatedly
cfg.MODEL.PRETRAIN = False
cfg.freeze()
logger = setup_logger("reid_baseline", False, 0)
logger.info("Using {} GPUS".format(num_gpus))
logger.info(args)
if args.config_file != "":
logger.info("Loaded configuration file {}".format(args.config_file))
logger.info("Running with config:\n{}".format(cfg))
cudnn.benchmark = True
model = build_model(cfg, 0)
model.load_params_wo_fc(torch.load(cfg.TEST.WEIGHT))
if num_gpus > 1:
model = nn.DataParallel(model)
model = model.cuda()
print('prepare test set ...')
test_dataloader_collection, num_query_collection, test_items_collection = get_test_dataloader(
cfg)
inference(cfg,
model,
test_dataloader_collection,
num_query_collection,
is_vis=True,
test_collection=test_items_collection)
