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])
