def detect(cfgfile, weightfile, imgfile):
m = Darknet(cfgfile)
m.print_network()
m.load_weights(weightfile)
print('Loading weights from %s... Done!' % (weightfile))
# if m.num_classes == 20:
# namesfile = 'data/voc.names'
# elif m.num_classes == 80:
# namesfile = 'data/coco.names'
# else:
# namesfile = 'data/names'
use_cuda = torch.cuda.is_available()
if use_cuda:
m.cuda()
img = Image.open(imgfile).convert('RGB')
sized = letterbox_image(img, m.width, m.height)
start = time.time()
boxes = do_detect(m, sized, 0.5, 0.1, use_cuda)
correct_yolo_boxes(boxes, img.width, img.height, m.width, m.height)
finish = time.time()
print('%s: Predicted in %f seconds.' % (imgfile, (finish - start)))
class_names = load_class_names(namesfile)
plot_boxes(img, boxes, 'predictions.jpg', class_names)
def test():
def truths_length(truths):
for i in range(50):
if truths[i][1] == 0:
return i
return 50
model.eval()
num_classes = model.num_classes
total = 0.0
proposals = 0.0
correct = 0.0
device = torch.device("cuda" if use_cuda else "cpu")
if model.net_name() == 'region': # region_layer
shape = (0, 0)
else:
shape = (model.width, model.height)
for data, target, org_w, org_h in test_loader:
print("======")
data = data.to(device)
output = model(data)
all_boxes = get_all_boxes(output,
shape,
conf_thresh,
num_classes,
use_cuda=use_cuda)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width,
model.height)
boxes = np.array(nms(boxes, nms_thresh))
truths = target[k].view(-1, 5)
num_gts = truths_length(truths)
total = total + num_gts
num_pred = len(boxes)
if num_pred == 0:
continue
proposals += int((boxes[:, 4] > conf_thresh).sum())
for i in range(num_gts):
gt_boxes = torch.FloatTensor([
truths[i][1], truths[i][2], truths[i][3], truths[i][4],
1.0, 1.0, truths[i][0]
])
gt_boxes = gt_boxes.repeat(num_pred, 1).t()
pred_boxes = torch.FloatTensor(boxes).t()
best_iou, best_j = torch.max(
multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0)
# pred_boxes and gt_boxes are transposed for torch.max
if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[
6][0]:
correct += 1
precision = 1.0 * correct / (proposals + eps)
recall = 1.0 * correct / (total + eps)
fscore = 2.0 * precision * recall / (precision + recall + eps)
logging("correct: %d, precision: %f, recall: %f, fscore: %f" %
(correct, precision, recall, fscore))
def inference(model, test_loader, **kwargs):
beta = kwargs['beta']
#device = kwargs['device']
beta_s = beta * beta
model = model.to(device)
model.eval()
total = 0.0
proposals = 0.0
correct = 0.0
for batch_idx, (data, target, org_w, org_h) in enumerate(test_loader):
data = data.to(device)
output = model(data)
all_boxes = get_all_boxes(output,
shape,
conf_thresh,
80,
use_cuda=use_cuda)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[k], org_h[k], 416, 416)
boxes = np.array(nms(boxes, nms_thresh))
num_pred = len(boxes)
if num_pred == 0:
continue
truths = target[k].view(-1, 5)
num_gts = truths_length(truths)
total = total + num_gts
pred_boxes = torch.FloatTensor(boxes).t()
proposals += int((boxes[:, 4] > conf_thresh).sum())
for i in range(num_gts):
gt_boxes = torch.FloatTensor([
truths[i][1], truths[i][2], truths[i][3], truths[i][4],
1.0, 1.0, truths[i][0]
])
gt_boxes = gt_boxes.repeat(num_pred, 1).t()
best_iou, best_j = torch.max(
multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0)
if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[
6][0]:
correct += 1
#prec_i = 1.0*correct/(proposals+eps)
#reca_i = 1.0*correct/(total+eps)
#fsco_i = (1.0+beta_s)*prec_i*reca_i/(beta_s*prec_i+reca_i+eps)
#print('%03d-th test, correct: %03d, precision: %f, recall: %f, fscore: %f' % (batch_idx, correct, prec_i, reca_i, fsco_i))
precision = 1.0 * correct / (proposals + eps)
recall = 1.0 * correct / (total + eps)
fscore = (1.0 + beta_s) * precision * recall / (beta_s * precision +
recall + eps)
print("Final correct: %03d, precision: %f, recall: %f, fscore: %f" %
(correct, precision, recall, fscore))
return fscore
def detect(m, img, img_name, use_cuda):
sized = letterbox_image(img, m.width, m.height)
start = time.time()
boxes = do_detect(m, sized, 0.5, 0.4, use_cuda)
correct_yolo_boxes(boxes, img.width, img.height, m.width, m.height)
finish = time.time()
print('%s: Predicted in %f seconds.' % (img_name, (finish - start)))
return boxes
def camera_detect(cfgfile, weightfile):
"""
- camera detect
:cfgfile use tiny config file
:weightfile use tiny weight file
"""
model = DarkNet(cfgfile)
model.print_net()
model.load_weights(weightfile)
print('load weights done!')
num_classes = 80
if num_classes == 20:
namesfile = '../data/voc.names'
elif num_classes == 80:
namesfile = '../data/coco.names'
else:
namesfile = '../data/names'
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Unable to open camera")
exit(-1)
while True:
res, img = cap.read()
if res:
img = Image.fromarray(img, mode='RGB') # numpy.array -> PIL.Image
sized = letterbox_image(img, model.width, model.height)
boxes = do_detect(model, sized, 0.5, 0.4, False)
correct_yolo_boxes(boxes, img.width, img.height, model.width,
model.height)
class_names = load_class_names(namesfile)
image_draw = plot_boxes(img, boxes, None, class_names)
np_img = np.asarray(image_draw) # PIL.Image -> numpy.array
cv2.imshow(cfgfile, np_img)
cv2.waitKey(1)
else:
print("Unable to read image")
exit(-1)
def inference(model, test_loader,**kwargs):
assert kwargs['device'] != None, 'Device error'
device = kwargs['device']
print(device)
model.to(device)
for w in FLAGS.weights:
model.load_weights(w)
logging('evaluating ... %s' % (w))
def truths_length(truths):
for i in range(50):
if truths[i][1] == 0:
return i
return 50
model.eval()
num_classes = model.num_classes
total = 0.0
proposals = 0.0
correct = 0.0
if model.net_name() == 'region': # region_layer
shape=(0,0)
else:
shape=(model.width, model.height)
print(len(test_loader))
'''
for data, target, org_w, org_h in test_loader:
data = data.to(device)
output = model(data)
all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=False if device == "cpu" else True)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width, model.height)
boxes = np.array(nms(boxes, nms_thresh))
truths = target[k].view(-1, 5)
num_gts = truths_length(truths)
total = total + num_gts
num_pred = len(boxes)
if num_pred == 0:
continue
proposals += int((boxes[:,4]>conf_thresh).sum())
for i in range(num_gts):
gt_boxes = torch.FloatTensor([truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0]])
gt_boxes = gt_boxes.repeat(num_pred,1).t()
pred_boxes = torch.FloatTensor(boxes).t()
best_iou, best_j = torch.max(multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False),0)
# pred_boxes and gt_boxes are transposed for torch.max
if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[6][0]:
correct += 1
#print('fps: ', len(data)/(time.time()-t0))
'''
for idx in range(len(test_loader)):
data[idx] = data[idx].to(device)
output = model(data[idx])
all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=False if device == "cpu" else True)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[idx][k], org_h[idx][k], model.width, model.height)
boxes = np.array(nms(boxes, nms_thresh))
truths = target[idx][k].view(-1, 5)
num_gts = truths_length(truths)
total = total + num_gts
num_pred = len(boxes)
if num_pred == 0:
continue
proposals += int((boxes[:,4]>conf_thresh).sum())
for i in range(num_gts):
gt_boxes = torch.FloatTensor([truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0]])
gt_boxes = gt_boxes.repeat(num_pred,1).t()
pred_boxes = torch.FloatTensor(boxes).t()
best_iou, best_j = torch.max(multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False),0)
# pred_boxes and gt_boxes are transposed for torch.max
if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[6][0]:
correct += 1
precision = 1.0*correct/(proposals+eps)
recall = 1.0*correct/(total+eps)
fscore = 2.0*precision*recall/(precision+recall+eps)
#logging("correct: %d, precision: %f, recall: %f, fscore: %f" % (correct, precision, recall, fscore))
return fscore
def PR_Valid(epoch, valid_sampler):
'''
This function is the same with precision and recall function, but validate on the valid set (not on test set).
:param epoch:
:param valid_sampler:
:return:
'''
def truths_length(truths):
for i in range(50):
if truths[i][1] == 0:
return i
return 50
model.eval()
cur_model = curmodel()
valid_batchsize = 1
kwargs = {
'num_workers': num_workers,
'pin_memory': True
} if use_cuda else {}
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=valid_batchsize,
sampler=valid_sampler,
**kwargs)
num_classes = cur_model.num_classes
total = 0.0
proposals = 0.0
correct = 0.0
if cur_model.net_name() == 'region': # region_layer
shape = (0, 0)
else:
shape = (cur_model.width, cur_model.height)
with torch.no_grad():
for data, target, org_w, org_h in tqdm.tqdm(valid_loader):
data = data.to(device)
if condition:
output, cls_output = model(data)
else:
output = model(data)
all_boxes = get_all_boxes(output,
shape,
conf_thresh,
num_classes,
use_cuda=use_cuda)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[k], org_h[k], cur_model.width,
cur_model.height)
boxes = np.array(nms(boxes, nms_thresh))
truths = target[k].view(-1, 5)
num_gts = truths_length(truths)
total = total + num_gts
num_pred = len(boxes)
if num_pred == 0:
continue
proposals += int((boxes[:, 4] > conf_thresh).sum())
for i in range(num_gts):
gt_boxes = torch.FloatTensor([
truths[i][1], truths[i][2], truths[i][3], truths[i][4],
1.0, 1.0, truths[i][0]
])
gt_boxes = gt_boxes.repeat(num_pred, 1).t()
pred_boxes = torch.FloatTensor(boxes).t()
best_iou, best_j = torch.max(
multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False),
0)
# pred_boxes and gt_boxes are transposed for torch.max
if best_iou > iou_thresh and pred_boxes[6][
best_j] == gt_boxes[6][0]:
correct += 1
precision = 1.0 * correct / (proposals + eps)
recall = 1.0 * correct / (total + eps)
fscore = 2.0 * precision * recall / (precision + recall + eps)
# savelog("[%03d] vfscore: %.4f vpre: %.4f vrec: %.4f \n" % (epoch, fscore, precision, recall))
# with open(logfile,"a+") as myfile:
# myfile.writelines("vfscore: %.4f vpre: %.4f vrec: %.4f \n"%(fscore,precision,recall))
return fscore, precision, recall
from utils import *
from image import letterbox_image, correct_yolo_boxes
from darknet import Darknet
globals()["namesfile"] = "coco.names"
def detect(m, cfgfile, weightfile, imgfile, destfile):
m = Darknet(cfgfile)
m.print_network()
m.load_weights(weightfile)
print('Loading weights from %s... Done!' % (weightfile))
use_cuda = torch.cuda.is_available()
if use_cuda:
m.cuda()
img = Image.open(imgfile).convert('RGB')
sized = letterbox_image(img, m.width, m.height)
start = time.time()
boxes = do_detect(m, sized, 0.5, 0.4, use_cuda)
correct_yolo_boxes(boxes, img.width, img.height, m.width, m.height)
finish = time.time()
print('%s: Predicted in %f seconds.' % (imgfile, (finish-start)))
class_names = load_class_names(namesfile)
plot_boxes(img, boxes, destfile, class_names)
def valid(datacfg, cfgfile, weightfile, outfile):
options = read_data_cfg(datacfg)
valid_images = options['valid']
name_list = options['names']
prefix = 'results'
names = load_class_names(name_list)
with open(valid_images) as fp:
tmp_files = fp.readlines()
valid_files = [item.rstrip() for item in tmp_files]
m = Darknet(cfgfile)
m.print_network()
m.load_weights(weightfile)
m.cuda()
m.eval()
valid_dataset = dataset.listDataset(valid_images,
shape=(m.width, m.height),
shuffle=False,
transform=transforms.Compose([
transforms.ToTensor(),
]))
valid_batchsize = 2
assert (valid_batchsize > 1)
kwargs = {'num_workers': 4, 'pin_memory': True}
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=valid_batchsize,
shuffle=False,
**kwargs)
fps = [0] * m.num_classes
if not os.path.exists('results'):
os.mkdir('results')
for i in range(m.num_classes):
buf = '%s/%s%s.txt' % (prefix, outfile, names[i])
fps[i] = open(buf, 'w')
lineId = -1
conf_thresh = 0.005
nms_thresh = 0.45
if m.net_name() == 'region': # region_layer
shape = (0, 0)
else:
shape = (m.width, m.height)
for _, (data, target, org_w, org_h) in enumerate(valid_loader):
data = data.cuda()
output = m(data)
batch_boxes = get_all_boxes(output,
shape,
conf_thresh,
m.num_classes,
only_objectness=0,
validation=True)
for i in range(len(batch_boxes)):
lineId += 1
fileId = os.path.basename(valid_files[lineId]).split('.')[0]
#width, height = get_image_size(valid_files[lineId])
width, height = float(org_w[i]), float(org_h[i])
print(valid_files[lineId])
boxes = batch_boxes[i]
correct_yolo_boxes(boxes, width, height, m.width, m.height)
boxes = nms(boxes, nms_thresh)
for box in boxes:
x1 = (box[0] - box[2] / 2.0) * width
y1 = (box[1] - box[3] / 2.0) * height
x2 = (box[0] + box[2] / 2.0) * width
y2 = (box[1] + box[3] / 2.0) * height
det_conf = box[4]
for j in range((len(box) - 5) // 2):
cls_conf = box[5 + 2 * j]
cls_id = int(box[6 + 2 * j])
prob = det_conf * cls_conf
fps[cls_id].write('%s %f %f %f %f %f\n' %
(fileId, prob, x1, y1, x2, y2))
for i in range(m.num_classes):
fps[i].close()
def test():
def truths_length(truths):
for i in range(50):
if truths[i][1] == 0:
return i
return 50
conf_thresh = FLAGS.FB_thresh
print("Conf_thresh%.2f" % conf_thresh)
model.eval()
num_classes = model.num_classes
total = 0.0
proposals = 0.0
correct = 0.0
total_c = np.zeros((num_classes))
proposals_c = np.zeros((num_classes))
correct_c = np.zeros((num_classes))
device = torch.device("cuda" if use_cuda else "cpu")
count_iter = 0.0
if model.net_name() == 'region': # region_layer
shape = (0, 0)
else:
shape = (model.width, model.height)
for data, target, org_w, org_h in test_loader:
data = data.to(device)
output = model(data)
all_boxes = get_all_boxes(output,
shape,
conf_thresh,
num_classes,
use_cuda=use_cuda)
for k in range(len(all_boxes)):
boxes = all_boxes[k]
correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width,
model.height)
boxes = np.array(nms(boxes, nms_thresh))
truths = target[k].view(-1, 5)
num_gts = truths_length(truths)
total_c[range(num_classes)] += np.histogram(
truths[:, 0], range(num_classes + 1))[0]
total = total + num_gts
num_pred = len(boxes)
if num_pred == 0:
continue
Fg_mask = boxes[:, 4] > conf_thresh
proposals += int(Fg_mask.sum())
[numberofdata, _] = np.histogram(boxes[Fg_mask, 6],
range(num_classes + 1))
proposals_c[range(num_classes)] += numberofdata
for i in range(num_gts):
gt_boxes = torch.FloatTensor([
truths[i][1], truths[i][2], truths[i][3], truths[i][4],
1.0, 1.0, truths[i][0]
])
gt_boxes = gt_boxes.repeat(num_pred, 1).t()
pred_boxes = torch.FloatTensor(boxes).t()
best_iou, best_j = torch.max(
multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0)
# pred_boxes and gt_boxes are transposed for torch.max
if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[
6][0]:
correct += 1
correct_c[int(gt_boxes[6][0])] += 1
precision = 1.0 * correct / (proposals + eps)
recall = 1.0 * correct / (total + eps)
fscore = 2.0 * precision * recall / (precision + recall + eps)
logging("Total correct: %d, precision: %f, recall: %f, fscore: %f" %
(correct, precision, recall, fscore))
print("%d", len(namelist))
print("%d,%d,%d" % (len(correct_c), len(total_c), len(proposals_c)))
for i in range(num_classes):
precision = 1.0 * correct_c[i] / (proposals_c[i] + eps)
recall = 1.0 * correct_c[i] / (total_c[i] + eps)
fscore = 2.0 * precision * recall / (precision + recall + eps)
logging("%s\t correct: %d, precision: %f, recall: %f, fscore: %f" %
(namelist[i], correct_c[i], precision, recall, fscore))
