def main(opt): torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test Dataset = get_dataset(opt.dataset, opt.task) opt = opts().update_dataset_info_and_set_heads(opt, Dataset) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu') print('Creating model...') model = create_model('res_101', opt.heads, opt.head_conv) # print(model) optimizer = torch.optim.Adam(model.parameters(), opt.lr) model, optimizer, start_epoch = load_model(model, train_model, optimizer=optimizer, resume=opt.resume, lr=opt.lr, lr_step=opt.lr_step) from utils.prune_util import obtain_filters_mask_l1_dict, gather_l1_weights_dict, obtain_filters_mask_l1_dict_percent # l1_weights = gather_l1_weights_dict(model) # sorted_l1, sorted_l1_index = torch.sort(l1_weights) # thresh_index_l1 = int(len(l1_weights)*global_percent) # thresh_l1 = sorted_l1[thresh_index_l1].cuda() # print("global percent l1_weights is", thresh_l1) # print("len l1 is", len(l1_weights)) # num_filters, filters_mask, prune_idx, prune_bn_bias_idx= obtain_filters_mask_l1_dict(model, thresh_l1, keep_layer) # print(model) num_filters, filters_mask, prune_idx, prune_bn_bias_idx = obtain_filters_mask_l1_dict_percent( model, percent) print("num_filters is", num_filters) print("prune idx is", prune_idx) # print("filters_mask is", filters_mask) print("prune bn and bias idx is", prune_bn_bias_idx) prune_weight_dict = {} idx_name = {} idx_bias_name = {} id_mask = 0 from utils.prune_util import del_current_weights ############################# del channels and save weights and save bias and save bn params ###################### for idx, name in enumerate(model.state_dict()): prune_weight_dict[name] = model.state_dict()[name] if idx in prune_idx: idx_name[idx] = name del_weigh_mask = filters_mask[id_mask] id_mask += 1 del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() weights_numpy = model.state_dict()[name].cpu().numpy() channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) new_weights = np.delete(weights_numpy, current_zero_id, axis=0) prune_weight_dict[idx_name[idx]] = torch.from_numpy(new_weights) # print("finished del channels name is", name) # print("orignal shape is ", model.state_dict()[name].shape) # print("last shape is ", prune_weight_dict[name].shape) elif idx in prune_bn_bias_idx: idx_bias_name[idx] = name print("prune idx is ", prune_idx) ################################ del input weights and del bias anddel bn params ################################# id_mask = 0 prune_id = 0 deconv_zero_id = [] for i, (layer_name, value) in enumerate(prune_weight_dict.items()): if i in prune_idx: current_idx = i try: next_idx = prune_idx[prune_idx.index(current_idx) + 1] except: print("current idx is", current_idx) print("len prune idx is", len(prune_idx)) continue if "downsample" in idx_name[next_idx]: id_mask -= 3 del_weigh_mask = filters_mask[id_mask] del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) # print("next layer name is", idx_name[next_idx]) # print("ori layer name shape is ", prune_weight_dict[idx_name[next_idx]].shape) prune_weight_dict[idx_name[next_idx]] = torch.from_numpy( np.delete(prune_weight_dict[idx_name[next_idx]].numpy(), current_zero_id, axis=1)) # print("last layer name shape is ", prune_weight_dict[idx_name[next_idx]].shape) if "downsample" in idx_name[next_idx]: id_mask += 3 id_mask += 1 if "downsample" in idx_name[next_idx]: print(" idx_name[next_idx] is", idx_name[next_idx]) print("current_zero_id is", current_zero_id) # break prune_id += 1 elif i in prune_bn_bias_idx: current_bias_idx = i if id_mask == 0: continue current_bias_mask_idx = id_mask - 1 del_weigh_mask = filters_mask[current_bias_mask_idx] ############# because del channels last layer don not use id_mask+1, so in herem last layer must use current_bias_mask_idx= current_bias_mask_idx+1 if "layer4.2.bn3" in idx_bias_name[current_bias_idx]: # print('idx_bias_name[current_bias_idx] is', idx_bias_name[current_bias_idx]) del_weigh_mask = filters_mask[current_bias_mask_idx + 1] print("ori del mask is", del_weigh_mask) del_weigh_mask = filters_mask[-1] print("last del mask is", del_weigh_mask) del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() # print("current name is ", layer_name) # print("current prune_idx_bias name is ", idx_bias_name[current_bias_idx]) # print("orignal bias layer shape is", prune_weight_dict[idx_bias_name[current_bias_idx]].shape) channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) prune_weight_dict[ idx_bias_name[current_bias_idx]] = torch.from_numpy( np.delete(prune_weight_dict[ idx_bias_name[current_bias_idx]].numpy(), current_zero_id, axis=0)) if 'layer4.2.bn3.running_var' == idx_bias_name[current_bias_idx]: print("before deconv_layers.0.weight shape is", prune_weight_dict["deconv_layers.0.weight"].shape) print("current zero id is", current_zero_id) prune_weight_dict["deconv_layers.0.weight"] = torch.from_numpy( np.delete( prune_weight_dict["deconv_layers.0.weight"].numpy(), current_zero_id, axis=0)) print("last deconv_layers.0.weight shape is", prune_weight_dict["deconv_layers.0.weight"].shape) print("finished del deconv input") torch.save(prune_weight_dict, 'exp/ctdet/default/l1_prune_model.pt') prune_model = create_model_101_prune('resPrune_101', opt.heads, opt.head_conv, percent=percent) prune_model.load_state_dict( torch.load('exp/ctdet/default/l1_prune_model.pt'), strict=False)
from utils.debugger import Debugger import cv2 import os # num_classes = 3 num_classes = 5 pause = True # vis_thresh = 0.01 vis_thresh = 0.3 import os os.environ['CUDA_VISIBLE_DEVICES'] = '7' # MODEL_PATH ='/home/pcl/pytorch_work/my_github/centernet_simple/weights/model_best_dla34.pth' MODEL_PATH ='/home/pcl/pytorch_work/my_github/centernet_simple/exp/ctdet/coco_res_prune/model_best_map_0.48.pth' TASK = 'ctdet' # or 'multi_pose' for human pose estimation # opt = opts().init('{} --load_model {} --flip_test'.format(TASK, MODEL_PATH).split(' ')) opt = opts().init('{} --load_model {}'.format(TASK, MODEL_PATH).split(' ')) print(opt) detector = detector_factory[opt.task](opt) img_dir = '/home/pcl/pytorch_work/CenterNet-master/dianli_images/' def show_results(debugger, image, results): debugger.add_img(image, img_id='ctdet') for j in range(1, num_classes + 1): for bbox in results[j]: if bbox[4] > vis_thresh: debugger.add_coco_bbox(bbox[:4], j - 1, bbox[4], img_id='ctdet') debugger.show_all_imgs(pause=pause) def inference(img_dir): results_imgs = [] for img in os.listdir(img_dir):
# def prune_and_eval(model, CBL_idx, CBLidx2mask): # import copy # model_copy = copy.deepcopy(model) # for idx, name in enumerate(model_copy.state_dict()): # if idx in prune_idx: # bn_module = model_copy.state_dict()[name] # mask = CBLidx2mask[idx].cuda() # for i in range(mask.shape[0]): # if mask[i].cpu().numpy() == 0: # bn_module[i,:,:,:].zero_() # val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, # pin_memory=True) # trainer = CtTrainer(opt, model_copy, optimizer) # trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) # with torch.no_grad(): # log_dict_val, preds = trainer.val(0, val_loader) # val_loader.dataset.run_eval(preds, opt.save_dir) # # print(f'mask the gamma as zero, mAP of the model is {mAP:.4f}') # # prune_and_eval(model, CBL_idx, CBLidx2mask) # # for i in CBLidx2mask: # CBLidx2mask[i] = CBLidx2mask[i].clone().cpu().numpy() # pruned_model = prune_model_keep_size2(model, prune_idx, CBL_idx, CBLidx2mask) if __name__ == '__main__': opt = opts().parse() main(opt)
return: pred_content: 2d list. ''' image_id = id_list[number] inference_img_name = name_list[number] pred_content = [] results = inference_img(inference_img_name) for j in range(1, cfg.class_num + 1): for bbox in results[j]: if bbox[4] > cfg.score_th: x_min, y_min, x_max, y_max = bbox[0], bbox[1], bbox[2], bbox[3] score = bbox[4] label = j - 1 pred_content.append( [image_id, x_min, y_min, x_max, y_max, score, label]) print("obj is", pred_content) # debugger.add_coco_bbox(bbox[:4], j - 1, bbox[4], img_id='ctdet') return pred_content if __name__ == "__main__": MODEL_PATH = '/home/pcl/tf_work/map/weights/model_best_dla34.pth' import os opt = opts().init('{} --load_model {}'.format("ctdet", MODEL_PATH).split(' ')) os.environ['CUDA_VISIBLE_DEVICES'] = '7' TASK = 'ctdet' # or 'multi_pose' for human pose estimation detector_test = detector_factory[TASK](opt) img_dir = '/home/pcl/pytorch_work/CenterNet-master/dianli_images/' inference(img_dir=img_dir, model=detector_test)
def main(opt): mkdir_pth_dir(opt.save_dir) torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test Dataset = get_dataset(opt.dataset, opt.task) opt = opts().update_dataset_info_and_set_heads(opt, Dataset) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu') print('Creating model...') model = create_model('resPrune_101', opt.heads, opt.head_conv, percent_rate=percent_rate, prune_cnt=ori_prune_cnt) # model = create_model('res_101', opt.heads, opt.head_conv) optimizer = torch.optim.Adam(model.parameters(), opt.lr) model, optimizer, start_epoch = load_model(model, train_model, optimizer=optimizer, resume=opt.resume, lr=opt.lr, lr_step=opt.lr_step) from utils.prune_util import obtain_filters_mask_l1_dict, gather_l1_weights_dict, obtain_filters_mask_l1_dict_percent num_filters, filters_mask, prune_idx, prune_bn_bias_idx = obtain_filters_mask_l1_dict_percent( model, percent_rate) print("num_filters is", num_filters) print("prune idx is", prune_idx) # print("filters_mask is", filters_mask) print("prune bn and bias idx is", prune_bn_bias_idx) prune_weight_dict = {} idx_name = {} idx_bias_name = {} id_mask = 0 from utils.prune_util import del_current_weights ############################# del channels and save weights and save bias and save bn params ###################### for idx, name in enumerate(model.state_dict()): prune_weight_dict[name] = model.state_dict()[name] if idx in prune_idx: idx_name[idx] = name del_weigh_mask = filters_mask[id_mask] id_mask += 1 del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() weights_numpy = model.state_dict()[name].cpu().numpy() channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) new_weights = np.delete(weights_numpy, current_zero_id, axis=0) prune_weight_dict[idx_name[idx]] = torch.from_numpy(new_weights) # print("finished del channels name is", name) # print("orignal shape is ", model.state_dict()[name].shape) # print("last shape is ", prune_weight_dict[name].shape) elif idx in prune_bn_bias_idx: idx_bias_name[idx] = name print("prune idx is ", prune_idx) ################################ del input weights and del bias anddel bn params ################################# id_mask = 0 prune_id = 0 deconv_zero_id = [] for i, (layer_name, value) in enumerate(prune_weight_dict.items()): if i in prune_idx: current_idx = i try: next_idx = prune_idx[prune_idx.index(current_idx) + 1] except: print("current idx is", current_idx) print("len prune idx is", len(prune_idx)) continue if "downsample" in idx_name[next_idx]: id_mask -= 3 del_weigh_mask = filters_mask[id_mask] del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) # print("next layer name is", idx_name[next_idx]) # print("ori layer name shape is ", prune_weight_dict[idx_name[next_idx]].shape) prune_weight_dict[idx_name[next_idx]] = torch.from_numpy( np.delete(prune_weight_dict[idx_name[next_idx]].numpy(), current_zero_id, axis=1)) # print("last layer name shape is ", prune_weight_dict[idx_name[next_idx]].shape) if "downsample" in idx_name[next_idx]: id_mask += 3 id_mask += 1 if "downsample" in idx_name[next_idx]: print(" idx_name[next_idx] is", idx_name[next_idx]) print("current_zero_id is", current_zero_id) # break prune_id += 1 elif i in prune_bn_bias_idx: current_bias_idx = i if id_mask == 0: continue current_bias_mask_idx = id_mask - 1 del_weigh_mask = filters_mask[current_bias_mask_idx] ############# because del channels last layer don not use id_mask+1, so in herem last layer must use current_bias_mask_idx= current_bias_mask_idx+1 if "layer4.2.bn3" in idx_bias_name[current_bias_idx]: # print('idx_bias_name[current_bias_idx] is', idx_bias_name[current_bias_idx]) del_weigh_mask = filters_mask[current_bias_mask_idx + 1] print("ori del mask is", del_weigh_mask) del_weigh_mask = filters_mask[-1] print("last del mask is", del_weigh_mask) del_weigh_mask_numpy = del_weigh_mask.cpu().numpy() # print("current name is ", layer_name) # print("current prune_idx_bias name is ", idx_bias_name[current_bias_idx]) # print("orignal bias layer shape is", prune_weight_dict[idx_bias_name[current_bias_idx]].shape) channel_indices = set(np.arange(len(del_weigh_mask_numpy))) non_zero_id = set(list(np.nonzero(del_weigh_mask_numpy)[0])) current_zero_id = list(channel_indices.difference(non_zero_id)) prune_weight_dict[ idx_bias_name[current_bias_idx]] = torch.from_numpy( np.delete(prune_weight_dict[ idx_bias_name[current_bias_idx]].numpy(), current_zero_id, axis=0)) if 'layer4.2.bn3.running_var' == idx_bias_name[ current_bias_idx]: #in here, must del input in first deconv , mask use layer4.bn3.runing_var mask---no_zero_id print("before deconv_layers.0.weight shape is", prune_weight_dict["deconv_layers.0.weight"].shape) print("current zero id is", current_zero_id) prune_weight_dict["deconv_layers.0.weight"] = torch.from_numpy( np.delete( prune_weight_dict["deconv_layers.0.weight"].numpy(), current_zero_id, axis=0)) print("last deconv_layers.0.weight shape is", prune_weight_dict["deconv_layers.0.weight"].shape) print("finished del deconv input") torch.save(prune_weight_dict, os.path.join(opt.save_dir, prune_model_name)) prune_model = create_model_101_prune('resPrune_101', opt.heads, opt.head_conv, percent_rate=percent_rate, prune_cnt=prune_cnt) optimizer = torch.optim.Adam(prune_model.parameters(), opt.lr) prune_model.load_state_dict(torch.load( os.path.join(opt.save_dir, prune_model_name)), strict=True) start_epoch = 0 train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'), batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True, drop_last=True) val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, pin_memory=True) trainer = CtTrainer(opt, prune_model, optimizer) trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) best_val_loss = 1e10 best_ap = 1e-10 for epoch in range(start_epoch + 1, opt.num_epochs + 1): mark = epoch log_dict_train, _ = trainer.train(epoch, train_loader) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, prune_model, optimizer) with torch.no_grad(): log_dict_val, preds = trainer.val(epoch, val_loader) val_loader.dataset.run_eval(preds, opt.save_dir) # result_json_pth = '/home/pcl/pytorch_work/my_github/centernet_simple/exp/ctdet/coco_res_prune/results.json' result_json_pth = os.path.join(opt.save_dir, "results.json") anno_json_pth = '/home/pcl/pytorch_work/my_github/centernet_simple/data/dianli/annotations/test.json' ap_list, map = trainer.run_epoch_voc(result_json_pth, anno_json_pth, score_th=0.01, class_num=opt.num_classes) print(ap_list, map) if log_dict_val[opt.metric] <= best_val_loss: best_val_loss = log_dict_val[opt.metric] save_model( os.path.join( opt.save_dir, 'model_best_val_loss_' + str(round(best_val_loss, 2)) + '.pth'), epoch, prune_model) if map > best_ap: best_ap = map save_model( os.path.join( opt.save_dir, 'model_best_map_' + str(round(best_ap, 3)) + '.pth'), epoch, prune_model) else: save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch, prune_model, optimizer) if epoch in opt.lr_step: save_model( os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, prune_model, optimizer) lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr
def main(opt): torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test Dataset = get_dataset(opt.dataset, opt.task) opt = opts().update_dataset_info_and_set_heads(opt, Dataset) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu') print('Creating model...') # prune_model = create_model_101_prune('resPrune_101', opt.heads, opt.head_conv, percent=percent) prune_model = create_model_101_prune('resPrune_101', opt.heads, opt.head_conv, percent_rate=percent_rate, prune_cnt=prune_cnt) optimizer = torch.optim.Adam(prune_model.parameters(), opt.lr) prune_model, optimizer, start_epoch = load_model(prune_model, os.path.join( opt.save_dir, prune_model_name), optimizer=optimizer, resume=opt.resume, lr=opt.lr, lr_step=opt.lr_step) # prune_model.load_state_dict(torch.load(os.path.join(opt.save_dir, prune_model_name)), strict=True) # start_epoch = 0 train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'), batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True, drop_last=True) val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, pin_memory=True) trainer = CtTrainer(opt, prune_model, optimizer) trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) best_val_loss = 1e10 best_ap = 1e-10 for epoch in range(start_epoch + 1, opt.num_epochs + 1): mark = epoch log_dict_train, _ = trainer.train(epoch, train_loader) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, prune_model, optimizer) with torch.no_grad(): log_dict_val, preds = trainer.val(epoch, val_loader) val_loader.dataset.run_eval(preds, opt.save_dir) # result_json_pth = '/home/pcl/pytorch_work/my_github/centernet_simple/exp/ctdet/coco_res_prune/results.json' result_json_pth = os.path.join(opt.save_dir, "results.json") anno_json_pth = '/home/pcl/pytorch_work/my_github/centernet_simple/data/dianli/annotations/test.json' ap_list, map = trainer.run_epoch_voc(result_json_pth, anno_json_pth, score_th=0.01, class_num=opt.num_classes) print(ap_list, map) if log_dict_val[opt.metric] <= best_val_loss: best_val_loss = log_dict_val[opt.metric] save_model( os.path.join( opt.save_dir, 'model_best_val_loss_' + str(round(best_val_loss, 2)) + '.pth'), epoch, prune_model) if map > best_ap: best_ap = map save_model( os.path.join( opt.save_dir, 'model_best_map_' + str(round(best_ap, 3)) + '.pth'), epoch, prune_model) else: save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch, prune_model, optimizer) if epoch in opt.lr_step: save_model( os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, prune_model, optimizer) lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr
def main(opt): torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test Dataset = get_dataset(opt.dataset, opt.task) opt = opts().update_dataset_info_and_set_heads(opt, Dataset) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu') logger = Logger(opt) print('Creating model...') model = create_model(opt.arch, opt.heads, opt.head_conv) optimizer = torch.optim.Adam(model.parameters(), opt.lr) start_epoch = 0 if opt.load_model != '': model, optimizer, start_epoch = load_model(model, opt.load_model, optimizer, opt.resume, opt.lr, opt.lr_step) train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'), batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True, drop_last=True) val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, pin_memory=True) trainer = CtTrainer(opt, model, optimizer) trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) TASK = 'ctdet' # or 'multi_pose' for human pose estimation best_val_loss = 1e10 best_ap = 1e-10 for epoch in range(start_epoch + 1, opt.num_epochs + 1): mark = epoch log_dict_train, _ = trainer.train(epoch, train_loader) print("log_dict_train is: ", log_dict_train) # logger.write('epoch: {} |'.format(epoch)) # for k, v in log_dict_train.items(): # logger.scalar_summary('train_{}'.format(k), v, epoch) # logger.write('{} {:8f} | '.format(k, v)) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, model, optimizer) with torch.no_grad(): log_dict_val, preds = trainer.val(epoch, val_loader) val_loader.dataset.run_eval(preds, opt.save_dir) result_json_pth = os.path.join(opt.save_dir, "results.json") anno_json_pth = '/home/pcl/pytorch_work/my_github/centernet_simple/data/dianli/annotations/test.json' ap_list, map = trainer.run_epoch_voc(result_json_pth, anno_json_pth, score_th=0.01, class_num=opt.num_classes) print(ap_list, map) # for k, v in log_dict_val.items(): # logger.scalar_summary('val_{}'.format(k), v, epoch) # logger.write('{} {:8f} | '.format(k, v)) if log_dict_val[opt.metric] <= best_val_loss: best_val_loss = log_dict_val[opt.metric] save_model( os.path.join( opt.save_dir, 'model_best_val_loss_' + str(round(best_val_loss, 2)) + '.pth'), epoch, model) if map > best_ap: best_ap = map save_model( os.path.join( opt.save_dir, 'model_best_map_' + str(round(best_ap, 2)) + '.pth'), epoch, model) else: save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch, model, optimizer) # logger.write('\n') if epoch in opt.lr_step: save_model( os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, model, optimizer) lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr