def create_core():
if openvino_absent:
raise ImportError('The OpenVINO package is not installed')
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
return IECore()
def make_plugin_or_core():
version = get_version()
use_core_openvino = False
try:
major, minor, reference = [int(x) for x in version.split('.')]
if major >= 2 and minor >= 1:
use_core_openvino = True
except Exception:
pass
if use_core_openvino:
ie = IECore()
return ie
if _IE_PLUGINS_PATH is None:
raise OSError('Inference engine plugin path env not found in the system.')
plugin = IEPlugin(device='CPU', plugin_dirs=[_IE_PLUGINS_PATH])
if (_check_instruction('avx2')):
plugin.add_cpu_extension(os.path.join(_IE_PLUGINS_PATH, 'libcpu_extension_avx2.so'))
elif (_check_instruction('sse4')):
plugin.add_cpu_extension(os.path.join(_IE_PLUGINS_PATH, 'libcpu_extension_sse4.so'))
elif platform.system() == 'Darwin':
plugin.add_cpu_extension(os.path.join(_IE_PLUGINS_PATH, 'libcpu_extension.dylib'))
else:
raise Exception('Inference engine requires a support of avx2 or sse4.')
return plugin
def __init__(self, args):
self.gpu_ext = args.gpu_lib
self.allow_grow = args.allow_grow and not args.no_show
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if args.cpu_lib and 'CPU' in {args.d_fd, args.d_lm, args.d_reid}:
ie.add_extension(args.cpu_lib, 'CPU')
self.face_detector = FaceDetector(ie,
args.m_fd,
args.fd_input_size,
confidence_threshold=args.t_fd,
roi_scale_factor=args.exp_r_fd)
self.landmarks_detector = LandmarksDetector(ie, args.m_lm)
self.face_identifier = FaceIdentifier(ie,
args.m_reid,
match_threshold=args.t_id,
match_algo=args.match_algo)
self.face_detector.deploy(args.d_fd, self.get_config(args.d_fd))
self.landmarks_detector.deploy(args.d_lm, self.get_config(args.d_lm),
self.QUEUE_SIZE)
self.face_identifier.deploy(args.d_reid, self.get_config(args.d_reid),
self.QUEUE_SIZE)
log.debug('Building faces database using images from {}'.format(
args.fg))
self.faces_database = FacesDatabase(
args.fg, self.face_identifier, self.landmarks_detector,
self.face_detector if args.run_detector else None, args.no_show)
self.face_identifier.set_faces_database(self.faces_database)
log.info('Database is built, registered {} identities'.format(
len(self.faces_database)))
def main():
args = build_argparser().parse_args()
start_time = perf_counter()
with wave.open(args.input, 'rb') as wave_read:
channel_num, sample_width, sampling_rate, pcm_length, compression_type, _ = wave_read.getparams(
)
assert sample_width == 2, "Only 16-bit WAV PCM supported"
assert compression_type == 'NONE', "Only linear PCM WAV files supported"
assert channel_num == 1, "Only mono WAV PCM supported"
assert sampling_rate == 16000, "Only 16 KHz audio supported"
audio = np.frombuffer(wave_read.readframes(pcm_length * channel_num),
dtype=np.int16).reshape(
(pcm_length, channel_num))
log_melspectrum = QuartzNet.audio_to_melspectrum(audio.flatten(),
sampling_rate)
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
quartz_net = QuartzNet(ie, args.model, log_melspectrum.shape, args.device)
character_probs = quartz_net.infer(log_melspectrum)
transcription = QuartzNet.ctc_greedy_decode(character_probs)
total_latency = (perf_counter() - start_time) * 1e3
log.info("Metrics report:")
log.info("\tLatency: {:.1f} ms".format(total_latency))
print(transcription)
def create_ie_plugin(self, log=True):
if hasattr(self, 'plugin'):
del self.plugin
if log:
print_info('IE version: {}'.format(ie.get_version()))
if self._is_multi():
self._create_multi_device_plugin(log)
else:
self.plugin = ie.IEPlugin(self._device)
self.async_mode = self.get_value_from_config('async_mode')
num_requests = get_or_parse_value(self.config.get('num_requests', 1), casting_type=int)
if len(num_requests) != 1:
raise ConfigError('Several values for _num_requests specified')
self._num_requests = num_requests[0]
if self._num_requests != 1 and not self.async_mode:
warning('{} infer requests in sync mode is not supported. Only 1 infer request will be used.')
self._num_requests = 1
if log:
print_info('Loaded {} plugin version: {}'.format(self.plugin.device, self.plugin.version))
cpu_extensions = self.config.get('cpu_extensions')
if cpu_extensions and 'CPU' in self._devices_list():
selection_mode = self.config.get('_cpu_extensions_mode')
cpu_extensions = DLSDKLauncher.get_cpu_extension(cpu_extensions, selection_mode)
self.plugin.add_cpu_extension(str(cpu_extensions))
gpu_extensions = self.config.get('gpu_extensions')
if gpu_extensions and 'GPU' in self._devices_list():
self.plugin.set_config('CONFIG_FILE', str(gpu_extensions))
if self._is_vpu():
log_level = self.config.get('_vpu_log_level')
if log_level:
self.plugin.set_config({'VPU_LOG_LEVEL': log_level})
def main():
args = build_argparser()
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if args.device == "CPU" and args.cpu_extension:
ie.add_extension(args.cpu_extension, 'CPU')
log.info('Reading model {}'.format(args.model))
net = ie.read_network(args.model, args.model[:-4] + ".bin")
if len(net.input_info) != 1:
log.error("Demo supports only models with 1 input layer")
sys.exit(1)
input_blob = next(iter(net.input_info))
input_shape = net.input_info[input_blob].input_data.shape
if len(net.outputs) != 1:
log.error("Demo supports only models with 1 output layer")
sys.exit(1)
output_blob = next(iter(net.outputs))
batch_size, channels, one, length = input_shape
if one != 1:
raise RuntimeError("Wrong third dimension size of model input shape - {} (expected 1)".format(one))
hop = length - args.overlap if isinstance(args.overlap, int) else int(length * (1.0 - args.overlap))
if hop < 0:
log.error("Wrong value for '-ol/--overlap' argument - overlapping more than clip length")
sys.exit(1)
exec_net = ie.load_network(network=net, device_name=args.device)
log.info('The model {} is loaded to {}'.format(args.model, args.device))
labels = []
if args.labels:
with open(args.labels, "r") as file:
labels = [line.rstrip() for line in file.readlines()]
start_time = perf_counter()
audio = AudioSource(args.input, channels=channels, samplerate=args.sample_rate)
outputs = []
clips = 0
for idx, chunk in enumerate(audio.chunks(length, hop, num_chunks=batch_size)):
chunk.shape = input_shape
output = exec_net.infer(inputs={input_blob: chunk})
clips += batch_size
output = output[output_blob]
for batch, data in enumerate(output):
start_time = (idx*batch_size + batch)*hop / audio.samplerate
end_time = ((idx*batch_size + batch)*hop + length) / audio.samplerate
outputs.append(data)
label = np.argmax(data)
if start_time < audio.duration():
log.info("[{:.2f}-{:.2f}] - {:6.2%} {:s}".format(start_time, end_time, data[label],
labels[label] if labels else "Class {}".format(label)))
total_latency = (perf_counter() - start_time) * 1e3
log.info("Metrics report:")
log.info("\tLatency: {:.1f} ms".format(total_latency))
def __init__(self, args, interactive_mode):
self.args = args
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
self.ie = IECore()
self.encoder = read_net(self.args.m_encoder, self.ie,
'Formula Recognition Encoder')
self.dec_step = read_net(self.args.m_decoder, self.ie,
'Formula Recognition Decoder')
self.exec_net_encoder = self.ie.load_network(
network=self.encoder, device_name=self.args.device)
log.info(
'The Formula Recognition Encoder model {} is loaded to {}'.format(
args.m_encoder, args.device))
self.exec_net_decoder = self.ie.load_network(
network=self.dec_step, device_name=self.args.device)
log.info(
'The Formula Recognition Decoder model {} is loaded to {}'.format(
args.m_decoder, args.device))
self.images_list = []
self.vocab = Vocab(self.args.vocab_path)
self.model_status = Model.Status.READY
self.is_async = interactive_mode
self.num_infers_decoder = 0
self.check_model_dimensions()
if not interactive_mode:
self.preprocess_inputs()
def load_ie_core(device, cpu_extension=None):
"""Loads IE Core"""
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if device == "CPU" and cpu_extension:
ie.add_extension(cpu_extension, "CPU")
return ie
def get_version_info(self) -> str:
logger.info('InferenceEngine:\n{: <9}{:.<24} {}'.format('', 'API version', get_version()))
version_string = 'Device info\n'
for device, version in self.ie.get_versions(self.device).items():
version_string += '{: <9}{}\n'.format('', device)
version_string += '{: <9}{:.<24}{} {}.{}\n'.format('', version.description, ' version', version.major,
version.minor)
version_string += '{: <9}{:.<24} {}\n'.format('', 'Build', version.build_number)
return version_string
def _prepare_ie(self, log=True):
if log:
print_info('IE version: {}'.format(ie.get_version()))
if self._is_multi():
self._prepare_multi_device(log)
else:
self.async_mode = self.get_value_from_config('async_mode')
self._set_nireq()
if log:
self._log_versions()
self._device_specific_configuration()
def openvino_version_check():
try:
version = tuple(map(int, get_version().split(".")))[:2]
if version != (2, 1):
logger.warning(
f"OpenVINO version: {version!r} not compatible with this library, "
f"expected version: 2.1.xxx"
)
except NameError:
version = '0.0.0'
return version
def __init__(self, model_xml, model_bin, device, output_name):
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
log.info('Reading model {}'.format(model_xml))
self.net = ie.read_network(model=model_xml, weights=model_bin)
self.net_exec = ie.load_network(self.net, device)
log.info('The model {} is loaded to {}'.format(model_xml, device))
self.output_name = output_name
assert self.output_name != "", "there is not output in model"
def __init__(self, model_path, device, cpu_extension):
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if cpu_extension and device == 'CPU':
ie.add_extension(cpu_extension, 'CPU')
path = '.'.join(model_path.split('.')[:-1])
log.info('Reading model {}'.format(model_path))
self.net = ie.read_network(path + '.xml', path + '.bin')
self.output_name = list(self.net.outputs.keys())[0]
self.exec_net = ie.load_network(network=self.net, device_name=device)
log.info('The model {} is loaded to {}'.format(model_path, device))
def __init__(self, model_path, device, cpu_extension):
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if cpu_extension and device == 'CPU':
ie.add_extension(cpu_extension, 'CPU')
log.info('Reading model {}'.format(model_path))
self.net = ie.read_network(model_path, model_path.with_suffix('.bin'))
self.input_name = next(iter(self.net.input_info))
self.output_name = next(iter(self.net.outputs))
self.input_size = self.net.input_info[self.input_name].input_data.shape
self.exec_net = ie.load_network(network=self.net, device_name=device)
log.info('The model {} is loaded to {}'.format(model_path, device))
def __init__(self, config_entry, model_name='', delayed_model_loading=False,
preprocessor=None, postpone_inputs_configuration=False):
super().__init__(config_entry, model_name=model_name)
if ie.get_version().split('-')[0] >= '2022.1.0':
warnings.warn('dlsdk launcher is deprecated. Please use openvino instead', DeprecationWarning)
self._set_variable = False
self.ie_config = self.config.get('ie_config')
self.ie_core = ie.IECore(xml_config_file=str(self.ie_config)) if self.ie_config is not None else ie.IECore()
self._delayed_model_loading = delayed_model_loading
dlsdk_launcher_config = DLSDKLauncherConfigValidator(
'DLSDK_Launcher', fields=self.parameters(), delayed_model_loading=delayed_model_loading,
)
dlsdk_launcher_config.validate(self.config, ie_core=self.ie_core)
device = self.config['device'].split('.')
self._device = '.'.join((device[0].upper(), device[1])) if len(device) > 1 else device[0].upper()
self.dynamic_shapes_policy = self.get_value_from_config('_undefined_shapes_resolving_policy')
self._set_variable = False
self._async_mode = False
self._prepare_ie()
self._delayed_model_loading = delayed_model_loading
self._postpone_input_configuration = postpone_inputs_configuration
self._preprocess_info = {}
self._preprocess_steps = []
self.disable_resize_to_input = False
self._do_reshape = False
self._use_set_blob = False
self._output_layouts = {}
self._output_precisions = {}
self.dyn_input_layers = []
self._partial_shapes = {}
self.is_dynamic = False
self.preprocessor = preprocessor
if not delayed_model_loading:
self._model, self._weights = automatic_model_search(
self._model_name, self.get_value_from_config('model'),
self.get_value_from_config('weights'),
self.get_value_from_config('_model_type')
)
self.load_network(log=True, preprocessing=preprocessor)
self.allow_reshape_input = self.get_value_from_config('allow_reshape_input') and self.network is not None
else:
self.allow_reshape_input = self.get_value_from_config('allow_reshape_input')
self._target_layout_mapping = {}
self._lstm_inputs = None
if '_list_lstm_inputs' in self.config:
self._configure_lstm_inputs()
self.reset_memory_state = self.get_value_from_config('reset_memory_state')
def main():
model_bin, model_xml = get_ir_paths(args.model, args.bin)
config = NNCFConfig.from_json(args.config)
input_infos_list = create_input_infos(config)
image_size = input_infos_list[0].shape[-1]
size = int(image_size / 0.875)
print('IE version: {}'.format(get_version()))
# NOTE: importing torch after loading IE to plugin to avoid issue with built-in MKLDNN of PyTorch
plugin = IEPlugin(device='CPU', plugin_dirs=args.cpu_plugin_dir)
plugin.add_cpu_extension(
os.path.join(args.cpu_plugin_dir, "libcpu_extension.so"))
net = IENetwork(model=model_xml, weights=model_bin)
exec_net = getExecNet(plugin, net)
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
import torchvision.transforms as transforms
val_loader = DataLoader(datasets.ImageFolder(
args.data,
transforms.Compose([
transforms.Resize(size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])),
batch_size=1,
shuffle=False,
num_workers=4,
pin_memory=True)
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
config['log_dir'] = args.output_dir
infer_fn = partial(infer_ie_model, net=net)
validate_general(val_loader, exec_net, infer_fn)
validate_torch_model(os.path.join(args.output_dir, "PTH"),
config=config,
num_layers=args.num_layers,
dump=args.dump,
val_loader=val_loader,
cuda=args.cuda)
def import_core_modules(silent: bool, path_to_module: str):
try:
from openvino.inference_engine import IECore, get_version # pylint: disable=import-error
from openvino.offline_transformations import ApplyMOCTransformations, CheckAPI # pylint: disable=import-error
import openvino # pylint: disable=import-error
ie_version = str(get_version())
mo_version = str(version.get_version()) # pylint: disable=no-member
if not silent:
print("\t- {}: \t{}".format("Inference Engine found in",
os.path.dirname(openvino.__file__)))
print("{}: \t{}".format("Inference Engine version", ie_version))
print("{}: \t {}".format("Model Optimizer version", mo_version))
# MO and IE version have a small difference in the beginning of version because
# IE version also includes API version. For example:
# Inference Engine version: 2.1.custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# Model Optimizer version: custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# So to match this versions we skip IE API version.
if not re.match(r"^([0-9]+).([0-9]+).{}$".format(mo_version),
ie_version):
extracted_release_version = extract_release_version()
is_custom_mo_version = extracted_release_version == (None, None)
if not silent:
print(
"[ WARNING ] Model Optimizer and Inference Engine versions do no match."
)
print(
"[ WARNING ] Consider building the Inference Engine Python API from sources or reinstall OpenVINO (TM) toolkit using \"pip install openvino{}\" {}"
.format(
"",
"(may be incompatible with the current Model Optimizer version)"
if is_custom_mo_version else "=={}.{}".format(
*extracted_release_version), ""))
return True
except Exception as e:
# Do not print a warning if module wasn't found or silent mode is on
if "No module named 'openvino'" not in str(e) and not silent:
print(
"[ WARNING ] Failed to import Inference Engine Python API in: {}"
.format(path_to_module))
print("[ WARNING ] {}".format(e))
return False
def _create_ie_plugin(self, log=True):
if hasattr(self, 'plugin'):
del self.plugin
self.plugin = ie.IEPlugin(self._device)
if log:
print_info('IE version: {}'.format(ie.get_version()))
print_info('Loaded {} plugin version: {}'.format(
self.plugin.device, self.plugin.version))
cpu_extensions = self._config.get('cpu_extensions')
if cpu_extensions and 'CPU' in self._device:
selection_mode = self._config.get('_cpu_extensions_mode')
cpu_extensions = DLSDKLauncher.get_cpu_extension(
cpu_extensions, selection_mode)
self.plugin.add_cpu_extension(str(cpu_extensions))
if self._config.get('gpu_extensions') and 'GPU' in self._device:
self.plugin.set_config('CONFIG_FILE',
str(self._config.get('gpu_extensions')))
def __init__(self, net_model_xml_path, device, stride):
self.device = device
self.stride = stride
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
self.ie = IECore()
log.info('Reading model {}'.format(net_model_xml_path))
self.net = self.ie.read_network(net_model_xml_path,
net_model_xml_path.with_suffix('.bin'))
required_input_key = {'data'}
assert required_input_key == set(self.net.input_info), \
'Demo supports only topologies with the following input key: {}'.format(', '.join(required_input_key))
required_output_keys = {'features', 'heatmaps', 'pafs'}
assert required_output_keys.issubset(self.net.outputs.keys()), \
'Demo supports only topologies with the following output keys: {}'.format(', '.join(required_output_keys))
self.exec_net = self.ie.load_network(network=self.net,
num_requests=1,
device_name=device)
log.info('The model {} is loaded to {}'.format(net_model_xml_path,
device))
def main():
args = build_arg_parser().parse_args()
# Loading source image
img = cv2.imread(args.input, cv2.IMREAD_COLOR)
if img is None:
log.error("Cannot load image " + args.input)
return -1
if args.auto_mask_color and args.auto_mask_random:
log.error("-ar and -ac options cannot be used together")
return -1
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
log.info('Reading model {}'.format(args.model))
inpainting_processor = ImageInpainting(ie, args.model, args.device)
log.info('The model {} is loaded to {}'.format(args.model, args.device))
if args.auto_mask_color or args.auto_mask_random:
# Command-line inpaining for just one image
concat_image, result = inpaint_auto(img, inpainting_processor, args)
if args.output != "":
cv2.imwrite(args.output, result)
if not args.no_show:
cv2.imshow('Image Inpainting Demo', concat_image)
cv2.waitKey(0)
else:
# Inpainting with GUI
if args.no_show:
log.error("--no_show argument cannot be used in GUI mode")
return -1
InpaintingGUI(img, inpainting_processor).run()
return 0
def import_core_modules(silent: bool, path_to_module: str):
"""
This function checks that InferenceEngine Python API is available
and necessary python modules exists. So the next list of imports
must contain all IE/NG Python API imports that are used inside MO.
:param silent: enables or disables logs printing to stdout
:param path_to_module: path where python API modules were found
:return: True if all imports were successful and False otherwise
"""
try:
from openvino.inference_engine import get_version, read_network # pylint: disable=import-error,no-name-in-module
from openvino.offline_transformations import ApplyMOCTransformations, ApplyLowLatencyTransformation, \
ApplyMakeStatefulTransformation, GenerateMappingFile # pylint: disable=import-error,no-name-in-module
# TODO: it is temporary import to check that nGraph python API is available. But in future
# we need to replace it with Frontend imports
from ngraph.impl.op import Parameter # pylint: disable=import-error,no-name-in-module
from _pyngraph import PartialShape, Dimension # pylint: disable=import-error,no-name-in-module
import openvino # pylint: disable=import-error,no-name-in-module
import ngraph # pylint: disable=import-error,no-name-in-module
import ngraph.frontend # pylint: disable=import-error,no-name-in-module
if silent:
return True
ie_version = str(get_version())
mo_version = str(v.get_version()) # pylint: disable=no-member,no-name-in-module
print("\t- {}: \t{}".format("Inference Engine found in",
os.path.dirname(openvino.__file__)))
# TODO: when nGraph version will be available we need to start compare it to IE and MO versions. Ticket: 58091
print("\t- {}: \t{}".format("nGraph found in",
os.path.dirname(ngraph.__file__)))
print("{}: \t{}".format("Inference Engine version", ie_version))
print("{}: \t{}".format("Model Optimizer version", mo_version))
versions_mismatch = False
if mo_version != ie_version:
versions_mismatch = True
extracted_mo_release_version = v.extract_release_version(
mo_version)
mo_is_custom = extracted_mo_release_version == (None, None)
print(
"[ WARNING ] Model Optimizer and Inference Engine versions do no match."
)
print(
"[ WARNING ] Consider building the Inference Engine Python API from sources or reinstall OpenVINO "
"(TM) toolkit using",
end=" ")
if mo_is_custom:
print(
"\"pip install openvino\" (may be incompatible with the current Model Optimizer version)"
)
else:
print("\"pip install openvino=={}.{}\"".format(
*extracted_mo_release_version))
simplified_mo_version = v.get_simplified_mo_version()
message = str(
dict({
"platform": platform.system(),
"mo_version": simplified_mo_version,
"ie_version": v.get_simplified_ie_version(version=ie_version),
"versions_mismatch": versions_mismatch,
}))
send_telemetry(simplified_mo_version, message, 'ie_version_check')
return True
except Exception as e:
# Do not print a warning if module wasn't found or silent mode is on
if "No module named 'openvino'" not in str(e):
print(
"[ WARNING ] Failed to import Inference Engine Python API in: {}"
.format(path_to_module))
print("[ WARNING ] {}".format(e))
# Send telemetry message about warning
simplified_mo_version = v.get_simplified_mo_version()
message = str(
dict({
"platform": platform.system(),
"mo_version": simplified_mo_version,
"ie_version": v.get_simplified_ie_version(env=os.environ),
"python_version": sys.version,
"error_type": classify_error_type(e),
}))
send_telemetry(simplified_mo_version, message, 'ie_import_failed')
return False
def main(args=None):
try:
# ------------------------------ 1. Parsing and validating input arguments -------------------------------------
next_step()
if not args:
args = parse_args()
# ------------------------------ 2. Loading Inference Engine ---------------------------------------------------
next_step()
device_name = args.target_device.upper()
ie = IECore()
if CPU_DEVICE_NAME in device_name:
if args.path_to_extension:
ie.add_cpu_extension(extension_path=args.path_to_extension,
device_name=CPU_DEVICE_NAME)
if GPU_DEVICE_NAME in device_name:
if args.path_to_cldnn_config:
ie.set_config({'CONFIG_FILE': args.path_to_cldnn_config},
GPU_DEVICE_NAME)
logger.info("GPU extensions is loaded {}".format(
args.path_to_cldnn_config))
logger.info("InferenceEngine:\n{: <9}{}".format("", get_version()))
version_string = "Device is {}\n".format(device_name)
for device, version in ie.get_versions(device_name).items():
version_string += "{: <9}{}\n".format("", device)
version_string += "{: <9}{:.<24}{} {}.{}\n".format(
"", version.description, " version", version.major,
version.minor)
version_string += "{: <9}{:.<24} {}\n".format(
"", "Build", version.build_number)
logger.info(version_string)
# --------------------- 3. Read the Intermediate Representation of the network ---------------------------------
next_step()
xml_filename = os.path.abspath(args.path_to_model)
head, tail = os.path.splitext(xml_filename)
bin_filename = os.path.abspath(head + BIN_EXTENSION)
ie_network = IENetwork(xml_filename, bin_filename)
input_info = ie_network.inputs
if len(input_info) == 0:
raise AttributeError('No inputs info is provided')
# --------------------- 4. Resizing network to match image sizes and given batch -------------------------------
next_step()
batch_size = ie_network.batch_size
precision = ie_network.precision
if args.batch_size and args.batch_size != ie_network.batch_size:
new_shapes = {}
for key in input_info.keys():
shape = input_info[key].shape
layout = input_info[key].layout
batchIndex = -1
if ((layout == 'NCHW') or (layout == 'NCDHW')
or (layout == 'NHWC') or (layout == 'NDHWC')
or (layout == 'NC')):
batchIndex = 0
elif (layout == 'CN'):
batchIndex = 1
if ((batchIndex != -1)
and (shape[batchIndex] != args.batch_size)):
shape[batchIndex] = args.batch_size
new_shapes[key] = shape
if (len(new_shapes) > 0):
logger.info("Resizing network to batch = {}".format(
args.batch_size))
ie_network.reshape(new_shapes)
batch_size = args.batch_size
logger.info("Network batch size: {}, precision {}".format(
batch_size, precision))
# --------------------- 5. Configuring input of the model ------------------------------------------------------
next_step()
for key in input_info.keys():
if (isImage(input_info[key])):
# Set the precision of input data provided by the user
# Should be called before load of the network to the plugin
input_info[key].precision = 'U8'
# --------------------- 6. Setting device configuration --------------------------------------------------------
next_step()
devices = parseDevices(device_name)
device_nstreams = parseValuePerDevice(devices, args.number_streams)
for device in devices:
if device == CPU_DEVICE_NAME: ## CPU supports few special performance-oriented keys
## limit threading for CPU portion of inference
if args.number_threads:
ie.set_config(
{'CPU_THREADS_NUM': str(args.number_threads)}, device)
if MULTI_DEVICE_NAME in device_name and GPU_DEVICE_NAME in device_name:
ie.set_config({'CPU_BIND_THREAD': 'NO'}, CPU_DEVICE_NAME)
else:
# pin threads for CPU portion of inference
ie.set_config(
{'CPU_BIND_THREAD': args.infer_threads_pinning},
device)
## for CPU execution, more throughput-oriented execution via streams
# for pure CPU execution, more throughput-oriented execution via streams
if args.api_type == 'async':
ie.set_config(
{
'CPU_THROUGHPUT_STREAMS':
str(device_nstreams.get(device))
if device in device_nstreams.keys() else
'CPU_THROUGHPUT_AUTO'
}, device)
device_nstreams[device] = int(
ie.get_config(device, 'CPU_THROUGHPUT_STREAMS'))
elif device == GPU_DEVICE_NAME:
if args.api_type == 'async':
ie.set_config(
{
'GPU_THROUGHPUT_STREAMS':
str(device_nstreams.get(device))
if device in device_nstreams.keys() else
'GPU_THROUGHPUT_AUTO'
}, device)
device_nstreams[device] = int(
ie.get_config(device, 'GPU_THROUGHPUT_STREAMS'))
if MULTI_DEVICE_NAME in device_name and CPU_DEVICE_NAME in device_name:
## multi-device execution with the CPU+GPU performs best with GPU trottling hint,
## which releases another CPU thread (that is otherwise used by the GPU driver for active polling)
ie.set_config({'CLDNN_PLUGIN_THROTTLE': str(1)}, device)
elif device == MYRIAD_DEVICE_NAME:
ie.set_config(
{
'LOG_LEVEL': 'LOG_INFO',
'VPU_LOG_LEVEL': 'LOG_WARNING'
}, MYRIAD_DEVICE_NAME)
# --------------------- 7. Loading the model to the device -----------------------------------------------------
next_step()
config = {'PERF_COUNT': ('YES' if args.perf_counts else 'NO')}
exe_network = ie.load_network(ie_network,
device_name,
config=config,
num_requests=args.number_infer_requests
if args.number_infer_requests else 0)
# --------------------- 8. Setting optimal runtime parameters --------------------------------------------------
next_step()
## Number of requests
infer_requests = exe_network.requests
nireq = len(infer_requests)
## Iteration limit
niter = args.number_iterations
if niter and args.api_type == 'async':
niter = (int)((niter + nireq - 1) / nireq) * nireq
if (args.number_iterations != niter):
logger.warn(
"Number of iterations was aligned by request number "
"from {} to {} using number of requests {}".format(
args.number_iterations, niter, nireq))
## Time limit
duration_seconds = 0
if args.time:
## time limit
duration_seconds = args.time
elif not args.number_iterations:
## default time limit
duration_seconds = get_duration_in_secs(device)
# ------------------------------------ 8. Creating infer requests and filling input blobs ----------------------
next_step()
request_queue = InferRequestsQueue(infer_requests)
path_to_input = os.path.abspath(
args.path_to_input) if args.path_to_input else None
requests_input_data = getInputs(path_to_input, batch_size,
ie_network.inputs, infer_requests)
# ------------------------------------ 9. Measuring performance ------------------------------------------------
progress_count = 0
progress_bar_total_count = 10000
output_string = "Start inference {}ronously".format(args.api_type)
if (args.api_type == "async"):
if output_string != "":
output_string += ", "
output_string += str(nireq) + " inference requests"
device_ss = ''
for device, nstreams in device_nstreams.items():
if device_ss != '':
device_ss += ', '
device_ss += "{} streams for {}".format(str(nstreams), device)
if device_ss != '':
output_string += " using " + device_ss
output_string += ", limits: "
if niter:
if not duration_seconds:
progress_bar_total_count = niter
output_string += str(niter) + " iterations"
if duration_seconds:
if niter:
output_string += ", "
output_string += str(
getDurationInMilliseconds(duration_seconds)) + " ms duration"
next_step(output_string)
## warming up - out of scope
infer_request = request_queue.getIdleRequest()
if not infer_request:
raise Exception("No idle Infer Requests!")
if (args.api_type == 'sync'):
infer_request.infer(requests_input_data[infer_request.id])
else:
infer_request.startAsync(requests_input_data[infer_request.id])
request_queue.waitAll()
request_queue.resetTimes()
start_time = datetime.now()
exec_time = (datetime.now() - start_time).total_seconds()
iteration = 0
progress_bar = ProgressBar(progress_bar_total_count,
args.stream_output, args.progress)
## Start inference & calculate performance
## to align number if iterations to guarantee that last infer requests are executed in the same conditions **/
while ((niter and iteration < niter)
or (duration_seconds and exec_time < duration_seconds)
or (args.api_type == "async" and iteration % nireq != 0)):
infer_request = request_queue.getIdleRequest()
if not infer_request:
raise Exception("No idle Infer Requests!")
if (args.api_type == 'sync'):
infer_request.infer(requests_input_data[infer_request.id])
else:
infer_request.startAsync(requests_input_data[infer_request.id])
iteration += 1
exec_time = (datetime.now() - start_time).total_seconds()
if niter:
progress_bar.add_progress(1)
else:
## calculate how many progress intervals are covered by current iteration.
## depends on the current iteration time and time of each progress interval.
## Previously covered progress intervals must be skipped.
progress_interval_time = duration_seconds / progress_bar_total_count
new_progress = (int)(exec_time / progress_interval_time -
progress_count)
progress_bar.add_progress(new_progress)
progress_count += new_progress
## wait the latest inference executions
request_queue.waitAll()
total_duration_sec = request_queue.getDurationInSeconds()
times = request_queue.times
times.sort()
latency_ms = median(times)
fps = batch_size * 1000 / latency_ms if args.api_type == 'sync' else batch_size * iteration / total_duration_sec
progress_bar.finish()
# ------------------------------------ 10. Dumping statistics report -------------------------------------------
next_step()
if args.exec_graph_path:
try:
exec_graph_info = exe_network.get_exec_graph_info()
exec_graph_info.serialize(args.exec_graph_path)
logger.info("Executable graph is stored to {}".format(
args.exec_graph_path))
del exec_graph_info
except Exception as e:
logging.exception(e)
if args.perf_counts:
for ni in range(int(nireq)):
perf_counts = exe_network.requests[ni].get_perf_counts()
logger.info(
"Pefrormance counts for {}-th infer request".format(ni))
for layer, stats in perf_counts.items():
max_layer_name = 30
print("{:<30}{:<15}{:<30}{:<20}{:<20}{:<20}".format(
layer[:max_layer_name - 4] + '...' if
(len(layer) >= max_layer_name) else layer,
stats['status'],
'layerType: ' + str(stats['layer_type']),
'realTime: ' + str(stats['real_time']),
'cpu: ' + str(stats['cpu_time']),
'execType: ' + str(stats['exec_type'])))
print("Count: {} iterations".format(iteration))
print("Duration: {:.2f} ms".format(
getDurationInMilliseconds(total_duration_sec)))
if not MULTI_DEVICE_NAME in device_name:
print("Latency: {:.4f} ms".format(latency_ms))
print("Throughput: {:.2f} FPS".format(fps))
del exe_network
del ie
next_step.step_id = 0
except Exception as e:
logging.exception(e)
if enable_detection:
devices = [
args.device, args.device, args.device_age_gender,
args.device_emotions, args.device_head_pose,
args.device_facial_landmarks
]
models = [
args.model_ssd, args.model_face, args.model_age_gender,
args.model_emotions, args.model_head_pose,
args.model_facial_landmarks
]
# openvino.inference_engine version '2.1.37988' is openvino_2020.1.033 build
# , which does not need cpu extension.
# https://software.intel.com/en-us/forums/intel-distribution-of-openvino-toolkit/topic/848825
if "CPU" in devices and args.cpu_extension is None and (get_version() < '2.1.37988'):
print(
"\nPlease try to specify cpu extensions library path in demo's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
# Create detectors class instance
detections = interactive_detection.Detections(
devices, models, args.cpu_extension, args.plugin_dir,
args.prob_threshold, args.prob_threshold_face, is_async_mode)
models = detections.models # Get models to display WebUI.
# Create a UDP socket to send and receive message with tello
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
host = '0.0.0.0'
port = 9000
def main():
args = build_argparser().parse_args()
cap = open_images_capture(args.input, args.loop)
# Plugin initialization for specified device and load extensions library if specified.
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, 'CPU')
# Read IR
log.info('Reading Mask-RCNN model {}'.format(args.mask_rcnn_model))
mask_rcnn_net = ie.read_network(args.mask_rcnn_model)
model_required_inputs = {'image'}
if set(mask_rcnn_net.input_info) == model_required_inputs:
required_output_keys = {'boxes', 'labels', 'masks', 'text_features.0'}
n, c, h, w = mask_rcnn_net.input_info['image'].input_data.shape
assert n == 1, 'Only batch 1 is supported by the demo application'
else:
raise RuntimeError(
'Demo supports only topologies with the following input keys: '
f'{model_required_inputs}.')
assert required_output_keys.issubset(mask_rcnn_net.outputs.keys()), \
f'Demo supports only topologies with the following output keys: {required_output_keys}' \
f'Found: {mask_rcnn_net.outputs.keys()}.'
log.info('Reading Text Recognition Encoder model {}'.format(
args.text_enc_model))
text_enc_net = ie.read_network(args.text_enc_model)
log.info('Reading Text Recognition Decoder model {}'.format(
args.text_dec_model))
text_dec_net = ie.read_network(args.text_dec_model)
mask_rcnn_exec_net = ie.load_network(network=mask_rcnn_net,
device_name=args.device,
num_requests=2)
log.info('The Mask-RCNN model {} is loaded to {}'.format(
args.mask_rcnn_model, args.device))
text_enc_exec_net = ie.load_network(network=text_enc_net,
device_name=args.device)
log.info('The Text Recognition Encoder model {} is loaded to {}'.format(
args.text_enc_model, args.device))
text_dec_exec_net = ie.load_network(network=text_dec_net,
device_name=args.device)
log.info('The Text Recognition Decoder model {} is loaded to {}'.format(
args.text_dec_model, args.device))
hidden_shape = text_dec_net.input_info[
args.trd_input_prev_hidden].input_data.shape
del mask_rcnn_net
del text_enc_net
del text_dec_net
if args.no_track:
tracker = None
else:
tracker = StaticIOUTracker()
if args.delay:
delay = args.delay
else:
delay = int(cap.get_type() in ('VIDEO', 'CAMERA'))
visualizer = Visualizer(['__background__', 'text'],
show_boxes=args.show_boxes,
show_scores=args.show_scores)
frames_processed = 0
metrics = PerformanceMetrics()
video_writer = cv2.VideoWriter()
start_time = perf_counter()
frame = cap.read()
if frame is None:
raise RuntimeError("Can't read an image from the input")
presenter = monitors.Presenter(args.utilization_monitors, 45,
(frame.shape[1] // 4, frame.shape[0] // 8))
if args.output and not video_writer.open(
args.output, cv2.VideoWriter_fourcc(*'MJPG'), cap.fps(),
(frame.shape[1], frame.shape[0])):
raise RuntimeError("Can't open video writer")
while frame is not None:
if not args.keep_aspect_ratio:
# Resize the image to a target size.
scale_x = w / frame.shape[1]
scale_y = h / frame.shape[0]
input_image = cv2.resize(frame, (w, h))
else:
# Resize the image to keep the same aspect ratio and to fit it to a window of a target size.
scale_x = scale_y = min(h / frame.shape[0], w / frame.shape[1])
input_image = cv2.resize(frame, None, fx=scale_x, fy=scale_y)
input_image_size = input_image.shape[:2]
input_image = np.pad(input_image,
((0, h - input_image_size[0]),
(0, w - input_image_size[1]), (0, 0)),
mode='constant',
constant_values=0)
# Change data layout from HWC to CHW.
input_image = input_image.transpose((2, 0, 1))
input_image = input_image.reshape((n, c, h, w)).astype(np.float32)
# Run the net.
outputs = mask_rcnn_exec_net.infer({'image': input_image})
# Parse detection results of the current request
boxes = outputs['boxes'][:, :4]
scores = outputs['boxes'][:, 4]
classes = outputs['labels'].astype(np.uint32)
raw_masks = outputs['masks']
text_features = outputs['text_features.0']
# Filter out detections with low confidence.
detections_filter = scores > args.prob_threshold
scores = scores[detections_filter]
classes = classes[detections_filter]
boxes = boxes[detections_filter]
raw_masks = raw_masks[detections_filter]
text_features = text_features[detections_filter]
boxes[:, 0::2] /= scale_x
boxes[:, 1::2] /= scale_y
masks = []
for box, cls, raw_mask in zip(boxes, classes, raw_masks):
mask = segm_postprocess(box, raw_mask, frame.shape[0],
frame.shape[1])
masks.append(mask)
texts = []
for feature in text_features:
feature = text_enc_exec_net.infer({'input': feature})['output']
feature = np.reshape(feature,
(feature.shape[0], feature.shape[1], -1))
feature = np.transpose(feature, (0, 2, 1))
hidden = np.zeros(hidden_shape)
prev_symbol_index = np.ones((1, )) * SOS_INDEX
text = ''
text_confidence = 1.0
for i in range(MAX_SEQ_LEN):
decoder_output = text_dec_exec_net.infer({
args.trd_input_prev_symbol:
prev_symbol_index,
args.trd_input_prev_hidden:
hidden,
args.trd_input_encoder_outputs:
feature
})
symbols_distr = decoder_output[args.trd_output_symbols_distr]
symbols_distr_softmaxed = softmax(symbols_distr, axis=1)[0]
prev_symbol_index = int(np.argmax(symbols_distr, axis=1))
text_confidence *= symbols_distr_softmaxed[prev_symbol_index]
if prev_symbol_index == EOS_INDEX:
break
text += args.alphabet[prev_symbol_index]
hidden = decoder_output[args.trd_output_cur_hidden]
texts.append(text if text_confidence >= args.tr_threshold else '')
if len(boxes) and args.raw_output_message:
log.debug(
' -------------------------- Frame # {} -------------------------- '
.format(frames_processed))
log.debug(
' Class ID | Confidence | XMIN | YMIN | XMAX | YMAX '
)
for box, cls, score, mask in zip(boxes, classes, scores, masks):
log.debug(
'{:>10} | {:>10f} | {:>8.2f} | {:>8.2f} | {:>8.2f} | {:>8.2f} '
.format(cls, score, *box))
# Get instance track IDs.
masks_tracks_ids = None
if tracker is not None:
masks_tracks_ids = tracker(masks, classes)
presenter.drawGraphs(frame)
# Visualize masks.
frame = visualizer(frame, boxes, classes, scores, masks, texts,
masks_tracks_ids)
metrics.update(start_time, frame)
frames_processed += 1
if video_writer.isOpened() and (args.output_limit <= 0 or
frames_processed <= args.output_limit):
video_writer.write(frame)
if not args.no_show:
# Show resulting image.
cv2.imshow('Results', frame)
if not args.no_show:
key = cv2.waitKey(delay)
esc_code = 27
if key == esc_code:
break
presenter.handleKey(key)
start_time = perf_counter()
frame = cap.read()
metrics.log_total()
for rep in presenter.reportMeans():
log.info(rep)
cv2.destroyAllWindows()
# -*- coding: utf-8 -*-
# Copyright (C) 2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import openvino.inference_engine as ie
print('OpenVINO version:', ie.get_version())
print('Available devices: ', ie.IECore().available_devices)
def main():
args = build_argparser().parse_args()
# load vocabulary file for model
vocab = load_vocab_file(args.vocab)
log.debug("Loaded vocab file from {}, get {} tokens".format(
args.vocab, len(vocab)))
# create tokenizer
tokenizer = Tokenizer(BPE(str(args.vocab), str(args.merges)))
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)
tokenizer.decoder = decoders.ByteLevel()
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
# read IR
model_xml = args.model
model_bin = model_xml.with_suffix(".bin")
log.info('Reading model {}'.format(args.model))
ie_net = ie.read_network(model=model_xml, weights=model_bin)
# check input and output names
if len(ie_net.input_info) != 1:
raise RuntimeError(
'The demo expects model with single input, while provided {}'.
format(len(ie_net.input_info)))
if len(ie_net.outputs) != 1:
raise RuntimeError(
'The demo expects model with single output, while provided {}'.
format(len(ie_net.outputs)))
input_names = next(iter(ie_net.input_info))
output_names = next(iter(ie_net.outputs))
# load model to the device
ie_net_exec = ie.load_network(network=ie_net, device_name=args.device)
log.info('The model {} is loaded to {}'.format(args.model, args.device))
if args.input:
def prompts():
for prompt in args.input:
log.info("Input prompt: {}".format(prompt))
yield prompt
else:
def prompts():
while True:
yield input('Type input prompt (empty string to exit):')
# loop on user's or prepared prompts
for prompt in prompts():
if not prompt.strip():
break
# encode input
tokens = tokenizer.encode_batch([prompt])[0].ids
input_ids = np.array([tokens], dtype=np.int32)
# maximum number of tokens that can be processed by network at once
max_length = ie_net.input_info[input_names].input_data.shape[1]
eos_token_id = len(vocab) - 1
cur_input_len = input_ids.shape[-1]
# maximum number of tokens that will be generated
max_sample_token_num = args.max_sample_token_num + cur_input_len
t0 = time.perf_counter()
t_count = 0
while True:
# pad the rest of the request
pad_len = max_length - cur_input_len
model_input = np.concatenate(
(input_ids, [[eos_token_id] * pad_len]), axis=-1)
# create numpy inputs for IE
inputs = {
input_names: model_input,
}
# infer by IE
t_start = time.perf_counter()
res = ie_net_exec.infer(inputs=inputs)
t_end = time.perf_counter()
t_count += 1
log.info(
"Sequence of length {} is processed with {:0.2f} requests/sec ({:0.2} sec per request)"
.format(max_length, 1 / (t_end - t_start), t_end - t_start))
outputs = res[output_names]
next_token_logits = outputs[:, cur_input_len - 1, :]
# pre-process distribution
next_token_scores = process_logits(input_ids, next_token_logits,
eos_token_id)
if args.top_k > 0:
next_token_scores = get_top_k_logits(next_token_scores,
args.top_k)
if args.top_p < 1.0:
next_token_scores = get_top_p_logits(next_token_scores,
args.top_p)
# get next token id
probs = softmax(next_token_scores)
next_tokens = np.random.choice(probs.shape[-1],
1,
p=probs[0],
replace=True)
# update info for the next step
input_ids = np.concatenate((input_ids, [next_tokens]), axis=-1)
cur_input_len = input_ids.shape[-1]
if stop_criteria(input_ids, min(max_length, max_sample_token_num),
eos_token_id):
break
t1 = time.perf_counter()
text = tokenizer.decode_batch(input_ids)[0]
log.info(
"{} requests of {} length were processed in {:0.2f}sec ({:0.2}sec per request)"
.format(t_count, max_length, t1 - t0, (t1 - t0) / t_count))
# print result
log.info("GENERATED SEQUENCE: {}".format(text))
def main():
current_dir = os.path.dirname(os.path.abspath(__file__))
"""Prepares data for the object tracking demo"""
parser = argparse.ArgumentParser(description='Multi camera multi object \
tracking live demo script')
parser.add_argument(
'-i',
'--input',
required=True,
nargs='+',
help=
'Required. Input sources (indexes of cameras or paths to video files)')
parser.add_argument('--loop',
default=False,
action='store_true',
help='Optional. Enable reading the input in a loop')
parser.add_argument('--config',
type=str,
default=os.path.join(current_dir, 'configs/person.py'),
required=False,
help='Configuration file')
parser.add_argument('--detections',
type=str,
help='JSON file with bounding boxes')
parser.add_argument('-m',
'--m_detector',
type=str,
required=False,
help='Path to the object detection model')
parser.add_argument('--t_detector',
type=float,
default=0.6,
help='Threshold for the object detection model')
parser.add_argument('--m_segmentation',
type=str,
required=False,
help='Path to the object instance segmentation model')
parser.add_argument(
'--t_segmentation',
type=float,
default=0.6,
help='Threshold for object instance segmentation model')
parser.add_argument(
'--m_reid',
type=str,
required=True,
help='Required. Path to the object re-identification model')
parser.add_argument('--output_video',
type=str,
default='',
required=False,
help='Optional. Path to output video')
parser.add_argument(
'--history_file',
type=str,
default='',
required=False,
help='Optional. Path to file in JSON format to save results of the demo'
)
parser.add_argument(
'--save_detections',
type=str,
default='',
required=False,
help='Optional. Path to file in JSON format to save bounding boxes')
parser.add_argument("--no_show",
help="Optional. Don't show output",
action='store_true')
parser.add_argument('-d', '--device', type=str, default='CPU')
parser.add_argument('-l',
'--cpu_extension',
help='MKLDNN (CPU)-targeted custom layers.Absolute \
path to a shared library with the kernels impl.',
type=str,
default=None)
parser.add_argument('-u',
'--utilization_monitors',
default='',
type=str,
help='Optional. List of monitors to show initially.')
args = parser.parse_args()
if check_detectors(args) != 1:
sys.exit(1)
if len(args.config):
log.debug('Reading config from {}'.format(args.config))
config = read_py_config(args.config)
else:
log.error(
'No configuration file specified. Please specify parameter \'--config\''
)
sys.exit(1)
random.seed(config.random_seed)
capture = MulticamCapture(args.input, args.loop)
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if args.detections:
object_detector = DetectionsFromFileReader(args.detections,
args.t_detector)
elif args.m_segmentation:
object_detector = MaskRCNN(ie, args.m_segmentation,
config.obj_segm.trg_classes,
args.t_segmentation,
args.device, args.cpu_extension,
capture.get_num_sources())
else:
object_detector = Detector(ie, args.m_detector,
config.obj_det.trg_classes, args.t_detector,
args.device, args.cpu_extension,
capture.get_num_sources())
if args.m_reid:
object_recognizer = VectorCNN(ie, args.m_reid, args.device,
args.cpu_extension)
else:
object_recognizer = None
run(args, config, capture, object_detector, object_recognizer)
def main():
args = build_argparser().parse_args()
cap = open_images_capture(args.input, args.loop)
with open(args.labels, 'rt') as labels_file:
class_labels = labels_file.read().splitlines()
assert len(class_labels), 'The file with class labels is empty'
# Plugin initialization for specified device and load extensions library if specified.
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
if args.cpu_extension and 'CPU' in args.device:
ie.add_extension(args.cpu_extension, 'CPU')
# Read IR
log.info('Reading model {}'.format(args.model))
net = ie.read_network(args.model, args.model.with_suffix('.bin'))
image_input, image_info_input, (
n, c, h, w), model_type, postprocessor = check_model(net)
args.no_keep_aspect_ratio = model_type == 'yolact' or args.no_keep_aspect_ratio
exec_net = ie.load_network(network=net,
device_name=args.device,
num_requests=2)
log.info('The model {} is loaded to {}'.format(args.model, args.device))
if args.no_track:
tracker = None
else:
tracker = StaticIOUTracker()
if args.delay:
delay = args.delay
else:
delay = int(cap.get_type() in ('VIDEO', 'CAMERA'))
frames_processed = 0
metrics = PerformanceMetrics()
visualizer = Visualizer(class_labels,
show_boxes=args.show_boxes,
show_scores=args.show_scores)
video_writer = cv2.VideoWriter()
start_time = perf_counter()
frame = cap.read()
if frame is None:
raise RuntimeError("Can't read an image from the input")
out_frame_size = (frame.shape[1], frame.shape[0])
presenter = monitors.Presenter(
args.utilization_monitors, 45,
(round(out_frame_size[0] / 4), round(out_frame_size[1] / 8)))
if args.output and not video_writer.open(args.output,
cv2.VideoWriter_fourcc(*'MJPG'),
cap.fps(), out_frame_size):
raise RuntimeError("Can't open video writer")
while frame is not None:
if args.no_keep_aspect_ratio:
# Resize the image to a target size.
scale_x = w / frame.shape[1]
scale_y = h / frame.shape[0]
input_image = cv2.resize(frame, (w, h))
else:
# Resize the image to keep the same aspect ratio and to fit it to a window of a target size.
scale_x = scale_y = min(h / frame.shape[0], w / frame.shape[1])
input_image = cv2.resize(frame, None, fx=scale_x, fy=scale_y)
input_image_size = input_image.shape[:2]
input_image = np.pad(input_image,
((0, h - input_image_size[0]),
(0, w - input_image_size[1]), (0, 0)),
mode='constant',
constant_values=0)
# Change data layout from HWC to CHW.
input_image = input_image.transpose((2, 0, 1))
input_image = input_image.reshape((n, c, h, w)).astype(np.float32)
input_image_info = np.asarray(
[[input_image_size[0], input_image_size[1], 1]], dtype=np.float32)
# Run the net.
feed_dict = {image_input: input_image}
if image_info_input:
feed_dict[image_info_input] = input_image_info
outputs = exec_net.infer(feed_dict)
# Parse detection results of the current request
scores, classes, boxes, masks = postprocessor(outputs, scale_x,
scale_y,
*frame.shape[:2], h, w,
args.prob_threshold)
if len(boxes) and args.raw_output_message:
log.debug(
' -------------------------- Frame # {} -------------------------- '
.format(frames_processed))
log.debug(
' Class ID | Confidence | XMIN | YMIN | XMAX | YMAX '
)
for box, cls, score, mask in zip(boxes, classes, scores, masks):
log.debug(
'{:>10} | {:>10f} | {:>8.2f} | {:>8.2f} | {:>8.2f} | {:>8.2f} '
.format(cls, score, *box))
# Get instance track IDs.
masks_tracks_ids = None
if tracker is not None:
masks_tracks_ids = tracker(masks, classes)
# Visualize masks.
frame = visualizer(frame, boxes, classes, scores, presenter, masks,
masks_tracks_ids)
metrics.update(start_time, frame)
frames_processed += 1
if video_writer.isOpened() and (args.output_limit <= 0 or
frames_processed <= args.output_limit):
video_writer.write(frame)
if not args.no_show:
# Show resulting image.
cv2.imshow('Results', frame)
if not args.no_show:
key = cv2.waitKey(delay)
esc_code = 27
if key == esc_code:
break
presenter.handleKey(key)
start_time = perf_counter()
frame = cap.read()
metrics.log_total()
for rep in presenter.reportMeans():
log.info(rep)
cv2.destroyAllWindows()
def import_core_modules(silent: bool, path_to_module: str):
try:
from openvino.inference_engine import IECore, get_version # pylint: disable=import-error
from openvino.offline_transformations import ApplyMOCTransformations, CheckAPI # pylint: disable=import-error
import openvino # pylint: disable=import-error
if silent:
return True
ie_version = str(get_version())
mo_version = str(v.get_version()) # pylint: disable=no-member
print("\t- {}: \t{}".format("Inference Engine found in",
os.path.dirname(openvino.__file__)))
print("{}: \t{}".format("Inference Engine version", ie_version))
print("{}: \t {}".format("Model Optimizer version", mo_version))
versions_mismatch = False
# MO and IE version have a small difference in the beginning of version because
# IE version also includes API version. For example:
# Inference Engine version: 2.1.custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# Model Optimizer version: custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# So to match this versions we skip IE API version.
if not re.match(r"^([0-9]+).([0-9]+).{}$".format(mo_version),
ie_version):
versions_mismatch = True
extracted_mo_release_version = v.extract_release_version(
mo_version)
mo_is_custom = extracted_mo_release_version == (None, None)
print(
"[ WARNING ] Model Optimizer and Inference Engine versions do no match."
)
print(
"[ WARNING ] Consider building the Inference Engine Python API from sources or reinstall OpenVINO (TM) toolkit using",
end=" ")
if mo_is_custom:
print(
"\"pip install openvino\" (may be incompatible with the current Model Optimizer version)"
)
else:
print("\"pip install openvino=={}.{}\"".format(
*extracted_mo_release_version))
simplified_mo_version = v.get_simplified_mo_version()
message = str(
dict({
"platform": platform.system(),
"mo_version": simplified_mo_version,
"ie_version": v.get_simplified_ie_version(version=ie_version),
"versions_mismatch": versions_mismatch,
}))
send_telemetry(simplified_mo_version, message, 'ie_version_check')
return True
except Exception as e:
# Do not print a warning if module wasn't found or silent mode is on
if "No module named 'openvino'" not in str(e) and not silent:
print(
"[ WARNING ] Failed to import Inference Engine Python API in: {}"
.format(path_to_module))
print("[ WARNING ] {}".format(e))
# Send telemetry message about warning
simplified_mo_version = v.get_simplified_mo_version()
message = str(
dict({
"platform": platform.system(),
"mo_version": simplified_mo_version,
"ie_version": v.get_simplified_ie_version(env=os.environ),
"python_version": sys.version,
"error_type": classify_error_type(e),
}))
send_telemetry(simplified_mo_version, message, 'ie_import_failed')
return False
def main():
args = build_argparser().parse_args()
cap = open_images_capture(args.input, args.loop)
# Plugin initialization for specified device and load extensions library if specified
log.info('OpenVINO Inference Engine')
log.info('\tbuild: {}'.format(get_version()))
ie = IECore()
# Read IR
log.info('Reading Proposal model {}'.format(args.model_pnet))
p_net = ie.read_network(args.model_pnet)
assert len(p_net.input_info.keys()) == 1, "Pnet supports only single input topologies"
assert len(p_net.outputs) == 2, "Pnet supports two output topologies"
log.info('Reading Refine model {}'.format(args.model_rnet))
r_net = ie.read_network(args.model_rnet)
assert len(r_net.input_info.keys()) == 1, "Rnet supports only single input topologies"
assert len(r_net.outputs) == 2, "Rnet supports two output topologies"
log.info('Reading Output model {}'.format(args.model_onet))
o_net = ie.read_network(args.model_onet)
assert len(o_net.input_info.keys()) == 1, "Onet supports only single input topologies"
assert len(o_net.outputs) == 3, "Onet supports three output topologies"
pnet_input_blob = next(iter(p_net.input_info))
rnet_input_blob = next(iter(r_net.input_info))
onet_input_blob = next(iter(o_net.input_info))
for name, blob in p_net.outputs.items():
if blob.shape[1] == 2:
pnet_cls_name = name
elif blob.shape[1] == 4:
pnet_roi_name = name
else:
raise RuntimeError("Unsupported output layer for Pnet")
for name, blob in r_net.outputs.items():
if blob.shape[1] == 2:
rnet_cls_name = name
elif blob.shape[1] == 4:
rnet_roi_name = name
else:
raise RuntimeError("Unsupported output layer for Rnet")
for name, blob in o_net.outputs.items():
if blob.shape[1] == 2:
onet_cls_name = name
elif blob.shape[1] == 4:
onet_roi_name = name
elif blob.shape[1] == 10:
onet_pts_name = name
else:
raise RuntimeError("Unsupported output layer for Onet")
next_frame_id = 0
metrics = PerformanceMetrics()
presenter = None
video_writer = cv2.VideoWriter()
is_loaded_before = False
while True:
start_time = perf_counter()
origin_image = cap.read()
if origin_image is None:
if next_frame_id == 0:
raise ValueError("Can't read an image from the input")
break
if next_frame_id == 0:
presenter = monitors.Presenter(args.utilization_monitors, 55,
(round(origin_image.shape[1] / 4), round(origin_image.shape[0] / 8)))
if args.output and not video_writer.open(args.output, cv2.VideoWriter_fourcc(*'MJPG'),
cap.fps(), (origin_image.shape[1], origin_image.shape[0])):
raise RuntimeError("Can't open video writer")
next_frame_id += 1
rgb_image = cv2.cvtColor(origin_image, cv2.COLOR_BGR2RGB)
oh, ow, _ = rgb_image.shape
scales = utils.calculate_scales(rgb_image)
# *************************************
# Pnet stage
# *************************************
pnet_res = []
for i, scale in enumerate(scales):
hs = int(oh*scale)
ws = int(ow*scale)
image = preprocess_image(rgb_image, ws, hs)
p_net.reshape({pnet_input_blob: [1, 3, ws, hs]}) # Change weidth and height of input blob
exec_pnet = ie.load_network(network=p_net, device_name=args.device)
if i == 0 and not is_loaded_before:
log.info("The Proposal model {} is loaded to {}".format(args.model_pnet, args.device))
p_res = exec_pnet.infer(inputs={pnet_input_blob: image})
pnet_res.append(p_res)
image_num = len(scales)
rectangles = []
for i in range(image_num):
roi = pnet_res[i][pnet_roi_name]
cls = pnet_res[i][pnet_cls_name]
_, _, out_h, out_w = cls.shape
out_side = max(out_h, out_w)
rectangle = utils.detect_face_12net(cls[0][1], roi[0], out_side, 1/scales[i], ow, oh,
score_threshold[0], iou_threshold[0])
rectangles.extend(rectangle)
rectangles = utils.NMS(rectangles, iou_threshold[1], 'iou')
# Rnet stage
if len(rectangles) > 0:
r_net.reshape({rnet_input_blob: [len(rectangles), 3, 24, 24]}) # Change batch size of input blob
exec_rnet = ie.load_network(network=r_net, device_name=args.device)
if not is_loaded_before:
log.info("The Refine model {} is loaded to {}".format(args.model_rnet, args.device))
rnet_input = []
for rectangle in rectangles:
crop_img = rgb_image[int(rectangle[1]):int(rectangle[3]), int(rectangle[0]):int(rectangle[2])]
crop_img = preprocess_image(crop_img, 24, 24)
rnet_input.extend(crop_img)
rnet_res = exec_rnet.infer(inputs={rnet_input_blob: rnet_input})
roi = rnet_res[rnet_roi_name]
cls = rnet_res[rnet_cls_name]
rectangles = utils.filter_face_24net(cls, roi, rectangles, ow, oh, score_threshold[1], iou_threshold[2])
# Onet stage
if len(rectangles) > 0:
o_net.reshape({onet_input_blob: [len(rectangles), 3, 48, 48]}) # Change batch size of input blob
exec_onet = ie.load_network(network=o_net, device_name=args.device)
if not is_loaded_before:
log.info("The Output model {} is loaded to {}".format(args.model_onet, args.device))
is_loaded_before = True
onet_input = []
for rectangle in rectangles:
crop_img = rgb_image[int(rectangle[1]):int(rectangle[3]), int(rectangle[0]):int(rectangle[2])]
crop_img = preprocess_image(crop_img, 48, 48)
onet_input.extend(crop_img)
onet_res = exec_onet.infer(inputs={onet_input_blob: onet_input})
roi = onet_res[onet_roi_name]
cls = onet_res[onet_cls_name]
pts = onet_res[onet_pts_name]
rectangles = utils.filter_face_48net(cls, roi, pts, rectangles, ow, oh,
score_threshold[2], iou_threshold[3])
# display results
for rectangle in rectangles:
# Draw detected boxes
cv2.putText(origin_image, 'confidence: {:.2f}'.format(rectangle[4]),
(int(rectangle[0]), int(rectangle[1])), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0))
cv2.rectangle(origin_image, (int(rectangle[0]), int(rectangle[1])), (int(rectangle[2]), int(rectangle[3])),
(255, 0, 0), 1)
# Draw landmarks
for i in range(5, 15, 2):
cv2.circle(origin_image, (int(rectangle[i+0]), int(rectangle[i+1])), 2, (0, 255, 0))
metrics.update(start_time, origin_image)
if video_writer.isOpened() and (args.output_limit <= 0 or next_frame_id <= args.output_limit):
video_writer.write(origin_image)
if not args.no_show:
cv2.imshow('MTCNN Results', origin_image)
key = cv2.waitKey(1)
if key in {ord('q'), ord('Q'), 27}:
break
presenter.handleKey(key)
metrics.log_total()
