def run_ie_on_dataset(model_xml, model_bin, cpu_extension_path, images_dir, prob_threshold=0.01):
plugin = IEPlugin(device='CPU')
plugin.add_cpu_extension(cpu_extension_path)
net = IENetwork.from_ir(model=model_xml, weights=model_bin)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(net.outputs) == 1, "Sample supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
exec_net = plugin.load(network=net, num_requests=2)
num, chs, height, width = net.inputs[input_blob]
del net
cur_request_id = 0
detection_data = []
for image in os.listdir(images_dir):
im_path = os.path.join(images_dir, image)
frame = cv2.imread(im_path)
initial_h, initial_w, _ = frame.shape
in_frame = cv2.resize(frame, (width, height))
in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((num, chs, height, width))
objects_per_image = []
exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
res = exec_net.requests[cur_request_id].outputs[out_blob]
for obj in res[0][0]:
if obj[2] > prob_threshold:
xmin = int(obj[3] * initial_w)
ymin = int(obj[4] * initial_h)
xmax = int(obj[5] * initial_w)
ymax = int(obj[6] * initial_h)
class_id = int(obj[1])
conf = obj[2]
objects_per_image.append({'bbox': [xmin, ymin, xmax, ymax], 'class_id': class_id, 'score': conf})
det_item = {'image': im_path, 'objects': objects_per_image}
detection_data.append(det_item)
del exec_net
del plugin
return detection_data
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format(args.device))
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Reading IR...")
net = IENetwork.from_ir(model=model_xml, weights=model_bin)
if "CPU" in plugin.device:
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
if len(not_supported_layers) != 0:
log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
format(plugin.device, ', '.join(not_supported_layers)))
log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(net.outputs) == 1, "Sample supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=2)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob]
del net
predictions = []
data = Input(args.input_type, args.input)
cur_request_id = 0
fps = 25
out_width = 640
out_height = 480
if args.dump_output_video:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter(args.path_to_output_video, fourcc, fps, (int(out_width), int(out_height)))
while not data.is_finished():
frame, img_id = data.get_next_item()
initial_h, initial_w, channels = frame.shape
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
# Parse detection results of the current request
res = exec_net.requests[cur_request_id].outputs[out_blob]
coco_detections = []
for obj in res[0][0]:
# Draw only objects when probability more than specified threshold
if obj[2] > args.prob_threshold:
x1 = float(obj[3] * initial_w)
y1 = float(obj[4] * initial_h)
x2 = float(obj[5] * initial_w)
y2 = float(obj[6] * initial_h)
x_, y_ = round(x1, 1), round(y1, 1)
w_ = round(x2 - x1, 1)
h_ = round(y2 - y1, 1)
class_id = int(obj[1])
coco_det = {}
coco_det['image_id'] = img_id
coco_det['category_id'] = class_id
coco_det['bbox'] = [x_, y_, w_, h_]
coco_det['score'] = round(float(obj[2]), 1)
coco_detections.append(coco_det)
# Draw box and label\class_id
cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(frame, str(class_id) + ' ' + str(round(obj[2] * 100, 1)) + ' %', (int(x1), int(y1) - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
predictions.extend(coco_detections)
if args.dump_output_video:
img_resized = cv2.resize(frame, (out_width, out_height))
out.write(img_resized)
if args.show:
cv2.imshow("Detection Results", frame)
key = cv2.waitKey(10)
if key == 27:
break
if args.dump_predictions_to_json:
with open(args.output_json_path, 'w') as output_file:
json.dump(predictions, output_file, sort_keys=True, indent=4)
cv2.destroyAllWindows()
del exec_net
del plugin
def main():
#line for log configuration
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
#parser for the arguments
args = build_argparser().parse_args()
#get xml model argument
model_xml = args.model
#get weight model argument
model_bin = os.path.splitext(model_xml)[0] + ".bin"
#Hardware plugin initialization for specified device and
log.info("Initializing plugin for {} device...".format(args.device))
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
#load extensions library if specified
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
#Read intermediate representation of the model
log.info("Reading IR...")
net = IENetwork.from_ir(model=model_xml, weights=model_bin)
# check if the model is supported
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(plugin.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in demo's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
# check if the input and output of model is the right format, here we expect just one input (one image) and one output type (bounding boxes)
assert len(
net.inputs.keys()) == 1, "Demo supports only single input topologies"
#assert len(net.outputs) == 1, "Demo supports only single output topologies"
# start the iterator on the input nodes
input_blob = next(iter(net.inputs))
print(input_blob)
# start the iterator on the output
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
# load the network
exec_net = plugin.load(network=net)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob].shape
del net
#take care of the input data (camera or video file)
if args.input == 'cam':
input_stream = 0
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
#take care of the labels
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
#opencv function to take care of the video reading/capture
cap = cv2.VideoCapture(input_stream)
log.info("Starting inference ")
log.info("To stop the demo execution press Esc button")
render_time = 0
#open the camera
ret, frame = cap.read()
#if open, we loop over the incoming frames
i = 1
while cap.isOpened():
#we get the frame
ret, frame = cap.read()
if not ret:
break
#get frame size
initial_w = cap.get(3)
initial_h = cap.get(4)
#start the time counter
inf_start = time.time()
#reshape the frame size and channels order to fit the model input
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
#start the inference
exec_net.infer(inputs={input_blob: in_frame})
#stop the clock
inf_end = time.time()
det_time = inf_end - inf_start
# Parse detection results
res = exec_net.requests[0].outputs[out_blob]
#iterate over the results
for obj in res[0][0]:
# check the object probability , if higher than threshold it will create the bounding box
if obj[2] > args.prob_threshold:
# class ID
class_id = int(obj[1])
#define top left corner column value
xmin = int(obj[3] * initial_w)
#define top left corner row value
ymin = int(obj[4] * initial_h)
#define bottom right corner column value
xmax = int(obj[5] * initial_w)
#define bottom right corner row value
ymax = int(obj[6] * initial_h)
deltax = int((xmax - xmin) / 2)
deltay = int((ymax - ymin) / 2)
xmin = xmin - deltax
xmax = xmax + deltax
ymin = ymin + deltay
ymax = ymax + deltay
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = gray[ymin:ymax, xmin:xmax]
ret, thresh = cv2.threshold(
gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
minSize = 128 * 128
if thresh is not None and thresh.size > minSize and thresh.shape[
0] > int(
thresh.shape[1] / 2) and thresh.shape[0] > int(
thresh.shape[1] / 2):
#print(thresh.shape)
i = i + 1
if i % 5 == 0:
gray = cv2.resize(gray, (128, 100))
#cv2.imshow("littleframe",gray)
cv2.imwrite("images3/image" + str(i) + '.png', gray)
# Draw box and label and class_id
# color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 5, 255))
rd = np.random.randint(0, 2)
color = (rd * 255, rd * 255, rd * 255)
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
det_label = labels_map[class_id] if labels_map else str(
class_id)
cv2.putText(
frame,
det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %',
(xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1)
# Draw performance stats
inf_time_message = "Inference time: {:.3f} ms".format(det_time *
1000)
cv2.putText(frame, inf_time_message, (15, 15),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
# show the result image
#cv2.imshow("Detection Results", frame)
key = cv2.waitKey(1)
if key == 27:
break
cv2.destroyAllWindows()
del exec_net
del plugin
def main():
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# ------------- 1. Plugin initialization for specified device and load extensions library if specified -------------
log.info("Creating Inference Engine...")
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, "CPU")
# -------------------- 2. Reading the IR generated by the Model Optimizer (.xml and .bin files) --------------------
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
# ---------------------------------- 3. Load CPU extension for support specific layer ------------------------------
if "CPU" in args.device:
supported_layers = ie.query_network(net, "CPU")
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(args.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys(
)) == 1, "Sample supports only YOLO V3 based single input topologies"
# ---------------------------------------------- 4. Preparing inputs -----------------------------------------------
log.info("Preparing inputs")
input_blob = next(iter(net.inputs))
# Defaulf batch_size is 1
net.batch_size = 1
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
input_stream = 0 if args.input == "cam" else args.input
is_async_mode = True
cap = cv2.VideoCapture(input_stream)
number_input_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
number_input_frames = 1 if number_input_frames != -1 and number_input_frames < 0 else number_input_frames
wait_key_code = 1
# Number of frames in picture is 1 and this will be read in cycle. Sync mode is default value for this case
if number_input_frames != 1:
ret, frame = cap.read()
else:
is_async_mode = False
wait_key_code = 0
# ----------------------------------------- 5. Loading model to the plugin -----------------------------------------
log.info("Loading model to the plugin")
exec_net = ie.load_network(network=net,
num_requests=2,
device_name=args.device)
cur_request_id = 0
next_request_id = 1
render_time = 0
parsing_time = 0
# ----------------------------------------------- 6. Doing inference -----------------------------------------------
log.info("Starting inference...")
print(
"To close the application, press 'CTRL+C' here or switch to the output window and press ESC key"
)
print(
"To switch between sync/async modes, press TAB key in the output window"
)
while cap.isOpened():
# Here is the first asynchronous point: in the Async mode, we capture frame to populate the NEXT infer request
# in the regular mode, we capture frame to the CURRENT infer request
if is_async_mode:
ret, next_frame = cap.read()
else:
ret, frame = cap.read()
if not ret:
break
if is_async_mode:
request_id = next_request_id
in_frame = cv2.resize(next_frame, (w, h))
else:
request_id = cur_request_id
in_frame = cv2.resize(frame, (w, h))
# resize input_frame to network size
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
# Start inference
start_time = time()
exec_net.start_async(request_id=request_id,
inputs={input_blob: in_frame})
det_time = time() - start_time
# Collecting object detection results
objects = list()
if exec_net.requests[cur_request_id].wait(-1) == 0:
output = exec_net.requests[cur_request_id].outputs
start_time = time()
for layer_name, out_blob in output.items():
out_blob = out_blob.reshape(
net.layers[net.layers[layer_name].parents[0]].shape)
layer_params = YoloParams(net.layers[layer_name].params,
out_blob.shape[2])
log.info("Layer {} parameters: ".format(layer_name))
layer_params.log_params()
objects += parse_yolo_region(out_blob, in_frame.shape[2:],
frame.shape[:-1], layer_params,
args.prob_threshold)
parsing_time = time() - start_time
# Filtering overlapping boxes with respect to the --iou_threshold CLI parameter
objects = sorted(objects,
key=lambda obj: obj['confidence'],
reverse=True)
for i in range(len(objects)):
if objects[i]['confidence'] == 0:
continue
for j in range(i + 1, len(objects)):
if intersection_over_union(objects[i],
objects[j]) > args.iou_threshold:
objects[j]['confidence'] = 0
# Drawing objects with respect to the --prob_threshold CLI parameter
objects = [
obj for obj in objects if obj['confidence'] >= args.prob_threshold
]
if len(objects) and args.raw_output_message:
log.info("\nDetected boxes for batch {}:".format(1))
log.info(
" Class ID | Confidence | XMIN | YMIN | XMAX | YMAX | COLOR ")
origin_im_size = frame.shape[:-1]
for obj in objects:
# Validation bbox of detected object
if obj['xmax'] > origin_im_size[1] or obj['ymax'] > origin_im_size[
0] or obj['xmin'] < 0 or obj['ymin'] < 0:
continue
color = (int(min(obj['class_id'] * 12.5,
255)), min(obj['class_id'] * 7,
255), min(obj['class_id'] * 5, 255))
det_label = labels_map[obj['class_id']] if labels_map and len(labels_map) >= obj['class_id'] else \
str(obj['class_id'])
if args.raw_output_message:
log.info(
"{:^9} | {:10f} | {:4} | {:4} | {:4} | {:4} | {} ".format(
det_label, obj['confidence'], obj['xmin'], obj['ymin'],
obj['xmax'], obj['ymax'], color))
cv2.rectangle(frame, (obj['xmin'], obj['ymin']),
(obj['xmax'], obj['ymax']), color, 2)
cv2.putText(
frame, "#" + det_label + ' ' +
str(round(obj['confidence'] * 100, 1)) + ' %',
(obj['xmin'], obj['ymin'] - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6,
color, 1)
# Draw performance stats over frame
inf_time_message = "Inference time: N\A for async mode" if is_async_mode else \
"Inference time: {:.3f} ms".format(det_time * 1e3)
render_time_message = "OpenCV rendering time: {:.3f} ms".format(
render_time * 1e3)
async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
"Async mode is off. Processing request {}".format(cur_request_id)
parsing_message = "YOLO parsing time is {:.3f} ms".format(
parsing_time * 1e3)
cv2.putText(frame, inf_time_message, (15, 15),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
cv2.putText(frame, render_time_message, (15, 45),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
cv2.putText(frame, async_mode_message,
(10, int(origin_im_size[0] - 20)),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
cv2.putText(frame, parsing_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX,
0.5, (10, 10, 200), 1)
start_time = time()
if not args.no_show:
cv2.imshow("DetectionResults", frame)
render_time = time() - start_time
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
frame = next_frame
if not args.no_show:
key = cv2.waitKey(wait_key_code)
# ESC key
if key == 27:
break
# Tab key
if key == 9:
exec_net.requests[cur_request_id].wait()
is_async_mode = not is_async_mode
log.info("Switched to {} mode".format(
"async" if is_async_mode else "sync"))
cv2.destroyAllWindows()
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
frame_counter = 0
frame_waiter = -1
#for tracking movement
coordlist = []
log.info("Creating Inference Engine...")
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, "CPU")
# Read IR
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
if "CPU" in args.device:
supported_layers = ie.query_network(net, "CPU")
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(args.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
img_info_input_blob = None
feed_dict = {}
for blob_name in net.inputs:
if len(net.inputs[blob_name].shape) == 4:
input_blob = blob_name
elif len(net.inputs[blob_name].shape) == 2:
img_info_input_blob = blob_name
else:
raise RuntimeError(
"Unsupported {}D input layer '{}'. Only 2D and 4D input layers are supported"
.format(len(net.inputs[blob_name].shape), blob_name))
assert len(net.outputs) == 1, "Demo supports only single output topologies"
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = ie.load_network(network=net,
num_requests=2,
device_name=args.device)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob].shape
if img_info_input_blob:
feed_dict[img_info_input_blob] = [h, w, 1]
#for tracking movement in 3d
# Create a blank 300x300 black image
image_tracking = np.zeros((h * 2, w, 3), np.uint8)
image_tracking[:] = (255, 255, 255)
if args.input == 'cam':
input_stream = 0
else:
input_stream = args.input
cap = cv2.VideoCapture(input_stream)
assert cap.isOpened(), "Can't open " + input_stream
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
cur_request_id = 0
next_request_id = 1
log.info("Starting inference in async mode...")
is_async_mode = True
render_time = 0
if is_async_mode:
ret, frame = cap.read()
frame_h, frame_w = frame.shape[:2]
print(
"To close the application, press 'CTRL+C' here or switch to the output window and press ESC key"
)
print(
"To switch between sync/async modes, press TAB key in the output window"
)
while cap.isOpened():
if is_async_mode:
ret, next_frame = cap.read()
else:
ret, frame = cap.read()
if ret:
frame_h, frame_w = frame.shape[:2]
if not ret:
break # abandons the last frame in case of async_mode
# Main sync point:
# in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
# in the regular mode we start the CURRENT request and immediately wait for it's completion
inf_start = time.time()
if is_async_mode:
in_frame = cv2.resize(next_frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
feed_dict[input_blob] = in_frame
exec_net.start_async(request_id=next_request_id, inputs=feed_dict)
else:
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
feed_dict[input_blob] = in_frame
exec_net.start_async(request_id=cur_request_id, inputs=feed_dict)
if exec_net.requests[cur_request_id].wait(-1) == 0:
inf_end = time.time()
det_time = inf_end - inf_start
# Parse detection results of the current request
res = exec_net.requests[cur_request_id].outputs[out_blob]
n_ppl = 0
for obj in res[0][0]:
# Draw only objects when probability more than specified threshold
if obj[2] > args.prob_threshold:
n_ppl = n_ppl + 1
xmin = int(obj[3] * frame_w)
ymin = int(obj[4] * frame_h)
xmax = int(obj[5] * frame_w)
ymax = int(obj[6] * frame_h)
class_id = int(obj[1])
# Draw box and label\class_id
color = (min(class_id * 12.5,
255), min(class_id * 7,
255), min(class_id * 5, 255))
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
det_label = labels_map[class_id] if labels_map else str(
class_id)
cv2.putText(
frame,
det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %',
(xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color,
1)
x_track = round(xmin + abs(xmax - xmin) / 2)
y_track = round(ymax)
depth = round(ymax - ymin)
rawdepth = round(ymax - ymin)
coordlist += [(x_track, y_track, depth)]
# Draw performance stats
# inf_time_message = "Inference time: N\A for async mode" if is_async_mode else \
# "Inference time: {:.3f} ms".format(det_time * 1000)
# render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
# async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
# "Async mode is off. Processing request {}".format(cur_request_id)
#
# cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
# cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
# cv2.putText(frame, async_mode_message, (10, int(frame_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
# (10, 10, 200), 1)
#new: adding the tracking spots
color_blue = (255, 0, 0)
for coord in coordlist:
new_depth = round(((coord[2]) / 100)**2.5)
frame = cv2.circle(frame, (coord[0], coord[1]),
new_depth,
color_blue,
thickness=2)
image_tracking = cv2.circle(image_tracking,
(coord[0], round(coord[2] * 2)),
3,
color_blue,
thickness=1)
# adding text
ppl_message = "People detected: {}".format(n_ppl)
cv2.putText(frame, ppl_message, (30, round(frame_h - 50)),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
ppl_message_alert = "!!OVERCROWDING!!"
frame_counter = frame_counter + 1
frame_waiter = frame_waiter - 1
if (n_ppl > 7 and frame_waiter < 0):
frame_waiter = 100
cv2.putText(frame, ppl_message_alert,
(100, round(frame_h / 2)),
cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 255), 3)
add_data.send_data(n_ppl, 7)
#
render_start = time.time()
if not args.no_show:
cv2.imshow("Detection Results", frame)
render_end = time.time()
render_time = render_end - render_start
cv2.imshow('movement tracking', image_tracking)
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
frame = next_frame
frame_h, frame_w = frame.shape[:2]
if not args.no_show:
key = cv2.waitKey(1)
if key == 27:
break
if (9 == key):
is_async_mode = not is_async_mode
log.info("Switched to {} mode".format(
"async" if is_async_mode else "sync"))
cv2.destroyAllWindows()
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format(args.device))
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
log.info("Loading plugins for {} device...".format(args.device))
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(plugin.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(
net.outputs) == 1, "Sample supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=2)
# Read and pre-process input image
if isinstance(net.inputs[input_blob], list):
n, c, h, w = net.inputs[input_blob]
else:
n, c, h, w = net.inputs[input_blob].shape
del net
if args.input == 'cam':
input_stream = 0
out_file_name = 'cam'
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
out_file_name = os.path.splitext(os.path.basename(args.input))[0]
if args.output_dir:
out_path = os.path.join(args.output_dir, out_file_name + '.mp4')
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
cap = cv2.VideoCapture(input_stream)
video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
cur_request_id = 0
next_request_id = 1
log.info("Starting inference in async mode...")
log.info("To switch between sync and async modes press Tab button")
log.info("To stop the sample execution press Esc button")
job_id = os.environ['PBS_JOBID']
result_file = open(
os.path.join(args.output_dir, 'output_' + str(job_id) + '.txt'), "w")
progress_file_path = os.path.join(args.output_dir,
'i_progress_' + str(job_id) + '.txt')
is_async_mode = True
render_time = 0
fps_sum = 0
frame_count = 0
inf_list = []
res_list = []
try:
infer_time_start = time.time()
while cap.isOpened():
read_time = time.time()
ret, frame = cap.read()
if not ret:
break
initial_w = cap.get(3)
initial_h = cap.get(4)
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
# Main sync point:
# in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
# in the regular mode we start the CURRENT request and immediately wait for it's completion
inf_start = time.time()
if is_async_mode:
exec_net.start_async(request_id=next_request_id,
inputs={input_blob: in_frame})
else:
exec_net.start_async(request_id=cur_request_id,
inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
inf_end = time.time()
det_time = inf_end - inf_start
#Parse detection results of the current request
res = exec_net.requests[cur_request_id].outputs[out_blob]
processBoxes(frame_count, res, labels_map, args.prob_threshold,
frame, initial_w, initial_h, result_file,
det_time)
#
frame_count += 1
#Write data to progress tracker
if frame_count % 10 == 0:
progressUpdate(progress_file_path,
time.time() - infer_time_start, frame_count,
video_len)
key = cv2.waitKey(1)
if key == 27:
break
if (9 == key):
is_async_mode = not is_async_mode
log.info("Switched to {} mode".format(
"async" if is_async_mode else "sync"))
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
##End while loop /
cap.release()
result_file.close()
if args.output_dir is None:
cv2.destroyAllWindows()
else:
total_time = time.time() - infer_time_start
with open(
os.path.join(args.output_dir,
'stats_' + str(job_id) + '.txt'), 'w') as f:
f.write(str(round(total_time, 1)) + '\n')
f.write(str(frame_count) + '\n')
finally:
del exec_net
del plugin
def main():
log.basicConfig(format='[ %(levelname)s ] %(message)s',
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
input_images = list_input_images(args.input)
# Loading network using ngraph function
ngraph_function = create_ngraph_function(args)
net = IENetwork(Function.to_capsule(ngraph_function))
assert len(net.input_info.keys()
) == 1, "Sample supports only single input topologies"
assert len(
net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.input_info))
out_blob = next(iter(net.outputs))
net.batch_size = len(input_images)
# Read and pre-process input images
n, c, h, w = net.input_info[input_blob].input_data.shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = read_image(input_images[i])
assert image is not None, log.error("Can't open an image {}".format(
input_images[i]))
assert len(image.shape) == 2, log.error(
'Sample supports images with 1 channel only')
if image.shape[:] != (w, h):
log.warning("Image {} is resized from {} to {}".format(
input_images[i], image.shape[:], (w, h)))
image = cv2.resize(image, (w, h))
images[i] = image
log.info("Batch size is {}".format(n))
log.info("Creating Inference Engine")
ie = IECore()
log.info('Loading model to the device')
exec_net = ie.load_network(network=net, device_name=args.device.upper())
# Start sync inference
log.info('Creating infer request and starting inference')
res = exec_net.infer(inputs={input_blob: images})
# Processing results
log.info("Processing output blob")
res = res[out_blob]
log.info("Top {} results: ".format(args.number_top))
# Read labels file if it is provided as argument
labels_map = None
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.split(sep=' ', maxsplit=1)[-1].strip() for x in f]
classid_str = "classid"
probability_str = "probability"
for i, probs in enumerate(res):
probs = np.squeeze(probs)
top_ind = np.argsort(probs)[-args.number_top:][::-1]
print("Image {}\n".format(input_images[i]))
print(classid_str, probability_str)
print("{} {}".format('-' * len(classid_str),
'-' * len(probability_str)))
for class_id in top_ind:
det_label = labels_map[class_id] if labels_map else "{}".format(
class_id)
label_length = len(det_label)
space_num_before = (len(classid_str) - label_length) // 2
space_num_after = len(classid_str) - (space_num_before +
label_length) + 2
space_num_before_prob = (len(probability_str) -
len(str(probs[class_id]))) // 2
print("{}{}{}{}{:.7f}".format(' ' * space_num_before, det_label,
' ' * space_num_after,
' ' * space_num_before_prob,
probs[class_id]))
print("\n")
log.info('This sample is an API example, for any performance measurements '
'please use the dedicated benchmark_app tool')
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(plugin.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(
net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
net.batch_size = len(args.input)
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = cv2.imread(args.input[i])
if image.shape[:-1] != (h, w):
log.warning("Image {} is resized from {} to {}".format(
args.input[i], image.shape[:-1], (h, w)))
image = cv2.resize(image, (w, h))
image = image.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
images[i] = image
log.info("Batch size is {}".format(n))
# Loading model to the plugin
log.info("Loading model to the plugin")
exec_net = plugin.load(network=net)
# Start sync inference
log.info("Starting inference ({} iterations)".format(args.number_iter))
infer_time = []
for i in range(args.number_iter):
t0 = time()
infer_request_handle = exec_net.start_async(
request_id=0, inputs={input_blob: images})
infer_request_handle.wait()
infer_time.append((time() - t0) * 1000)
log.info("Average running time of one iteration: {} ms".format(
np.average(np.asarray(infer_time))))
if args.perf_counts:
perf_counts = infer_request_handle.get_perf_counts()
log.info("Performance counters:")
print("{:<70} {:<15} {:<15} {:<15} {:<10}".format(
'name', 'layer_type', 'exet_type', 'status', 'real_time, us'))
for layer, stats in perf_counts.items():
print("{:<70} {:<15} {:<15} {:<15} {:<10}".format(
layer, stats['layer_type'], stats['exec_type'],
stats['status'], stats['real_time']))
# Processing output blob
log.info("Processing output blob")
res = infer_request_handle.outputs[out_blob]
log.info("Top {} results: ".format(args.number_top))
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.split(sep=' ', maxsplit=1)[-1].strip() for x in f]
else:
labels_map = None
classid_str = "classid"
probability_str = "probability"
for i, probs in enumerate(res):
probs = np.squeeze(probs)
top_ind = np.argsort(probs)[-args.number_top:][::-1]
print("Image {}\n".format(args.input[i]))
print(classid_str, probability_str)
print("{} {}".format('-' * len(classid_str),
'-' * len(probability_str)))
for id in top_ind:
det_label = labels_map[id] if labels_map else "{}".format(id)
label_length = len(det_label)
space_num_before = (7 - label_length) // 2
space_num_after = 7 - (space_num_before + label_length) + 2
space_num_before_prob = (11 - len(str(probs[id]))) // 2
print("{}{}{}{}{:.7f}".format(' ' * space_num_before, det_label,
' ' * space_num_after,
' ' * space_num_before_prob,
probs[id]))
print("\n")
import sys
import time
import random
import numpy
from tqdm import tqdm
import torch
from openvino.inference_engine import IECore, IENetwork
from networks import vgg11s
from netslim import load_pruned_model
# Initialize inference engine core
ie = IECore()
# build network with FP32
model_name = "vgg11s-pr05-FP32"
net = IENetwork(model="{}.xml".format(model_name), weights="{}.bin".format(model_name))
input_name = next(iter(net.inputs))
output_name = next(iter(net.outputs))
exec_net = ie.load_network(network=net, device_name="CPU")
openvino_pr05_fp32_pack = ["vgg11s-pr05-fp32-openvino", exec_net.infer, input_name]
# build network with FP16
model_name = "vgg11s-pr05-FP16"
net = IENetwork(model="{}.xml".format(model_name), weights="{}.bin".format(model_name))
input_name = next(iter(net.inputs))
output_name = next(iter(net.outputs))
exec_net = ie.load_network(network=net, device_name="CPU")
openvino_pr05_fp16_pack = ["vgg11s-pr05-fp16-openvino", exec_net.infer, input_name]
def run_openvino(net, input_name, n):
for i in range(n):
# ----------------- Load the model and create the inference engine ------------
# -----------------------------------------------------------------------------
log.info(f'Loading model')
model_xml = args['model']
model_bin = os.path.splitext(model_xml)[0] + '.bin'
log.info(f'... model file {model_xml}')
log.info(f'... weights file {model_bin}')
# -----------------------------------------------------------------------------
# ----------------- Create inference engine -----------------------------------
# -----------------------------------------------------------------------------
log.info('Creating inference engine')
ie = IECore()
net = IENetwork(model=model_xml, weights=model_bin)
if args['extension'] and 'CPU' in args['device']:
ie.add_extension(args['extension'], 'CPU')
log.info('...Checking that the network can be run on the selected device')
supported_layers = ie.query_network(net, args['device'])
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
'...The following layers are not supported by the device.\n {}'.format(
', '.join(not_supported_layers)))
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
with open(args.testparam, 'r') as stream:
test_param = yaml.load(stream, Loader=yaml.FullLoader)
sample_rate = test_param['sample_rate']
rolling_step = test_param['rolling_step'] # this is rolling step
test_folder = test_param['test_path'] + "/audio"
yaml_file = test_param['test_path'] + \
"/meta/mixture_recipes_devtest_gunshot.yaml"
print("Testing folder to proceed:")
print(test_folder)
print(model_bin)
log.info("Creating Inference Engine...")
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, "CPU")
# Read IR
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
if "CPU" in args.device:
supported_layers = ie.query_network(net, "CPU")
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(args.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
info_input_blob = None
input_shape_dims = None
feed_dict = {}
for blob_name in net.inputs:
print(len(net.inputs[blob_name].shape))
if len(net.inputs[blob_name].shape) == 3:
input_blob = blob_name
input_shape_dims = 3
elif len(net.inputs[blob_name].shape) == 2:
info_input_blob = blob_name
input_shape_dims = 2
else:
raise RuntimeError(
"Unsupported {}D input layer '{}'. Only 2D and 4D input layers are supported"
.format(len(net.inputs[blob_name].shape), blob_name))
print(len(net.outputs))
assert len(net.outputs) == 1, "Demo supports only single output topologies"
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = ie.load_network(network=net,
num_requests=1,
device_name=args.device)
# Read and pre-process input image
if input_shape_dims == 3:
batch_size, window_width, num_class = net.inputs[input_blob].shape
elif input_shape_dims == 2:
batch_size, window_width = net.inputs[input_blob].shape
else:
print("check input shape dimension: ")
return
print(net.inputs[input_blob].shape)
files = aux_fn.get_all_files(test_folder)
sig_process = {}
file_meta = None
with open(yaml_file, 'r') as infile:
metadata = yaml.load(infile, Loader=yaml.SafeLoader)
for file in tqdm(files):
file_time = time()
print(file)
logging.info(f' inference on {file}: ')
filename_wav = os.path.basename(file)
for i in range(len(metadata)):
if filename_wav in metadata[i]['mixture_audio_filename']:
file_meta = metadata[i]
break
data = load_data(window_width, file, sample_rate, rolling_step)
if input_shape_dims == 3:
data = np.expand_dims(data, axis=2)
iteration = data.shape[0]
pred = []
for iterate in range(iteration):
print(input_blob)
if input_shape_dims == 3:
feed_dict[input_blob] = data[iterate, :, :]
else:
feed_dict[input_blob] = data[iterate, :]
# inf_start = time.time()
exec_net.start_async(request_id=0, inputs=feed_dict)
if exec_net.requests[0].wait(-1) == 0:
# inf_end = time.time()
# det_time = inf_end - inf_start
res = exec_net.requests[0].outputs[out_blob]
print("result shape", res.shape)
pred.append(list(res))
sig_process[filename_wav] = get_response(data, pred, file_meta,
sample_rate, rolling_step)
tmp_time = time() - file_time
logging.info(
f" \tfile inference time = {tmp_time:.2f} s, {(tmp_time / 117) * 1000:.4f} ms per sample"
)
def read_segmentation_demo():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format("CPU"))
plugin = IEPlugin(device="CPU", plugin_dirs=plugin_dir)
plugin.add_cpu_extension(cpu_extension)
# Read IR
log.info("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(plugin.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in demo's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Demo supports only single input topologies"
assert len(net.outputs) == 1, "Demo supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=2)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob].shape
del net
cap = cv2.VideoCapture(
"/home/kang/Downloads/openvino_sample_show-master/material/read_segmentation_demo.mp4"
)
cur_request_id = 0
next_request_id = 1
log.info("Starting inference in async mode...")
log.info("To switch between sync and async modes press Tab button")
log.info("To stop the demo execution press Esc button")
is_async_mode = True
render_time = 0
ret, frame = cap.read()
print(
"To close the application, press 'CTRL+C' or any key with focus on the output window"
)
while cap.isOpened():
if is_async_mode:
ret, next_frame = cap.read()
else:
ret, frame = cap.read()
if not ret:
break
initial_w = cap.get(3)
initial_h = cap.get(4)
# 开启同步或者异步执行模式
inf_start = time.time()
if is_async_mode:
in_frame = cv2.resize(next_frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=next_request_id,
inputs={input_blob: in_frame})
else:
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=cur_request_id,
inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
# 获取网络输出
res = exec_net.requests[cur_request_id].outputs[out_blob]
# 解析道路分割结果
res = np.squeeze(res, 0)
res = res.transpose(1, 2, 0) #HWC格式
res = np.argmax(res, 2)
hh, ww = res.shape
mask = np.zeros((hh, ww, 3), dtype=np.uint8)
mask[np.where(res > 0)] = (0, 255, 255)
mask[np.where(res > 1)] = (255, 0, 255)
# 显示mask
cv2.imshow("mask", mask)
# 叠加输出结果 --解决图的不一样大小问题,1是高度，0是宽度
mask = cv2.resize(mask, dsize=(frame.shape[1], frame.shape[0]))
# 想要增加颜色深度，就增大0.2，减小0.8，和为1
frame = cv2.addWeighted(mask, 0.2, frame, 0.8, 0)
inf_end = time.time()
det_time = inf_end - inf_start
# Draw performance stats
inf_time_message = "Inference time: {:.3f} ms, FPS:{:.3f}".format(
det_time * 1000, 1000 / (det_time * 1000 + 1))
render_time_message = "OpenCV rendering time: {:.3f} ms".format(
render_time * 1000)
async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
"Async mode is off. Processing request {}".format(cur_request_id)
cv2.putText(frame, inf_time_message, (15, 15),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
cv2.putText(frame, render_time_message, (15, 30),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
#
render_start = time.time()
cv2.imshow("segmentation Results", frame)
render_end = time.time()
render_time = render_end - render_start
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
frame = next_frame
key = cv2.waitKey(1)
if key == 27:
break
cv2.destroyAllWindows()
del exec_net
del plugin
def main_IE_infer():
# Define Constants.
t1 = 0
fps = ""
#framepos = 0
#frame_count = 0
#vidfps = 0
#skip_frame = 0
#elapsedTime = 0
detected_people_frames = [0, 0, 0, 0, 0]
detected_hat_frames = [0, 0, 0, 0, 0]
detected_vest_frames = [0, 0, 0, 0, 0]
print("loading the model...")
# args = build_argparser().parse_args()
model_xml = "tiny_yolo_IR_500000_FP32.xml" #<--- MYRIAD
model_bin = os.path.splitext(model_xml)[0] + ".bin"
time.sleep(1)
print("loading plugin on Intel NCS2...")
plugin = IEPlugin(device="CPU")
net = IENetwork(model=model_xml, weights=model_bin)
input_blob = next(iter(net.inputs))
exec_net = plugin.load(network=net)
# Define a window to show the cam stream on it
window_title = "PPE Detector"
cv2.namedWindow(window_title, cv2.WINDOW_NORMAL)
while cap.isOpened():
current_time = time.ctime()
# initialize lists to store objects in frame
People = []
Hats = []
Vests = []
objects = []
det_person = 0
det_hat = 0
det_vest = 0
# Shift register for detected objects.
detected_people_frames[1:] = detected_people_frames[0:9]
detected_hat_frames[1:] = detected_hat_frames[0:9]
detected_vest_frames[1:] = detected_vest_frames[0:9]
#lload the image from the camera.
ret, image = cap.read()
if not ret:
break
#resized_image = cv2.resize(image, (new_w, new_h), interpolation = cv2.INTER_CUBIC) #resize image to 416x416
resized_image = cv2.resize(image,
(new_w, new_h)) #resize image to 416x416
resized_image = cv2.cvtColor(resized_image, cv2.COLOR_RGB2BGR)
canvas = np.full((m_input_size, m_input_size, 3), 0)
canvas[(m_input_size - new_h) // 2:(m_input_size - new_h) // 2 + new_h,
(m_input_size - new_w) // 2:(m_input_size - new_w) // 2 +
new_w, :] = resized_image
prepimg = canvas
prepimg = prepimg[np.newaxis, :, :, :] # Batch size axis add
prepimg = prepimg.transpose((0, 3, 1, 2)) # NHWC to NCHW
outputs = exec_net.infer(inputs={input_blob: prepimg})
for output in outputs.values():
objects = ParseYOLOV3Output(output, new_h, new_w, camera_height,
camera_width, confidence_threshold_hat,
objects)
# Filtering overlapping boxes same class
# Separate classes detected.
objlen = len(objects)
for i in range(objlen):
if (objects[i].class_id == 0):
People.append(objects[i])
if (objects[i].class_id == 1):
Hats.append(objects[i])
if (objects[i].class_id == 2):
Vests.append(objects[i])
# Elimitate overlaping Hats.
objlen = len(Hats)
for i in range(objlen):
if (Hats[i].confidence == 0.0):
continue
for j in range(i + 1, objlen):
if (IntersectionOverUnion(Hats[i], Hats[j]) >= IOU_threshold):
if Hats[i].confidence < Hats[j].confidence:
Hats[i], Hats[j] = Hats[j], Hats[i]
Hats[j].confidence = 0.0
# Drawing hats boxes.
for obj in Hats:
if obj.confidence < confidence_threshold_hat:
continue
label = obj.class_id
confidence = obj.confidence
#if confidence >= 0.2:
label_text = LABELS[label] + " (" + "{:.1f}".format(
confidence * 100) + "%)"
#label_text = LABELS[label]
cv2.rectangle(image, (obj.xmin, obj.ymin), (obj.xmax, obj.ymax),
color2, box_thickness)
cv2.putText(image, label_text, (obj.xmin, obj.ymin - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_text_color, 1)
det_hat = det_hat + 1
detected_hat_frames[0] = det_hat
# Eliminate overlaping vests.
objlen = len(Vests)
for i in range(objlen):
if (Vests[i].confidence == 0.0):
continue
for j in range(i + 1, objlen):
if (IntersectionOverUnion(Vests[i], Vests[j]) >=
IOU_threshold):
if Vests[i].confidence < Vests[j].confidence:
Vests[i], Vests[j] = Vests[j], Vests[i]
Vests[j].confidence = 0.0
# Drawing vests boxes
for obj in Vests:
#print(str(confidence))
if obj.confidence < confidence_threshold_vest:
continue
label = obj.class_id
confidence = obj.confidence
#print(str(confidence))
label_text = LABELS[label] + " (" + "{:.1f}".format(
confidence * 100) + "%)"
#label_text = LABELS[label]
cv2.rectangle(image, (obj.xmin, obj.ymin), (obj.xmax, obj.ymax),
color3, box_thickness)
cv2.putText(image, label_text, (obj.xmin, obj.ymin - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_text_color, 1)
det_vest = det_vest + 1
detected_vest_frames[0] = det_vest
# Eliminate overlaping people
objlen = len(People)
for i in range(objlen):
if (People[i].confidence == 0.0):
continue
for j in range(i + 1, objlen):
if (IntersectionOverUnion(People[i], People[j]) >=
IOU_threshold):
if People[i].confidence < People[j].confidence:
People[i], People[j] = People[j], People[i]
People[j].confidence = 0.0
# Drawing people's boxes
for obj in People:
if obj.confidence < confidence_threshold_person:
continue
label = obj.class_id
confidence = obj.confidence
#if confidence >= 0.2:
label_text = LABELS[label] + " (" + "{:.1f}".format(
confidence * 100) + "%)"
#label_text = LABELS[label]
cv2.rectangle(image, (obj.xmin, obj.ymin), (obj.xmax, obj.ymax),
color1, box_thickness)
cv2.putText(image, label_text, (obj.xmin, obj.ymin - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_text_color, 1)
det_person = det_person + 1
detected_people_frames[0] = det_person
conclusion_color = [0, 0, 255]
if max(detected_people_frames) != 0:
if max(detected_hat_frames) != 0:
if max(detected_vest_frames) != 0:
conclusion = "PPE: Detected!"
conclusion_color = [0, 0, 255]
print(current_time[11:19] + ' - ' + '\x1b[6;30;42m' +
'[✔] %s [✔]' % (conclusion) + '\x1b[0m')
#sh.set_pixels(Person_Vest_Hat)
conclusion_color = [0, 255, 0]
else:
conclusion = "PPE: Not Pass, Missing Vest"
print(current_time[11:19] + ' - ' + '\x1b[1;29;41m' +
'[✘]' + conclusion + '[✘]' + '\x1b[0m')
#sh.set_pixels(Person_hat)
else:
if max(detected_vest_frames) != 0:
conclusion = "PPE: Not Pass, Missing Hat"
print(current_time[11:16] + ' - ' + '\x1b[1;29;41m' +
'[✘]' + conclusion + '[✘]' + '\x1b[0m')
#sh.set_pixels(Person_Vest)
else:
conclusion = "PPE: Not Pass, Missing Vest and hat"
print(current_time[11:19] + ' - ' + '\x1b[1;29;41m' +
'[✘]' + conclusion + '[✘]' + '\x1b[0m')
#sh.set_pixels(Person)
else:
conclusion = "No Person Detected"
#sh.set_pixels(question_mark) #display a question mark
print(current_time[11:19] + ' - ' + conclusion)
# Write Performance information.
elapsedTime = time.time() - t1
fps = "{:.1f} FPS".format(1 / elapsedTime)
# print((fps+ " - " + conclusion))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Restart the time.
#t1 = time.time()
cv2.putText(image, (fps), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
conclusion_color, 1, cv2.LINE_AA)
#Display Image
cv2.imshow(window_title, image)
# wrute the output
for f in range(3):
out.write(image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Restart the time.
t1 = time.time()
#temp = sh.get_temperature()
#print("Temp: %s ºC" % str(round(temp,1))) # Show temp on console
#rawCapture.truncate(0)
out.release()
cv2.destroyAllWindows()
#sh.clear(0,0,0)
del net
del exec_net
del plugin
def make_network(model, weights):
return IENetwork(model = model, weights = weights)
def main():
parser = argparse.ArgumentParser(
description='Component executing inference operation')
parser.add_argument('--model_bin',
type=str,
required=True,
help='GCS or local path to model weights file (.bin)')
parser.add_argument('--model_xml',
type=str,
required=True,
help='GCS or local path to model graph (.xml)')
parser.add_argument('--input_numpy_file',
type=str,
required=True,
help='GCS or local path to input dataset numpy file')
parser.add_argument('--label_numpy_file',
type=str,
required=True,
help='GCS or local path to numpy file with labels')
parser.add_argument('--output_folder',
type=str,
required=True,
help='GCS or local path to results upload folder')
parser.add_argument('--batch_size',
type=int,
default=1,
help='batch size to be used for inference')
parser.add_argument('--scale_div',
type=float,
default=1,
help='scale the np input by division of by the value')
parser.add_argument('--scale_sub',
type=float,
default=128,
help='scale the np input by substraction of the value')
args = parser.parse_args()
print(args)
device = "CPU"
plugin_dir = None
model_xml = get_local_file(args.model_xml)
print("model xml", model_xml)
if model_xml == "":
exit(1)
model_bin = get_local_file(args.model_bin)
print("model bin", model_bin)
if model_bin == "":
exit(1)
input_numpy_file = get_local_file(args.input_numpy_file)
print("input_numpy_file", input_numpy_file)
if input_numpy_file == "":
exit(1)
label_numpy_file = get_local_file(args.label_numpy_file)
print("label_numpy_file", label_numpy_file)
if label_numpy_file == "":
exit(1)
cpu_extension = "/usr/local/lib/libcpu_extension.so"
plugin = IEPlugin(device=device, plugin_dirs=plugin_dir)
if cpu_extension and 'CPU' in device:
plugin.add_cpu_extension(cpu_extension)
print("inference engine:", model_xml, model_bin, device)
# Read IR
print("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
batch_size = args.batch_size
net.batch_size = batch_size
print("Model loaded. Batch size", batch_size)
input_blob = next(iter(net.inputs))
output_blob = next(iter(net.outputs))
print(output_blob)
print("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=1)
print("Loading input numpy")
imgs = np.load(input_numpy_file, mmap_mode='r', allow_pickle=False)
imgs = (imgs / args.scale_div) - args.scale_div
lbs = np.load(label_numpy_file, mmap_mode='r', allow_pickle=False)
print("Loaded input data", imgs.shape, imgs.dtype, "Min value:",
np.min(imgs), "Max value", np.max(imgs))
combined_results = {} # dictionary storing results for all model outputs
processing_times = np.zeros((0), int)
matched_count = 0
total_executed = 0
for x in range(0, imgs.shape[0] - batch_size + 1, batch_size):
img = imgs[x:(x + batch_size)]
lb = lbs[x:(x + batch_size)]
start_time = datetime.datetime.now()
results = exec_net.infer(inputs={input_blob: img})
end_time = datetime.datetime.now()
duration = (end_time - start_time).total_seconds() * 1000
print("Inference duration:", duration, "ms")
processing_times = np.append(processing_times,
np.array([int(duration)]))
output = list(results.keys())[0] # check only one output
nu = results[output]
for i in range(nu.shape[0]):
single_result = nu[[i], ...]
ma = np.argmax(single_result)
total_executed += 1
if ma == lb[i]:
matched_count += 1
mark_message = "; Correct match."
else:
mark_message = "; Incorrect match. Should be {} {}".format(
lb[i], classes.imagenet_classes[lb[i]])
print("\t", i, classes.imagenet_classes[ma], ma, mark_message)
if output in combined_results:
combined_results[output] = np.append(combined_results[output],
results[output], 0)
else:
combined_results[output] = results[output]
filename = output.replace("/", "_") + ".npy"
np.save(filename, combined_results[output])
upload_file(filename, args.output_folder)
print("Inference results uploaded to", filename)
print('Classification accuracy: {:.2f}'.format(100 * matched_count /
total_executed))
print('Average time: {:.2f} ms; average speed: {:.2f} fps'.format(
round(np.average(processing_times), 2),
round(1000 * batch_size / np.average(processing_times), 2)))
accuracy = matched_count / total_executed
latency = np.average(processing_times)
metrics = {
'metrics': [{
'name': 'accuracy-score',
'numberValue': accuracy,
'format': "PERCENTAGE"
}, {
'name': 'latency',
'numberValue': latency,
'format': "RAW"
}]
}
with open('/mlpipeline-metrics.json', 'w') as f:
json.dump(metrics, f)
# load the configuration file
conf = Conf(args["conf"])
# load the COCO class labels our YOLO model was trained on and
# initialize a list of colors to represent each possible class
# label
LABELS = open(conf["labels_path"]).read().strip().split("\n")
np.random.seed(42)
COLORS = np.random.uniform(0, 255, size=(len(LABELS), 3))
# initialize the plugin in for specified device
plugin = IEPlugin(device="MYRIAD")
# read the IR generated by the Model Optimizer (.xml and .bin files)
print("[INFO] loading models...")
net = IENetwork(model=conf["xml_path"], weights=conf["bin_path"])
# prepare inputs
print("[INFO] preparing inputs...")
inputBlob = next(iter(net.inputs))
# set the default batch size as 1 and get the number of input blobs,
# number of channels, the height, and width of the input blob
net.batch_size = 1
(n, c, h, w) = net.inputs[inputBlob].shape
# if a video path was not supplied, grab a reference to the webcam
if args["input"] is None:
print("[INFO] starting video stream...")
# vs = VideoStream(src=0).start()
vs = VideoStream(usePiCamera=True).start()
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format(args.device))
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
if len(not_supported_layers) != 0:
log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
format(plugin.device, ', '.join(not_supported_layers)))
log.error("Please try to specify cpu extensions library path in demo's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Demo supports only single input topologies"
assert len(net.outputs) == 1, "Demo supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=2)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob].shape
log.info("Net input shape: " + str((n, c, h, w)))
log.info("Net output shape: " + str(net.outputs[out_blob].shape))
del net
if args.input == 'cam':
input_stream = 0
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
cap = cv2.VideoCapture(input_stream)
cur_request_id = 0
next_request_id = 1
log.info("Starting inference in async mode...")
log.info("To switch between sync and async modes press Tab button")
log.info("To stop the demo execution press Esc button")
is_async_mode = True
render_time = 0
ret, frame = cap.read()
print("To close the application, press 'q'")
while cap.isOpened():
if is_async_mode:
ret, next_frame = cap.read()
else:
ret, frame = cap.read()
if not ret:
break
initial_w = cap.get(3)
initial_h = cap.get(4)
# Main sync point:
# in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
# in the regular mode we start the CURRENT request and immediately wait for it's completion
inf_start = time.time()
if is_async_mode:
in_frame = cv2.resize(next_frame, (w, h))
in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=next_request_id, inputs={input_blob: in_frame})
else:
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
inf_end = time.time()
det_time = inf_end - inf_start
# Parse detection results of the current request, only need one so choose max prob
res = exec_net.requests[cur_request_id].outputs[out_blob]
for obj in res[0][0]:
# Draw only objects when probability more than specified threshold
if obj[2] > args.prob_threshold:
best_proposal = obj
xmin = int(best_proposal[3] * initial_w)
ymin = int(best_proposal[4] * initial_h)
xmax = int(best_proposal[5] * initial_w)
ymax = int(best_proposal[6] * initial_h)
class_id = int(best_proposal[1])
# Draw box and label\class_id
color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 5, 255))
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
det_label = labels_map[class_id - 1] if labels_map else str(class_id)
label_and_prob = det_label + ", " + str(obj[2] * 100) + "%"
cv2.putText(frame, label_and_prob, (xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1)
# Draw performance stats
inf_time_message = "Inference time: N\A for async mode" if is_async_mode else \
"Inference time: {:.3f} ms".format(det_time * 1000)
render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
"Async mode is off. Processing request {}".format(cur_request_id)
cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
(10, 10, 200), 1)
render_start = time.time()
cv2.imshow("Detection Results", frame)
render_end = time.time()
render_time = render_end - render_start
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
frame = next_frame
key = cv2.waitKey(1)
if (key & 0xFF) == ord('q'): # NOTICE: Changed exit key to 'q', not 'CTRL + C'
break
if (9 == key):
is_async_mode = not is_async_mode
log.info("Switched to {} mode".format("async" if is_async_mode else "sync"))
cv2.destroyAllWindows()
import cv2
import numpy as np
from openvino.inference_engine import IENetwork, IECore # 環境設定をした環境下で読み込みできる
model_xml = "./model/face-detection-adas-0001.xml" # 学習モデルの呼び出し
model_bin = "./model/face-detection-adas-0001.bin" # xmlに対応するbinファイル
model_age_xml = "./model/age-gender-recognition-retail-0013.xml" # 学習モデルの呼び出し
model_age_bin = "./model/age-gender-recognition-retail-0013.bin" # xmlに対応するbinファイル
#age版
ie_age = IECore() # IRの作成
net_age = IENetwork(model=model_age_xml, weights=model_age_bin) # モデルの読み込み、定義
input_blob_age = next(iter(net_age.inputs)) # モデルの入力パラメータを取り出す
out_blob_age = next(iter(net_age.outputs)) # 出力パラメータを取り出す
net_age.batch_size = 1 # バッチサイズ（周りのやつ）
net_age.inputs[input_blob_age].precision = "U8" # uint8型(画像配列)に変換
n, c, h_age, w_age = net_age.inputs[input_blob_age].shape # モデルで必要とされる枚数n､深さc､幅高さ
#image = np.ndarray(shape=(c, h, w)) # 配列を準備
image = cv2.imread('me.png') # 画像の読み込み
if image.shape[:-1] != (w_age ,h_age): # 大きさが違うときリサイズ
image = cv2.resize(image, (w_age, h_age))
image = image.transpose((2, 0, 1)) # 入力画像がHWC なのをCHWの変換
exec_net_age = ie_age.load_network(network=net_age, device_name='CPU') # 設定したプラグインの読み込み
res_age = exec_net_age.infer(inputs={input_blob_age: image}) # 推論を行う
res_age = res_age[out_blob_age] # 結果の取り出し
prob = exec_net_age.requests[0].outputs['prob']
def load_model(self,
model,
device,
input_size,
output_size,
num_requests,
cpu_extension=None):
"""
Loads a network and an image to the Inference Engine plugin.
:param model: .xml file of pre trained model
:param cpu_extension: extension for the CPU device
:param device: Target device
:param input_size: Number of input layers
:param output_size: Number of output layers
:param num_requests: Index of Infer request value. Limited to device capabilities.
:return: Shape of input layer
"""
model_xml = model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device
# and load extensions library if specified
log.info("Initializing plugin for {} device...".format(device))
#self.plugin = IEPlugin(device=device)
ie = IECore()
#if cpu_extension and 'CPU' in device:
if cpu_extension and 'CPU' == device:
#self.plugin.add_cpu_extension(cpu_extension)
ie.add_extension(cpu_extension, device)
# Read IR
log.info("Reading IR...")
self.net = IENetwork(model=model_xml, weights=model_bin)
log.info("Loading IR to the plugin...")
if device == "CPU":
supported_layers = ie.query_network(self.net, device)
not_supported_layers = \
[l for l in self.net.layers.keys() if l not in supported_layers]
if len(not_supported_layers) != 0:
log.error("Following layers are not supported by "
"the plugin for specified device {}:\n {}".format(
device, ', '.join(not_supported_layers)))
log.error("Please try to specify cpu extensions library path"
" in command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
if num_requests == 0:
# Loads network read from IR to the plugin
# self.net_plugin = self.plugin.load(network=self.net)
self.net_plugin = ie.load_network(network=self.net,
device_name=device)
else:
#self.net_plugin = self.plugin.load(network=self.net, num_requests=2,device_name=TARGET_DEVICE )
self.net_plugin = ie.load_network(network=self.net,
num_requests=2,
device_name=device)
self.input_blob = next(iter(self.net.inputs))
self.out_blob = next(iter(self.net.outputs))
assert len(self.net.inputs.keys()) == input_size,\
"Supports only {} input topologies".format(len(self.net.inputs))
assert len(self.net.outputs) == output_size, \
"Supports only {} output topologies".format(len(self.net.outputs))
return self.get_input_shape()
def predict(img):
model_xml = "C:\modeloptimizing\HTRModel.xml"
model_bin = "C:\modeloptimizing\HTRModel.bin"
ie = IECore()
net = IENetwork(model=model_xml, weights=model_bin)
input_blob = next(iter(net.inputs))
n, c, h, w = net.inputs[input_blob].shape
exec_net = ie.load_network(network=net, device_name="CPU")
input_size = (1024, 128, 1)
img = preprocess(img, input_size=input_size)
img = normalization([img])
img = np.squeeze(img, axis=3)
img = np.expand_dims(img, axis=0)
start = timer()
print("Starting inference...")
res = exec_net.infer(inputs={input_blob: img})
end = timer()
print("End inference time: ", 1000 * (end - start))
output_data = res['dense/BiasAdd/Softmax']
print(output_data)
steps_done = 0
steps = 1
batch_size = int(np.ceil(len(output_data) / steps))
input_length = len(max(output_data, key=len))
predicts, probabilities = [], []
while steps_done < steps:
index = steps_done * batch_size
until = index + batch_size
x_test = np.asarray(output_data[index:until])
x_test_len = np.asarray([input_length for _ in range(len(x_test))])
decode, log = K.ctc_decode(x_test,
x_test_len,
greedy=False,
beam_width=10,
top_paths=3)
probabilities.extend([np.exp(x) for x in log])
decode = [[[int(p) for p in x if p != -1] for x in y] for y in decode]
predicts.extend(np.swapaxes(decode, 0, 1))
steps_done += 1
for p in predicts:
print(str(p))
for pb in probabilities:
print(str(pb))
#interpretation of the data
max_text_length = 128
charset_base = string.printable[:95]
tokenizer = Tokenizer(chars=charset_base, max_text_length=max_text_length)
predicts = [[tokenizer.decode(x) for x in y] for y in predicts]
print("\n####################################")
for i, (pred, prob) in enumerate(zip(predicts, probabilities)):
print("\nProb. - Predict")
for (pd, pb) in zip(pred, prob):
print(f"{pb:.4f} - {pd}")
if i == 0:
pbperc = pb * 100
pdfinal = pd
i = 1 + i
print("\n####################################")
return pdfinal, pbperc
def load_model(self, model, batch_size, concurrency, device, cpu_ext=None):
# Initialize the Inference Engine
self.plugin = IECore()
#self.plugin.set_config({'CPU_THREADS_NUM': '8'}, "CPU")
#self.plugin.set_config({'DYN_BATCH_ENABLED': 'YES'}, "CPU")
#print(self.plugin.available_devices)
### Add any necessary extensions ###
if cpu_ext and device.lower() == 'cpu':
self.plugin.add_extension(cpu_ext, device)
# Initialize IENetwork object from IR files
model_xml = model
model_bin = os.path.splitext(model_xml)[0] + '.bin'
self.network = IENetwork(model=model_xml, weights=model_bin)
# Support topologies with 1 and 2 inputs
self.image_tensor_blob = None
self.image_info_blob = None
for input_key, input_val in self.network.inputs.items():
if len(input_val.shape) == 4: # image tensor
self.image_tensor_blob = input_key
elif len(input_val.shape) == 2: # image info
self.image_info_blob = input_key
assert self.image_tensor_blob is not None, \
"Failed to find the input image specification"
self.output_blob = next(iter(self.network.outputs))
# Works for SSD models, but for Faster RCNN it fails:
# RuntimeError: Failed to infer shapes for Reshape layer
# (Reshape_Transpose_Class) with error: Invalid reshape mask
# (dim attribute): number of elements in input: [7,2,12,1444]
# and output: [1,24,38,38] mismatch
## This will reshape the network, so it can take
## several frames in a batch and also the output
## tensor will be (1,1,N*100,7) instead of (N,1,100,7).
#input_shape = self.network.inputs[self.image_tensor_blob].shape
#input_shape[0] = batch_size
#self.network.reshape({self.image_tensor_blob: input_shape})
# Set the network batch size
self.network.batch_size = batch_size
### Check for unsupported layers ###
supported_layers = self.plugin.query_network(network=self.network,
device_name=device)
supported_layers = set(supported_layers.keys())
net_layers = set(self.network.layers.keys())
unsupported_layers = net_layers.difference(supported_layers)
if unsupported_layers:
raise Exception('Unsupported layers: ' +
', '.join(unsupported_layers))
### Load the model ###
self.exec_network = self.plugin.load_network(network=self.network,
device_name=device,
num_requests=concurrency)
# Initialize member variables
self.request_id = 0
self.request_count = 0
self.concurrency = concurrency
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Creating Inference Engine")
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, "CPU")
# Read IR
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
if "CPU" in args.device:
supported_layers = ie.query_network(net, "CPU")
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(args.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(
net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
net.batch_size = len(args.input)
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = cv2.imread(args.input[i])
if image.shape[:-1] != (h, w):
log.warning("Image {} is resized from {} to {}".format(
args.input[i], image.shape[:-1], (h, w)))
image = cv2.resize(image, (w, h))
image = image.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
images[i] = image
log.info("Batch size is {}".format(n))
# Loading model to the plugin
log.info("Loading model to the plugin")
exec_net = ie.load_network(network=net, device_name=args.device)
# Start sync inference
log.info("Starting inference in synchronous mode")
res = exec_net.infer(inputs={input_blob: images})
# Processing output blob
log.info("Processing output blob")
res = res[out_blob]
log.info("Top {} results: ".format(args.number_top))
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.split(sep=' ', maxsplit=1)[-1].strip() for x in f]
else:
labels_map = None
classid_str = "classid"
probability_str = "probability"
for i, probs in enumerate(res):
probs = np.squeeze(probs)
top_ind = np.argsort(probs)[-args.number_top:][::-1]
print("Image {}\n".format(args.input[i]))
print(classid_str, probability_str)
print("{} {}".format('-' * len(classid_str),
'-' * len(probability_str)))
for id in top_ind:
det_label = labels_map[id] if labels_map else "{}".format(id)
label_length = len(det_label)
space_num_before = (len(classid_str) - label_length) // 2
space_num_after = len(classid_str) - (space_num_before +
label_length) + 2
space_num_before_prob = (len(probability_str) -
len(str(probs[id]))) // 2
print("{}{}{}{}{:.7f}".format(' ' * space_num_before, det_label,
' ' * space_num_after,
' ' * space_num_before_prob,
probs[id]))
print("\n")
log.info(
"This sample is an API example, for any performance measurements please use the dedicated benchmark_app tool\n"
)
def main():
args = build_argparser().parse_args()
model_name = args.model
device = args.device
video_file = args.video
max_people = args.max_people
threshold = args.threshold
output_path = args.output_path
## Load Model
model_weights = model_name + '.bin'
model_structure = model_name + '.xml'
# Loading time
start_model_load_time = time.time()
# Extension
CPU_EXTENSION = "/opt/intel/openvino/deployment_tools/inference_engine/lib/intel64/libcpu_extension_sse4.so"
# Read the model
core = IECore()
#model = core.read_network(model=model_structure, weights=model_weights) # new openvino version
model = IENetwork(model=model_structure,
weights=model_weights) #old openvino version
# Add CPU extension
core.add_extension(CPU_EXTENSION, device)
# Load the network into an executable network
exec_network = core.load_network(network=model,
device_name=device,
num_requests=1)
print("Model is loaded")
# Time to load the model
total_model_load_time = time.time() - start_model_load_time
print("Time to load model: " + str(total_model_load_time))
# Get the input layer
input_name = next(iter(model.inputs))
input_shape = model.inputs[input_name].shape
output_name = next(iter(model.outputs))
output_shape = model.outputs[output_name].shape
print("input_name:" + str(input_name))
print("input_shape:" + str(input_shape))
print("output_name: " + str(output_name))
print("output_shape: " + str(output_shape))
# Get the input shape
n, c, h, w = (core, input_shape)[1]
# Get the input video stream
cap = cv2.VideoCapture(video_file)
# Information about the input video stream
initial_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
initial_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
print("initial_w: " + str(initial_w))
print("initial_h: " + str(initial_h))
print("video_len: " + str(video_len))
print("fps: " + str(fps))
# Define output video
out_video = cv2.VideoWriter(os.path.join(output_path, 'output_video3.mp4'),
cv2.VideoWriter_fourcc(*'avc1'), fps,
(initial_w, initial_h), True)
request_id = 0
### Read from the video capture ###
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
key_pressed = cv2.waitKey(60)
# Pre-process the image as needed
image = cv2.resize(frame, (w, h))
image = image.transpose((2, 0, 1))
image = image.reshape((n, c, h, w))
print("n-c-h-w " + str(n) + "-" + str(c) + "-" + str(h) + "-" + str(w))
# Start asynchronous inference for specified request
start_inference_time = time.time()
infer_request_handle = async_inference(exec_network, input_name, image)
# Get the output data
res = get_output(exec_network,
infer_request_handle,
output_name,
request_id=0,
output=None)
detection_time = time.time() - start_inference_time
print("Detection time: " + str(detection_time))
# Draw Bounding Box
frame = boundingbox(res, initial_w, initial_h, frame, threshold)
# Write the output video
out_video.write(frame)
cap.release()
cv2.destroyAllWindows()
class ModelOpenVINO(object):
def __init__(self,
xml_file_path,
bin_file_path=None,
mapping_file_path=None,
device='CPU',
required_inputs=None,
required_outputs=None,
max_num_requests=1,
collect_perf_counters=False,
cfg=None,
classes=None):
from openvino.inference_engine import IENetwork
ie = IECore()
logging.info('Reading network from IR...')
if bin_file_path is None:
bin_file_path = osp.splitext(xml_file_path)[0] + '.bin'
if mapping_file_path is None:
mapping_file_path = osp.splitext(xml_file_path)[0] + '.mapping'
self.net = IENetwork(model=xml_file_path, weights=bin_file_path)
self.orig_ir_mapping = self.get_mapping(mapping_file_path)
self.ir_orig_mapping = {v: k for k, v in self.orig_ir_mapping.items()}
self.net_inputs_mapping = OrderedDict({})
self.net_outputs_mapping = OrderedDict({})
self.configure_inputs(required_inputs)
self.configure_outputs(required_outputs)
if 'CPU' in device:
self.check_cpu_support(ie, self.net)
logging.info('Loading network to plugin...')
self.max_num_requests = max_num_requests
self.exec_net = ie.load_network(network=self.net,
device_name=device,
num_requests=max_num_requests)
self.perf_counters = None
if collect_perf_counters:
self.perf_counters = PerformanceCounters()
self.pt_model = None
if cfg is not None:
self.pt_model = build_detector(cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg)
if classes is not None:
self.pt_model.CLASSES = classes
@staticmethod
def check_cpu_support(ie, net):
logging.info('Check that all layers are supported...')
supported_layers = ie.query_network(net, 'CPU')
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
unsupported_info = '\n\t'.join(
'{} ({} with params {})'.format(
layer_id, net.layers[layer_id].type,
str(net.layers[layer_id].params))
for layer_id in not_supported_layers)
logging.warning(
'Following layers are not supported '
'by the CPU plugin:\n\t{}'.format(unsupported_info))
logging.warning(
'Please try to specify cpu extensions library path.')
raise ValueError('Some of the layers are not supported.')
def get_mapping(self, mapping_file_path=None):
mapping = {}
if mapping_file_path is not None:
logging.info('Loading mapping file...')
root = etree.parse(mapping_file_path).getroot()
for m in root:
if m.tag != 'map':
continue
framework = m.find('framework')
ir = m.find('IR')
framework_name = framework.get('name')
ir_name = ir.get('name')
mapping[framework_name] = ir_name
if framework_name != ir_name:
# FIXME. This may not be correct for all operations.
mapping[framework_name] += '.0'
return mapping
def try_add_extra_outputs(self, extra_outputs):
if extra_outputs is None:
return
for extra_output in extra_outputs:
if extra_output not in self.orig_ir_mapping:
continue
ir_name = self.orig_ir_mapping[extra_output]
try:
self.net.add_outputs(ir_name)
except RuntimeError:
pass
def configure_inputs(self, required):
self.net_inputs_mapping = OrderedDict(
(i, i) for i in self.net.inputs.keys())
self.check_required(self.net_inputs_mapping.keys(), required)
def configure_outputs(self, required):
self.try_add_extra_outputs(required)
self.net_outputs_mapping = OrderedDict(
(i, self.ir_orig_mapping[i]) for i in self.net.outputs.keys())
self.check_required(self.orig_ir_mapping.keys(), required)
def set_outputs(self, outputs):
self.check_required(self.orig_ir_mapping.keys(), outputs)
self.net_outputs_mapping = OrderedDict(
(self.orig_ir_mapping[i], i) for i in outputs)
@staticmethod
def check_required(available, required):
if required is None:
return
for x in required:
if x not in available:
raise ValueError(
f'Failed to identify data blob with name "{x}"')
def rename_outputs(self, outputs):
return {
self.net_outputs_mapping[k]: v
for k, v in outputs.items() if k in self.net_outputs_mapping
}
def unify_inputs(self, inputs):
if not isinstance(inputs, dict):
if len(self.net_inputs_mapping) == 1 and not isinstance(
inputs, (list, tuple)):
inputs = [inputs]
inputs = {
k: v
for (k, _), v in zip(self.net_inputs_mapping.items(), inputs)
}
inputs = {self.net_inputs_mapping[k]: v for k, v in inputs.items()}
return inputs
def __call__(self, inputs):
inputs = self.unify_inputs(inputs)
outputs = self.exec_net.infer(inputs)
if self.perf_counters:
perf_counters = self.exec_net.requests[0].get_perf_counts()
self.perf_counters.update(perf_counters)
return self.rename_outputs(outputs)
def print_performance_counters(self):
if self.perf_counters:
self.perf_counters.print()
def show(self, data, result, dataset=None, score_thr=0.3, wait_time=0):
if self.pt_model is not None:
self.pt_model.show_result(data,
result,
dataset=dataset,
score_thr=score_thr,
wait_time=wait_time)
from openvino.inference_engine import IENetwork, IECore
import numpy as np
import time
# Loading model
model_path = 'sep_cnn/sep_cnn'
model_weights = model_path + '.bin'
model_structure = model_path + '.xml'
# TODO: Load the model
model = IENetwork(model_structure, model_weights)
core = IECore()
net = core.load_network(network=model, device_name='CPU', num_requests=1)
print('Model loaded successfully')
input_name = next(iter(model.inputs))
# Reading and Preprocessing Image
input_img = np.load('image.npy')
input_img = input_img.reshape(1, 28, 28)
input_dict = {input_name: input_img}
# TODO: Using the input image, run inference on the model for 10 iterations
start = time.time()
for _ in range(10):
net.infer(input_dict)
# TODO: Finish the print statement
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
# Configure plugin to support dynamic batch size
plugin.set_config({"DYN_BATCH_ENABLED": "YES"})
# Load cpu_extensions library if specified
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
net = IENetwork(model=model_xml, weights=model_bin)
# Check for unsupported layers if the device is 'CPU'
if plugin.device == "CPU":
unsupported_layers = [layer for layer in net.layers if layer not in plugin.get_supported_layers(net)]
if len(unsupported_layers) != 0:
log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
format(plugin.device, ', '.join(unsupported_layers)))
log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
# Set max batch size
inputs_count = len(args.input)
if args.max_batch < inputs_count:
log.warning("Defined max_batch size {} less than input images count {}."
"\n\t\t\tInput images count will be used as max batch size".format(args.max_batch, inputs_count))
net.batch_size = max(args.max_batch, inputs_count)
# Create numpy array for the max_batch size images
n, c, h, w = net.inputs[input_blob].shape
images = np.zeros(shape=(n, c, h, w))
# Read and pre-process input images
for i in range(inputs_count):
image = cv2.imread(args.input[i])
if image.shape[:-1] != (h, w):
log.warning("Image {} is resized from {} to {}".format(args.input[i], image.shape[:-1], (h, w)))
image = cv2.resize(image, (w, h))
image = image.transpose((2, 0, 1)) # Change data layout from HWC to CHW
images[i] = image
log.info("Batch size is {}".format(n))
# Loading model to the plugin
log.info("Loading model to the plugin")
exec_net = plugin.load(network=net)
def infer():
for i in range(args.number_iter):
t0 = time()
exec_net.infer(inputs={input_blob: images})
infer_time.append((time() - t0) * 1000)
log.info("Average running time of one iteration: {} ms".format(np.average(np.asarray(infer_time))))
if args.perf_counts:
perf_counts = exec_net.requests[0].get_perf_counts()
log.info("Performance counters:")
print("{:<70} {:<15} {:<15} {:<15} {:<10}".format('name', 'layer_type', 'exet_type', 'status',
'real_time, us'))
for layer, stats in perf_counts.items():
print("{:<70} {:<15} {:<15} {:<15} {:<10}".format(layer, stats['layer_type'], stats['exec_type'],
stats['status'], stats['real_time']))
# Start sync inference with full batch size
log.info(
"Starting inference with full batch {} ({} iterations)".format(n, args.number_iter)
)
infer_time = []
infer()
# Set batch size dynamically for the infer request and start sync inference
infer_time = []
exec_net.requests[0].set_batch(inputs_count)
log.info("Starting inference with dynamically defined batch {} for the 2nd infer request ({} iterations)".format(
inputs_count, args.number_iter))
infer()
def get_input_shape(model):
"""GIven a model, returns its input shape"""
model_bin = model[:-3] + "bin"
net = IENetwork(model=model, weights=model_bin)
input_blob = next(iter(net.inputs))
return net.inputs[input_blob].shape
def load_model(self):
#self.core = IECore()
#self.net = self.core.load_network(network = self.model, device_name = args.device, num_requests = 1)
self.model = IENetwork(self.model_structure, self.model_weights)
self.core = IECore()
type=str,
default="MYRIAD",
help="Default MYRIAD or CPU")
args = args.parse_args()
input_image_size = (300, 300)
data_type = "FP16"
if args.device == "CPU": data_type = "FP32"
#STEP-2
model_xml = 'tfnet/' + data_type + '/yolov2-voc.xml'
model_bin = 'tfnet/' + data_type + '/yolov2-voc.bin'
model_xml = os.environ['HOME'] + "/" + model_xml
model_bin = os.environ['HOME'] + "/" + model_bin
net = IENetwork(model=model_xml, weights=model_bin)
#STEP-3
print(model_bin, "on", args.device)
plugin = IEPlugin(device=args.device, plugin_dirs=None)
if args.device == "CPU":
HOME = os.environ['HOME']
PATHLIBEXTENSION = os.getenv(
"PATHLIBEXTENSION", HOME +
"/inference_engine_samples_build/intel64/Release/lib/libcpu_extension.so"
)
plugin.add_cpu_extension(PATHLIBEXTENSION)
exec_net = plugin.load(network=net, num_requests=1)
#STEP-4
action='store_true', default=False)
return parser
if __name__ == '__main__':
args = build_arg().parse_args()
model_path = os.path.splitext(args.model)[0]
weights_bin = model_path + ".bin"
coeffs = args.coeffs
# mean is stored in the source caffe model and passed to IR
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO if not args.verbose else log.DEBUG, stream=sys.stdout)
log.debug("Load network")
load_net = IENetwork(model=args.model, weights=weights_bin)
load_net.batch_size = 1
exec_net = IECore().load_network(network=load_net, device_name=args.device)
assert len(load_net.inputs) == 1, "Expected number of inputs is equal 1"
input_blob = next(iter(load_net.inputs))
input_shape = load_net.inputs[input_blob].shape
assert input_shape[1] == 1, "Expected model input shape with 1 channel"
assert len(load_net.outputs) == 1, "Expected number of outputs is equal 1"
output_blob = next(iter(load_net.outputs))
output_shape = load_net.outputs[output_blob].shape
assert output_shape == [1, 313, 56, 56], "Shape of outputs does not match network shape outputs"
_, _, h_in, w_in = input_shape
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format(args.device))
ie = IECore()
#plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
log.info("Loading plugins for {} device...".format(args.device))
#ie.add_extension(args.cpu_extension, args.device) // openvino2019-R1
ie.add_extension(args.cpu_extension, "CPU")
# Read IR
log.info("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
if "CPU" in args.device:
supported_layers = ie.query_network(net, "CPU")
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(args.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(
net.outputs) == 1, "Sample supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
if args.input == 'cam':
input_stream = 0
out_file_name = 'cam'
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
out_file_name = os.path.splitext(os.path.basename(args.input))[0]
log.info("Loading IR to the plugin...")
exec_net = ie.load_network(network=net,
num_requests=args.number_infer_requests,
device_name=args.device)
log.info(
"Starting inference in async mode, {} requests in parallel...".format(
args.number_infer_requests))
job_id = str(os.environ['PBS_JOBID'])
result_file = open(
os.path.join(args.output_dir, 'output_' + job_id + '.txt'), "w")
pre_infer_file = os.path.join(args.output_dir,
'pre_progress_' + job_id + '.txt')
infer_file = os.path.join(args.output_dir, 'i_progress_' + job_id + '.txt')
processed_vid = '/tmp/processed_vid.bin'
# Read and pre-process input image
if isinstance(net.inputs[input_blob], list):
n, c, h, w = net.inputs[input_blob]
else:
n, c, h, w = net.inputs[input_blob].shape
del net
cap = cv2.VideoCapture(input_stream)
video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
if video_len < args.number_infer_requests:
args.number_infer_requests = video_len
#Pre inference processing, read mp4 frame by frame, process using openCV and write to binary file
width = int(cap.get(3))
height = int(cap.get(4))
CHUNKSIZE = n * c * w * h
id_ = 0
with open(processed_vid, 'w+b') as f:
time_start = time.time()
while cap.isOpened():
ret, next_frame = cap.read()
if not ret:
break
in_frame = cv2.resize(next_frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
bin_frame = bytearray(in_frame)
f.write(bin_frame)
id_ += 1
if id_ % 10 == 0:
progressUpdate(pre_infer_file,
time.time() - time_start, id_, video_len)
cap.release()
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
current_inference = 0
previous_inference = 1 - args.number_infer_requests
infer_requests = exec_net.requests
frame_count = 0
try:
infer_time_start = time.time()
with open(processed_vid, "rb") as data:
while frame_count < video_len:
# Read next frame from input stream if available and submit it for inference
byte = data.read(CHUNKSIZE)
if not byte == b"":
deserialized_bytes = np.frombuffer(byte, dtype=np.uint8)
in_frame = np.reshape(deserialized_bytes,
newshape=(n, c, h, w))
exec_net.start_async(request_id=current_inference,
inputs={input_blob: in_frame})
# Retrieve the output of an earlier inference request
if previous_inference >= 0:
status = infer_requests[previous_inference].wait()
if status is not 0:
raise Exception(
"Infer request not completed successfully")
# Parse inference results
res = infer_requests[previous_inference].outputs[out_blob]
processBoxes(frame_count, res, labels_map,
args.prob_threshold, width, height,
result_file)
frame_count += 1
# Write data to progress tracker
if frame_count % 10 == 0:
progressUpdate(infer_file,
time.time() - infer_time_start,
frame_count + 1, video_len + 1)
# Increment counter for the inference queue and roll them over if necessary
current_inference += 1
if current_inference >= args.number_infer_requests:
current_inference = 0
previous_inference += 1
if previous_inference >= args.number_infer_requests:
previous_inference = 0
# End while loop
total_time = time.time() - infer_time_start
with open(os.path.join(args.output_dir, 'stats_{}.txt'.format(job_id)),
'w') as f:
f.write('{:.3g} \n'.format(total_time))
f.write('{} \n'.format(frame_count))
result_file.close()
finally:
log.info("Processing done...")
del exec_net
import argparse
parser = argparse.ArgumentParser(
description='Run video super resolution with OpenVINO')
parser.add_argument('-i', dest='input', help='Path to input video')
parser.add_argument('-m',
dest='model',
default='single-image-super-resolution-1033',
help='Path to the model')
parser.add_argument('-o', dest='output', help='Path to output')
args = parser.parse_args()
# Setup network
net = IENetwork(args.model + '.xml', args.model + '.bin')
# Read a video stream from file
cap = cv.VideoCapture(args.input)
inp_w = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
inp_h = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv.CAP_PROP_FPS))
out_h, out_w = inp_h * 3, inp_w * 3 # Do not change! This is how model works
c1 = net.layers['79/Cast_11815_const']
c1.blobs['custom'][4] = inp_h
c1.blobs['custom'][5] = inp_w
c2 = net.layers['86/Cast_11811_const']
c2.blobs['custom'][2] = out_h
