def detection_task(num_inferences): tid = threading.get_ident() print('Thread: %d, %d inferences for detection task' % (tid, num_inferences)) model_name = 'mobilenet_ssd_v1_coco_quant_postprocess_edgetpu.tflite' engine = DetectionEngine(test_utils.test_data_path(model_name)) print('Thread: %d, using device %s' % (tid, engine.device_path())) with test_utils.test_image('cat.bmp') as img: for _ in range(num_inferences): ret = engine.detect_with_image(img, top_k=1) self.assertEqual(len(ret), 1) self.assertEqual(ret[0].label_id, 16) # cat self.assertGreater(ret[0].score, 0.7) self.assertGreater( test_utils.iou(np.array([[0.1, 0.1], [0.7, 1.0]]), ret[0].bounding_box), 0.88) print('Thread: %d, done detection task' % tid)
default="edgetpu/test_data/mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite", \ help=".tflite model to be executed") parser.add_argument("-l", "--label_file", default="edgetpu/edgetpu_models/coco_labels.txt", \ help="name of file containing labels") parser.add_argument("-k", "--top_k", default=5, help="top_k") parser.add_argument("-t", "--threshold", default=0.0, help="threshold") parser.add_argument("-c", "--loop_counts", default=1, help="loop counts") parser.add_argument("-s", "--show_image", default=False, help="show image") parser.add_argument("-d", "--device_path", help="device_path") args = parser.parse_args() if args.device_path: engine = DetectionEngine(args.model_file, device_path=args.device_path) else: engine = DetectionEngine(args.model_file) print("device path:", engine.device_path()) output_sizes = engine.get_all_output_tensors_sizes() # print("output sizes:", output_sizes) count = 0 indices = [] for i in output_sizes: count = count + i indices.append(count) # print("indices:", indices) input_tensor_shape = engine.get_input_tensor_shape() if (input_tensor_shape.size != 4 or input_tensor_shape[3] != 3 or input_tensor_shape[0] != 1): raise RuntimeError(
def inference_thread(running, state, result_buffer, frame_buffer, args, identity_dict, current_identity): global IDLE, TRACK, RESET, FACE_RECOG_THRESHOLD, FACE_RECOG_THRESHOLD_A global od_engine, face_detector, facenet_engine, svm_clf # Initialize object detection engine. od_engine = DetectionEngine(args.od_model) print("device_path: ", od_engine.device_path()) _, od_width, od_height, _ = od_engine.get_input_tensor_shape() print("od input dim: ", od_width, od_height) # initial face detector using the opencv haarcascade model face_detector = FaceDetector(args.hc_model) # Initialize facenet engine. facenet_engine = BasicEngine(args.fn_model) # load the sklearn support vector machine model from disk svm_clf = pickle.load(open(args.svm_model, 'rb')) while running.value: # check if the frame buffer has a frame, else busy waiting if frame_buffer.empty(): continue frame = frame_buffer.get() tinf = time.perf_counter() if state.value == IDLE: fd_results = None # reorder image frame from BGR to RGB img = frame[:,:,::-1] # face detection faces_coord = face_detector.detect(img, True) # image preprocessing, downsampling print("faces_coord: ",faces_coord) if not isinstance(faces_coord, type(None)): # normalize face image face_image = np.array(normalize_faces(img ,faces_coord)) # facenet to generate face embedding facenet_engine.RunInference(face_image.flatten()) face_emb = facenet_engine.get_raw_output().reshape(1,-1) # use SVM to classfy identity with face embedding pred_prob = svm_clf.predict_proba(face_emb) best_class_index = np.argmax(pred_prob, axis=1)[0] best_class_prob = pred_prob[0, best_class_index] print("best_class_index: ",best_class_index) print("best_class_prob: ",best_class_prob) print("label", svm_clf.classes_[best_class_index]) # Check threshold and verify identify is in the identifiy dictionary if best_class_prob > FACE_RECOG_THRESHOLD: face_label = svm_clf.classes_[best_class_index] if face_label in identity_dict: print("\n=================================") print("Identity found: ", face_label, " ",identity_dict[face_label], " with Prob = ", best_class_prob) print("=================================\n") current_identity.value = identity_dict[face_label][0] # ID result_buffer.put(faces_coord) elif state.value == TRACK: od_results = None # convert numpy array representation to PIL image with rgb format img = Image.fromarray(frame[:,:,::-1], 'RGB') # Run inference. od_results = od_engine.DetectWithImage(img, threshold=0.30, keep_aspect_ratio=True, relative_coord=False, top_k=10) # push result to buffer queue result_buffer.put(od_results) print(time.perf_counter() - tinf, "sec") print("[Finish] inference_thread")
# print(str(cap.get(3)) + ', ' + str(cap.get(4)) + ', ' + str(cap.get(5)) + ', ' + str(cap.get(16))) ##########load labels labels = {} i = 0 for row in open('labels/lite_labelmap.txt'): # unpack the row and update the labels dictionary label = row.strip() labels[int(i)] = label.strip() i += 1 ###########load models to engines from edgetpu.detection.engine import DetectionEngine from PIL import Image model_a = DetectionEngine('tflite-models/coral_objdtct_mnet_ssd_v1.tflite') model_b = DetectionEngine('tflite-models/detect.tflite', model_a.device_path()) print('edgetpu models loaded') ############camera cap = cv.VideoCapture(-1) ############runtime model_a_times = [] model_b_times = [] while True: # Capture frame-by-frame frame_s = time.time() ret, img = cap.read() # Read and preprocess an image.