def _apply_mosaic(self, images, targets):
assert len(images) == 4 and len(targets) == 4
sw, sh = self._img_size
c = images[0].shape[2]
sum_rgb = np.zeros([images[0].ndim, ])
for img in images:
sum_rgb += np.array(cv2.mean(img))[:3]
mean_rgb = sum_rgb / len(images)
img4 = np.full((sh * 2, sw * 2, c), mean_rgb, dtype=np.uint8) # base image with 4 tiles
offsets = [(0, 0), (sw, 0), (0, sh), (sw, sh)]
target4 = ParamList((sw, sh))
for i, img, target in zip(range(4), images, targets):
h, w, _ = img.shape
pad_w = int(sw - w) // 2
pad_h = int(sh - h) // 2
y_st = pad_h + offsets[i][1]
x_st = pad_w + offsets[i][0]
img4[y_st:y_st + h, x_st:x_st + w] = img
bbox = target.get_field('bbox')
bbox[:, 0::2] += x_st
bbox[:, 1::2] += y_st
target.update_field('bbox', bbox)
# np.clip(bbox[:, 0::2], 0, 2 * sw, out=bbox[:, 0::2]) # use with random_affine
# np.clip(bbox[:, 1::2], 0, 2 * sh, out=bbox[:, 1::2])
target4.merge(target)
raff = transforms.RandomAffine2D()
param = {
'border': (-sh//2, -sw//2)
}
param.update(self._config)
return raff(img4, target4, **param)
def collate_fn(batch):
img, target, path, shape = zip(*batch) # transposed
ntarget = ParamList((None, None))
for i, t in enumerate(target):
id = t.get_field('img_id')
id[:, ] = i
t.update_field('img_id', id)
ntarget.merge(t)
# ntarget.to_tensor()
return torch.stack(img, 0), ntarget, path, shape
def __getitem__(self, index):
indices = [index]
if self._is_mosaic and self.is_training:
indices += [
random.randint(0,
len(self._labels) - 1) for _ in range(3)
] # 3 additional image indices
images = []
targets = []
for i, idx in enumerate(indices):
img = self._load_image(idx)
target = ParamList((img.shape[1], img.shape[0]))
K = self._K[idx]
_labels = self._labels[idx].copy()
cls, noise_mask, repeats = self._transform_obj_label(
self._labels[idx][:, 0].copy())
_labels = np.repeat(_labels, repeats=repeats, axis=0)
N = len(cls)
target.add_field('class', cls)
target.add_field('img_id', np.zeros((N, ), dtype=np.int))
target.add_field('bbox', _labels[:, 1:5])
target.add_field('dimension', _labels[:, 5:8])
target.add_field('alpha', _labels[:, 8])
target.add_field('Ry', _labels[:, 9])
target.add_field('location', _labels[:, -3:])
mask = np.ones((N, ), dtype=np.int)
mask[cls == -1] = 0
target.add_field('mask', mask)
target.add_field('noise_mask', noise_mask)
target.add_field(
'K', np.repeat(K.copy().reshape(1, 9), repeats=N, axis=0))
if self._augment is not None:
img, target = self._augment(img,
targets=target,
**self._aug_params)
images.append(img)
targets.append(target)
if self._is_mosaic and self.is_training:
img, target = self._apply_mosaic(images, targets)
else:
img, target = self._apply_padding(images, targets)
# Convert
img = np.ascontiguousarray(img)
params = {'device': self._config.DEVICE}
target = self._build_targets(target)
params.update(self._norm_params)
img, target = self._transform(img, targets=target, **params)
path = os.path.join(self._root, 'training',
'image_2/{}.png'.format(self._image_files[index]))
return img, target, path, self.__shapes[index]
def _build_targets(self, targets):
outputs = ParamList(self._img_size, is_training=self.is_training)
outputs.copy_field(targets, ['img_id', 'mask', 'noise_mask', 'K'])
down_ratio = self._config.MODEL.DOWN_SAMPLE
bboxes = targets.get_field('bbox') / down_ratio
m_masks = targets.get_field('mask')
W, H = self._img_size[0] // 4, self._img_size[1] // 4
N = m_masks.shape[0]
centers = data_utils.bbox_center(bboxes)
m_projs = centers.astype(np.long)
m_offs = centers - m_projs
outputs.add_field('m_proj', m_projs)
outputs.add_field('m_off', m_offs)
locations = targets.get_field('location')
Rys = targets.get_field('Ry')
dimensions = targets.get_field('dimension')
Ks = targets.get_field('K')
Ks[:, 0:6] /= down_ratio
vertexs, _, mask_3ds = kitti_utils.calc_proj2d_bbox3d(
dimensions, locations, Rys, Ks.reshape(-1, 3, 3))
vertexs = np.ascontiguousarray(np.transpose(vertexs, axes=[0, 2,
1]))[:, :-1]
v_projs = vertexs.astype(np.long)
v_offs = vertexs - v_projs
v_coor_offs = vertexs - centers.reshape(-1, 1, 2)
v_masks = (v_projs[..., 0] >= 0) & (v_projs[..., 0] < W) & (
v_projs[..., 1] >= 0) & (v_projs[..., 1] < H)
outputs.add_field('v_proj', v_projs)
outputs.add_field('v_off', v_offs)
outputs.add_field('v_coor_off', v_coor_offs)
outputs.add_field('v_mask', v_masks)
outputs.add_field('mask_3d', mask_3ds)
if self._config.DATASET.GAUSSIAN_GEN_TYPE == 'dynamic_radius':
gaussian_sigma, gaussian_radius = data_utils.dynamic_radius(bboxes)
else:
gaussian_sigma, gaussian_radius = data_utils.dynamic_sigma(
bboxes, self._config.DATASET.BBOX_AREA_MAX,
self._config.DATASET.BBOX_AREA_MIN)
clses = targets.get_field('class')
num_cls = len(self._classes)
noise_masks = targets.get_field('noise_mask')
num_vertex = vertexs.shape[1]
m_hm = np.zeros((num_cls, H, W), dtype=np.float)
# v_hm = np.zeros((num_vertex, H, W), dtype=np.float)
for i in range(N):
m_mask = m_masks[i]
noise_mask = noise_masks[i]
mask_3d = mask_3ds[i]
gaussian_kernel, xs, ys = None, None, None
if m_mask | mask_3d:
gaussian_kernel, xs, ys = data_utils.gaussian2D(
gaussian_sigma[i], gaussian_radius[i])
if noise_mask:
gaussian_kernel[len(xs) // 2] = 0.9999
if m_mask:
# to-do
m_proj = m_projs[i]
cls = clses[i]
m_xs = xs + m_proj[0]
m_ys = ys + m_proj[1]
valid = (m_xs >= 0) & (m_xs < W) & (m_ys >= 0) & (m_ys < H)
m_hm[cls, m_ys[valid], m_xs[valid]] = np.maximum(
m_hm[cls, m_ys[valid], m_xs[valid]],
gaussian_kernel[valid])
# if mask_3d:
# # to-do
# v_proj = v_projs[i]
# for j, v in enumerate(v_proj):
# v_xs = xs + v[0]
# v_ys = ys + v[1]
# valid = (v_xs >= 0) & (v_xs < W) & (v_ys >= 0) & (v_ys < H)
# v_hm[j, v_ys[valid], v_xs[valid]] = np.maximum(v_hm[j, v_ys[valid], v_xs[valid]],
# gaussian_kernel[valid])
outputs.add_field('m_hm', np.expand_dims(m_hm, axis=0))
# outputs.add_field('v_hm', np.expand_dims(v_hm, axis=0))
return outputs
def optim_decode_bbox3d(clses, bbox3d_projs, K, ref_dim, ref_loc):
'''
:param clses: (N, )
:param bbox3d_projs: (N, 8, 2)
:return:
'''
x_corners = []
y_corners = []
z_corners = []
for i in [1, -1]: # x
for j in [1, -1]: # y
for k in [1, -1]: # z
x_corners.append(i)
y_corners.append(j)
z_corners.append(k)
Cor = np.vstack([x_corners, y_corners, z_corners]) * 0.5
K = K.reshape(3, 3)
cons = constraint()
dims = []
Rys = []
locs = []
clses_new = []
Ks = []
options = {'disp': None, 'maxcor': 10, 'ftol': 2.220446049250313e-09, 'gtol': 1e-05, 'eps': 1e-08,
'maxfun': 15000, 'maxiter': 15000, 'iprint': -1, 'maxls': 20, 'finite_diff_rel_step': None}
for cls, UV in zip(clses, bbox3d_projs):
dim = ref_dim[cls]
X0 = np.array([0, 1] + [dim[2], dim[0], dim[1]] + ref_loc)
res = minimize(aimFun(*(Cor, K, UV.T)), X0, method='L-BFGS-B',
jac=jac(*(Cor, K, UV.T)), constraints=cons, options=options)
if res.fun < 0.1:
x = res.x
Ry = np.arctan2(x[0], x[1])
Rys.append(Ry)
dims.append(np.array([x[3], x[4], x[2]]).reshape(1, 3))
locs.append(np.array([x[-3], x[-2], x[-1]]).reshape(1, 3))
clses_new.append(cls)
Ks.append(K.reshape(1, 9))
out = ParamList((640, 640))
out.add_field('class', clses_new)
out.add_field('Ry', np.array(Rys))
out.add_field('dimension', np.concatenate(dims, axis=0) if len(dims) else np.zeros((0, 3)))
out.add_field('location', np.concatenate(locs, axis=0) if len(dims) else np.zeros((0, 3)))
out.add_field('K', np.concatenate(Ks, axis=0) if len(dims) else np.zeros((0, 9)))
return out
def train(config):
utils.init_seeds(1)
results_file = os.path.join(config['logdir'], 'results.txt')
# Remove previous results
for f in glob.glob(os.path.join(
config['logdir'], 'train_batch*.jpg')) + glob.glob(results_file):
os.remove(f)
epochs = config['epochs'] # 300
batch_size = config['batch_size'] # 64
weights = config['weights'] # initial training weights
imgsz, imgsz_test = config['img_size']
strides = config['detect_strides']
num_classes = config['num_classes']
if config['only_3d']:
config['notest'] = True
config['include_scopes'] = ['model.24.bbox3d_headers']
config['giou'] = 0.
config['obj'] = 0.
config['cls'] = 0.
elif config['only_2d']:
config['exclude_scopes'] = ['model.24.bbox3d_headers']
config['conf'] = 0.
config['orient'] = 0.
config['dim'] = 0.
config[
'cls'] *= num_classes / 80. # scale coco-tuned config['cls'] to current dataset
gs = int(max(strides))
# dataset
with open(config['data']) as f:
data_dict = yaml.load(f, Loader=yaml.FullLoader) # model dict
dataset_path = data_dict['dataset_path']
# Trainloader
test_cfg = {}
test_cfg.update(config)
dataloader, dataset = create_dataloader(dataset_path,
config,
transform=TrainAugmentation(
cfg['img_size'][0],
mean=config['brg_mean']),
is_training=True)
mlc = np.concatenate(dataset.labels, 0)[:, 0].max() # max label class
assert mlc < num_classes, \
'Label class %g exceeds nc=%g in %s. Correct your labels or your model.' % (mlc, num_classes, config['cfg'])
# Testloader
test_cfg['is_rect'] = True
test_cfg['is_mosaic'] = False
testloader = create_dataloader(dataset_path,
test_cfg,
transform=TestTransform(
cfg['img_size'][0],
mean=config['brg_mean']),
is_training=False,
split='test')[0]
# Create model
model = Model(config).to(device)
nb = len(dataloader) # number of batches
max_step_burn_in = max(
3 * nb, 1e3) # burn-in iterations, max(3 epochs, 1k iterations)
solver = Solver(model,
config,
max_steps_burn_in=max_step_burn_in,
apex=None)
losser = losses.YoloLoss(model)
# Load Model
start_epoch, best_fitness = 0, 0.0
checkpointer = model_utils.CheckPointer(model,
solver,
save_dir='./weights',
save_to_disk=True,
device=device)
if weights.endswith('.pt'): # pytorch format
ckpt = checkpointer.load(weights,
use_latest=False,
load_solver=(not config['resume']))
# load results
if ckpt.get('training_results') is not None:
with open(results_file, 'w') as file:
file.write(ckpt['training_results']) # write results.txt
if not config['resume']:
start_epoch = ckpt['epoch'] + 1
best_fitness = ckpt['best_fitness']
del ckpt
else:
solver.build_optim_and_scheduler()
if tb_writer:
# Class frequency
labels = np.concatenate(dataset.labels, 0)
c = torch.tensor(labels[:, 0]) # classes
visual_utils.plot_labels(labels, config['logdir'])
tb_writer.add_histogram('classes', c, 0)
# Check anchors
if not config['noautoanchor']:
anchor_utils.check_anchors(dataset,
model=model,
thr=config['anchor_t'],
imgsz=imgsz)
# Start training
t0 = time.time()
results = (
0, 0, 0, 0, 0, 0, 0
) # 'P', 'R', 'mAP', 'F1', 'val GIoU', 'val Objectness', 'val Classification'
print('Image sizes %g train, %g test' % (imgsz, imgsz_test))
print('Using %g dataloader workers' % dataloader.num_workers)
print('Starting training for %g epochs...' % epochs)
for epoch in range(
start_epoch, epochs
): # epoch ------------------------------------------------------------------
model.train()
mloss = torch.zeros(7, device=device) # mean losses
print(('\n' + '%10s' * 12) %
('Epoch', 'gpu_mem', 'GIoU', 'obj', 'cls', 'conf', 'orient',
'dim', 'total', 'targets', 'img_size', 'lr'))
pbar = tqdm.tqdm(enumerate(dataloader), total=nb) # progress bar
for i, (
imgs, targets, paths, _
) in pbar: # batch -------------------------------------------------------------
targets.delete_by_mask()
targets.to_float32()
targ = ParamList(targets.size, True)
targ.copy_from(targets)
img_id = targets.get_field('img_id')
classes = targets.get_field('class')
bboxes = targets.get_field('bbox')
targets = torch.cat(
[img_id.unsqueeze(-1),
classes.unsqueeze(-1), bboxes], dim=-1)
ni = i + nb * epoch # number integrated batches (since train start)
imgs = imgs.to(
device).float() / 1.0 # uint8 to float32, 0 - 255 to 0.0 - 1.0
solver.update(epoch)
# Multi-scale
if config['multi_scale']:
sz = random.randrange(imgsz * 0.5,
imgsz * 1.5 + gs) // gs * gs # size
sf = sz / max(imgs.shape[2:]) # scale factor
if sf != 1:
ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]
] # new shape (stretched to gs-multiple)
imgs = F.interpolate(imgs,
size=ns,
mode='bilinear',
align_corners=False)
# Forward
pred = model(imgs)
# Loss
# loss, loss_items = losses.calc_loss(pred, targets.to(device), model)
loss, loss_items = losser(pred, targ)
# print(loss_items)
if not torch.isfinite(loss):
print('WARNING: non-finite loss, ending training ', loss_items)
return results
solver.optimizer_step(loss)
# Print
mloss = (mloss * i + loss_items) / (i + 1) # update mean losses
mem = '%.3gG' % (torch.cuda.memory_cached() /
1E9 if torch.cuda.is_available() else 0) # (GB)
s = ('%10s' * 2 + '%10.4g' * 10) % (
'%g/%g' % (epoch, epochs - 1), mem, *mloss, targets.shape[0],
imgs.shape[-1], solver.learn_rate)
pbar.set_description(s)
# Plot
if ni < 3:
f = os.path.join(config['logdir'],
'train_batch%g.jpg' % ni) # filename
result = visual_utils.plot_images(images=imgs,
targets=targets,
paths=paths,
fname=f)
if tb_writer and result is not None:
tb_writer.add_image(f,
result,
dataformats='HWC',
global_step=epoch)
# tb_writer.add_graph(model, imgs) # add model to tensorboard
# end batch ============================================================================================
solver.scheduler_step()
# mAP
solver.ema.update_attr(model)
final_epoch = epoch + 1 == epochs
if not config['notest'] or final_epoch: # Calculate mAP
results, maps, times = test.test(
config['data'],
batch_size=batch_size,
imgsz=imgsz_test,
save_json=final_epoch
and config['data'].endswith(os.sep + 'kitti.yaml'),
model=solver.ema.model,
logdir=config['logdir'],
dataloader=testloader)
# Write
with open(os.path.join(results_file), 'a') as f:
f.write(s + '%10.4g' * 7 % results +
'\n') # P, R, mAP, F1, test_losses=(GIoU, obj, cls)
# Tensorboard
if tb_writer:
tags = [
'train/giou_loss', 'train/obj_loss', 'train/cls_loss',
'metrics/precision', 'metrics/recall', 'metrics/mAP_0.5',
'metrics/F1', 'val/giou_loss', 'val/obj_loss', 'val/cls_loss'
]
for x, tag in zip(list(mloss[:-1]) + list(results), tags):
tb_writer.add_scalar(tag, x, epoch)
# Update best mAP
fi = utils.fitness(np.array(results).reshape(
1, -1)) # fitness_i = weighted combination of [P, R, mAP, F1]
if fi > best_fitness:
best_fitness = fi
# Save model
save = (not config['nosave']) or final_epoch
if save:
with open(results_file, 'r') as f: # create checkpoint
ckpt = {
'epoch': epoch,
'best_fitness': best_fitness,
'training_results': f.read()
}
# Save last, best and delete
checkpointer.save(last, **ckpt)
if (best_fitness == fi) and not final_epoch:
checkpointer.save(best, **ckpt)
del ckpt
# end epoch =================================================================================================
# end training
print('%g epochs completed in %.3f hours.\n' % (epoch - start_epoch + 1,
(time.time() - t0) / 3600))
torch.cuda.empty_cache()
return results
def test(
data,
weights=None,
batch_size=16,
imgsz=640,
conf_thres=0.001,
iou_thres=0.6, # for NMS
save_json=False,
verbose=False,
model=None,
dataloader=None,
logdir='./runs',
merge=False):
# Initialize/load model and set device
if model is None:
training = False
device = torch_utils.select_device(opt.device, batch_size=batch_size)
# Remove previous
for f in glob.glob(os.path.join(logdir, 'test_batch*.jpg')):
os.remove(f)
# Load model
model = torch.load(
weights, map_location=device)['model'].float() # load to FP32
torch_utils.model_info(model)
model.fuse()
model.to(device)
# Multi-GPU disabled, incompatible with .half() https://github.com/ultralytics/yolov5/issues/99
# if device.type != 'cpu' and torch.cuda.device_count() > 1:
# model = nn.DataParallel(model)
else: # called by train.py
training = True
device = next(model.parameters()).device # get model device
# Half
half = device.type != 'cpu' and torch.cuda.device_count(
) == 1 # half precision only supported on single-GPU
half = False
if half:
model.half() # to FP16
# Configure
model.eval()
with open(data) as f:
data = yaml.load(f, Loader=yaml.FullLoader) # model dict
nc = int(data['num_classes']) # number of classes
iouv = torch.linspace(0.5, 0.95,
10).to(device) # iou vector for [email protected]:0.95
niou = iouv.numel()
losser = YoloLoss(model)
# Dataloader
if dataloader is None: # not training
merge = opt.merge # use Merge NMS
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img
) if device.type != 'cpu' else None # run once
path = data['test'] if opt.task == 'test' else data[
'val'] # path to val/test images
dataloader = kitti.create_dataloader(path,
imgsz,
batch_size,
int(max(model.stride)),
config=None,
augment=False,
cache=False,
pad=0.5,
rect=True)[0]
seen = 0
names = data['names']
kitti8class = data_utils.kitti8_classes()
s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R',
'[email protected]', '[email protected]:.95')
p, r, f1, mp, mr, map50, map, t0, t1 = 0., 0., 0., 0., 0., 0., 0., 0., 0.
loss = torch.zeros(3, device=device)
jdict, stats, ap, ap_class = [], [], [], []
for batch_i, (img, targets, paths,
shapes) in enumerate(tqdm.tqdm(dataloader, desc=s)):
targets.delete_by_mask()
targets.to_float32()
targ = ParamList(targets.size, True)
targ.copy_from(targets)
img_id = targets.get_field('img_id')
classes = targets.get_field('class')
bboxes = targets.get_field('bbox')
targets = torch.cat(
[img_id.unsqueeze(-1),
classes.unsqueeze(-1), bboxes], dim=-1)
img = img.to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
# img /= 1.0 # 0 - 255 to 0.0 - 1.0
targets = targets.to(device)
nb, _, height, width = img.shape # batch size, channels, height, width
whwh = torch.Tensor([width, height, width, height]).to(device)
# Disable gradients
with torch.no_grad():
# Run model
t = torch_utils.time_synchronized()
inf_out, train_out = model(img) # inference and training outputs
t0 += torch_utils.time_synchronized() - t
# Compute loss
if training: # if model has loss hyperparameters
# loss += calc_loss([x.float() for x in train_out], targets, model)[1][:3] # GIoU, obj, cls
loss += losser([x.float() for x in train_out], targ)[1][:3]
# Run NMS
t = torch_utils.time_synchronized()
output = postprocess.apply_nms(inf_out,
nc,
conf_thres=conf_thres,
iou_thres=iou_thres,
merge=merge)
t1 += torch_utils.time_synchronized() - t
# Statistics per image
for si, pred in enumerate(output):
labels = targets[targets[:, 0] == si, 1:]
nl = len(labels)
tcls = labels[:, 0].tolist() if nl else [] # target class
seen += 1
if pred is None:
if nl:
stats.append((torch.zeros(0, niou, dtype=torch.bool),
torch.Tensor(), torch.Tensor(), tcls))
continue
# Append to text file
# with open('test.txt', 'a') as file:
# [file.write('%11.5g' * 7 % tuple(x) + '\n') for x in pred]
# Clip boxes to image bounds
utils.clip_coords(pred, (height, width))
# Append to pycocotools JSON dictionary
if save_json:
# [{"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}, ...
image_id = int(Path(paths[si]).stem.split('_')[-1])
box = pred[:, :4].clone() # xyxy
utils.scale_coords(img[si].shape[1:], box, shapes[si][0],
shapes[si][1]) # to original shape
box = data_utils.xyxy2xywh(box) # xywh
box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
for p, b in zip(pred.tolist(), box.tolist()):
jdict.append({
'image_id': image_id,
'category_id': kitti8class[int(p[5])],
'bbox': [round(x, 3) for x in b],
'score': round(p[4], 5)
})
# Assign all predictions as incorrect
correct = torch.zeros(pred.shape[0],
niou,
dtype=torch.bool,
device=device)
if nl:
detected = [] # target indices
tcls_tensor = labels[:, 0]
# target boxes
tbox = data_utils.xywh2xyxy(labels[:, 1:5]) * whwh
# Per target class
for cls in torch.unique(tcls_tensor):
ti = (cls == tcls_tensor).nonzero(as_tuple=False).view(
-1) # prediction indices
pi = (cls == pred[:, 5]).nonzero(as_tuple=False).view(
-1) # target indices
# Search for detections
if pi.shape[0]:
# Prediction to target ious
ious, i = metrics_utils.box_iou(
pred[pi, :4],
tbox[ti]).max(1) # best ious, indices
# Append detections
for j in (ious > iouv[0]).nonzero(as_tuple=False):
d = ti[i[j]] # detected target
if d not in detected:
detected.append(d)
correct[
pi[j]] = ious[j] > iouv # iou_thres is 1xn
if len(
detected
) == nl: # all targets already located in image
break
# Append statistics (correct, conf, pcls, tcls)
stats.append(
(correct.cpu(), pred[:, 4].cpu(), pred[:, 5].cpu(), tcls))
# Plot images
if batch_i < 1:
f = os.path.join(logdir,
'test_batch%g_gt.jpg' % batch_i) # filename
visual_utils.plot_images(img, targets, paths, f,
names) # ground truth
f = os.path.join(logdir, 'test_batch%g_pred.jpg' % batch_i)
visual_utils.plot_images(img,
utils.output_to_target(
output, width, height), paths, f,
names) # predictions
# Compute statistics
stats = [np.concatenate(x, 0) for x in zip(*stats)] # to numpy
if len(stats):
p, r, ap, f1, ap_class = metrics_utils.ap_per_class(*stats)
p, r, ap50, ap = p[:, 0], r[:, 0], ap[:, 0], ap.mean(
1) # [P, R, [email protected], [email protected]:0.95]
mp, mr, map50, map = p.mean(), r.mean(), ap50.mean(), ap.mean()
nt = np.bincount(stats[3].astype(np.int64),
minlength=nc) # number of targets per class
else:
nt = torch.zeros(1)
# Print results
pf = '%20s' + '%12.3g' * 6 # print format
print(pf % ('all', seen, nt.sum(), mp, mr, map50, map))
# Print results per class
if verbose and nc > 1 and len(stats):
for i, c in enumerate(ap_class):
print(pf % (names[c], seen, nt[c], p[i], r[i], ap50[i], ap[i]))
# Print speeds
t = tuple(x / seen * 1E3
for x in (t0, t1, t0 + t1)) + (imgsz, imgsz, batch_size) # tuple
if not training:
print(
'Speed: %.1f/%.1f/%.1f ms inference/NMS/total per %gx%g image at batch-size %g'
% t)
# Save JSON
if save_json and map50 and len(jdict):
imgIds = [
int(Path(x).stem.split('_')[-1])
for x in dataloader.dataset.img_files
]
f = 'detections_val2017_%s_results.json' % \
(weights.split(os.sep)[-1].replace('.pt', '') if weights else '') # filename
print('\nCOCO mAP with pycocotools... saving %s...' % f)
with open(f, 'w') as file:
json.dump(jdict, file)
try:
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval
# https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
cocoGt = COCO(
glob.glob('../coco/annotations/instances_val*.json')
[0]) # initialize COCO ground truth api
cocoDt = cocoGt.loadRes(f) # initialize COCO pred api
cocoEval = COCOeval(cocoGt, cocoDt, 'bbox')
cocoEval.params.imgIds = imgIds # image IDs to evaluate
cocoEval.evaluate()
cocoEval.accumulate()
cocoEval.summarize()
map, map50 = cocoEval.stats[:
2] # update results ([email protected]:0.95, [email protected])
except:
print(
'WARNING: pycocotools must be installed with numpy==1.17 to run correctly. '
'See https://github.com/cocodataset/cocoapi/issues/356')
# Return results
model.float() # for training
maps = np.zeros(nc) + map
for i, c in enumerate(ap_class):
maps[c] = ap[i]
return (mp, mr, map50, map,
*(loss.cpu() / len(dataloader)).tolist()), maps, t
def __getitem__(self, index):
indices = [index]
if self._is_mosaic and self.is_training:
indices += [random.randint(0, len(self._labels) - 1) for _ in range(3)] # 3 additional image indices
images = []
targets = []
transform = transforms.Compose([
transforms.ImageTo(np.float32),
transforms.Normalize(),
transforms.ToPercentCoords(),
transforms.ToXYWH(),
transforms.ToTensor(),
transforms.ToNCHW()
])
for i, idx in enumerate(indices):
img = self._load_image(idx)
K = self._K[idx]
# K = self._load_calib_param(idx)
N = len(self._labels[idx])
target = ParamList((img.shape[1], img.shape[0]))
target.add_field('img_id', np.zeros((N,), dtype=np.int))
target.add_field('class', self._labels[idx][:, 0].copy())
target.add_field('bbox', self._labels[idx][:, 1:5].copy())
target.add_field('dimension', self._labels[idx][:, 5:8].copy())
target.add_field('alpha', self._labels[idx][:, 8].copy())
target.add_field('Ry', self._labels[idx][:, 9].copy())
target.add_field('location', self._labels[idx][:, -3:].copy())
target.add_field('mask', np.ones((N,), dtype=np.int))
target.add_field('K', np.repeat(K.copy().reshape(1, 9), repeats=N, axis=0))
if self._augment is not None:
img, target = self._augment(img, targets=target, **self._config)
images.append(img)
targets.append(target)
if self._is_mosaic and self.is_training:
img, target = self._apply_mosaic(images, targets)
else:
img, target = self._apply_padding(images, targets)
# Convert
# img = img[:, :, ::-1]
img = np.ascontiguousarray(img)
img, target = transform(img, targets=target)
path = os.path.join(self._root, 'training', 'image_2/{}.png'.format(self._image_files[index]))
# print('K: ', target.get_field('K'))
# print('shape: ', self.__shapes[index])
# print('')
return img, target, path, self.__shapes[index]