def benchmark_callback(self, network_inputs_data): latencies = list() if self._network: ie_network = self._network.ie_network else: ie_network = ie.IENetwork(self._configuration.model, self._configuration.weights) plugin = ie.IEPlugin(self._configuration.device) if self._configuration.cpu_extension: plugin.add_cpu_extension(self._configuration.cpu_extension) exec_network = plugin.load(ie_network) # warming up exec_network.infer(network_inputs_data) for i in range(self._iterations_count): start = datetime.datetime.now() exec_network.infer(network_inputs_data) latencies.append((datetime.datetime.now() - start).microseconds) self._latency = numpy.mean(latencies) / 1000000.0 del ie_network del exec_network del plugin
def _create_multi_device_plugin(self, log=True): async_mode = self.get_value_from_config('async_mode') if not async_mode: warning('Using multi device in sync mode non-applicable. Async mode will be used.') self.async_mode = True num_per_device_req = re.findall(NIREQ_REGEX, self._device) device_list = self._devices_list() num_devices = len(device_list) if num_per_device_req: brackets = r"(\()|(\))" num_per_device_requests = [int(re.sub(brackets, '', nreq)) for nreq in num_per_device_req] if 'num_requests' in self.config: warning( "number requests already provided in device name specification. " "'num_requests' option will be ignored." ) else: num_per_device_requests = get_or_parse_value(self.config.get('num_requests', 1), casting_type=int) if len(num_per_device_requests) == 1: num_per_device_requests = [num_per_device_requests[0]] * len(device_list) if num_devices != len(num_per_device_requests): raise ConfigError('num requests for all {} should be specified'.format(num_devices)) device_strings = [ '{device}({nreq})'.format(device=device, nreq=nreq) for device, nreq in zip(device_list, num_per_device_requests) ] self.plugin = ie.IEPlugin('MULTI:{}'.format(','.join(device_strings))) self._num_requests = sum(num_per_device_requests)*2 if log: print_info('Loaded {} plugin version: {}'.format(self.plugin.device, self.plugin.version)) print_info('Request number for each device:') for device, nreq in zip(device_list, num_per_device_requests): print_info(' {} - {}'.format(device, nreq))
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 openvino_random_input(xml, weights, scale=255.): net = ie.IENetwork(model=xml, weights=weights) assert (len(net.inputs) == 1) i0 = [k for k in net.inputs.keys()][0] plugin = ie.IEPlugin(device="CPU") exec_net = plugin.load(network=net) input_shape = exec_net.requests[0].inputs[i0].shape input_array = np.random.random(input_shape).astype(np.float32) * scale return input_array
def __init__(self, configuration: CalibratorConfiguration): self._configuration = configuration network = self.create_network() self._input_layer_name = next(iter(network.inputs)) self._output_layer_name = next(iter(network.outputs)) self.plugin = ie.IEPlugin(self._configuration.device) if self._configuration.cpu_extension and self._configuration.device == 'CPU': self.plugin.add_cpu_extension(self._configuration.cpu_extension) if self._configuration.gpu_extension and self._configuration.device == 'GPU': self.plugin.set_config('CONFIG_FILE', self._configuration.gpu_extension)
def main(): ####################### Device Initialization ######################## # Plugin initialization for specified device and load extensions library if specified plugin = ie.IEPlugin(device="MYRIAD") ######################################################################### ######################### Load Neural Network ######################### # Read in Graph file (IR) net = ie.IENetwork(model="cnn-mnist_inference.xml", weights="cnn-mnist_inference.bin") input_blob = next(iter(net.inputs)) out_blob = next(iter(net.outputs)) # Load network to the plugin exec_net = plugin.load(network=net) del net ######################################################################## ######################### Obtain Input Tensor ######################## # Obtain and preprocess input tensor (image) # Read and pre-process input image maybe we don't need to show these details image_for_inference = cv2.imread("./1.JPG") image_for_inference = cv2.cvtColor(image_for_inference, cv2.COLOR_BGR2GRAY) image_for_inference = cv2.resize(image_for_inference, (28, 28)) image_for_inference = image_for_inference.astype(numpy.float32) image_for_inference[:] = 1 - ((image_for_inference[:]) * (1.0 / 255.0)) image_for_inference = image_for_inference.reshape(-1, 28, 28) # ######################################################################## # ########################## Start Inference ########################## # # Start synchronous inference and get inference result start_time = time.time() req_handle = exec_net.start_async(0, inputs={input_blob: image_for_inference}) # # ######################################################################## # res = exec_net.infer({input_blob:image_for_inference}) # # ######################## Get Inference Result ######################### status = req_handle.wait() res = req_handle.outputs[out_blob] # Do something with the results... (like print top 5) print("FPS:", 1 / (time.time() - start_time)) print((1 - res[0]).argsort()[:1]) # ############################### Clean Up ############################ del exec_net del plugin
def __init__(self, config_entry, adapter): super().__init__(config_entry, adapter) dlsdk_launcher_config = DLSDKLauncherConfig('DLSDK_Launcher') dlsdk_launcher_config.validate(self._config) self._device = self._config['device'].upper() self._prepare_bitstream_firmware(self._config) self.plugin = ie.IEPlugin(self._device) print_info('Loaded {} plugin version: {}'.format( self.plugin.device, self.plugin.version)) if dlsdk_launcher_config.need_conversion: self._convert_model(self._config, dlsdk_launcher_config.framework) else: self._model = self._config['model'] self._weights = self._config['weights'] if self._config.get('cpu_extensions') and 'CPU' in self._device: self.plugin.add_cpu_extension( str(self._config.get('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'))) self.network = ie.IENetwork.from_ir(model=str(self._model), weights=str(self._weights)) self.original_outputs = self.network.outputs outputs = self._config.get('outputs') if outputs: self.network.add_outputs(outputs) self.exec_network = self.plugin.load(network=self.network) self._config_inputs = parse_inputs(self._config.get('inputs', [])) check_user_inputs(self.network.inputs.keys(), self._config_inputs) reshape_user_inputs(self._config_inputs, self.exec_network.requests[0].inputs) image_inputs = list( filter(lambda input: input not in self._config_inputs, self.inputs.keys())) if not image_inputs: raise ValueError('image input is not found') if len(image_inputs) > 1: raise ValueError( 'topologies with several image inputs are not supported') self._image_input_blob = image_inputs[0] self._batch = self.network.inputs[self._image_input_blob].shape[0]
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 main(): frame_interval = 3 # Number of frames after which to run face detection fps_display_interval = 5 # seconds frame_rate = 0 frame_count = 0 start_time = time.time() parser = get_parser() args = parser.parse_args() use_classifier = bool(args.classifier) extensions = os.environ.get('INTEL_EXTENSIONS_PATH') plugin = ie.IEPlugin(device=args.device) if extensions and "CPU" in args.device: for ext in extensions.split(':'): print("LOAD extension from {}".format(ext)) plugin.add_cpu_extension(ext) print('Load PNET') pnets = [] for r in parse_resolutions(args.resolutions): p = PNetHandler(plugin, r[0], r[1]) pnets.append(p) print('Load RNET') net = ie.IENetwork.from_ir(*net_filenames(plugin, 'rnet')) rnet_input_name = list(net.inputs.keys())[0] rnet_output_name0 = net.outputs[0] rnet_output_name1 = net.outputs[1] r_net = plugin.load(net) print('Load ONET') net = ie.IENetwork.from_ir(*net_filenames(plugin, 'onet')) onet_input_name = list(net.inputs.keys())[0] onet_batch_size = net.inputs[onet_input_name][0] onet_output_name0 = net.outputs[0] onet_output_name1 = net.outputs[1] onet_output_name2 = net.outputs[2] print('ONET_BATCH_SIZE = {}'.format(onet_batch_size)) o_net = plugin.load(net) if use_classifier: print('Load FACENET') model_file = args.graph weights_file = model_file[:-3] + 'bin' net = ie.IENetwork.from_ir(model_file, weights_file) facenet_input = list(net.inputs.keys())[0] facenet_output = net.outputs[0] face_net = plugin.load(net) # Load classifier with open(args.classifier, 'rb') as f: opts = {'file': f} if six.PY3: opts['encoding'] = 'latin1' (model, class_names) = pickle.load(**opts) minsize = 20 # minimum size of face threshold = [0.6, 0.7, 0.7] # three steps's threshold factor = 0.709 # scale factor # video_capture = cv2.VideoCapture(0) if args.image is None: from imutils.video import VideoStream from imutils.video import FPS vs = VideoStream(usePiCamera=args.camera_device == "PI", # resolution=(640, 480), # framerate=24 ).start() time.sleep(1) fps = FPS().start() bounding_boxes = [] labels = [] pnets_proxy = [] for p in pnets: pnets_proxy.append(p.proxy()) def _rnet_proxy(img): output = r_net.infer({rnet_input_name: img}) return output[rnet_output_name0], output[rnet_output_name1] def _onet_proxy(img): # img = img.reshape([1, 3, 48, 48]) output = o_net.infer({onet_input_name: img}) return output[onet_output_name0], output[onet_output_name1], output[ onet_output_name2] pnet, rnet, onet = detect_face.create_openvino_mtcnn( pnets_proxy, _rnet_proxy, _onet_proxy, onet_batch_size) try: while True: # Capture frame-by-frame if args.image is None: frame = vs.read() if isinstance(frame, tuple): frame = frame[1] else: frame = cv2.imread(args.image).astype(np.float32) # h = 400 # w = int(round(frame.shape[1] / (frame.shape[0] / float(h)))) h = 480 w = 640 if (frame.shape[1] != w) or (frame.shape[0] != h): frame = cv2.resize(frame, (w, h), interpolation=cv2.INTER_AREA) # BGR -> RGB rgb_frame = frame[:, :, ::-1] # rgb_frame = frame # print("Frame {}".format(frame.shape)) if (frame_count % frame_interval) == 0: # t = time.time() bounding_boxes, _ = detect_face.detect_face_openvino( rgb_frame, pnet, rnet, onet, threshold) # d = (time.time() - t) * 1000 # LOG.info('recognition: %.3fms' % d) # Check our current fps end_time = time.time() if (end_time - start_time) > fps_display_interval: frame_rate = int(frame_count / (end_time - start_time)) start_time = time.time() frame_count = 0 if use_classifier: imgs = get_images(rgb_frame, bounding_boxes) labels = [] # t = time.time() for img_idx, img in enumerate(imgs): img = img.astype(np.float32) # Infer img = img.transpose([2, 0, 1]).reshape([1, 3, 160, 160]) output = face_net.infer({facenet_input: img}) output = output[facenet_output] try: output = output.reshape(1, model.shape_fit_[1]) predictions = model.predict_proba(output) except ValueError as e: # Can not reshape print("ERROR: Output from graph doesn't consistent" " with classifier model: %s" % e) continue best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[ np.arange(len(best_class_indices)), best_class_indices] for i in range(len(best_class_indices)): bb = bounding_boxes[img_idx].astype(int) text = '%.1f%% %s' % ( best_class_probabilities[i] * 100, class_names[best_class_indices[i]]) labels.append({ 'label': text, 'left': bb[0], 'top': bb[1] - 5 }) # DEBUG print('%4d %s: %.3f' % (i, class_names[best_class_indices[i]], best_class_probabilities[i])) # d = (time.time() - t) * 1000 # LOG.info('facenet: %.3fms' % d) add_overlays(frame, bounding_boxes, frame_rate, labels=labels) frame_count += 1 if args.image is None: cv2.imshow('Video', frame) else: print(bounding_boxes) break if cv2.waitKey(1) & 0xFF == ord('q'): break except (KeyboardInterrupt, SystemExit) as e: print('Caught %s: %s' % (e.__class__.__name__, e)) # When everything is done, release the capture # video_capture.release() if args.image is None: fps.stop() vs.stop() cv2.destroyAllWindows() print('Finished')
def main(args): use_mlboard = False mlboard = None if client: mlboard = client.Client() try: mlboard.apps.get() except Exception: mlboard = None print('Do not use mlboard.') else: print('Use mlboard parameters logging.') use_mlboard = True if args.use_split_dataset: dataset_tmp = facenet.get_dataset(args.data_dir) train_set, test_set = split_dataset(dataset_tmp, args.min_nrof_images_per_class, args.nrof_train_images_per_class) if args.mode == 'TRAIN': dataset = train_set elif args.mode == 'CLASSIFY': dataset = test_set else: dataset = facenet.get_dataset(args.data_dir) update_data({'mode': args.mode}, use_mlboard, mlboard) # Check that there are at least one training image per class for cls in dataset: assert len( cls.image_paths ) > 0, 'There must be at least one image for each class in the dataset' paths, labels = facenet.get_image_paths_and_labels(dataset) print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) data = { 'num_classes': len(dataset), 'num_images': len(paths), 'model_path': args.model, 'image_size': args.image_size, 'data_dir': args.data_dir, 'batch_size': args.batch_size, } update_data(data, use_mlboard, mlboard) # Load the model print('Loading feature extraction model') xml_file = args.model bin_file = xml_file[:-3] + 'bin' net = ie.IENetwork.from_ir(xml_file, bin_file) extensions = os.environ.get('INTEL_EXTENSIONS_PATH') plugin = ie.IEPlugin(device=args.device) if extensions and "CPU" in args.device: for ext in extensions.split(':'): print("LOAD extension from {}".format(ext)) plugin.add_cpu_extension(ext) input_name = list(net.inputs.keys())[0] output_name = net.outputs[0] exec_net = plugin.load(net) # Run forward pass to calculate embeddings print('Calculating features for images') nrof_images = len(paths) nrof_batches_per_epoch = int(math.ceil(1.0 * nrof_images / args.batch_size)) emb_array = np.zeros((nrof_images, 512)) for i in range(nrof_batches_per_epoch): start_index = i * args.batch_size end_index = min((i + 1) * args.batch_size, nrof_images) paths_batch = paths[start_index:end_index] for j in range(end_index - start_index): print('Batch {} <-> {}'.format(paths_batch[j], labels[start_index + j])) images = facenet.load_data(paths_batch, False, False, args.image_size) images = images.transpose([0, 3, 1, 2]) feed_dict = {input_name: images} output = exec_net.infer(feed_dict) output = output[output_name] emb_array[start_index:end_index, :] = output classifier_filename_exp = os.path.expanduser(args.classifier_filename) if args.mode == 'TRAIN': # Train classifier print('Training classifier') model = svm.SVC(kernel='linear', probability=True) model.fit(emb_array, labels) # Create a list of class names class_names = [cls.name.replace('_', ' ') for cls in dataset] print('Classes:') print(class_names) # Saving classifier model with open(classifier_filename_exp, 'wb') as outfile: pickle.dump((model, class_names), outfile, protocol=2) print('Saved classifier model to file "%s"' % classifier_filename_exp) elif args.mode == 'CLASSIFY': # Classify images print('Testing classifier') with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) print('Loaded classifier model from file "%s"' % classifier_filename_exp) predictions = model.predict_proba(emb_array) best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[ np.arange(len(best_class_indices)), best_class_indices] for i in range(len(best_class_indices)): print('%4d %s: %.3f' % (i, class_names[best_class_indices[i]], best_class_probabilities[i])) accuracy = np.mean(np.equal(best_class_indices, labels)) update_data({'accuracy': accuracy}, use_mlboard, mlboard) print('Accuracy: %.3f' % accuracy) if args.upload_model and accuracy >= args.upload_threshold: timestamp = datetime.datetime.now().strftime('%s') upload_model(use_mlboard, mlboard, classifier_filename_exp, 'facenet-classifier', '1.0.0-%s' % timestamp)
def __init__( self, device, face_detection_path, facenet_path=None, classifier=None, bg_remove_path=None, loaded_plugin=None, debug=False): self.use_classifiers = False self.debug = debug extensions = os.environ.get('INTEL_EXTENSIONS_PATH') if loaded_plugin is not None: plugin = loaded_plugin else: plugin = ie.IEPlugin(device=device) if extensions and "CPU" in device: for ext in extensions.split(':'): print("LOAD extension from {}".format(ext)) plugin.add_cpu_extension(ext) print('Load FACE DETECTION') face_path = face_detection_path weights_file = face_path[:face_path.rfind('.')] + '.bin' net = ie.IENetwork(face_path, weights_file) self.face_detect = nets.FaceDetect(plugin, net) if facenet_path: print('Load FACENET') model_file = facenet_path weights_file = model_file[:model_file.rfind('.')] + '.bin' net = ie.IENetwork(model_file, weights_file) self.facenet_input = list(net.inputs.keys())[0] outputs = list(iter(net.outputs)) self.facenet_output = outputs[0] self.face_net = plugin.load(net) if classifier and len(classifier) > 0: self.use_classifiers = bool(facenet_path) self.classifiers = [] self.classifier_names = [] self.embedding_sizes = [] self.class_names = None self.class_stats = None for clfi, clf in enumerate(classifier): # Load classifier with open(clf, 'rb') as f: print('Load CLASSIFIER %s' % clf) opts = {'file': f} if six.PY3: opts['encoding'] = 'latin1' (classifier, class_names, class_stats) = pickle.load(**opts) if isinstance(classifier, svm.SVC): embedding_size = classifier.shape_fit_[1] clfn = "SVM classifier" self.classifier_names.append("SVM") elif isinstance(classifier, neighbors.KNeighborsClassifier): embedding_size = classifier._fit_X.shape[1] clfn = "kNN (neighbors %d) classifier" % classifier.n_neighbors # self.classifier_names.append("kNN(%2d)" % classifier.n_neighbors) self.classifier_names.append("kNN") else: # try embedding_size = 512 embedding_size = 512 clfn = type(classifier) self.classifier_names.append("%d" % clfi) print('Loaded %s, embedding size: %d' % (clfn, embedding_size)) if self.class_names is None: self.class_names = class_names elif class_names != self.class_names: raise RuntimeError("Different class names in classifiers") if self.class_stats is None: self.class_stats = class_stats elif class_stats != self.class_stats: raise RuntimeError("Different class stats in classifiers") self.embedding_sizes.append(embedding_size) self.classifiers.append(classifier) self.bg_remove = bg_remove.get_driver(bg_remove_path)