def yolo2_postprocess_np(yolo_outputs, image_shape, anchors, num_classes, model_image_size, max_boxes=20, confidence=0.25, iou_threshold=0.1):
predictions = yolo2_head(yolo_outputs, anchors, num_classes, input_dims=model_image_size)
boxes, classes, scores = yolo3_handle_predictions(predictions,
max_boxes=max_boxes,
confidence=confidence,
iou_threshold=iou_threshold)
boxes = yolo3_adjust_boxes(boxes, image_shape, model_image_size)
return boxes, classes, scores
def yolo_predict_tflite(interpreter, image, anchors, num_classes,
conf_threshold):
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# check the type of the input tensor
#if input_details[0]['dtype'] == np.float32:
#floating_model = True
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
image_data = preprocess_image(image, (height, width))
image_shape = image.size
interpreter.set_tensor(input_details[0]['index'], image_data)
interpreter.invoke()
out_list = []
for output_detail in output_details:
output_data = interpreter.get_tensor(output_detail['index'])
out_list.append(output_data)
predictions = yolo3_head(out_list,
anchors,
num_classes=num_classes,
input_dims=(height, width))
boxes, classes, scores = yolo3_handle_predictions(
predictions,
max_boxes=100,
confidence=conf_threshold,
iou_threshold=0.4)
boxes = adjust_boxes(boxes, image_shape, (height, width))
return boxes, classes, scores
def validate_yolo_model_mnn(model_path, image_file, anchors, class_names,
loop_count):
interpreter = MNN.Interpreter(model_path)
session = interpreter.createSession()
# TODO: currently MNN python API only support getting input/output tensor by default or
# by name. so we need to hardcode the output tensor names here to get them from model
if len(anchors) == 6:
output_tensor_names = ['conv2d_1/Conv2D', 'conv2d_3/Conv2D']
elif len(anchors) == 9:
output_tensor_names = [
'conv2d_3/Conv2D', 'conv2d_8/Conv2D', 'conv2d_13/Conv2D'
]
else:
raise ValueError('invalid anchor number')
# assume only 1 input tensor for image
input_tensor = interpreter.getSessionInput(session)
# get input shape
input_shape = input_tensor.getShape()
if input_tensor.getDimensionType() == MNN.Tensor_DimensionType_Tensorflow:
batch, height, width, channel = input_shape
elif input_tensor.getDimensionType() == MNN.Tensor_DimensionType_Caffe:
batch, channel, height, width = input_shape
else:
# should be MNN.Tensor_DimensionType_Caffe_C4, unsupported now
raise ValueError('unsupported input tensor dimension type')
# prepare input image
img = Image.open(image_file)
image = np.array(img, dtype='uint8')
image_data = preprocess_image(img, (height, width))
image_shape = img.size
# use a temp tensor to copy data
tmp_input = MNN.Tensor(input_shape, input_tensor.getDataType(),\
image_data, input_tensor.getDimensionType())
# predict once first to bypass the model building time
input_tensor.copyFrom(tmp_input)
interpreter.runSession(session)
start = time.time()
for i in range(loop_count):
input_tensor.copyFrom(tmp_input)
interpreter.runSession(session)
end = time.time()
print("Average Inference time: {:.8f}ms".format(
(end - start) * 1000 / loop_count))
out_list = []
for output_tensor_name in output_tensor_names:
output_tensor = interpreter.getSessionOutput(session,
output_tensor_name)
output_shape = output_tensor.getShape()
assert output_tensor.getDataType() == MNN.Halide_Type_Float
# copy output tensor to host, for further postprocess
tmp_output = MNN.Tensor(output_shape, output_tensor.getDataType(),\
np.zeros(output_shape, dtype=float), output_tensor.getDimensionType())
output_tensor.copyToHostTensor(tmp_output)
#tmp_output.printTensorData()
output_data = np.array(tmp_output.getData(),
dtype=float).reshape(output_shape)
# our postprocess code based on TF channel last format, so if the output format
# doesn't match, we need to transpose
if output_tensor.getDimensionType() == MNN.Tensor_DimensionType_Caffe:
output_data = output_data.transpose((0, 2, 3, 1))
elif output_tensor.getDimensionType(
) == MNN.Tensor_DimensionType_Caffe_C4:
raise ValueError('unsupported output tensor dimension type')
out_list.append(output_data)
start = time.time()
predictions = yolo3_head(out_list,
anchors,
num_classes=len(class_names),
input_dims=(height, width))
boxes, classes, scores = yolo3_handle_predictions(predictions,
confidence=0.1,
iou_threshold=0.4)
boxes = yolo3_adjust_boxes(boxes, image_shape, (height, width))
end = time.time()
print("PostProcess time: {:.8f}ms".format((end - start) * 1000))
print('Found {} boxes for {}'.format(len(boxes), image_file))
for box, cls, score in zip(boxes, classes, scores):
print("Class: {}, Score: {}".format(class_names[cls], score))
colors = get_colors(class_names)
image = draw_boxes(image, boxes, classes, scores, class_names, colors)
Image.fromarray(image).show()
def validate_yolo_model_tflite(model_path, image_file, anchors, class_names,
loop_count):
interpreter = interpreter_wrapper.Interpreter(model_path=model_path)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
#print(input_details)
#print(output_details)
# check the type of the input tensor
if input_details[0]['dtype'] == np.float32:
floating_model = True
img = Image.open(image_file)
image = np.array(img, dtype='uint8')
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
image_data = preprocess_image(img, (height, width))
image_shape = img.size
# predict once first to bypass the model building time
interpreter.set_tensor(input_details[0]['index'], image_data)
interpreter.invoke()
start = time.time()
for i in range(loop_count):
interpreter.set_tensor(input_details[0]['index'], image_data)
interpreter.invoke()
end = time.time()
print("Average Inference time: {:.8f}ms".format(
(end - start) * 1000 / loop_count))
out_list = []
for output_detail in output_details:
output_data = interpreter.get_tensor(output_detail['index'])
out_list.append(output_data)
start = time.time()
predictions = yolo3_head(out_list,
anchors,
num_classes=len(class_names),
input_dims=(height, width))
boxes, classes, scores = yolo3_handle_predictions(predictions,
confidence=0.1,
iou_threshold=0.4)
boxes = yolo3_adjust_boxes(boxes, image_shape, (height, width))
end = time.time()
print("PostProcess time: {:.8f}ms".format((end - start) * 1000))
print('Found {} boxes for {}'.format(len(boxes), image_file))
for box, cls, score in zip(boxes, classes, scores):
print("Class: {}, Score: {}".format(class_names[cls], score))
colors = get_colors(class_names)
image = draw_boxes(image, boxes, classes, scores, class_names, colors)
Image.fromarray(image).show()
def yolo_predict_mnn(interpreter, session, image, anchors, num_classes,
conf_threshold):
from functools import reduce
from operator import mul
# TODO: currently MNN python API only support getting input/output tensor by default or
# by name. so we need to hardcode the output tensor names here to get them from model
if len(anchors) == 6:
output_tensor_names = ['conv2d_1/Conv2D', 'conv2d_3/Conv2D']
elif len(anchors) == 9:
output_tensor_names = [
'conv2d_3/Conv2D', 'conv2d_8/Conv2D', 'conv2d_13/Conv2D'
]
else:
raise ValueError('invalid anchor number')
# assume only 1 input tensor for image
input_tensor = interpreter.getSessionInput(session)
# get input shape
input_shape = input_tensor.getShape()
if input_tensor.getDimensionType() == MNN.Tensor_DimensionType_Tensorflow:
batch, height, width, channel = input_shape
elif input_tensor.getDimensionType() == MNN.Tensor_DimensionType_Caffe:
batch, channel, height, width = input_shape
else:
# should be MNN.Tensor_DimensionType_Caffe_C4, unsupported now
raise ValueError('unsupported input tensor dimension type')
# prepare input image
image_data = preprocess_image(image, (height, width))
image_shape = image.size
# use a temp tensor to copy data
# TODO: currently MNN python binding have mem leak when creating MNN.Tensor
# from numpy array, only from tuple is good. So we convert input image to tuple
input_elementsize = reduce(mul, input_shape)
tmp_input = MNN.Tensor(input_shape, input_tensor.getDataType(),\
tuple(image_data.reshape(input_elementsize, -1)), input_tensor.getDimensionType())
input_tensor.copyFrom(tmp_input)
interpreter.runSession(session)
out_list = []
for output_tensor_name in output_tensor_names:
output_tensor = interpreter.getSessionOutput(session,
output_tensor_name)
output_shape = output_tensor.getShape()
assert output_tensor.getDataType() == MNN.Halide_Type_Float
# copy output tensor to host, for further postprocess
output_elementsize = reduce(mul, output_shape)
tmp_output = MNN.Tensor(output_shape, output_tensor.getDataType(),\
tuple(np.zeros(output_shape, dtype=float).reshape(output_elementsize, -1)), output_tensor.getDimensionType())
output_tensor.copyToHostTensor(tmp_output)
#tmp_output.printTensorData()
output_data = np.array(tmp_output.getData(),
dtype=float).reshape(output_shape)
# our postprocess code based on TF channel last format, so if the output format
# doesn't match, we need to transpose
if output_tensor.getDimensionType() == MNN.Tensor_DimensionType_Caffe:
output_data = output_data.transpose((0, 2, 3, 1))
elif output_tensor.getDimensionType(
) == MNN.Tensor_DimensionType_Caffe_C4:
raise ValueError('unsupported output tensor dimension type')
out_list.append(output_data)
predictions = yolo3_head(out_list,
anchors,
num_classes=num_classes,
input_dims=(height, width))
boxes, classes, scores = yolo3_handle_predictions(
predictions,
max_boxes=100,
confidence=conf_threshold,
iou_threshold=0.4)
boxes = adjust_boxes(boxes, image_shape, (height, width))
return boxes, classes, scores