class Network:
"""
Load and configure inference plugins for the specified target devices
and performs synchronous and asynchronous modes for the specified infer requests.
"""
def __init__(self):
"""
Initialize any class variables desired
"""
self.net = None
self.plugin = None
self.input_blob = None
self.out_blob = None
self.net_plugin = None
self.infer_request_handle = None
def load_model(self,
model,
device,
input_size,
output_size,
num_requests,
cpu_extension=None,
plugin=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.
:param plugin: Plugin for specified device
: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
if not plugin:
log.info("Initializing plugin for {} device...".format(device))
self.plugin = IEPlugin(device=device)
else:
self.plugin = plugin
if cpu_extension and 'CPU' in device:
self.plugin.add_cpu_extension(cpu_extension)
# Read IR
log.info("Reading IR...")
self.net = IENetwork(model=model_xml, weights=model_bin)
log.info("Loading IR to the plugin...")
if self.plugin.device == "CPU":
supported_layers = self.plugin.get_supported_layers(self.net)
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(
self.plugin.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)
else:
self.net_plugin = self.plugin.load(network=self.net,
num_requests=num_requests)
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.plugin, self.get_input_shape()
def load_model_2(self,
model,
device,
input_size,
output_size,
num_requests,
cpu_extension=None,
plugin=None):
"""
Load the model
Check for supported layers
Add any necessary extensions
Return the loaded inference plugin
"""
model_xml = model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device
# and load extensions library if specified
if not plugin:
log.info("Initializing plugin for {} device...".format(device))
self.plugin = IECore()
else:
self.plugin = plugin
if cpu_extension and 'CPU' in device:
self.plugin.add_extension(cpu_extension, "CPU")
# Read IR
log.info("Reading IR...")
self.net = IECore.load_network(model=model_xml, weights=model_bin)
log.info("Loading IR to the plugin...")
if "CPU" in device:
supported_layers = self.plugin.query_network(self.net, "CPU")
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(network=self.net,
device_name=device)
else:
self.net_plugin = self.plugin.load_network(
network=self.net,
num_requests=num_requests,
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.plugin, self.get_input_shape()
def get_input_shape(self):
"""
Return the shape of the input layer
"""
return self.net.inputs[self.input_blob].shape
def exec_net(self, request_id, frame):
"""
Start an asynchronous request
Return any necessary information
Note: You may need to update the function parameters.
"""
self.infer_request_handle = self.net_plugin.start_async(
request_id=request_id, inputs={self.input_blob: frame})
return self.net_plugin
def wait(self, request_id):
"""
Wait for the request to be complete.
Return any necessary information
Note: You may need to update the function parameters.
"""
request_waiting = self.net_plugin.requests[request_id].wait(-1)
return request_waiting
def get_output(self, request_id, output=None):
"""
Extract and return the output results
Note: You may need to update the function parameters.
"""
if output:
return self.infer_request_handle.outputs[output]
else:
return self.net_plugin.requests[request_id].outputs[self.out_blob]
class Network:
"""
Load and configure inference plugins for the specified target devices
and performs synchronous and asynchronous modes for the specified infer requests.
"""
def __init__(self):
### TODO: Initialize any class variables desired ###
self.net = None
self.plugin = None
self.input_blob = None
self.output_blob = None
self.net_plugin = None
self.infer_request = None
def load_model(self,
model,
device,
num_requests,
cpu_extension=None,
plugin=None):
### TODO: Load the model ###
load_model_xml = model
load_model_bin = os.path.splitext(load_model_xml)[0] + ".bin"
while not plugin:
log.info("Please wait. Starting plugin for {} device... ".format(
device))
self.plugin = IECore()
else:
self.plugin = plugin
if cpu_extension and CPU in device:
self.plugin.add_cpu_extension(cpu_extension)
log.info('Reading IR, Please wait.')
self.net = IENetwork(model=load_model_xml, weights=load_model_bin)
log.info(
'Completed. Loading IR to the plugin. This may take some time')
### TODO: Check for supported layers ###
if self.plugin.device == "CPU":
supported_layers = self.plugin.get_supported_layers(self.net)
unsupported_layers = [
l for l in self.net.layers.key() if l not in supported_layers
]
if len(unsupported_layers) != 0:
log.error(
'There are a number of unsupported layers found: '.format(
unsupported_layers))
sys.exit(1)
if num_request == 0:
self.net_plugin = self.plugin.load(network=self.net)
else:
self.net_plugin = self.plugin.load(network=self.net,
num_requests=num_requests)
self.input_blob = next(iter(self.net.input))
self.output_blob = next(iter(self.net.output))
if len(self.net.inputs.key()) == input_size:
log.error(
'Sorry, this app supports {} input topologies. Please make the necessary changes and try again'
.format(len(self.net.inputs)))
sys.exit(1)
if len(self.net.outputs) == output_size:
log.error(
'Sorry, this app supports {} output topologies. Please make the necessary changes and try again'
.format(len(self.net.inputs)))
sys.exit(1)
return self.plugin, self.get_input_shape
### TODO: Add any necessary extensions ###
### TODO: Return the loaded inference plugin ###
### Note: You may need to update the function parameters. ###
return
def get_input_shape(self):
### TODO: Return the shape of the input layer ###
return self.net.inputs[self.input.blob].shape
def exec_net(self, request_id, frame):
### TODO: Start an asynchronous request ###
### TODO: Return any necessary information ###
### Note: You may need to update the function parameters. ###
self.infer_request = self.net_plugin.start_async(
request_id=request_id, inputs={self.input_blob: frame})
return self.net_plugin
def wait(self, request_id):
### TODO: Wait for the request to be complete. ###
### TODO: Return any necessary information ###
### Note: You may need to update the function parameters. ###
wait_status = self.net_plugin.requests[request_id].wait(-1)
return wait_status
def get_output(self):
### TODO: Extract and return the output results
### Note: You may need to update the function parameters. ###
if output:
result = self.infer_request.outputs[output]
else:
result = self.net_plugin.requests[request_id].outputs[
self.output_blob]
return result
def delete_instances(self):
del self.net_plugin
del self_plugin
del self.net
