def evaluate(model, device, opt=None):
if opt == None:
class opt:
anno_json = '/workspace/GitHub/YOLO/coco_forTest/annotations/instances_val2017_64.json'
pred_json = './YOLOv4_training_pred.json'
img_path = '/workspace/GitHub/YOLO/coco_forTest/images/val2017_64/'
img_size = 416
batch_size = 4
conf_thresh = 0.001
nms_thresh = 0.6
use_cuda = 1
model.to(device)
# Data Loader
anno = COCO(opt.anno_json)
val_set = COCOImage(opt.anno_json, opt.img_path, opt.img_size)
val_loader = DataLoader(val_set,
opt.batch_size,
shuffle=True,
num_workers=0)
# Accumulate results
result_dict = dict([])
print('STRAT detection')
for imgs, img_ids, sizes in tqdm(val_loader):
# model
boxes = do_detect(model,
imgs,
conf_thresh=opt.conf_thresh,
nms_thresh=opt.nms_thresh,
use_cuda=opt.use_cuda,
verbose=False)
# process
for img_id, box, H, W in zip(img_ids.numpy(), boxes, sizes[0].numpy(),
sizes[1].numpy()):
result_dict[img_id] = (img_id, box, H, W)
# Transform results to COCO format
print('Convert results to COCO format')
total = []
for img_id in tqdm(result_dict.keys()):
one_result = coco_format(result_dict[img_id])
total.extend(one_result)
with open(opt.pred_json, 'w') as f:
json.dump(total, f)
# COCO Evaluation
from pycocotools.cocoeval import COCOeval
pred = anno.loadRes(opt.pred_json) # init predictions api
eval = COCOeval(anno, pred, 'bbox')
eval.evaluate()
eval.accumulate()
eval.summarize()
return eval
def demo(model, config, anchors):
if torch.cuda.is_available():
model.cuda()
class_names = load_class_names(config.namesfile)
fh = open(config.val_label)
print("load val_label: {}".format(config.val_label))
i = 0
image_paths = get_first_10_imgs(config)
print("Got images: ")
print(image_paths)
for i, image_path in enumerate(image_paths):
img = cv2.imread(image_path)
sized = cv2.resize(img, (config.width, config.height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
start = time.time()
boxes = do_detect(model, sized, 0.4, 0.6, torch.cuda.is_available())
finish = time.time()
print('{}: Predicted in {:.04f} seconds.'.format(
image_path, (finish - start)))
plot_boxes_cv2(img,
boxes[0],
savename=os.path.join("demo_img",
"predictions_{}.jpg".format(i)),
class_names=class_names)
def test_model_time(opts, model, frame_size, annotations):
output_file = open('profile_latency_{}.txt'.format(frame_size), 'w')
print("{:<20s},{:<20s},{:<20s}".format(
"ModelSize", "Batch", "InferenceTime"), file=output_file)
images = annotations["images"]
img_idx = 0
total_images = len(images)
for batch in range(1, opts.max_batch_size+1, 1):
print("Processing batch size", batch)
for _ in range(opts.total_iter):
jpg_files = read_image_in_jpg(
opts, frame_size, img_idx, batch, total_images, images)
# input = np.random.rand(batch, frame_size, frame_size, 3)
torch.cuda.synchronize(opts.gpu_id)
start_time = timeit.default_timer()
start_perf = time.perf_counter()
input = read_jpg_in_numpy(jpg_files, frame_size) # dtype is uint8
assert input.shape[0] == batch and input.shape[1] == frame_size \
and input.shape[2] == frame_size and input.shape[3] == 3
with torch.no_grad():
output = do_detect(model, input, 0.5, 0.4,
use_cuda=(not opts.no_cuda), gpu_number=opts.gpu_id)
torch.cuda.synchronize(opts.gpu_id)
inference_time = (timeit.default_timer() - start_time) * 1000
perf_time = (time.perf_counter() - start_perf) * 1000
print("Processing batch size:", batch, inference_time, perf_time)
print("{:<20d},{:<20d},{:<20.2f}".format(
frame_size, batch, inference_time), file=output_file)
# ms = torch.cuda.memory_summary(device=None, abbreviated=False)
# stats = torch.cuda.memory_stats(device=None)
# print(ms)
# torch.cuda.empty_cache()
output_file.close()
def main():
import sys
import cv2
namesfile = None
if len(sys.argv) == 6:
n_classes = int(sys.argv[1])
weightfile = sys.argv[2]
imgfile = sys.argv[3]
height = int(sys.argv[4])
width = int(sys.argv[5])
elif len(sys.argv) == 7:
n_classes = int(sys.argv[1])
weightfile = sys.argv[2]
imgfile = sys.argv[3]
height = sys.argv[4]
width = int(sys.argv[5])
namesfile = int(sys.argv[6])
else:
print('Usage: ')
print(' python models.py num_classes weightfile imgfile namefile')
model = Yolov4(yolov4conv137weight=None, n_classes=n_classes, inference=True)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.4, 0.6, use_cuda)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
elif n_classes == 1:
namesfile = 'data/smoke.names'
else:
print("please give namefile")
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
def __call__(self, img):
width, height = 416, 416
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
boxes = do_detect(self.model, sized, 0.4, 0.6, self.use_cuda)
return boxes[0]
def get_predictions_yolov4(imgfile):
namesfile = None
n_classes = 80
weightfile = 'yolov4.pth'
height = 608
width = 608
model = Yolov4(yolov4conv137weight=None,
n_classes=n_classes,
inference=True)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
W = img.shape[1]
H = img.shape[0]
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
preds = do_detect(model, sized, 0.4, 0.6, use_cuda)
print(preds)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
else:
print("please give namefile")
class_names = load_class_names(namesfile)
boxes = []
classes = []
scores = []
for r in preds[0]:
box = r[0:4]
x1 = int((box[0] - box[2] / 2.0) * W)
y1 = int((box[1] - box[3] / 2.0) * H)
x2 = int((box[0] + box[2] / 2.0) * W)
y2 = int((box[1] + box[3] / 2.0) * H)
score = r[5]
c = class_names[r[6]]
boxes.append((x1, y1, x2, y2))
classes.append(c)
scores.append(score)
return boxes, classes, scores
def detect(self,
cv_image,
IS_BGR=True): # cv_imaeg <- cv2.imread / numpy image(BGR)
resized_image = cv2.resize(cv_image, (416, 416))
if IS_BGR:
resized_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB)
boxes = do_detect(self.model, resized_image, 0.4, 0.6, self.use_cuda)
return boxes
def predict(self, image, session_id):
''' predicts objects on image and return an image with bounding box on it '''
out_path = f'./out/{session_id}.jpg'
t1 = time.time()
image_resized_arr = self.preprocess(image)
boxes = do_detect(self.model, image_resized_arr, 0.4, 0.6,
self.use_cuda)
plot_boxes_cv2(image_resized_arr, boxes[0], out_path, self.class_names)
t2 = time.time()
print("----------")
print(f"total latency: {str((t2-t1)*1000)} ms")
print("----------")
return out_path
def object_detection(self, frame, ret):
if ret == False:
print(ret)
return 'no_frame'
else:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
sized = cv2.resize(frame, (512, 512))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
#### Start detection using do_detect() function
# start = time.time()
######### output must be boxes[0], which contains tbrl, confidence level, and class number
boxes = do_detect(self.m, sized, 0.4, 0.6, True)
# print(type(boxes), len(boxes[0]), ': number of detected cars', boxes[0])
# finish = time.time()
# print('yolo elapsed in: %f sec' % (finish - start))
return boxes[0]
def detect(img):
namesfile = 'data/coco.names'
n_classes = 80
weightfile = './yolov4.pth'
imgfile = img
height = 512
width = 512
model = Yolov4(yolov4conv137weight=None, n_classes=n_classes, inference=True)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.4, 0.6, use_cuda) # 输出框位置和名字
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
return boxes[0]
def detect_and_draw(model, image_path, conf_thresh=0.5, show=False, **kwargs):
"""
"""
model.eval()
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
resized = cv2.resize(image, (Cfg.width, Cfg.height))
detected_boxes = do_detect(model, resized, conf_thresh, 0.5, False)[0]
detected_acne_num = len(detected_boxes)
img_with_boxes, detected_boxes, detected_scores = plot_boxes_cv2(
image, detected_boxes)
detected_severity = to_severity(detected_acne_num)
if show:
title = kwargs.get("title", None)
fig, (ax1, ax2) = plt.subplots(1,
2,
figsize=kwargs.get("figsize", (30, 18)))
ax1.imshow(img_with_boxes)
ax2.imshow(image)
if title:
ax1.set_title(title + f'\ndetected number {detected_acne_num}',
y=-0.1,
fontsize=20)
ax1.axis("off")
ax2.set_title('original image', y=-0.1, fontsize=20)
ax2.axis("off")
if kwargs.get("savefig", False):
fmt = kwargs.get("fmt", "png")
plt.savefig(f"./fig/{title or str(int(time.time()))}.{fmt}",
bbox_inches='tight',
transparent=True)
plt.show()
return detected_acne_num, detected_boxes, detected_scores, detected_severity
width, height = (darknet_model.width, darknet_model.height)
darknet_model.load_weights(weightfile)
if use_cuda:
darknet_model.cuda()
class_names = load_class_names(namesfile)
t1 = time.time()
total_time = round(t1 - t0, 2)
print("1 - Initiated DepthModel. -- {} minutes {} seconds".format(
total_time // 60, total_time % 60))
print("====================================")
print("====================================")
print("====================================")
# Inference
img = cv2.imread(imgfile)
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
start = time.time()
boxes = do_detect(darknet_model, sized, 0.4, 0.6, use_cuda)
finish = time.time()
print('%s: Predicted in %f seconds.' % (imgfile, (finish - start)))
print(boxes)
plot_boxes_cv2(img,
boxes[0],
savename='demo_yolo.jpg',
class_names=class_names)
print("====================================")
print("====================================")
print("====================================")
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
conf_thresh = 0.01
nms_thresh = 0.01
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model,
sized,
conf_thresh,
nms_thresh,
use_cuda,
device=device)
img_box = []
scores = []
labels = []
width = img.shape[1]
height = img.shape[0]
for i in range(len(boxes)):
# (y1, x1, y2, x2). (top,left,right,bottom)
box = boxes[0][i]
x1 = box[0] * width
y1 = box[1] * height
x2 = box[2] * width
y2 = box[3] * height
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.4, 0.6, use_cuda)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
else:
print("please give namefile")
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
print(' python models.py num_classes weightfile imgfile namefile')
model = Yolov4(n_classes=n_classes)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cpu'))
model.load_state_dict(pretrained_dict)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
else:
print("please give namefile")
use_cuda = 0
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
sized = cv2.resize(img, (608, 608))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
boxes = do_detect(model, sized, 0.5, n_classes, 0.4, use_cuda)
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes, 'predictions.jpg', class_names)
def main():
n_classes = 18
weightfile = r'D:\DeepBlueProjects\chem-lab\pytorch-YOLOv4-master\checkpoints\Yolov4_epoch6.pth'
imgfile = r'D:\Data\CMS01_single-end\val\JPEGImages\frontfront_0518.jpg'
base_dir = r'D:\Data\chem-yolov4\eval-dataset\top'
gt_path = os.path.join(base_dir, 'gt.json')
name_id_path = os.path.join(base_dir, 'name_id.json')
with open(gt_path, 'r') as f:
gt_dict = json.load(f)
with open(name_id_path, 'r') as f:
name_id_dict = json.load(f)
input_size = (960, 960)
model = Yolov4(yolov4conv137weight=None,
n_classes=n_classes,
inference=True)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cuda'))
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in pretrained_dict.items():
name = k[7:] # remove `module.`，表面从第7个key值字符取到最后一个字符，正好去掉了module.
new_state_dict[name] = v # 新字典的key值对应的value为一一对应的值。
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
data_txt = os.path.join(base_dir, 'data.txt')
save_dir = os.path.join(base_dir, 'JPEGImages_pred')
result_dir = os.path.join(base_dir, 'result_txt')
with open(data_txt, 'r') as f:
imgfiles = f.readlines()
box_list = []
for imgfile in imgfiles:
img = cv2.imread(imgfile.strip('\n'))
img_h, img_w, _ = img.shape
img_name = imgfile.split('\\')[-1].strip('\n')
img_id = name_id_dict[img_name]
result_txt = os.path.join(result_dir, img_name[:-4] + '.txt')
result_f = open(result_txt, 'w')
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (input_size[1], input_size[0]))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
# for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.01, 0.3, use_cuda)
for box in boxes[0]:
x1 = int((box[0] - box[2] / 2.0) * img_w)
y1 = int((box[1] - box[3] / 2.0) * img_h)
x2 = int((box[0] + box[2] / 2.0) * img_w)
y2 = int((box[1] + box[3] / 2.0) * img_h)
w = x2 - x1
h = y2 - y1
if len(box) >= 7:
cls_conf = box[5]
cls_id = box[6]
box_list.append({
"image_id": img_id,
"category_id": int(cls_id),
"bbox": [x1, y1, w, h],
"score": float(cls_conf)
})
string = ','.join([
str(cls_id),
str(x1),
str(y1),
str(x2),
str(y2),
str(cls_conf)
]) + '\n'
result_f.write(string)
if cls_conf > 0.3:
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)),
(255, 0, 255), 1)
cv2.putText(img, str(cls_id), (int(x1 + 10), int(y1 + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 255),
1)
cv2.putText(img, str(round(cls_conf, 3)),
(int(x1 + 30), int(y1 + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (20, 240, 0), 1)
else:
print('????')
result_f.close()
namesfile = 'data/chem.names'
class_names = load_class_names(namesfile)
save_name = os.path.join(save_dir, img_name)
plot_boxes_cv2(img, boxes[0], save_name, class_names)
# cv2.imshow('result', img)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
info, map_iou0_5 = get_coco_mAP(gt_dict, box_list)
# print("---base_eval---epoch%d"%real_epoch)
print(info)
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes, period = do_detect(model, sized, 0.4, 0.6, use_cuda)
# print(len(boxes))
# print(boxes)
# print(len(box))
# print(box)
box = boxes[0]
pred_fname = 'predictions/mAp512_30/' + imgfile[imgfile.rfind('\\') +
1:]
output_fname = 'predictions/mAp512_30/' + imgfile[
imgfile.rfind('\\') + 1:imgfile.rfind('.png')] + '.txt'
with open(output_fname, 'w') as outfile:
if len(box) >= 1:
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, box, pred_fname, class_names)
width = 608
model = Yolov4(yolov4conv137weight=None,
n_classes=n_classes,
inference=True)
pretrained_dict = torch.load(weightfile, map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
# img = cv2.imread(imgfile)
##############################################################################################
namesfile = 'data/coco.names'
class_names = load_class_names(namesfile)
trans = trans_thread()
trans.start()
while (1):
if trans.inQue.empty() or trans.img.empty():
continue
trans.lock.acquire()
mid = trans.inQue.get()
img = trans.img.get()
trans.lock.release()
boxes = do_detect(model, [(mid[0], mid[1]), mid[2], mid[3]], img, 0.4,
0.6, use_cuda)
frame = plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
trans.fillData(frame)
args = get_args()
model = Yolov4(yolov4conv137weight=None,
n_classes=args.num_classes,
inference=True)
pretrained_dict = torch.load(args.weightfile,
map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
## Warming up the model
do_detect(model, np.zeros((args.height, args.width, 3), np.uint8), .4, .6,
use_cuda)
if os.path.isdir(args.input):
for parent, _, files_list in os.walk(args.input):
parent_path = os.path.relpath(parent, args.input)
if parent_path.startswith('.'):
parent_path = parent_path[1:]
for file in files_list:
img_path = os.path.join(parent, file)
rel_img_path = os.path.join(parent_path, file)
img = cv2.imread(img_path)
sized = cv2.resize(img, (args.width, args.height))
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.7, 0.3, use_cuda)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
elif n_classes == 18:
namesfile = 'data/chem.names'
else:
print("please give namefile")
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
def test(model, annotations, dataset_dir, gt_annotations_path, visualize=True):
if not annotations["images"]:
print("Annotations do not have 'images' key")
return
images = annotations["images"]
# images = images[:10]
resFile = 'data/coco_val_outputs.json'
if torch.cuda.is_available():
use_cuda = 1
else:
use_cuda = 0
# do one forward pass first to circumvent cold start
throwaway_image = Image.open('data/dog.jpg').convert('RGB').resize(
(model.width, model.height))
do_detect(model, throwaway_image, 0.5, 0.4, use_cuda=1)
boxes_json = []
for i, image_annotation in enumerate(images):
logging.info("currently on image: {}/{}".format(i + 1, len(images)))
image_file_name = image_annotation["file_name"]
image_id = image_annotation["id"]
image_height = image_annotation["height"]
image_width = image_annotation["width"]
# open and resize each image first
img = Image.open(os.path.join(dataset_dir, image_file_name))
img = np.array(img, dtype=np.uint8)
# sized = img
sized = cv2.resize(img, (model.width, model.height))
# sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
if use_cuda:
model.cuda()
start = time.time()
boxes = do_detect(model, sized, 0.5, 0.4, use_cuda=1)
boxes = boxes[0]
finish = time.time()
if type(boxes) == list:
for box in boxes[:100]:
box_json = {}
category_id = box[-1] + 1
score = box[-2]
bbox_normalized = box[:4]
box_json["category_id"] = int(category_id)
box_json["image_id"] = int(image_id)
x1 = float(box[0]) * image_width
y1 = float(box[1]) * image_height
x2 = float(box[2]) * image_width
y2 = float(box[3]) * image_height
bbox = [x1, y1, x2 - x1, y2 - y1]
box_json["bbox_normalized"] = list(
map(lambda x: round(float(x), 2), bbox_normalized))
box_json["bbox"] = bbox
box_json["score"] = round(float(score), 2)
box_json["timing"] = float(finish - start)
boxes_json.append(box_json)
# print("see box_json: ", box_json)
with open(resFile, 'w') as outfile:
json.dump(boxes_json,
outfile,
default=myconverter,
indent=4)
else:
print(
"warning: output from model after postprocessing is not a list, ignoring"
)
return
with open(resFile, 'w') as outfile:
json.dump(boxes_json, outfile, default=myconverter)
return evaluate_on_coco(dataset_dir,
gt_annotations_path,
resFile,
visualise_images=visualize)
def eval_mskim():
import os
import cv2
import pickle
import argparse
import numpy as np
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
parser = argparse.ArgumentParser()
parser.add_argument('--n_classes', default=1)
parser.add_argument('--weightfile', default='checkpoints/Yolov4_epoch10.pth')
parser.add_argument('--imgfile', default='data/mskim/test90_10percent.txt')
parser.add_argument('--size', type=int, nargs='+', default=[608, 608])
parser.add_argument('--namesfile', default='data/smoke.names')
parser.add_argument('--nms_th', default=0.6)
parser.add_argument('--conf_th', default=0.4)
parser.add_argument('--save_path', default='predictions/')
parser.add_argument('--save_image', default=False, action='store_true')
args = parser.parse_args()
target_h, target_w = args.size
model = Yolov4(yolov4conv137weight=None, n_classes=args.n_classes, inference=True)
pretrained_dict = torch.load(args.weightfile, map_location=torch.device('cuda'))
model.load_state_dict(pretrained_dict)
use_cuda = True
if use_cuda:
model.cuda()
with open(args.imgfile, 'r') as f:
img_file_lst = [line.strip() for line in f.readlines()]
common_path = os.path.commonpath(img_file_lst)
prediction_results = {}
class_names = load_class_names(args.namesfile)
for img_file in img_file_lst:
# origin image
img = cv2.imread(img_file)
origin_h, origin_w = img.shape[:2]
sized = cv2.resize(img, (target_w, target_h))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
# argument of do_detect: (model, img, conf_thresh, nms_thresh, use_cuda=1)
boxes = do_detect(model, sized, args.conf_th, args.nms_th, use_cuda)
boxes_np = np.asarray(boxes) # shape: (1, 0) or (1, N, 7) [7: xmin, ymin, xmax, ymax, score, id]
if boxes_np.shape[1] == 0:
pred = np.zeros((1, 5))
else:
# box coordinates are normalized to 0 ~ 1
pred = boxes_np[0, :, :-1]
# resize to origin image scale
pred[:, 0] = pred[:, 0] * origin_w
pred[:, 1] = pred[:, 1] * origin_h
pred[:, 2] = pred[:, 2] * origin_w
pred[:, 3] = pred[:, 3] * origin_h
prediction_results[os.path.relpath(img_file, common_path)] = pred
# save prediction results
if args.save_image:
filename = os.path.basename(img_file)
dirname = os.path.dirname(img_file)
rel_dir = os.path.relpath(dirname, common_path)
_save_path = os.path.join(args.save_path, rel_dir)
os.makedirs(_save_path, exist_ok=True)
plot_boxes_cv2(img, boxes[0], os.path.join(_save_path, filename), class_names)
with open(os.path.join(args.save_path, 'prediction_results.pickle'), 'wb') as f:
pickle.dump(prediction_results, f)
use_cuda = opt.use_cuda
if use_cuda:
torch.cuda.set_device(torch.device('cuda:{}'.format(opt.device)))
m.cuda()
# Data Loader
anno = COCO(opt.anno_json)
val_set = COCOImage(opt.anno_json, opt.img_path, opt.img_size)
val_loader = DataLoader(val_set, opt.batch_size, shuffle=True, num_workers=0)
# Accumulate results
result_dict = dict([])
print('STRAT detection')
for imgs, img_ids, sizes in tqdm(val_loader):
# model
boxes = do_detect(m, imgs, conf_thresh=opt.conf_thresh, nms_thresh=opt.nms_thresh, use_cuda=use_cuda, verbose=False)
# process
for img_id, box, H, W in zip(img_ids.numpy(), boxes, sizes[0].numpy(), sizes[1].numpy()):
result_dict[img_id] = (img_id, box, H, W)
# Transform results to COCO format
print('Convert results to COCO format')
total = []
for img_id in tqdm(result_dict.keys()):
one_result = coco_format(result_dict[img_id])
total.extend(one_result)
with open(opt.pred_json, 'w')as f:
json.dump(total, f)
if use_cuda:
model.cuda()
img = cv2.imread(imgfile)
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
from tool.utils import load_class_names, plot_boxes_cv2
from tool.torch_utils import do_detect
for i in range(2): # This 'for' loop is for speed check
# Because the first iteration is usually longer
boxes = do_detect(model, sized, 0.4, 0.6, use_cuda, profile=True)
if namesfile == None:
if n_classes == 20:
namesfile = 'data/voc.names'
elif n_classes == 80:
namesfile = 'data/coco.names'
else:
print("please give namefile")
class_names = load_class_names(namesfile)
plot_boxes_cv2(img, boxes[0], 'predictions.jpg', class_names)
def evaluate(model, val_label, val_dataset_dir, use_cuda, net_width, net_height):
os.makedirs("./tmp", exist_ok=True)
resFile = "./tmp/res.json"
f = open(val_label, 'r', encoding='utf-8')
truth = {}
for line in f.readlines():
data = line.split(" ") # 以空格分开不同目标
truth[data[0]] = [] # data[0]是图片名称（xxx.jpg）
for i in data[1:]:
# 每一项是一个列表，[x1,y1,x2,y2,cls_id],列表中的元素全部为int类型
truth[data[0]].append([int(float(j)) for j in i.split(',')])
imgs = list(truth.keys()) # 列表
# net_width = model.width
# net_height = model.height
# if use_cuda:
# model.cuda()
# if torch.cuda.device_count() > 1:
# model = torch.nn.DataParallel(model)
boxes_json = []
for i, image_file_name in enumerate(imgs):
image_id = get_image_id(image_file_name)
img = cv2.imread(os.path.join(val_dataset_dir, image_file_name))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
image_height, image_width = img.shape[:-1]
sized = cv2.resize(img, (net_width, net_height), cv2.INTER_LINEAR)
start = time.time()
boxes = do_detect(model, sized, 0.0, 0.6, use_cuda)
finish = time.time()
assert type(boxes[0]) == list
for box in boxes[0]:
box_json = {}
# xmin,ymin,xmax,ymax -> xmin,ymin,w,h
box[2] = box[2] - box[0]
box[3] = box[3] - box[1]
category_id = box[-1]
score = box[-2]
bbox_normalized = box[:4]
box_json["category_id"] = int(category_id)
box_json["image_id"] = int(image_id)
bbox = []
for i, bbox_coord in enumerate(bbox_normalized):
modified_bbox_coord = float(bbox_coord)
if i % 2:
modified_bbox_coord *= image_height
else:
modified_bbox_coord *= image_width
modified_bbox_coord = round(modified_bbox_coord, 2)
bbox.append(modified_bbox_coord)
box_json["bbox_normalized"] = list(map(lambda x: round(float(x), 2), bbox_normalized))
box_json["bbox"] = bbox
box_json["score"] = round(float(score), 2)
box_json["timing"] = float(finish - start)
boxes_json.append(box_json)
if len(boxes_json) == 0:
return None
with open(resFile, 'w') as outfile:
json.dump(boxes_json, outfile)
return resFile
# Inference input size is 416*416 does not mean training size is the same
# Training size could be 608*608 or even other sizes
# Optional inference sizes:
# Hight in {320, 416, 512, 608, ... 320 + 96 * n}
# Width in {320, 416, 512, 608, ... 320 + 96 * m}
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
to_plot = plot_boxes_cv2(img, gt_boxes, class_names=class_names)
if eval_model:
with torch.no_grad():
# for i in range(2): # This 'for' loop is for speed check
# # Because the first iteration is usually longer
# boxes = do_detect(model, sized, 0.4, 0.6, use_cuda)
boxes = do_detect(model, sized, 0.4, 0.6, use_device)
pred = plot_boxes_cv2(img,
boxes[0],
class_names=class_names)
to_plot = np.concatenate([to_plot, pred], axis=1)
# to_plot = (255 * np.clip(to_plot, 0, 1)).astype(np.uint8)
############################ detect: end ##################################
if output_video:
# to_plots.append(to_plot)
cv2.imwrite(os.path.join(video_dir, str(it) + ".png"), to_plot)
for i, name in enumerate(class_names):
contains = False
for box in gt_boxes:
Cfg.cfgfile = '/home/isv/Documents/tensorrt/yolov4/darknet-master/yolov4-tiny.cfg'
Cfg.weights_file = '/home/isv/Documents/tensorrt/yolov4/darknet-master/backup/yolov4-tiny_last.weights'
model = Darknet(Cfg.cfgfile)
model.print_network()
model.load_weights(Cfg.weights_file)
if torch.cuda.is_available():
use_cuda = 1
else:
use_cuda = 0
if use_cuda:
model = model.cuda()
img = cv2.imread('/home/isv/qt_projects/build-final_thread-Desktop_Qt_5_13_2_GCC_64bit-Debug/plateSaved/187.jpg')
img = cv2.resize(img, (320, 320))
# for i in range(10):
boxes = do_detect(model, img, 0.1, 0.4, use_cuda)
numberOfDetection = len(boxes[0])
for i in range(numberOfDetection):
each_box = boxes[0][i]
x = int(320 * each_box[0])
y = int(320 * each_box[1])
w = int(320 * each_box[2])
h = int(320 * each_box[3])
img = cv2.rectangle(img, (x, y), (w, h), (100, 220, 0), 2)
cv2.putText(img, str(each_box[6]), (x, h), cv2.FONT_ITALIC, 1, (100, 200, 100), 2)
print(each_box, ' ', x)
import matplotlib.pyplot as plt
plt.imshow(img, 'gray')
plt.show()
def test(model, annotations, cfg):
if not annotations["images"]:
print("Annotations do not have 'images' key")
return
images = annotations["images"]
# images = images[:10]
resFile = 'data/coco_val_outputs.json'
if torch.cuda.is_available():
use_cuda = 1
else:
use_cuda = 0
# do one forward pass first to circumvent cold start
throwaway_image = Image.open('data/dog.jpg').convert('RGB').resize(
(model.width, model.height))
do_detect(model, throwaway_image, 0.5, 80, 0.4, use_cuda)
boxes_json = []
for i, image_annotation in enumerate(images):
logging.info("currently on image: {}/{}".format(i + 1, len(images)))
image_file_name = image_annotation["file_name"]
image_id = image_annotation["id"]
image_height = image_annotation["height"]
image_width = image_annotation["width"]
# open and resize each image first
img = Image.open(os.path.join(cfg.dataset_dir,
image_file_name)).convert('RGB')
sized = img.resize((model.width, model.height))
if use_cuda:
model.cuda()
start = time.time()
boxes = do_detect(model, sized, 0.0, 80, 0.4, use_cuda)
finish = time.time()
if type(boxes) == list:
for box in boxes:
box_json = {}
category_id = box[-1]
score = box[-2]
bbox_normalized = box[:4]
box_json["category_id"] = int(category_id)
box_json["image_id"] = int(image_id)
bbox = []
for i, bbox_coord in enumerate(bbox_normalized):
modified_bbox_coord = float(bbox_coord)
if i % 2:
modified_bbox_coord *= image_height
else:
modified_bbox_coord *= image_width
modified_bbox_coord = round(modified_bbox_coord, 2)
bbox.append(modified_bbox_coord)
box_json["bbox_normalized"] = list(
map(lambda x: round(float(x), 2), bbox_normalized))
box_json["bbox"] = bbox
box_json["score"] = round(float(score), 2)
box_json["timing"] = float(finish - start)
boxes_json.append(box_json)
# print("see box_json: ", box_json)
with open(resFile, 'w') as outfile:
json.dump(boxes_json, outfile, default=myconverter)
else:
print(
"warning: output from model after postprocessing is not a list, ignoring"
)
return
# namesfile = 'data/coco.names'
# class_names = load_class_names(namesfile)
# plot_boxes(img, boxes, 'data/outcome/predictions_{}.jpg'.format(image_id), class_names)
with open(resFile, 'w') as outfile:
json.dump(boxes_json, outfile, default=myconverter)
evaluate_on_coco(cfg, resFile)
def infer(self,data): sized = cv2.resize(data, (self.width, self.height)) sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB) boxes = do_detect(self.model, sized, 0.4, 0.6, self.use_cuda,self.is_half) plot_boxes_cv2(data, boxes[0], savename='./data/predictions.jpg', class_names=self.class_names)
if use_cuda:
model.cuda()
# img = cv2.imread(imgfile)
##############################################################################################
# _thread.start_new_thread(key_check,(c,c1,s))
trans = trans_thread()
trans.start()
while (FLAG):
if trans.inQue.empty():
continue
trans.lock.acquire()
img = trans.inQue.get()
trans.lock.release()
# print(img.shape)
# cv2.imshow("11", img)
sized = cv2.resize(img, (width, height))
sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
y1, x10, x18 = do_detect(model, sized, 0.4, 0.6, use_cuda)
y11, y12, x10, x18 = y1[0].detach().cpu().numpy(), y1[1].detach().cpu(
).numpy(), x10.detach().cpu().numpy(), x18.detach().cpu().numpy()
if not trans.outQue.full():
trans.fillData((y11, y12, x10, x18))
# print(y1,y2,x18)
# c.close()
# c1.close()
# s.close()
