def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) cas_dir = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/000_thumos_29.13_save_model_Frame_wise_accuracy/save_for_post_process" epoch = 901 datas = list() file_name_list = os.listdir(cas_dir) for file_name in file_name_list: data = np.load(os.path.join(cas_dir, file_name)) datas.append(data) output_json_file_cas, test_acc_cas = evaluate_from_offline_cas( cfg, datas, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) mAP, average_mAP = evaluate_mAP( cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) base_branch_json = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight_save_model_debug/075_cas.json' cam_branch_json = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight_save_model_debug/089_cam.json' evaluate_mAP(cfg, base_branch_json, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE) evaluate_mAP(cfg, cam_branch_json, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE) base_branch_data = json.load(open(base_branch_json, 'r')) base_branch_results = base_branch_data['results'] cam_branch_data = json.load(open(cam_branch_json, 'r')) cam_branch_results = cam_branch_data['results'] for vid_name in cam_branch_results.keys(): cam_branch_results[vid_name].extend(base_branch_results[vid_name]) output_dict = {'version': 'VERSION 1.3', 'results': cam_branch_results, 'external_data': {}} result_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight_save_model_debug/cat.json' outfile = open(result_file, 'w') json.dump(output_dict, outfile) outfile.close() evaluate_mAP(cfg, result_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) cfg.BASIC.ROOT_DIR = os.path.join(os.path.dirname(__file__), '..') # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) model.cuda() if not os.path.exists(args.res_dir): os.makedirs(args.res_dir) model = load_weights(model, args.weight_file) evaluate_vis_cas(cfg, val_loader, model, args.res_dir, args.is_minmax_norm)
def main(): args = parse_args() update_config(cfg, args) extra = cfg.MODEL.EXTRA print(cfg.MODEL.NAME) print(extra.FINAL_CONV_KERNEL) print(cfg.MODEL.EXTRA.STAGE2.NUM_CHANNELS)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = "" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/thumos14_checkpoint_best_cas_epoch125_iou0.5__0.2928.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet12_checkpoint_best_cas_epoch30_map_0.2394.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet13_checkpoint_best_cas_epoch35_map_0.2348.pth" weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/000_thumos_29.13_save_model_Frame_wise_accuracy/checkpoint_best_cas.pth" epoch = 801 from utils.utils import load_weights model = load_weights(model, weight_file) evaluate_save_for_post_process(cfg, val_loader, model, epoch)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) gt_json_file = '/disk3/zt/code/1_actloc/1_simple_cas/lib/dataset/materials_THUMOS14/gt_thumos14_augment.json' with open(gt_json_file, 'r') as f: gt_datas = json.load(f) gt_data = gt_datas['database'] cas_dir = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/000_thumos_29.13_save_model_Frame_wise_accuracy/save_for_post_process" datas = list() file_name_list = os.listdir(cas_dir) for file_name in file_name_list: data = np.load(os.path.join(cas_dir, file_name)) datas.append(data) gts_list = [] max_idx_list = [] for data in datas: cas_base = data["cas_base"] vid_name = str(data["vid_name"]) # score_np=data["score_np"] # cls_label_np=data["cls_label_np"] # frame_num=data["frame_num"] # fps_or_vid_duration=data["fps_or_vid_duration"] # print() temporal_len = cfg.DATASET.NUM_SEGMENTS gts = [] try: gt_data[vid_name] # two special case except: continue for order, ann in enumerate(gt_data[vid_name]['annotations']): segment = ann['segment'] label_idx = ann['idx'] + 1 # make bg 0 gt = segment2idx(temporal_len, float(segment[0]), float(segment[1]), gt_data[vid_name]['duration'], label_idx) gts.append(gt) gts = np.array(gts) gts = np.sum(gts, axis=0) #750 idx+1 max_idx = np.argmax(cas_base, axis=0) max_idx += 1 max_score = np.max(cas_base, axis=0) max_idx[max_score <= 0.7] = 0 gts_list.append(gts) max_idx_list.append(max_idx) # print() print(round(accuracy_wo_bg(gts_list, max_idx_list, bg_class=0), 3))
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/thumos14_checkpoint_best_cas_epoch125_iou0.5__0.2928.pth' # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet12_checkpoint_best_cas_epoch30_map_0.2545.pth' # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet13_checkpoint_best_cas_epoch35_map_0.2348.pth' # weight_file = '' weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_inv_0_save_model/checkpoint_best_cas_inv0_epoch69_0.2636.pth' # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_save_model/checkpoint_best_cas_only_cas_epoch134_0.1957.pth' # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_individual_attention_2048k1_2048k1_2048k1_only_cam_svae_model/checkpoint_best_cas_only_cam_epoch96_0.1714.pth' res_dir = os.path.join(cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, 'vis/cas_gt_idx_minmax_norm_std') if not os.path.exists(res_dir): os.makedirs(res_dir) from utils.utils import load_weights model = load_weights(model, weight_file) epoch = 600 output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate( cfg, val_loader, model, epoch) evaluate_mAP(cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE) evaluate_mAP(cfg, output_json_file_cam, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE) is_minmax_norm = True evaluate_vis_cas_minmax_norm_std(cfg, val_loader, model, res_dir, is_minmax_norm)
def main(): args = args_parser() update_config(args.cfg) # path configuration cfg.BASIC.LOG_DIR = os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.TIME + cfg.BASIC.SUFFIX, 'log') cfg.BASIC.BACKUP_DIR = os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.TIME + cfg.BASIC.SUFFIX, 'codes_backup') cfg.TRAIN.OUTPUT_DIR = os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.TIME + cfg.BASIC.SUFFIX, 'output') cfg.TEST.RESULT_DIR = os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.TIME + cfg.BASIC.SUFFIX, 'results') cfg.BASIC.CKPT_DIR = os.path.join(os.path.dirname(__file__), '..') if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # log writer = SummaryWriter( log_dir=os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.LOG_DIR)) best_mAP = -1 info = list() # Notice: we will not evaluate the last data for epoch in range(1, cfg.TRAIN.EPOCH_NUM): # check whether t+1 CAS exists actions_json_file_next = os.path.join( cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, str(epoch + 1).zfill(3) + '_' + args.name + '.json') while not os.path.exists(actions_json_file_next): time.sleep(1) # dispose the json files at time step t actions_json_file_cas = os.path.join( cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, str(epoch).zfill(3) + '_' + args.name + '.json') writer, best_mAP, info = post_process(cfg, actions_json_file_cas, writer, best_mAP, info, epoch, args.name) # if best_mAP >0.2 and best_mAP == info[2][4]: # save_best_record_txt(cfg, info, os.path.join(cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, "best_record_{}_{}.txt".format(args.name, str(epoch).zfill(3)))) save_best_record_txt( cfg, info, os.path.join(cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, "best_record_{}.txt".format(args.name))) writer.close()
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model_cas = LocNet(cfg) # model.apply(weight_init) model_cam = LocNet(cfg) model_cas.cuda() model_cam.cuda() # weight_file = "" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/thumos14_checkpoint_best_cas_epoch125_iou0.5__0.2928.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet12_checkpoint_best_cas_epoch30_map_0.2394.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet13/anet13_same_as_anet12_seed1_epoch45_TOPK_K_R_0.6_LR_DECAY26_save_every_model/checkpoint_best_cas_epoch35.pth" weight_file_cas = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight_save_model/checkpoint_best_cas_epoch75_0.2055.pth" weight_file_cam = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight_save_model/checkpoint_best_cam_epoch89_0.176.pth" from utils.utils import load_weights model_cas = load_weights(model_cas, weight_file_cas) model_cam = load_weights(model_cam, weight_file_cam) epoch = 911 output_json_file_cas, test_acc_cas = evaluate_fuse_sequence( cfg, val_loader, model_cas, model_cam, epoch) # output_json_file_cas, test_acc_cas = evaluate(cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) mAP, average_mAP = evaluate_mAP( cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = "" weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/thumos14_checkpoint_best_cas_epoch125_iou0.5__0.2928.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet12_checkpoint_best_cas_epoch30_map_0.2394.pth" # weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet13_checkpoint_best_cas_epoch35_map_0.2348.pth" epoch = 801 from utils.utils import load_weights model = load_weights(model, weight_file) # actions_json_file = evaluate(cfg, val_loader, model, epoch) # # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE)) # output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate(cfg, val_loader, model, epoch) output_json_file_cas, test_acc_cas = evaluate(cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) mAP, average_mAP = evaluate_mAP( cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # # prepare running environment for the whole project # prepare_env(cfg) # # # # dataloader # val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) # val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, # num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # # # network # model = LocNet(cfg) # # model.apply(weight_init) # # model.cuda() # # # weight_file = '/disk3/zt/code/actloc/thumos/17_CAS_CAM_fast_tuning/output/20class_seed_0_save_model/checkpoint_best_cas.pth' # epoch = 800 # from utils.utils import load_weights # model = load_weights(model, weight_file) # # # actions_json_file = evaluate(cfg, val_loader, model, epoch) # # # # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE)) # # output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate(cfg, val_loader, model, epoch) # if cfg.BASIC.VERBOSE: # print('test_acc, cas %f, cam %f' % (test_acc_cas, test_acc_cam)) # output_json_file_cas = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet12/anet12_0.2350_cam_inv_1_seed7_epoch36_TOPK_K_R_0.25__save_model_LR_decay/030_cas.json" # output_json_file_cas = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet13/anet13_0.2348_ok/035_cas.json" output_json_file_cas = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas/134_cas.json" output_json_file_cas = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/thumos14/thumos_ablation_only_cas_only_cam_separate_weight/089_cam.json" mAP, average_mAP = evaluate_mAP( cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet12/anet12_0.2350_cam_inv_1_seed7_epoch36_TOPK_K_R_0.25__save_model_LR_decay/anet12_checkpoint_best_cas_0.2394.pth' weight_file = "/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet13/anet13_same_as_anet12_seed1_epoch45_TOPK_K_R_0.6_LR_DECAY26_save_every_model/anet13_checkpoint_best_cas_epoch28_0.2178.pth" epoch = 603 from utils.utils import load_weights model = load_weights(model, weight_file) # actions_json_file = evaluate(cfg, val_loader, model, epoch) # # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE)) # output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate(cfg, val_loader, model, epoch) output_json_file_cas, test_acc_cas = evaluate(cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) mAP, average_mAP = evaluate_mAP( cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/thumos14_checkpoint_best_cas_epoch125_iou0.5__0.2928.pth' # weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet12_checkpoint_best_cas_epoch30_map_0.2545.pth' weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/0_NeurIPS2020_code_ok/results_and_model/anet13_checkpoint_best_cas_epoch35_map_0.2348.pth' res_dir = os.path.join(cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR,'vis/cas_weight_gt_idx_iou_0.85_mul_instance') if not os.path.exists(res_dir): os.makedirs(res_dir) from utils.utils import load_weights model = load_weights(model, weight_file) # epoch = 600 # actions_json_file, _ = evaluate(cfg, val_loader, model, epoch) # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE) is_minmax_norm = True evaluate_vis_cas_select_specific(cfg, val_loader, model, res_dir, is_minmax_norm)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = '' weight_file = '/disk/yangle/Short-Actions/ECM/output/thumos14/ECM_baseline/checkpoint_best_150.pth' res_dir = os.path.join(cfg.BASIC.CKPT_DIR, cfg.TEST.RESULT_DIR, 'vis/ECM_thumos_score') if not os.path.exists(res_dir): os.makedirs(res_dir) from utils.utils import load_weights model = load_weights(model, weight_file) epoch = 600 # output_json_file_cas, test_acc_cas = evaluate(cfg, val_loader, model, epoch) output_json_file_cas = '/disk/yangle/Short-Actions/ECM/output/thumos14/ECM_baseline/vis/ecm.json' evaluate_mAP(cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() weight_file = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet12/anet12_no_inv_base_LR_0.0002_BATCH_128_save_model/checkpoint_best_cas_0.2243.pth' epoch = 600 res_dir = '/disk3/zt/code/4_a/1_ECM_no_inv_drop/output/anet12/anet12_no_inv_base_LR_0.0002_BATCH_128_save_model/vis/cas_minmax_norm' if not os.path.exists(res_dir): os.makedirs(res_dir) from utils.utils import load_weights model = load_weights(model, weight_file) is_minmax_norm = True # actions_json_file = evaluate(cfg, val_loader, model, epoch) # # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE)) # output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate(cfg, val_loader, model, epoch) evaluate_vis_cas(cfg, val_loader, model, epoch, res_dir, is_minmax_norm)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project # prepare_env(cfg) # dataloader val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = "" weight_file = "/disk/yangle/Short-Actions/ECM/output/thumos14/ECM_baseline/checkpoint_best_150.pth" epoch = 601 from utils.utils import load_weights model = load_weights(model, weight_file) # actions_json_file = evaluate(cfg, val_loader, model, epoch) # # evaluate_mAP(cfg, actions_json_file, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE)) # output_json_file_cas, output_json_file_cam, test_acc_cas, test_acc_cam = evaluate(cfg, val_loader, model, epoch) output_json_file_cas, test_acc_cas = evaluate(cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) mAP, average_mAP = evaluate_mAP(cfg, output_json_file_cas, os.path.join(cfg.BASIC.CKPT_DIR, cfg.DATASET.GT_FILE), cfg.BASIC.VERBOSE)
weight = torch.matmul(feature_uns, embedding) # [1, N, 1] weight = torch.squeeze(weight, dim=0) # [N, 1] # weight_norm = self.softmax(weight) feature_wei = feature * weight # [N, D] feature_agg = torch.sum(feature_wei, dim=0, keepdim=True) # [1, D] feature_cls = self.lrelu(self.fc_cls1(feature_agg)) # dropout feature_per = self.dropout(feature_cls) score = self.fc_cls2(feature_per) # [1, 1] score = torch.squeeze(score, dim=0) score = self.sigmoid(score) # we calculate BCEloss, thus use Sigmoid activation return score if __name__ == '__main__': import sys sys.path.insert(0, '../../lib') from config.default import config as cfg from config.default import update_config cfg_file = '../../experiments/IENet.yaml' update_config(cfg_file) data = torch.randn((10, 97)).cuda() network = IENet(cfg).cuda() score = network(data) print(score.size(), score)
tabs.append('*') table.append(tabs) from tabulate import tabulate # tab_name = join(output_dir, 'table_fancy.txt') print(tabulate(table, headers, tablefmt='fancy_grid')) if savename is not None: print(tabulate(table, headers, tablefmt='plain'), file=open(savename, 'w')) if __name__ == "__main__": from config.cmdline import parse_args from config.default import update_config, cfg args = parse_args() update_config(cfg, args) if args.usecpp: pass else: import torch if torch.cuda.is_available(): device = torch.device('cuda') else: device = torch.device('cpu') from smplmodel.smplx_utils import SMPLX from smplmodel.geometry import batch_rodrigues smpl_render = SMPLX(model_type=cfg.MODEL.model_type, gender=cfg.MODEL.gender, batch_size=cfg.MODEL.batch_size, device=device, model_folder=cfg.MODEL.model_folder)
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # log writer = SummaryWriter( log_dir=os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.LOG_DIR)) # dataloader train_dset = WtalDataset(cfg, cfg.DATASET.TRAIN_SPLIT) train_loader = DataLoader(train_dset, batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) model.cuda() # optimizer optimizer = optim.Adam(model.parameters(), lr=cfg.TRAIN.LR, betas=cfg.TRAIN.BETAS, weight_decay=cfg.TRAIN.WEIGHT_DECAY) # criterion criterion = BasNetLoss() for epoch in range(1, cfg.TRAIN.EPOCH_NUM + 1): print('Epoch: %d:' % epoch) loss_average_cas, loss_average_cam, loss_average_consistency, loss_average_norm, loss_average_cam_inv = train( cfg, train_loader, model, optimizer, criterion) writer.add_scalar('train_loss/cas', loss_average_cas, epoch) writer.add_scalar('train_loss/cam', loss_average_cam, epoch) writer.add_scalar('train_loss/consistency', loss_average_consistency, epoch) writer.add_scalar('train_loss/norm', loss_average_norm, epoch) writer.add_scalar('train_loss/cam_inv', loss_average_cam_inv, epoch) if cfg.BASIC.VERBOSE: print( 'loss: cas %f, cam %f, consistency %f, norm %f, cam_inv %f' % (loss_average_cas, loss_average_cam, loss_average_consistency, loss_average_norm, loss_average_cam_inv)) # decay learning rate if epoch in cfg.TRAIN.LR_DECAY_EPOCHS: decay_lr(optimizer, factor=cfg.TRAIN.LR_DECAY_FACTOR) if epoch % cfg.TEST.EVAL_INTERVAL == 0: _, test_acc_cas = evaluate(cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f' % (test_acc_cas)) writer.add_scalar('test_acc/cas', test_acc_cas, epoch) save_best_model(cfg, epoch=epoch, model=model, optimizer=optimizer, name='cas') writer.close()
opt.heads['depth'] = opt.num_output if opt.load_model == '': opt.load_model = '../models/fusion_3d_var.pth' if opt.gpus[0] >= 0: opt.device = torch.device('cuda:{}'.format(opt.gpus[0])) else: opt.device = torch.device('cpu') model, _, _ = create_model(cfg, opt) model = model.to(opt.device) model.eval() if os.path.isdir(opt.demo): ls = os.listdir(opt.demo) for file_name in sorted(ls): if is_image(file_name): image_name = os.path.join(opt.demo, file_name) print('Running {} ...'.format(image_name)) image = cv2.imread(image_name) demo_image(image, image_name, model, opt) elif is_image(opt.demo): print('Running {} ...'.format(opt.demo)) image = cv2.imread(opt.demo) demo_image(image, image_name, model, opt) if __name__ == '__main__': opt = opts().parse() update_config(cfg, opt) main(opt)
def main(opt): update_config(cfg, opt) if opt.disable_cudnn: torch.backends.cudnn.enabled = False print('Cudnn is disabled.') logger = Logger(opt) opt.device = torch.device('cuda:{}'.format(opt.gpus[0])) Dataset = dataset_factory[opt.dataset] train, val = task_factory[opt.task] model, optimizer, start_epoch = create_model(cfg, opt) if len(opt.gpus) > 1: model = torch.nn.DataParallel(model, device_ids=opt.gpus).cuda(opt.device) else: model = model.cuda(opt.device) val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, pin_memory=True) if opt.test: log_dict_train, preds = val(0, opt, val_loader, model) sio.savemat(os.path.join(opt.save_dir, 'preds.mat'), mdict={'preds': preds}) return train_loader = torch.utils.data.DataLoader( Dataset(opt, 'train'), batch_size=opt.batch_size * len(opt.gpus), shuffle=True, # if opt.debug == 0 else False, num_workers=opt.num_workers, pin_memory=True) best = -1 for epoch in range(start_epoch, opt.num_epochs + 1): mark = epoch if opt.save_all_models else 'last' log_dict_train, _ = train(epoch, opt, train_loader, model, optimizer) 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) log_dict_val, preds = val(epoch, opt, val_loader, model) 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: best = log_dict_val[opt.metric] save_model(os.path.join(opt.save_dir, 'model_best.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: 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 logger.close()
def main(): args = args_parser() update_config(args.cfg) if cfg.BASIC.SHOW_CFG: pprint.pprint(cfg) # prepare running environment for the whole project prepare_env(cfg) # log writer = SummaryWriter( log_dir=os.path.join(cfg.BASIC.CKPT_DIR, cfg.BASIC.LOG_DIR)) # dataloader train_dset = WtalDataset(cfg, cfg.DATASET.TRAIN_SPLIT) train_loader = DataLoader(train_dset, batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) val_dset = WtalDataset(cfg, cfg.DATASET.VAL_SPLIT) val_loader = DataLoader(val_dset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.BASIC.WORKERS, pin_memory=cfg.BASIC.PIN_MEMORY) # network model = LocNet(cfg) # model.apply(weight_init) model.cuda() # weight_file = "/disk3/zt/code/actloc/thumos/17_CAS_CAM_fast_tuning/output/20class_seed_0_save_model/checkpoint_best_cas_0.2701.pth" weight_file = '/disk3/zt/code/actloc/thumos/20_0.2701_try/output/debug_save_epoch30/checkpoint_best_cas.pth' from utils.utils import load_weights model = load_weights(model, weight_file) # optimizer optimizer = optim.Adam(model.parameters(), lr=cfg.TRAIN.LR, betas=cfg.TRAIN.BETAS, weight_decay=cfg.TRAIN.WEIGHT_DECAY) optimizer.load_state_dict(torch.load(weight_file)['optimizer']) # criterion criterion = BasNetLoss() for epoch in range(1, cfg.TRAIN.EPOCH_NUM + 1): print('Epoch: %d:' % epoch) loss_average_cas, loss_average_cam, loss_average_consistency, loss_average_norm, loss_average_cas_inv, loss_average_cam_inv = train( cfg, train_loader, model, optimizer, criterion) writer.add_scalar('train_loss/cas', loss_average_cas, epoch) writer.add_scalar('train_loss/cam', loss_average_cam, epoch) writer.add_scalar('train_loss/consistency', loss_average_consistency, epoch) writer.add_scalar('train_loss/norm', loss_average_norm, epoch) writer.add_scalar('train_loss/cas_inv', loss_average_cas_inv, epoch) writer.add_scalar('train_loss/cam_inv', loss_average_cam_inv, epoch) if cfg.BASIC.VERBOSE: print( 'loss: cas %f, cam %f, consistency %f, norm %f, cas_inv %f, cam_inv %f' % (loss_average_cas, loss_average_cam, loss_average_consistency, loss_average_norm, loss_average_cas_inv, loss_average_cam_inv)) # decay learning rate if epoch in cfg.TRAIN.LR_DECAY_EPOCHS: decay_lr(optimizer, factor=cfg.TRAIN.LR_DECAY_FACTOR) if epoch % cfg.TEST.EVAL_INTERVAL == 0: _, _, test_acc_cas, test_acc_cam = evaluate( cfg, val_loader, model, epoch) if cfg.BASIC.VERBOSE: print('test_acc, cas %f, cam %f' % (test_acc_cas, test_acc_cam)) writer.add_scalar('test_acc/cas', test_acc_cas, epoch) writer.add_scalar('test_acc/cam', test_acc_cam, epoch) writer.close()