def val(self, epoch):
predict_list = list()
target_list = list()
# self.model.eval()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for img_tensor, targets_tensor, _ in pbar:
_, _, h, w = img_tensor.shape
targets_tensor[:, 3:] = targets_tensor[:, 3:] * torch.tensor(
data=[w, h, w, h])
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts = self.ema.ema(img_tensor)
predicts = non_max_suppression(
predicts,
conf_thresh=self.val_cfg['conf_thresh'],
iou_thresh=self.val_cfg['iou_thresh'],
max_det=self.val_cfg['max_det'],
)
for i, predict in enumerate(predicts):
if predict is not None:
clip_coords(predict, (h, w))
predict_list.append(predict)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:,
2:]
target_list.append(targets_sample)
mp, mr, map50, map = coco_map(predict_list, target_list)
print(
"epoch: {:2d}|local:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1, self.local_rank, mp * 100, mr * 100,
map50 * 100, map * 100))
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_last.pth".format(self.cfg['model_name']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map.pth".format(self.cfg['model_name']))
best_map50_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map50.pth".format(self.cfg['model_name']))
# model_static = self.model.module.state_dict() if is_parallel(self.model) else self.model.state_dict()
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
"map50": map50 * 100
}
if self.local_rank != 0:
return
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
if map50 > self.best_map50:
torch.save(cpkt, best_map50_weight_path)
self.best_map50 = map50
def val(self, epoch):
self.ema.ema.eval()
predict_list = list()
target_list = list()
# self.model.eval()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for i, (img_tensor, targets_tensor, _) in enumerate(pbar):
_, _, h, w = img_tensor.shape
targets_tensor[:, 3:] = targets_tensor[:, 3:] * torch.tensor(
data=[w, h, w, h])
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts, _ = self.ema.ema(img_tensor, None)
for i, predict in enumerate(predicts):
predict_list.append(predict)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:,
2:]
target_list.append(targets_sample)
mp, mr, map50, map = coco_map(predict_list, target_list)
mp = reduce_sum(torch.tensor(mp,
device=self.device)).item() / self.gpu_num
mr = reduce_sum(torch.tensor(mr,
device=self.device)).item() / self.gpu_num
map50 = reduce_sum(torch.tensor(
map50, device=self.device)).item() / self.gpu_num
map = reduce_sum(torch.tensor(
map, device=self.device)).item() / self.gpu_num
if self.local_rank == 0:
print(
"epoch: {:2d}|gpu_num:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1, self.gpu_num, mp * 100, mr * 100,
map50 * 100, map * 100))
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_last.pth".format(self.cfg['model_name']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map.pth".format(self.cfg['model_name']))
best_map50_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map50.pth".format(self.cfg['model_name']))
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
"map50": map50 * 100
}
if self.local_rank != 0:
return
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
if map50 > self.best_map50:
torch.save(cpkt, best_map50_weight_path)
self.best_map50 = map50
def val(self, epoch):
self.model.eval()
self.ema.ema.eval()
predict_list = list()
target_list = list()
# self.model.eval()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for i, (input_tensor, _) in enumerate(pbar):
input_tensor.un_normalize_box()
input_tensor.to(self.device)
predicts, _ = self.model(input_tensor)
for i, predict in enumerate(predicts):
predict_list.append(predict)
boxes = input_tensor.boxes[i]
labels = input_tensor.labels[i]
target_list.append(
torch.cat([labels.float().unsqueeze(-1), boxes], dim=-1))
mp, mr, map50, map = coco_map(predict_list, target_list)
mp = reduce_sum(torch.tensor(mp,
device=self.device)).item() / self.gpu_num
mr = reduce_sum(torch.tensor(mr,
device=self.device)).item() / self.gpu_num
map50 = reduce_sum(torch.tensor(
map50, device=self.device)).item() / self.gpu_num
map = reduce_sum(torch.tensor(
map, device=self.device)).item() / self.gpu_num
if self.local_rank == 0:
print(
"epoch: {:2d}|gpu_num:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1, self.gpu_num, mp * 100, mr * 100,
map50 * 100, map * 100))
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_last.pth".format(self.cfg['model_name']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map.pth".format(self.cfg['model_name']))
best_map50_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map50.pth".format(self.cfg['model_name']))
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
"map50": map50 * 100,
"model": self.model.module.state_dict()
}
if self.local_rank != 0:
return
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
if map50 > self.best_map50:
torch.save(cpkt, best_map50_weight_path)
self.best_map50 = map50
def val(self, epoch):
self.model.eval()
self.ema.ema.eval()
predict_list = list()
target_list = list()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for img_tensor, targets_tensor in pbar:
_, _, h, w = img_tensor.shape
targets_tensor[:, 1:] = targets_tensor[:, 1:] * torch.tensor(data=[w, h, w, h])
targets_tensor[:, [1, 2]] = targets_tensor[:, [1, 2]] - targets_tensor[:, [3, 4]] * 0.5
targets_tensor[:, [3, 4]] = targets_tensor[:, [1, 2]] + targets_tensor[:, [3, 4]]
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts = self.ema.ema(img_tensor)['predicts']
for i, pred in enumerate(predicts):
if pred is not None:
pred = torch.cat([pred, torch.zeros_like(pred[..., [0]])], dim=-1)
predict_list.append(pred)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:, 1:]
targets_sample = torch.cat([torch.zeros_like(targets_sample[..., [0]]), targets_sample], dim=-1)
target_list.append(targets_sample)
mp, mr, map50, map = coco_map(predict_list, target_list)
mp = reduce_sum(torch.tensor(mp, device=self.device)).item() / self.gpu_num
mr = reduce_sum(torch.tensor(mr, device=self.device)).item() / self.gpu_num
map50 = reduce_sum(torch.tensor(map50, device=self.device)).item() / self.gpu_num
map = reduce_sum(torch.tensor(map, device=self.device)).item() / self.gpu_num
if self.local_rank == 0:
print("epoch: {:2d}|gpu_num:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1,
self.gpu_num,
mp * 100,
mr * 100,
map50 * 100,
map * 100))
last_weight_path = os.path.join(self.val_cfg['weight_path'],
"{:s}_{:s}_last.pth"
.format(self.cfg['model_name'], self.model_cfg['scale_name']))
best_map_weight_path = os.path.join(self.val_cfg['weight_path'],
"{:s}_{:s}_best_map.pth"
.format(self.cfg['model_name'], self.model_cfg['scale_name']))
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
}
if self.local_rank != 0:
return
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
def val(self, epoch):
predict_list = list()
target_list = list()
self.model.eval()
self.ema.ema.eval()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for img_tensor, valid_size, targets_tensor, mask_tensor, batch_len in pbar:
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts = self.ema.ema(img_tensor,
valid_size=valid_size)['predicts']
predicts = [p[0] for p in predicts]
for pred, target in zip(predicts, targets_tensor.split(batch_len)):
predict_list.append(pred)
target_list.append(target)
mp, mr, map50, mean_ap = coco_map(predict_list, target_list)
mp = reduce_sum(torch.tensor(mp, device=self.device)) / self.gpu_num
mr = reduce_sum(torch.tensor(mr, device=self.device)) / self.gpu_num
map50 = reduce_sum(torch.tensor(map50,
device=self.device)) / self.gpu_num
mean_ap = reduce_sum(torch.tensor(mean_ap,
device=self.device)) / self.gpu_num
if self.local_rank == 0:
print("*" * 20, "eval start", "*" * 20)
print(
"epoch: {:2d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}".
format(epoch + 1, mp * 100, mr * 100, map50 * 100,
mean_ap * 100))
print("*" * 20, "eval end", "*" * 20)
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_{:s}_last.pth".format(self.cfg['model_name'],
self.model_cfg['backbone']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_{:s}_best_map.pth".format(self.cfg['model_name'],
self.model_cfg['backbone']))
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": mean_ap * 100,
"epoch": epoch,
}
if self.local_rank != 0:
return
torch.save(cpkt, last_weight_path)
if mean_ap > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = mean_ap
def valid_model():
model = FCOS()
weights = torch.load("weights/0_focs_last.pth")['ema']
model.load_state_dict(weights)
model.cuda().eval()
predict_list = list()
target_list = list()
vdata = COCODataSets(
img_root="/home/huffman/data/val2017",
annotation_path="/home/huffman/data/annotations/instances_val2017.json",
use_crowd=False,
augments=False,
debug=False,
remove_blank=False,
img_size=640)
vloader = DataLoader(dataset=vdata,
batch_size=4,
num_workers=4,
collate_fn=vdata.collate_fn,
shuffle=False)
pbar = tqdm(vloader)
for img_tensor, targets_tensor, _ in pbar:
_, _, h, w = img_tensor.shape
targets_tensor[:, 3:] = targets_tensor[:, 3:] * torch.tensor(
data=[w, h, w, h])
img_tensor = img_tensor.cuda()
targets_tensor = targets_tensor.cuda()
predicts = model(img_tensor)
for i in range(len(predicts)):
predicts[i][:, [0, 2]] = predicts[i][:, [0, 2]].clamp(min=0, max=w)
predicts[i][:, [1, 3]] = predicts[i][:, [1, 3]].clamp(min=0, max=h)
predicts = non_max_suppression(predicts,
conf_thresh=0.05,
iou_thresh=0.6,
max_det=300)
for i, predict in enumerate(predicts):
predict_list.append(predict)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:, 2:]
target_list.append(targets_sample)
mp, mr, map50, map = coco_map(predict_list, target_list)
print(map50, map)
def val(self, epoch):
predict_list = list()
target_list = list()
self.model.eval()
if self.local_rank == 0:
pbar = tqdm(self.vloader)
else:
pbar = self.vloader
for img_tensor, targets_tensor, _ in pbar:
_, _, h, w = img_tensor.shape
targets_tensor[:, 3:] = targets_tensor[:, 3:] * torch.tensor(
data=[w, h, w, h])
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts = self.ema.ema(img_tensor)
for i in range(len(predicts)):
predicts[i][:, [0, 2]] = predicts[i][:, [0, 2]].clamp(min=0,
max=w)
predicts[i][:, [1, 3]] = predicts[i][:, [1, 3]].clamp(min=0,
max=h)
predicts = non_max_suppression(
predicts,
conf_thresh=self.val_cfg['conf_thresh'],
iou_thresh=self.val_cfg['iou_thresh'],
max_det=self.val_cfg['max_det'],
)
for i, predict in enumerate(predicts):
predict_list.append(predict)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:,
2:]
target_list.append(targets_sample)
mp, mr, map50, map = coco_map(predict_list, target_list)
print(
"epoch: {:2d}|local:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1, self.local_rank, mp * 100, mr * 100,
map50 * 100, map * 100))
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_last.pth".format(self.cfg['model_name']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map.pth".format(self.cfg['model_name']))
best_map50_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map50.pth".format(self.cfg['model_name']))
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
"map50": map50 * 100
}
if self.local_rank != 0:
return
if self.tb_writer:
tags = [
'metrics/precision', 'metrics/recall', 'metrics/mAP_0.5',
'metrics/mAP_0.5:0.95'
]
for x, tag in zip([mp, mr, map50, map], tags):
self.tb_writer.add_scalar(tag, x, epoch + 1)
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
if map50 > self.best_map50:
torch.save(cpkt, best_map50_weight_path)
self.best_map50 = map50
def val(self, epoch):
predict_list = list()
target_list = list()
# self.model.eval()
pbar = tqdm(self.vloader)
path_list, shape_list = [], []
for img_tensor, targets_tensor, imgIDs, shapes in pbar:
_, _, h, w = img_tensor.shape
targets_tensor[:, 3:] = targets_tensor[:, 3:] * torch.tensor(
data=[w, h, w, h])
img_tensor = img_tensor.to(self.device)
targets_tensor = targets_tensor.to(self.device)
predicts = self.ema.ema(img_tensor)
# predicts after nms is a list(len=bs), its element has shape=[N,6] 6==>(x1, y1, x2, y2, conf, cls)
predicts = non_max_suppression(
predicts,
conf_thresh=self.val_cfg['conf_thresh'],
iou_thresh=self.val_cfg['iou_thresh'],
max_det=self.val_cfg['max_det'])
for i, predict in enumerate(predicts):
if predict is not None:
clip_coords(predict, (h, w))
predict_list.append(predict)
targets_sample = targets_tensor[targets_tensor[:, 0] == i][:,
2:]
target_list.append(targets_sample)
path_list.append(imgIDs[i])
shape_list.append(shapes[i])
# after above code block, predict_list(len=len(dataset)), its element shape = [n,6] 6==>(x1,y1,x2,y2,score,cls_id)
# target_list(len=len(dataset)), its element shape = [m, 5] 5==>(cls_id,x1,y1,x2,y2)
mp, mr, map50, map, self.maps = coco_map(predict_list, target_list,
path_list, shape_list,
self.data_cfg['img_size'])
print(
"epoch: {:2d}|local:{:d}|mp:{:6.4f}|mr:{:6.4f}|map50:{:6.4f}|map:{:6.4f}"
.format(epoch + 1, 0, mp * 100, mr * 100, map50 * 100, map * 100))
last_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_last.pth".format(self.cfg['model_name']))
best_map_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map.pth".format(self.cfg['model_name']))
best_map50_weight_path = os.path.join(
self.val_cfg['weight_path'],
"{:s}_best_map50.pth".format(self.cfg['model_name']))
# model_static = self.model.module.state_dict() if is_parallel(self.model) else self.model.state_dict()
ema_static = self.ema.ema.state_dict()
cpkt = {
"ema": ema_static,
"map": map * 100,
"epoch": epoch,
"map50": map50 * 100
}
torch.save(cpkt, last_weight_path)
if map > self.best_map:
torch.save(cpkt, best_map_weight_path)
self.best_map = map
if map50 > self.best_map50:
torch.save(cpkt, best_map50_weight_path)
self.best_map50 = map50
