def main(DEVICE): # load model model = VQVC().to(DEVICE) vocoder = get_vocgan( ckpt_path=args.vocoder_pretrained_model_path).to(DEVICE) load_checkpoint(args.model_checkpoint_path, model) mel_stat = np.load(args.mel_stat_path) dataset_root = args.wav_dir src_paths = [ get_path(dataset_root, "p226_354.wav"), get_path(dataset_root, "p225_335.wav") ] ref_paths = [ get_path(dataset_root, "p225_335.wav"), get_path(dataset_root, "p226_354.wav") ] create_dir(args.converted_sample_dir) convert(model, vocoder, mel_stat, conversion_wav_paths=tuple(zip(src_paths, ref_paths)), DEVICE=DEVICE)
def eval_dataset_cls(cfg_path, device=None): """分类问题的eval dataset: 等效于runner中的load_from + val,但可用来脱离runner进行独立的数据集验证 """ # 准备验证所用的对象 cfg = get_config(cfg_path) dataset = get_dataset(cfg.valset, cfg.transform_val) dataloader = get_dataloader(dataset, cfg.valloader) model = get_model(cfg) if device is None: device = torch.device(cfg.load_device) # TODO: 如下两句的顺序 load_checkpoint(model, cfg.load_from, device) model = model.to(device) # 开始验证 buffer = {'acc': []} n_correct = 0 model.eval() for c_iter, data_batch in enumerate(dataloader): with torch.no_grad(): # 停止反向传播,只进行前向计算 img = to_device(data_batch['img'], device) label = to_device(data_batch['gt_labels'], device) y_pred = model(img) label = torch.cat(label, dim=0) acc1 = accuracy(y_pred, label, topk=1) buffer['acc'].append(acc1) # 计算总体精度 n_correct += buffer['acc'][-1] * len(data_batch['gt_labels']) vis_loss_acc(buffer, title='eval dataset') print('ACC on dataset: %.3f', n_correct / len(dataset))
def __init__(self, cfg_path, load_from=None, load_device=None): self.type = 'det' # 用来判断是什么类型的预测器 # 准备验证所用的对象 self.cfg = get_config(cfg_path) # 为了便于eval,不必常去修改cfg里边的设置,直接在func里边添加2个参数即可 if load_from is not None: self.cfg.load_from = load_from if load_device is not None: self.cfg.load_device = load_device self.model = get_model(self.cfg) self.device = torch.device(self.cfg.load_device) load_checkpoint(self.model, self.cfg.load_from, self.device) self.model = self.model.to(self.device)
def eval_dataset_det(cfg_path, load_from=None, load_device=None, resume_from=None, result_file=None): """检测问题的eval dataset: 为了便于eval,添加2个形参参数,不必常去修改cfg里边的设置 """ # 准备验证所用的对象 cfg = get_config(cfg_path) cfg.valloader.params.batch_size = 1 # 强制固定验证时batch_size=1 # 为了便于eval,不必常去修改cfg里边的设置,直接在func里边添加几个参数即可 if load_from is not None: cfg.load_from = load_from if load_device is not None: cfg.load_device = load_device if resume_from is not None: cfg.resume_from = resume_from dataset = get_dataset(cfg.valset, cfg.transform_val) dataloader = get_dataloader(dataset, cfg.valloader, len(cfg.gpus)) model = get_model(cfg) device = torch.device(cfg.load_device) load_checkpoint(model, cfg.load_from, device) model = model.to(device) # 如果没有验证过 if result_file is None: # 开始验证 model.eval() all_bbox_cls = [] for c_iter, data_batch in enumerate(dataloader): with torch.no_grad(): # 停止反向传播,只进行前向计算 bbox_det = batch_detector( model, data_batch, device, return_loss=False)['bboxes'] # 提取bbox即可(n_cls,)(m,5) # 显示进度 if c_iter % 100 == 0: print('%d / %d finished predict.' % (c_iter, len(dataset))) all_bbox_cls.append(bbox_det) # (n_img,)(n_class,)(k,5) # 保存预测结果到文件 filename = get_time_str() + '_eval_result.pkl' save2pkl(all_bbox_cls, cfg.work_dir + filename) # 如果有现成验证文件 else: all_bbox_cls = loadvar(result_file) # 评估 voc_eval(all_bbox_cls, dataset, iou_thr=0.5)
def __init__(self, cfg_path, load_from=None, load_device=None): super().__init__() self.type = 'cls' # 准备验证所用的对象 self.cfg = get_config(cfg_path) # 为了便于eval,不必常去修改cfg里边的设置,直接在func里边添加2个参数即可 if load_from is not None: self.cfg.load_from = load_from if load_device is not None: self.cfg.load_device = load_device self.model = get_model(self.cfg) self.device = torch.device(self.cfg.load_device) if self.cfg.load_from is not None or self.cfg.resume_from is not None: load_checkpoint(self.model, self.cfg.load_from, self.device) self.model = self.model.to(self.device)
def common_init_weights(model, pretrained=None, map_location=None): """通用的模型初始化函数""" if isinstance(pretrained, str): load_checkpoint(model, pretrained, map_location = map_location) elif pretrained is None: for m in model.modules(): if isinstance(m, nn.Conv2d): kaiming_init(m) elif isinstance(m, nn.BatchNorm2d): constant_init(m, 1) elif isinstance(m, nn.Linear): normal_init(m, std=0.01) else: raise TypeError('pretrained must be a str or None')
def onnx_exporter(cfg): """把一个pytorch模型转换成onnx模型。 对模型的要求: 1. 模型需要有forward_dummy()函数的实施,如下是一个实例: def forward_dummy(self, img): x = self.extract_feat(img) x = self.bbox_head(x) return x 2. 模型的终端输出,也就是head端的输出必须是tuple/list/variable类型,不能是dict,否则当前pytorch.onnx不支持。 """ img_shape = (1, 3) + cfg.img_size dummy_input = torch.randn(img_shape, device='cuda') # 创建配置和创建模型 model = get_model(cfg).cuda() if cfg.load_from is not None: _ = load_checkpoint(model, cfg.load_from) else: raise ValueError('need to assign checkpoint path to load from.') model.forward = model.forward_dummy torch.onnx.export(model, dummy_input, cfg.work_dir + cfg.model_name + '.onnx', verbose=True)
def initialization(self): WORK_PATH = self.config.WORK_PATH os.chdir(WORK_PATH) os.environ["CUDA_VISIBLE_DEVICES"] = self.config.CUDA_VISIBLE_DEVICES print("GPU is :", os.environ["CUDA_VISIBLE_DEVICES"]) self.model = get_model(self.config) self.optimizer = get_optimizer(self.config, self.model.parameters()) checkpoint = get_checkpoint(self.config) if torch.cuda.device_count() > 1: self.model = torch.nn.DataParallel(self.model) self.model = self.model.cuda() self.last_epoch, self.step = load_checkpoint(self.model, self.optimizer, self.center_model, self.optimizer_center, checkpoint) print("from checkpoint {} last epoch: {}".format( checkpoint, self.last_epoch)) self.collate_fn = get_collate_fn(self.config, self.config.data.frame_num, self.sample_type) #
def init_weights(self, pretrained=None): if isinstance(pretrained, str): logger = logging.getLogger() load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger) elif pretrained is None: for m in self.modules(): if isinstance(m, nn.Conv2d): kaiming_init(m) elif isinstance(m, nn.BatchNorm2d): constant_init(m, 1) else: raise TypeError('pretrained must be a str or None')
def __init__(self, cfg, weights): if cfg.DATASET.NAME == 'coco': dataset = yoloCOCO elif cfg.DATASET.NAME == 'pascal': dataset = yoloPascal else: raise Exception("not support") self.cfg = cfg self.loader = DataLoader(dataset(cfg, 'train'), batch_size=1, shuffle=False) self.loadImgs = self.loader.dataset.coco.loadImgs self.class_name = self.loader.dataset.class_name self.id_cats = self.loader.dataset.id_cats self.model = Yolodet(cfg, pretrained=False) if weights: load_checkpoint(self.model, weights) self.model.eval() self.model.cuda()
def resume_training(self, checkpoint_path, map_location='default'): # 先加载checkpoint文件 if map_location == 'default': device_id = torch.cuda.current_device() # 获取当前设备 checkpoint = load_checkpoint( self.model, checkpoint_path, map_location=lambda storage, loc: storage.cuda(device_id)) else: checkpoint = load_checkpoint(self.model, checkpoint_path, map_location=map_location) #再恢复训练数据 self.c_epoch = checkpoint['meta'][ 'c_epoch'] + 1 # 注意:保存的是上一次运行的epoch,所以恢复要从下一次开始 self.c_iter = checkpoint['meta']['c_iter'] + 1 self.optimizer.load_state_dict(checkpoint['optimizer']) self.logger.info('resumed epoch %d, iter %d', self.c_epoch, self.c_iter)
def init_weights(self, pretrained=None): if isinstance(pretrained, str): logger = logging.getLogger() load_checkpoint(self, pretrained, strict=False, logger=logger) elif pretrained is None: for m in self.features.modules(): if isinstance(m, nn.Conv2d): kaiming_init(m) elif isinstance(m, nn.BatchNorm2d): constant_init(m, 1) elif isinstance(m, nn.Linear): normal_init(m, std=0.01) else: raise TypeError('pretrained must be a str or None') for m in self.extra.modules(): if isinstance(m, nn.Conv2d): xavier_init(m, distribution='uniform') constant_init(self.l2_norm, val=20., bias=0.)
def main(DEVICE): # define model, optimizer, scheduler model = VQVC().to(DEVICE) recon_loss = nn.L1Loss().to(DEVICE) vocoder = get_vocgan( ckpt_path=args.vocoder_pretrained_model_path).to(DEVICE) mel_stat = torch.tensor(np.load(args.mel_stat_path)).to(DEVICE) optimizer = Adam(model.parameters(), lr=args.init_lr) scheduler = WarmupScheduler(optimizer, warmup_epochs=args.warmup_steps, initial_lr=args.init_lr, max_lr=args.max_lr, milestones=args.milestones, gamma=args.gamma) global_step = load_checkpoint(checkpoint_path=args.model_checkpoint_path, model=model, optimizer=optimizer, scheduler=scheduler) # load dataset & dataloader train_dataset = SpeechDataset(mem_mode=args.mem_mode, meta_dir=args.prepro_meta_train, dataset_name=args.dataset_name, mel_stat_path=args.mel_stat_path, max_frame_length=args.max_frame_length) eval_dataset = SpeechDataset(mem_mode=args.mem_mode, meta_dir=args.prepro_meta_eval, dataset_name=args.dataset_name, mel_stat_path=args.mel_stat_path, max_frame_length=args.max_frame_length) train_data_loader = DataLoader(dataset=train_dataset, batch_size=args.train_batch_size, shuffle=True, drop_last=True, pin_memory=True, num_workers=args.n_workers) eval_data_loader = DataLoader(dataset=eval_dataset, batch_size=args.train_batch_size, shuffle=False, pin_memory=True, drop_last=True) # tensorboard writer = Writer(args.model_log_path) if args.log_tensorboard else None # train the model! train(train_data_loader, eval_data_loader, model, recon_loss, vocoder, mel_stat, optimizer, scheduler, global_step, writer, DEVICE)
def run(args): df = pd.read_csv(args.df_path) df_train = df[df['fold'] != args.fold] model = get_model(args).cuda() dataloader = get_dataloader(args.data_dir, df_train, 'train', args.pretrain, args.batch_size) checkpoints = get_checkpoints(args) checkpoint.load_checkpoint( args, model, None, checkpoint=checkpoints[0] ) # args, model, ckpt_name, checkpoint=None, optimizer=None for i, ckpt in enumerate(checkpoints[1:]): print(i, ckpt) model2 = get_model(args).cuda() last_epoch, _ = checkpoint.load_checkpoint(args, model2, None, checkpoint=ckpt) if args.ema is None: swa.moving_average(model, model2, 1. / (i + 2)) else: swa.moving_average(model, model2, args.ema) with torch.no_grad(): swa.bn_update(dataloader, model) if args.ema is not None: output_name = f'model_ema_{len(checkpoints)}' else: output_name = f'model_swa_{len(checkpoints)}' print('save {}'.format(output_name)) checkpoint.save_checkpoint(args, model, None, 0, 0, name=output_name, weights_dict={'state_dict': model.state_dict()})
def __init__(self): self.device = 'cpu' dir_path = os.path.dirname(os.getcwd()) checkpoint_file = dir_path + f'{os.getenv("CHECKPOINT_DIR")}/dental_711_w_pretrained_wt_fix/epoch_100.pth' self.img_transform_cfg = \ dict( mean=[123.675, 116.28, 103.53], std=[1, 1, 1], to_rgb=True, size_divisor=None, scale=(480, 320), flip=False, resize_keep_ratio=False ) # init model self.model = SSDDetector( pretrained=None, # basic input_size=(480, 320), num_classes=4, in_channels=(512, 1024, 512, 256, 256, 256), # anchor generate anchor_ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2]), anchor_strides=((8, 8), (18, 19), (34, 36), (69, 64), (96, 107), (160, 320)), basesize_ratios=(0.02, 0.05, 0.08, 0.12, 0.15, 0.18), allowed_border=-1, # regression target_means=(.0, .0, .0, .0), target_stds=(0.1, 0.1, 0.2, 0.2), # box assign pos_iou_thr=0.5, neg_iou_thr=0.5, min_pos_iou=0., gt_max_assign_all=False, # sampling sampling=False, # balancing the loss neg_pos_ratio=3, # loss smoothl1_beta=1., # inference nms nms_pre=-1, score_thr=0.02, nms_cfg=['nms', 0.3, None], max_per_img=200, device='cpu') # load checkpoint self.checkpoint = load_checkpoint(model=self.model, filename=checkpoint_file, map_location='cpu', strict=False, logger=None)
def test(cfg): """ Test a model """ logging.setup_logging(logger, cfg) logger.info("Test with config") logger.info(pprint.pformat(cfg)) model = model_builder.build_model(cfg) if du.is_master_proc(): misc.log_model_info(model) if cfg.TEST.CHECKPOINT_FILE_PATH != "": logger.info("Load from given checkpoint file.") gs, checkpoint_epoch = cu.load_checkpoint( cfg.TEST.CHECKPOINT_FILE_PATH, model, cfg.NUM_GPUS > 1, optimizer=None, inflation=False, convert_from_caffe2=False) start_epoch = checkpoint_epoch + 1 elif cfg.TRAIN.AUTO_RESUME and cu.has_checkpoint(cfg.OUTPUT_DIR): logger.info("Load from last checkpoint.") last_checkpoint = cu.get_last_checkpoint(cfg.OUTPUT_DIR) gs, checkpoint_epoch = cu.load_checkpoint(last_checkpoint, model, cfg.NUM_GPUS > 1, None) start_epoch = checkpoint_epoch + 1 # Create the video train and val loaders. test_loader = loader.construct_loader(cfg, "test") test_meter = TestMeter(cfg) if cfg.TEST.AUGMENT_TEST: evaluate_with_augmentation(test_loader, model, test_meter, cfg) else: evaluate(test_loader, model, test_meter, cfg)
def __init__(self): dir_path = os.path.dirname(os.getcwd()) # checkpoints checkpoint_file = dir_path + f'{os.getenv("CHECKPOINT_DIR")}/dental_711_w_fix_SSD_classification/epoch_300.pth' # classes CLASSES = ( 'pigment', 'soft_deposit', ) # device # device = 'cuda:0' self.device = 'cpu' # image self.img_scale = (480, 320) self.img_transform_cfg = \ dict( mean=[-1, -1, -1], std=[1, 1, 1], to_rgb=True, pad_values=(0, 0, 0), flip=False, resize_keep_ratio=True, ) self.img_transform = ImageTransform( mean=self.img_transform_cfg['mean'], std=self.img_transform_cfg['std'], to_rgb=self.img_transform_cfg['to_rgb'], ) self.model = VGGClassifier( with_bn=False, num_classes=len(CLASSES), num_stages=5, dilations=(1, 1, 1, 1, 1), out_indices=(30, ), frozen_stages=-1, bn_eval=True, bn_frozen=False, ceil_mode=True, with_last_pool=True, dimension_before_fc=(10, 15), dropout_rate=0.5, pos_loss_weights=None, ) self.checkpoint = load_checkpoint(model=self.model, filename=checkpoint_file, map_location='cpu', strict=False, logger=None)
def main(): # build the model from a config file and a checkpoint file model = SSDDetector(pretrained=None) checkpoint = load_checkpoint(model=model, filename=checkpoint_file, map_location=None, strict=False, logger=None) if 'CLASSES' in checkpoint['meta']: warnings.warn('Class names are saved in the checkpoint.') model.CLASSES = checkpoint['meta']['CLASSES'] else: warnings.warn('Class names are not saved in the checkpoint\'s ' 'meta data, use COCO classes by default.') model.CLASSES = get_classes('coco') model.to(device) model.eval() print(model) img_transform = ImageTransform( mean=img_transform_cfg['mean'], std=img_transform_cfg['std'], to_rgb=img_transform_cfg['to_rgb'], size_divisor=img_transform_cfg['size_divisor'], ) result = inference_single( model=model, img=img, img_transform=img_transform, scale=img_transform_cfg['scale'], flip=img_transform_cfg['flip'], resize_keep_ratio=img_transform_cfg['resize_keep_ratio'], rescale=True, device=next(model.parameters()).device, ) show_result(img=img, result=result[0], class_names=model.CLASSES, score_thr=0.3, out_file=out_file)
def run(args, log): df = pd.read_csv(args.df_path) df_train = df[df['Fold']!=args.fold] df_valid = df[df['Fold']==args.fold] dfs = {} dfs['train'] = df_train dfs['val'] = df_valid model = get_model(args).cuda() if args.mode != 'segmentation': for param in model.model.encoder.parameters(): param.requires_grad = True for param in model.model.decoder.parameters(): param.requires_grad = True for params in model.model.classification_head.parameters(): params.requires_grad = False elif args.mode == 'classification': for param in model.model.encoder.parameters(): param.requires_grad = False for param in model.model.decoder.parameters(): param.requires_grad = False for param in model.classification_head.parameters(): param.requires_grad = True criterion = get_loss(args) optimizer = get_optimizer(args, model) if args.initial_ckpt is not None: last_epoch, step = checkpoint.load_checkpoint(args, model, checkpoint=args.initial_ckpt) log.write(f'Resume training from {args.initial_ckpt} @ {last_epoch}\n') else: last_epoch, step = -1, -1 dataloaders = {mode:get_dataloader(args.data_dir, dfs[mode], mode, args.pretrain, args.batch_size) for mode in ['train', 'val']} seed_everything(seed=123) clr = CLR(optimizer, len(dataloaders['train'])) train(args, model, dataloaders['train'], criterion, optimizer, clr)
def submit(args, log): df = pd.read_csv(args.df_path) df['Image'] = df.Image_Label.map(lambda v: v[:v.find('_')]) print(df.head()) model = get_model(args).cuda() last_epoch, step = checkpoint.load_checkpoint(args, model, checkpoint=args.initial_ckpt) log.write(f'Loaded checkpoint from {args.initial_ckpt} @ {last_epoch}\n') dataloader = get_dataloader(args.data_dir, df, 'test', args.pretrain, args.batch_size) seed_everything() # inference test_ids, mask_predictions = inference_submit(model, dataloader, args.tta_augment) assert len(test_ids) == mask_predictions.shape[0] ids = [] rles = [] for i, image_id in tqdm.tqdm(enumerate(test_ids), total=len(test_ids)): predictions = mask_predictions[i] for cls_idx in range(4): prediction = predictions[cls_idx, :, :] H, W = prediction.shape assert H == 350 and W == 525 rle_encoded = mask2rle(prediction) assert np.all(rle2mask(H, W, rle_encoded) == prediction) ids.append(f'{image_id}_{LABEL_LIST[cls_idx]}') rles.append(rle_encoded) df_submission = pd.DataFrame({'Image_Label': ids, 'EncodedPixels': rles}) df_submission.to_csv(args.sub_name, index=False) print(df_submission.head())
def main(): # define the model and restore checkpoint model = VGGClassifier( with_bn=False, num_classes=len(CLASSES), num_stages=5, dilations=(1, 1, 1, 1, 1), out_indices=(30, ), frozen_stages=-1, bn_eval=True, bn_frozen=False, ceil_mode=True, with_last_pool=True, dimension_before_fc=(10, 15), dropout_rate=0.5, pos_loss_weights=None, ) checkpoint = load_checkpoint(model=model, filename=checkpoint_file, map_location='cpu', strict=False, logger=None) # define classes model.CLASSES = checkpoint['meta']['CLASSES'] # put to device and freeze model.to(device) model.eval() # backbone # backbone.features # backbone.features.0 # backbone.features.1 # backbone.features.2 # backbone.features.3 # backbone.features.4 # backbone.features.5 # backbone.features.6 # backbone.features.7 # backbone.features.8 # backbone.features.9 # backbone.features.10 # backbone.features.11 # backbone.features.12 # backbone.features.13 # backbone.features.14 # backbone.features.15 # backbone.features.16 # backbone.features.17 # backbone.features.18 # backbone.features.19 # backbone.features.20 # backbone.features.21 # backbone.features.22 # backbone.features.23 # backbone.features.24 # backbone.features.25 # backbone.features.26 # backbone.features.27 # backbone.features.28 # backbone.features.29 # backbone.features.30 # classifier # classifier.0 # classifier.1 # classifier.2 # classifier.3 # classifier.4 # classifier.5 # classifier.6 # for name, module in model.named_modules(): # print(name) img_transform = ImageTransform( mean=img_transform_cfg['mean'], std=img_transform_cfg['std'], to_rgb=img_transform_cfg['to_rgb'], ) # inference # read image raw_img = mmcv.imread(img_path) ori_shape = raw_img.shape print(ori_shape) # transform image img, img_shape, pad_shape, scale_factor = img_transform( img=raw_img, scale=img_scale, flip=img_transform_cfg['flip'], pad_val=img_transform_cfg['pad_values'], keep_ratio=img_transform_cfg['resize_keep_ratio'], ) img = to_tensor(img).to(device).unsqueeze(0) img_meta = [ dict(ori_shape=ori_shape, img_shape=img_shape, pad_shape=pad_shape, scale_factor=scale_factor, flip=img_transform_cfg['flip']) ] # with torch.no_grad(): # result = model.forward_test(img=img, img_meta=img_meta, rescale=False) target_layers = ["backbone.features.30"] target_class = 0 gcam = GradCAM(model=model) probs = gcam.forward(img) ids_ = torch.LongTensor([[target_class]]).to(device) gcam.backward(ids=ids_) print(probs) for target_layer in target_layers: print("Generating Grad-CAM @{}".format(target_layer)) # Grad-CAM # regions: [1, 1, H, W] # raw_img: [H, W, 3] regions = gcam.generate(target_layer=target_layer) regions = regions[0, 0].cpu().numpy() ori_regions = image_transfer_back(img=regions, scale=scale_factor, cur_shape=regions.shape, ori_shape=raw_img.shape[0:2]) print(ori_regions.shape)
if __name__ == "__main__": # Reading command line args model_num = sys.argv[1] output_folder = sys.argv[2] # Creating model, loading checkpoint and creating output folder checkpoint_path = '/shared/abhinav.goyal/s2t/rnnt_data/ckpt-' + str( model_num) model, _ = create_model('rnnt', objdict({ 'batch_size': 2, 'decoding': False }), build=True) checkpoint.load_checkpoint(checkpoint_path, model) create_folder(output_folder) clean_folder(output_folder) # Extracting weights prednet_wt_names = {'embedding': [], 'lstm_10': [], 'lstm_11': []} jointnet_wt_names = {'dense': [], 'dense_1': []} for weight in model.weights: name = weight.name for prednet_wt_name in prednet_wt_names: if name.startswith(prednet_wt_name): fname = os.path.join(output_folder, 'pred_net_' + name.replace('/', '_')) prednet_wt_names[prednet_wt_name].append( [fname, weight.numpy()]) for jointnet_wt_name in jointnet_wt_names:
else: setup = ImageNetworkSetup(image_setup, dataset, args) train_loader, test_loader, q_network = \ setup.train_loader, setup.test_loader, setup.q_network # Activating training on GPU if args.cuda: print("\n---Activating GPU Training---\n") q_network.cuda() # Loading Reinforcement module ReinforcementLearning = ReinforcementLearning(args.class_vector_size) # Initialize/Load Q Network & Statistics q_network, statistics = load_checkpoint(q_network, args) # Initialize Optimizer & Loss Function optimizer = optimizers.Adam(q_network.parameters()) criterion = nn.MSELoss() training_status_handler = StatusHandler(args) # Training loop for epoch in range(args.start_epoch, args.epochs + 1): # Train for one epoch train.train(q_network, epoch, optimizer, train_loader,
def main(): # load image img = mmcv.imread(IMG_PATH) img_height = img.shape[0] img_width = img.shape[1] # image pre-processing img_transform = ImageTransform( mean=IMG_TRANSFORM_CONFIG['mean'], std=IMG_TRANSFORM_CONFIG['std'], to_rgb=IMG_TRANSFORM_CONFIG['to_rgb'], ) img, img_shape, pad_shape, scale_factor = \ img_transform( img=img, scale=IMG_SCALE, flip=False, pad_val=IMG_TRANSFORM_CONFIG['pad_values'], keep_ratio=IMG_TRANSFORM_CONFIG['resize_keep_ratio'] ) img_meta = dict(ori_shape=(img_height, img_width, 3), img_shape=img_shape, pad_shape=pad_shape, scale_factor=scale_factor, flip=False) data = dict(img=DataContainer(to_tensor(img), stack=True), img_meta=DataContainer(img_meta, cpu_only=True)) # define the model model = SSDDetector( # basic input_size=IMG_SCALE, num_classes=NUM_CLASS, in_channels=(512, 1024, 512, 256, 256), use_dropout=False, dropout_rate=None, # anchor generate anchor_ratios=([1 / 2.0, 1.0, 2.0], [1 / 3.0, 1 / 2.0, 1.0, 2.0, 3.0], [1 / 3.0, 1 / 2.0, 1.0, 2.0, 3.0], [1 / 3.0, 1 / 2.0, 1.0, 2.0, 3.0], [1 / 2.0, 1.0, 2.0]), anchor_strides=((16, 16), (16, 16), (30, 30), (60, 60), (100, 100)), basesizes=((12, 12), (16, 16), (24, 24), (30, 30), (36, 36)), allowed_border=-1, # regression target_means=(.0, .0, .0, .0), target_stds=(0.1, 0.1, 0.2, 0.2), # box assign pos_iou_thr=0.5, neg_iou_thr=0.5, min_pos_iou=0., gt_max_assign_all=False, # sampling sampling=False, # balancing the loss neg_pos_ratio=3, # loss smoothl1_beta=1., # inference nms nms_pre=-1, score_thr=0.02, min_size=100.0, max_scale_ratio=10.0, nms_cfg=['nms', 0.45, None], max_per_img=200, # device device='cpu', ) # load checkpoint _ = load_checkpoint(model=model, filename=CHECKPOINT_FILE, map_location='cpu', strict=True, logger=None) # parallelize model model.eval() # results and progress bar # inference the data with torch.no_grad(): result = model(is_test=True, rescale=True, img=data['img'].data.unsqueeze(0), img_meta=(data['img_meta'].data, )) show_one_image(result[0], IMG_PATH, SAVE_PATH)
def test(cfg): """ Perform multi-view testing on the pretrained video model. Args: cfg (CfgNode): configs. Details can be found in slowfast/config/defaults.py """ # Set up environment. du.init_distributed_training(cfg) # Set random seed from configs. np.random.seed(cfg.RNG_SEED) torch.manual_seed(cfg.RNG_SEED) # Setup logging format. logging.setup_logging(cfg.OUTPUT_DIR) # Print config. logger.info("Test with config:") logger.info(cfg) # Build the video model and print model statistics. model = build_model(cfg) if du.is_master_proc() and cfg.LOG_MODEL_INFO: misc.log_model_info(model, cfg, is_train=False) # Load a checkpoint to test if applicable. if cfg.TEST.CHECKPOINT_FILE_PATH != "": cu.load_checkpoint( cfg.TEST.CHECKPOINT_FILE_PATH, model, cfg.NUM_GPUS > 1, None, inflation=False, convert_from_caffe2=cfg.TEST.CHECKPOINT_TYPE == "caffe2", ) elif cu.has_checkpoint(cfg.OUTPUT_DIR): last_checkpoint = cu.get_last_checkpoint(cfg.OUTPUT_DIR) cu.load_checkpoint(last_checkpoint, model, cfg.NUM_GPUS > 1) elif cfg.TRAIN.CHECKPOINT_FILE_PATH != "": # If no checkpoint found in TEST.CHECKPOINT_FILE_PATH or in the current # checkpoint folder, try to load checkpint from # TRAIN.CHECKPOINT_FILE_PATH and test it. cu.load_checkpoint( cfg.TRAIN.CHECKPOINT_FILE_PATH, model, cfg.NUM_GPUS > 1, None, inflation=False, convert_from_caffe2=cfg.TRAIN.CHECKPOINT_TYPE == "caffe2", ) else: # raise NotImplementedError("Unknown way to load checkpoint.") logger.info("Testing with random initialization. Only for debugging.") # Create video testing loaders. test_loader = loader.construct_loader(cfg, "test") logger.info("Testing model for {} iterations".format(len(test_loader))) if cfg.DETECTION.ENABLE: assert cfg.NUM_GPUS == cfg.TEST.BATCH_SIZE test_meter = AVAMeter(len(test_loader), cfg, mode="test") else: assert ( len(test_loader.dataset) % (cfg.TEST.NUM_ENSEMBLE_VIEWS * cfg.TEST.NUM_SPATIAL_CROPS) == 0) # Create meters for multi-view testing. test_meter = TestMeter( len(test_loader.dataset) // (cfg.TEST.NUM_ENSEMBLE_VIEWS * cfg.TEST.NUM_SPATIAL_CROPS), cfg.TEST.NUM_ENSEMBLE_VIEWS * cfg.TEST.NUM_SPATIAL_CROPS, cfg.MODEL.NUM_CLASSES, len(test_loader), cfg.DATA.MULTI_LABEL, cfg.DATA.ENSEMBLE_METHOD, ) # Set up writer for logging to Tensorboard format. if cfg.TENSORBOARD.ENABLE and du.is_master_proc( cfg.NUM_GPUS * cfg.NUM_SHARDS): writer = tb.TensorboardWriter(cfg) else: writer = None # # Perform multi-view test on the entire dataset. perform_test(test_loader, model, test_meter, cfg, writer) if writer is not None: writer.close()
def test(cfg): # basic settings loss_F = torch.nn.CrossEntropyLoss() gpu_nums = int(cfg['NUM_GPUS']) if gpu_nums == 0: use_cuda = False else: use_cuda = True # load model model = AnyNet(cfg) if use_cuda: model = torch.nn.DataParallel(model, device_ids=[0]) model = model.cuda() # load_dataset Testpath = cfg['TEST']['PATH'] RESIZE_SIZE_val = cfg['TEST']['IM_SIZE'] test_data = SingleDataset(Testpath, split='val', resize_size=RESIZE_SIZE_val) test_loader = DataLoader(dataset=test_data, batch_size=cfg['TEST']['BATCH_SIZE'], shuffle=False, num_workers=cfg['DATA_LOADER']['NUM_WORKERS'], pin_memory=True) # optimizer and loss function and evaluator # optimizer and loss function and evaluator if cfg['OPTIM']['OPTIMIZER'] == 'Adam': optimizer = torch.optim.Adam(model.parameters(), lr=cfg['OPTIM']['BASE_LR'], weight_decay=1e-4) else: optimizer = torch.optim.SGD(model.parameters(), lr=cfg['OPTIM']['BASE_LR'], momentum=0.9, weight_decay=5e-4) # load checkpoint or initial weights if cfg['TEST']['WEIGHTS']: weights = cfg['TEST']['WEIGHTS'] if not os.path.isfile(weights): raise RuntimeError( "=> no checkpoint found at '{}'".format(weights)) cp.load_checkpoint(cfg['TEST']['WEIGHTS'], gpu_nums, model) # save testing process log_file = log_g.get_test_log_filename(os.path.join( cfg['OUT_DIR'], 'log/')) log = open(log_file, 'w+') # start testing batch_size = cfg['TEST']['BATCH_SIZE'] num_class = cfg['MODEL']['NUM_CLASSES'] ############################################################################# # start test ############################################################################# model.eval() mean_loss_val = 0 top1_sum = 0 c_perclass = np.zeros(num_class) t_perclass = np.zeros(num_class) for val_epoch, (img_val, lbl_val) in enumerate(test_loader): if use_cuda: img_val, lbl_val = img_val.cuda(), lbl_val.cuda() # predict preds_val = model(img_val) # calculate loss loss_val = loss_F(preds_val, lbl_val) mean_loss_val += loss_val.item() # evaluation top1_acc, top2_acc = Evaluator.accuracy(preds_val, lbl_val, [1, 2]) # top1_err, top2_err = Evaluator.topk_error(preds_val, lbl_val, [1,2]) correct, total = Evaluator.accuracy_perclass(preds_val, lbl_val, num_class) c_perclass += correct t_perclass += total top1_sum += top1_acc print('[%s][%d/%d]--top1_acc: %.3f' % (datetime.now().strftime('%Y-%m-%d %H:%M:%S'), val_epoch, len(test_loader), top1_acc)) print('[{}]--mean_loss: {}\ttop1_acc: {}\tper_class_acc: {}'.format( datetime.now().strftime('%Y-%m-%d %H:%M:%S'), mean_loss_val / len(test_loader), top1_sum / len(test_loader), float(c_perclass / t_perclass) * 100)) # save log log.write('[{}]--mean_loss: {}\ttop1_acc: {}\tper_class_acc: {}\n'.format( datetime.now().strftime('%Y-%m-%d %H:%M:%S'), (mean_loss_val / len(test_loader)), top1_sum / len(test_loader), float(c_perclass / t_perclass) * 100)) log.close()
def main(): # build the model from a config file and a checkpoint file model = SSDDetector( pretrained=None, # basic input_size=(480, 320), num_classes=4, in_channels=(512, 1024, 512, 256, 256, 256), # anchor generate anchor_ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2]), anchor_strides=((8, 8), (18, 19), (34, 36), (69, 64), (96, 107), (160, 320)), basesize_ratios=(0.02, 0.05, 0.08, 0.12, 0.15, 0.18), allowed_border=-1, # regression target_means=(.0, .0, .0, .0), target_stds=(0.1, 0.1, 0.2, 0.2), # box assign pos_iou_thr=0.5, neg_iou_thr=0.5, min_pos_iou=0., gt_max_assign_all=False, # sampling sampling=False, # balancing the loss neg_pos_ratio=3, # loss smoothl1_beta=1., # inference nms nms_pre=-1, score_thr=0.02, nms_cfg=['nms', 0.45, None], max_per_img=200, ) # model = SSDDetector( # pretrained=None, # # basic # input_size=(480, 320), # num_classes=4, # in_channels=(512, 256, 128, 64, 32), # # anchor generate # anchor_ratios=([2, 3], [2, 3], [2, 3], [2, 3], [2, 3]), # anchor_strides=((16, 16), (8, 8), (4, 4), (2, 2), (1, 1)), # basesize_ratios=(0.16, 0.13, 0.10, 0.06, 0.02), # allowed_border=-1, # # regression # target_means=(.0, .0, .0, .0), # target_stds=(0.1, 0.1, 0.2, 0.2), # # box assign # pos_iou_thr=0.5, # neg_iou_thr=0.5, # min_pos_iou=0., # gt_max_assign_all=False, # # sampling # sampling=False, # # balancing the loss # neg_pos_ratio=3, # # loss # smoothl1_beta=1., # # inference nms # nms_pre=3000, # score_thr=0.02, # nms_cfg=['nms', 0.2, None], # max_per_img=200, # ) checkpoint = load_checkpoint(model=model, filename=checkpoint_file, map_location=None, strict=False, logger=None) if 'CLASSES' in checkpoint['meta']: warnings.warn('Class names are saved in the checkpoint.') model.CLASSES = checkpoint['meta']['CLASSES'] else: warnings.warn('Class names are called from dataset.') model.CLASSES = get_classes('coco') model.to(device) model.eval() img_transform = ImageTransform( mean=img_transform_cfg['mean'], std=img_transform_cfg['std'], to_rgb=img_transform_cfg['to_rgb'], size_divisor=img_transform_cfg['size_divisor'], ) result = inference_single( model=model, img=img, img_transform=img_transform, scale=img_transform_cfg['scale'], flip=img_transform_cfg['flip'], resize_keep_ratio=img_transform_cfg['resize_keep_ratio'], rescale=True, device=next(model.parameters()).device, ) print(result) show_result(img=img, result=result[0], class_names=model.CLASSES, score_thr=0.3, out_file=out_file)
def main(): # get local rank from distributed launcher parser = argparse.ArgumentParser() parser.add_argument("--local_rank", type=int) args = parser.parse_args() print('what is the rank of the current program: ') print(args.local_rank) # initialize dist if mp.get_start_method(allow_none=True) is None: mp.set_start_method('spawn') rank = int(args.local_rank) torch.cuda.set_device(rank) dist.init_process_group(backend='nccl', init_method='env://') # define dataset dataset = DentalClassDataset( ann_file=ann_file, img_prefix=img_prefix, img_scale=img_scale, img_norm_cfg=img_transform_cfg, multiscale_mode='value', # select a scale, rather than random from a range. flip_ratio=flip_ratio, with_label=False, extra_aug=None, test_mode=True, ) # sampler for make number of samples % number of gpu == 0 rank, world_size = get_dist_info() sampler = NewDistributedSampler( dataset=dataset, num_replicas=world_size, images_per_gpu=imgs_per_gpu, rank=rank, shuffle=False ) # data loader. Note this is the code for one (each) gpu. batch_size = imgs_per_gpu num_workers = workers_per_gpu data_loader = DataLoader( dataset=dataset, batch_size=batch_size, # when sampler is given, shuffle must be False. shuffle=False, sampler=sampler, batch_sampler=None, num_workers=num_workers, collate_fn=partial(collate, samples_per_gpu=imgs_per_gpu), pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, ) # define the model and restore checkpoint model = VGGClassifier( with_bn=False, num_classes=len(dataset.CLASSES), num_stages=5, dilations=(1, 1, 1, 1, 1), out_indices=(30,), frozen_stages=-1, bn_eval=True, bn_frozen=False, ceil_mode=True, with_last_pool=True, dimension_before_fc=(10, 15), dropout_rate=0.5, pos_loss_weights=torch.tensor((15, 8), dtype=torch.float32, device=torch.device('cuda', rank)), ) checkpoint = load_checkpoint( model=model, filename=checkpoint_file, map_location='cpu', strict=False, logger=None ) # define classes model.CLASSES = checkpoint['meta']['CLASSES'] # parallelize model model = model.cuda() model = MMDistributedDataParallel( module=model, dim=0, broadcast_buffers=True, bucket_cap_mb=25 ) model.eval() # results and progress bar results = [] dataset = data_loader.dataset if rank == 0: prog_bar = mmcv.ProgressBar(len(dataset)) # enumerate all data for i, data in enumerate(data_loader): with torch.no_grad(): result = model(is_test=True, rescale=True, **data) results.extend(result) # update program bar only if it is rank 0. if rank == 0: batch_size = data['img'].size(0) for _ in range(batch_size * world_size): prog_bar.update() # collect results from all gpus results = collect_results( result_part=results, dataset_real_size=len(dataset), tmpdir=tmpdir ) # write results to file # [Number of images, Number of classes, (k, 5)]. # 5 for t, l, b, r, and prob. if rank == 0: print('\nwriting results to {}'.format(out_file)) mmcv.dump(results, out_file+'.pickle')
return GIOU_loss, prob_loss, conf_loss def __focal_loss(self, pred_conf, obj_conf, obj_bg): focal = self.alpha * torch.pow(torch.abs(pred_conf - obj_conf), self.gamma) loss = focal * ( obj_conf * F.binary_cross_entropy(pred_conf, obj_conf, reduce=False) + obj_bg * F.binary_cross_entropy(pred_conf, obj_conf, reduce=False)) return loss if __name__ == '__main__': from dataset import yoloCOCO, yoloPascal from torch.utils.data import DataLoader from models.yolo_head import Yolodet from config import hrnet_yolo, dark53_yolo from utils.checkpoint import load_checkpoint loader = DataLoader(yoloCOCO(dark53_yolo, 'val'), batch_size=4, shuffle=False) model = Yolodet(dark53_yolo, pretrained=True) load_checkpoint(model, '../weights/pretrained/this_imple_yolov3.pth') crit = yoloLoss() for batch in loader: out = model(batch['input']) loss, loss_state = crit(out, batch) loss.backward() for k in loss_state: print('{} : {} '.format(k, loss_state[k].item()), end='') print()
def main(): # get local rank from distributed launcher parser = argparse.ArgumentParser() parser.add_argument("--local_rank", type=int) args = parser.parse_args() print('what is the rank of the current program: ') print(args.local_rank) # initialize dist if mp.get_start_method(allow_none=True) is None: mp.set_start_method('spawn') rank = int(args.local_rank) torch.cuda.set_device(rank) dist.init_process_group(backend='nccl', init_method='env://') # define dataset dataset = CocoDataset( ann_file=ann_file, img_prefix=img_prefix, img_scale=img_scale, img_norm_cfg=img_transform_cfg, multiscale_mode='value', flip_ratio=flip_ratio, with_ignore=False, with_label=False, extra_aug=None, test_mode=True, ) # sampler for make number of samples % number of gpu == 0 rank, world_size = get_dist_info() sampler = NewDistributedSampler(dataset=dataset, num_replicas=world_size, images_per_gpu=imgs_per_gpu, rank=rank, shuffle=False) # data loader. Note this is the code for one (each) gpu. batch_size = imgs_per_gpu num_workers = workers_per_gpu data_loader = DataLoader( dataset=dataset, batch_size=batch_size, # when sampler is given, shuffle must be False. shuffle=False, sampler=sampler, batch_sampler=None, num_workers=num_workers, collate_fn=partial(collate, samples_per_gpu=imgs_per_gpu), pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, ) # define the model and restore checkpoint model = SSDDetector(pretrained=None) checkpoint = load_checkpoint(model=model, filename=checkpoint_file, map_location='cpu', strict=False, logger=None) # define classes if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES # parallelize model model = model.cuda() model = MMDistributedDataParallel(module=model, dim=0, broadcast_buffers=True, bucket_cap_mb=25) model.eval() # results and progress bar results = [] dataset = data_loader.dataset if rank == 0: prog_bar = mmcv.ProgressBar(len(dataset)) # enumerate all data for i, data in enumerate(data_loader): print(data['img_meta']) with torch.no_grad(): result = model(is_test=True, rescale=True, **data) results.extend(result) # update program bar only if it is rank 0. if rank == 0: batch_size = data['img'].size(0) for _ in range(batch_size * world_size): prog_bar.update() # collect results from all gpus results = collect_results(result_part=results, dataset_real_size=len(dataset), tmpdir=tmpdir) # write results to file # [Number of images, Number of classes, (k, 5)]. # 5 for t, l, b, r, and prob. if rank == 0: print('\nwriting results to {}'.format(out_file)) mmcv.dump(results, out_file + '.pickle') if not isinstance(results[0], dict): # result file that of coco format. save it to result.bbox.json and result.proposal.json. # jason format: # [Number_of_bboxes, # dict( # image_id: # bbox: [x, y, w, h] # score: # category_id: # )] results2json(dataset, results, out_file) # Average Precision (AP) @[ IoU=0.50 | maxDets= 1 ] = 0.310 # Average Precision (AP) @[ IoU=0.50 | maxDets= 10 ] = 0.431 # Average Precision (AP) @[ IoU=0.50 | maxDets=100 ] = 0.443 # Average Recall (AR) @[ IoU=0.50 | maxDets= 1 ] = 0.368 # Average Recall (AR) @[ IoU=0.50 | maxDets= 10 ] = 0.582 # Average Recall (AR) @[ IoU=0.50 | maxDets=100 ] = 0.637 # coco_eval( # result_file=out_file+'.bbox.json', # result_type='bbox', # coco=dataset.coco, # iou_thrs=[0.5], # max_dets=[1, 10, 100] # ) # Average Precision (AP) @[ IoU=0.50 | maxDets= 1 ] = 0.310 # Average Precision (AP) @[ IoU=0.50 | maxDets= 10 ] = 0.431 # Average Precision (AP) @[ IoU=0.50 | maxDets=100 ] = 0.443 # Average Precision (AP) @[ IoU=0.55 | maxDets= 1 ] = 0.298 # Average Precision (AP) @[ IoU=0.55 | maxDets= 10 ] = 0.411 # Average Precision (AP) @[ IoU=0.55 | maxDets=100 ] = 0.421 # Average Precision (AP) @[ IoU=0.60 | maxDets= 1 ] = 0.281 # Average Precision (AP) @[ IoU=0.60 | maxDets= 10 ] = 0.382 # Average Precision (AP) @[ IoU=0.60 | maxDets=100 ] = 0.390 # Average Precision (AP) @[ IoU=0.65 | maxDets= 1 ] = 0.263 # Average Precision (AP) @[ IoU=0.65 | maxDets= 10 ] = 0.350 # Average Precision (AP) @[ IoU=0.65 | maxDets=100 ] = 0.355 # Average Precision (AP) @[ IoU=0.70 | maxDets= 1 ] = 0.238 # Average Precision (AP) @[ IoU=0.70 | maxDets= 10 ] = 0.308 # Average Precision (AP) @[ IoU=0.70 | maxDets=100 ] = 0.312 # Average Precision (AP) @[ IoU=0.75 | maxDets= 1 ] = 0.206 # Average Precision (AP) @[ IoU=0.75 | maxDets= 10 ] = 0.260 # Average Precision (AP) @[ IoU=0.75 | maxDets=100 ] = 0.262 # Average Precision (AP) @[ IoU=0.80 | maxDets= 1 ] = 0.165 # Average Precision (AP) @[ IoU=0.80 | maxDets= 10 ] = 0.201 # Average Precision (AP) @[ IoU=0.80 | maxDets=100 ] = 0.202 # Average Precision (AP) @[ IoU=0.85 | maxDets= 1 ] = 0.111 # Average Precision (AP) @[ IoU=0.85 | maxDets= 10 ] = 0.130 # Average Precision (AP) @[ IoU=0.85 | maxDets=100 ] = 0.130 # Average Precision (AP) @[ IoU=0.90 | maxDets= 1 ] = 0.048 # Average Precision (AP) @[ IoU=0.90 | maxDets= 10 ] = 0.053 # Average Precision (AP) @[ IoU=0.90 | maxDets=100 ] = 0.053 # Average Precision (AP) @[ IoU=0.95 | maxDets= 1 ] = 0.005 # Average Precision (AP) @[ IoU=0.95 | maxDets= 10 ] = 0.005 # Average Precision (AP) @[ IoU=0.95 | maxDets=100 ] = 0.005 # Average Recall (AR) @[ IoU=0.50 | maxDets= 1 ] = 0.368 # Average Recall (AR) @[ IoU=0.50 | maxDets= 10 ] = 0.582 # Average Recall (AR) @[ IoU=0.50 | maxDets=100 ] = 0.637 # Average Recall (AR) @[ IoU=0.55 | maxDets= 1 ] = 0.354 # Average Recall (AR) @[ IoU=0.55 | maxDets= 10 ] = 0.557 # Average Recall (AR) @[ IoU=0.55 | maxDets=100 ] = 0.606 # Average Recall (AR) @[ IoU=0.60 | maxDets= 1 ] = 0.338 # Average Recall (AR) @[ IoU=0.60 | maxDets= 10 ] = 0.523 # Average Recall (AR) @[ IoU=0.60 | maxDets=100 ] = 0.565 # Average Recall (AR) @[ IoU=0.65 | maxDets= 1 ] = 0.319 # Average Recall (AR) @[ IoU=0.65 | maxDets= 10 ] = 0.478 # Average Recall (AR) @[ IoU=0.65 | maxDets=100 ] = 0.509 # Average Recall (AR) @[ IoU=0.70 | maxDets= 1 ] = 0.291 # Average Recall (AR) @[ IoU=0.70 | maxDets= 10 ] = 0.421 # Average Recall (AR) @[ IoU=0.70 | maxDets=100 ] = 0.443 # Average Recall (AR) @[ IoU=0.75 | maxDets= 1 ] = 0.258 # Average Recall (AR) @[ IoU=0.75 | maxDets= 10 ] = 0.360 # Average Recall (AR) @[ IoU=0.75 | maxDets=100 ] = 0.373 # Average Recall (AR) @[ IoU=0.80 | maxDets= 1 ] = 0.215 # Average Recall (AR) @[ IoU=0.80 | maxDets= 10 ] = 0.287 # Average Recall (AR) @[ IoU=0.80 | maxDets=100 ] = 0.295 # Average Recall (AR) @[ IoU=0.85 | maxDets= 1 ] = 0.158 # Average Recall (AR) @[ IoU=0.85 | maxDets= 10 ] = 0.203 # Average Recall (AR) @[ IoU=0.85 | maxDets=100 ] = 0.207 # Average Recall (AR) @[ IoU=0.90 | maxDets= 1 ] = 0.084 # Average Recall (AR) @[ IoU=0.90 | maxDets= 10 ] = 0.101 # Average Recall (AR) @[ IoU=0.90 | maxDets=100 ] = 0.103 # Average Recall (AR) @[ IoU=0.95 | maxDets= 1 ] = 0.014 # Average Recall (AR) @[ IoU=0.95 | maxDets= 10 ] = 0.017 # Average Recall (AR) @[ IoU=0.95 | maxDets=100 ] = 0.017 coco_eval(result_file=out_file + '.bbox.json', result_type='bbox', coco=ann_file, iou_thrs=[ 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95 ], max_dets=[1, 10, 100])