def __init__(self, model_name: str, label_file: str) -> None:
"""Initialize a pose classification model.
Args:
model_name: Name of the TFLite pose classification model.
label_file: Path of the label list file.
"""
# Append TFLITE extension to model_name if there's no extension
_, ext = os.path.splitext(model_name)
if not ext:
model_name += '.tflite'
# Initialize the TFLite model.
interpreter = Interpreter(model_path=model_name, num_threads=4)
interpreter.allocate_tensors()
self._input_index = interpreter.get_input_details()[0]['index']
self._output_index = interpreter.get_output_details()[0]['index']
self._interpreter = interpreter
self.pose_class_names = self._load_labels(label_file)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
#parser.add_argument('--model', help='File path of .tflite file.', required=True)
#parser.add_argument('--labels', help='File path of labels file.', required=True)
parser.add_argument('--image',
help='File path of image file to detect.',
required=True)
args = parser.parse_args()
labels = load_labels(
"/home/scripts/models/labels_mobilenet_quant_v1_224.txt")
interpreter = Interpreter(
"/home/scripts/models/mobilenet_v1_1.0_224_quant.tflite")
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
image = Image.open(args.image)
image = image.convert('RGB').resize((width, height), Image.ANTIALIAS)
results = classify_image(interpreter, image)
print("The image contains:", labels[results[0][0]])
def main():
interpreter = Interpreter(model_path, experimental_delegates=[load_delegate("libedgetpu.so.1")])
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
input_queue = input_manager.get_input_queue()
output_queue = output_manager.get_output_queue()
print('------------------------------------------------------------------------------------------')
print('Started Inference server, waiting for incoming requests ... (send \'stop\' to kill server)')
print('------------------------------------------------------------------------------------------')
while True:
data = input_queue.get()
print('recieved data with type ', type(data))
if type(data) == str and data == "stop": break
if type(data) == np.ndarray:
input_image = np.expand_dims(data, axis=0)
interpreter.set_tensor(input_details[0]["index"], input_image)
t_begin = time.perf_counter()
interpreter.invoke()
inference_time = time.perf_counter() - t_begin
boxes = interpreter.get_tensor(output_details[0]['index'])
labels = interpreter.get_tensor(output_details[1]['index'])
scores = interpreter.get_tensor(output_details[2]['index'])
num = interpreter.get_tensor(output_details[3]['index'])
print('number of detected objects: ', num , ', done in ', inference_time, ' seconds' )
output_queue.put({"num":num, "boxes": boxes, "labels": labels, "scores": scores})
# End while
input_manager.shutdown()
output_manager.shutdown()
def main():
model_path = 'data/detect.tflite'
labels_path = 'data/coco_labels.txt'
threshold = 0.4
labels = load_labels(labels_path)
interpreter = Interpreter(model_path)
interpreter.allocate_tensors()
_, input_height, input_width, _ = interpreter.get_input_details(
)[0]['shape']
with picamera.PiCamera(resolution=(CAMERA_WIDTH, CAMERA_HEIGHT),
framerate=30) as camera:
camera.start_preview()
try:
stream = io.BytesIO()
annotator = Annotator(camera)
for _ in camera.capture_continuous(stream,
format='jpeg',
use_video_port=True):
stream.seek(0)
image = Image.open(stream).convert('RGB').resize(
(input_width, input_height), Image.ANTIALIAS)
start_time = time.monotonic()
results = detect_objects(interpreter, image, threshold)
elapsed_ms = (time.monotonic() - start_time) * 1000
annotator.clear()
annotate_objects(annotator, results, labels)
annotator.text([5, 0], '%.1fms' % (elapsed_ms))
annotator.update()
stream.seek(0)
stream.truncate()
finally:
camera.stop_preview()
def __init__(self, model_filename='model.tflite'):
# load the .tflite model with the TF Lite runtime interpreter
self.interpreter = Interpreter(model_filename)
self.interpreter.allocate_tensors()
# get a handle to the input tensor details
input_details = self.interpreter.get_input_details()[0]
# get the input tensor index
self.input_index = input_details['index']
# get the shape of the input tensor, so we can rescale the
# input image to the appropriate size when making predictions
input_shape = input_details['shape']
self._input_height = input_shape[1]
self._input_width = input_shape[2]
# get a handle to the input tensor details
output_details = self.interpreter.get_output_details()[0]
# get the output tensor index
self.output_index = output_details['index']
def check_for_bird():
""" is there a bird at the feeder? """
labels = load_labels()
interpreter = Interpreter(path_to_model)
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
camera.start_preview()
time.sleep(2) # give the camera 2 seconds to adjust light balance
camera.capture(path_to_image)
image = Image.open(path_to_image)
results = classify_image(interpreter, image)
label_id, prob = results[0]
# print("bird: " + labels[label_id])
# print("prob: " + str(prob))
camera.stop_preview()
if prob > prob_threshold:
bird = labels[label_id]
bird = bird[bird.find(",") + 1:]
prob_pct = str(round(prob * 100, 1)) + "%"
send_note(bird, prob_pct)
def __init__(self):
print("init")
# self.MODEL_NAME = "D:\\TP_PROGS\\Projects\\TeProjSahara\\model_objDetec\\modelStart"
# self.MODEL_NAME = "D:\\TP_PROGS\\Projects\\TeProjSahara\\model_objDetec\\finalObjDet\\new\\new"
self.MODEL_NAME = "models\\model_objDetec\\modelStart"
# self.GRAPH_NAME = "detect.tflite"
self.GRAPH_NAME = "ssd_mobilenet_v1_1_metadata_1.tflite"
# self.LABELMAP_NAME = "labelmap.txt"
self.LABELMAP_NAME = "label.txt"
self.min_conf_threshold = 0.65
# use_TPU = args.edgetpu
self.listOfObjDetec = []
# Path to label map file
self.PATH_TO_LABELS = os.path.join(self.MODEL_NAME, self.LABELMAP_NAME)
print(self.PATH_TO_LABELS)
# Path to .tflite file, which contains the model that is used for object detection
self.PATH_TO_CKPT = os.path.join(self.MODEL_NAME, self.GRAPH_NAME)
# Load the label map
with open(self.PATH_TO_LABELS, 'r') as f:
self.labels = [line.strip() for line in f.readlines()]
# Have to do a weird fix for label map if using the COCO "starter model" from
# https://www.tensorflow.org/lite/models/object_detection/overview
# First label is '???', which has to be removed.
if self.labels[0] == '???':
del (self.labels[0])
# Load the Tensorflow Lite model.
self.interpreter = Interpreter(model_path=self.PATH_TO_CKPT)
self.interpreter.allocate_tensors()
# Get model details
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()
self.height = self.input_details[0]['shape'][1]
self.width = self.input_details[0]['shape'][2]
def main():
# parser = ArgumentParser(description='Demo Camera')
# parser.add_argument('-t','--threshold', type=float,help='threshold for classification')
# parser.add_argument('-m','--model_path', type=str,help='threshold for classification')
# args = parser.parse_args()
#
# threshold = args.threshold
# model_path = args.model_path
interpreter = Interpreter(model_path="./detect/detect.tflite")
interpreter.allocate_tensors()
_, input_height, input_width, _ = interpreter.get_input_details()[0]['shape']
labels = load_labels("./detect/labelmap.txt")
print("n-class : ",len(labels))
print(labels)
offset_label = 1
cap = cv2.VideoCapture(0)
while cap.isOpened():
ret,image = cap.read()
img = cv2.resize(image,(input_width, input_height))
results = detect_objects(interpreter,img,0.4)
for res in results:
box = res["bounding_box"]
class_id = res["class_id"]
tl,br = convert_boxs(box,size=(CAMERA_WIDTH,CAMERA_HEIGHT))
cv2.rectangle(image,tl,br,(0,255,0),2)
cv2.putText(image,labels[class_id+offset_label],tl,0,1,(0,255,255),2)
cv2.imshow("",image)
if cv2.waitKey(22) == ord('q'):
break
cv2.destroyAllWindows()
def __init__(self, config):
self.config = config
# Get the model name from the config
self.model_name = self.config.get_section_dict('Detector')['Name']
# Frames Per Second
self.fps = None
self.model_file = 'ped_ssd_mobilenet_v2_quantized_edgetpu.tflite'
self.model_path = '/repo/data/edgetpu/' + self.model_file
# Get the model .tflite file path from the config.
# If there is no .tflite file in the path it will be downloaded automatically from base_url
user_model_path = self.config.get_section_dict('Detector')['ModelPath']
if len(user_model_path) > 0:
print('using %s as model' % user_model_path)
self.model_path = user_model_path
else:
base_url = 'https://media.githubusercontent.com/media/neuralet/neuralet-models/master/edge-tpu/'
url = base_url + self.model_name + '/' + self.model_file
if not os.path.isfile(self.model_path):
print('model does not exist under: ', self.model_path,
'downloading from ', url)
wget.download(url, self.model_path)
# Load TFLite model and allocate tensors
self.interpreter = Interpreter(
self.model_path,
experimental_delegates=[load_delegate("libedgetpu.so.1")])
self.interpreter.allocate_tensors()
# Get the model input and output tensor details
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()
# Get class id from config
self.class_id = int(
self.config.get_section_dict('Detector')['ClassID'])
self.score_threshold = float(
self.config.get_section_dict('Detector')['MinScore'])
def main():
interpreter = Interpreter(model_path, experimental_delegates=[load_delegate("libedgetpu.so.1")])
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
input_queue = input_manager.get_input_queue()
output_queue = output_manager.get_output_queue()
print('------------------------------------------------------------------------------------------')
print('Started Inference server, waiting for incoming requests ... (send \'stop\' to kill server)')
print('------------------------------------------------------------------------------------------')
while True:
data = input_queue.get()
print('recieved data with type ', type(data))
if type(data) == str:
if data == "stop": break
else: pint('data is: ', data)
if type(data) == list:
data = np.array(data, dtype=np.uint8)
input_image = np.expand_dims(data, axis=0)
interpreter.set_tensor(input_details[0]["index"], input_image)
t_begin = time.perf_counter()
interpreter.invoke()
inference_time = time.perf_counter() - t_begin
net_output = interpreter.get_tensor(output_details[0]["index"])
print('inference output: ', net_output , ', done in ', inference_time, ' seconds' )
output_queue.put(net_output)
# End while
input_manager.shutdown()
output_manager.shutdown()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--model',
help='File path of .tflite file.',
required=True)
parser.add_argument('--labels',
help='File path of labels file.',
required=True)
args = parser.parse_args()
labels = load_labels(args.labels)
interpreter = Interpreter(args.model)
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
with picamera.PiCamera(resolution=(320, 240), framerate=30) as camera:
camera.start_preview()
try:
stream = io.BytesIO()
for _ in camera.capture_continuous(stream,
format='jpeg',
use_video_port=True):
stream.seek(0)
image = Image.open(stream).convert('RGB').resize(
(width, height), Image.ANTIALIAS)
start_time = time.time()
results = classify_image(interpreter, image)
logging.info(results)
elapsed_ms = (time.time() - start_time) * 1000
label_id, prob = results[0]
stream.seek(0)
stream.truncate()
camera.annotate_text = '%s %.2f\n%.1fms' % (labels[label_id],
prob, elapsed_ms)
finally:
camera.stop_preview()
def redwhitepredict():
# user input
parser = reqparse.RequestParser()
parser.add_argument('characteristics', type=str, required=True, help="This is expecting a selection of wine characteristics", action='append')
args = parser.parse_args()
characteristics = args['characteristics'][0].split(' ')
# Load the model
interpreter = Interpreter(model_path="Red_and_White_Analysis/redorwhite_model_trained.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Test the model on random input data.
input_shape = input_details[0]['shape']
user_input_characteristics=[float(i) for i in characteristics]
print(user_input_characteristics)
input_data = np.array([user_input_characteristics], dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)
#redorwhite_model = load_model('Red_and_White_Analysis/redorwhite_model_trained.h5')
# #predict the wine class based on model and save output to 'out'
# user_input_characteristics=[float(i) for i in characteristics]
#run model with user input
#result_characteristics = redorwhite_model.predict_classes([user_input_characteristics])
result_characteristics = "White" if output_data[0][0] ==0 else "Red"
return jsonify({'wine_selection': result_characteristics})
def image_classification_render():
#model configuration
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--model', help='File path of .tflite file.', required=True)
parser.add_argument('--labels', help='File path of labels file.', required=True)
args = parser.parse_args()
labels = load_labels(args.labels)
interpreter = Interpreter(args.model)
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
#image request
self.image_request()
#image classification
final_image = Image.open(final).convert('RGB').resize((width, height),Image.ANTIALIAS)
start_time = time.time()
results = classify_image(interpreter, final_image)
elapsed_ms = (time.time() - start_time) * 1000
label_id, prob = results[0]
cv2.putText(final_image, str(labels[label_id])+' '+str(prob)+' '+str(elapsed_ms), (10,20), cv2.FONT_HERSHEY_SIMPLEX, 0.6,(250,25,250), 2)
self.video.release()
return final_image
def main(base_path):
model_path = os.path.join(base_path, 'model.tflite')
label_path = os.path.join(base_path, 'labels.txt')
threshold = 0.4
labels = load_labels(label_path)
interpreter = Interpreter(model_path)
interpreter.allocate_tensors()
_, input_height, input_width, _ = interpreter.get_input_details(
)[0]['shape']
camera = cv2.VideoCapture(0)
while True:
s, image = camera.read()
if s: # frame captured without any errors
image = Image.fromarray(image).convert('RGB').resize(
(input_width, input_height), Image.ANTIALIAS)
results = detect_objects(interpreter, image, threshold)
if len(results) > 0:
print(labels[results[0]['class_id']])
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
'--model', help='File path of .tflite file.', required=True)
parser.add_argument(
'--labels', help='File path of labels file.', required=True)
parser.add_argument(
'--image', help='File path of image file.', required=True)
args = parser.parse_args()
labels = load_labels(args.labels)
interpreter = Interpreter(args.model)
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
print("%sx%s" % (height, width))
image = Image.open(args.image).convert('RGB').resize((width, height),
Image.ANTIALIAS)
results = classify_image(interpreter, image)
for label_id, prob in results:
annotate_text = '%s %.2f' % (labels[label_id], prob)
print(annotate_text)
def compute(model_path):
now = time.monotonic()
intp = Interpreter(model_path)
x = intp.tensor(intp.get_input_details()[0]['index'])
iy = intp.get_output_details()[0]['index']
intp.allocate_tensors()
t1 = time.monotonic() - now
now = time.monotonic()
for i in range(WARMUP):
#x().fill(CONSTANT)
x =np.random.rand()
intp.invoke()
y = intp.get_tensor(iy)
t2 = time.monotonic() - now
now = time.monotonic()
for i in range(ITER):
#x().fill(CONSTANT)
x =np.random.rand()
intp.invoke()
y = intp.get_tensor(iy)
t3 = time.monotonic() - now
return t1, t2/float(WARMUP), t3/float(ITER)
def apply(tflite_path, in0, in1, in2):
interpreter = Interpreter(model_path=tflite_path)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
input_tensor0 = input_details[0]['index']
input_tensor1 = input_details[1]['index']
input_tensor2 = input_details[2]['index']
output_tensors = [tensor['index'] for tensor in output_details]
res1 = []
res2 = []
res3 = []
for line0, line1, line2 in zip(in0.values, in1.values, in2.values):
line_res1 = []
line_res2 = []
line_res3 = []
interpreter.set_tensor(
input_tensor0,
np.array([line0]).astype(input_details[0]['dtype']))
interpreter.set_tensor(
input_tensor1,
np.array([line1]).astype(input_details[1]['dtype']))
interpreter.set_tensor(
input_tensor2,
np.array([line2]).astype(input_details[1]['dtype']))
interpreter.invoke()
for t in output_tensors:
a = interpreter.get_tensor(t)
line_res1.append(a[0][0])
line_res2.append(a[0][1])
line_res3.append(a[0][2])
res1.append(np.median(line_res1))
res2.append(np.median(line_res2))
res3.append(np.median(line_res3))
return res1, res2, res3
def main():
MODEL_PATH = BASE_DIR + '/pretrained_models/detect.tflite'
LABEL_PATH = BASE_DIR + '/pretrained_models/coco_labels.txt'
threshold = 0.4
labels = load_labels(LABEL_PATH)
interpreter = Interpreter(MODEL_PATH)
interpreter.allocate_tensors()
_, input_height, input_width, _ = interpreter.get_input_details(
)[0]['shape']
input_size = (input_width, input_height)
camera = cv2.VideoCapture(index=0)
camera.set(cv2.CAP_PROP_FPS, 3)
annotator = Annotator(img_size=(640, 480))
while (True):
ret, in_img = camera.read()
in_img = imutils.rotate_bound(in_img, angle=180)
img = cv2.resize(in_img,
dsize=input_size,
interpolation=cv2.INTER_NEAREST)
start_time = time.monotonic()
results = detect_objects(interpreter, img, threshold)
elapsed_ms = (time.monotonic() - start_time) * 1000
annotator.clear()
annotate_objects(annotator, results, labels)
annotator.text([5, 0], '%.1fms' % (elapsed_ms))
annotator.update(in_img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
camera.release()
cv2.destroyAllWindows()
def hair_pred(path, color):
img = cv2.imread(path)
deep_model = 'bisenetv2_celebamaskhq_448x448_float16_quant.tflite'
num_threads = 4
interpreter = Interpreter(model_path=deep_model, num_threads=num_threads)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()[0]['index']
bisenetv2_predictions = interpreter.get_output_details()[0]['index']
model_height = interpreter.get_input_details()[0]['shape'][1]
model_width = interpreter.get_input_details()[0]['shape'][2]
height, width, channels = img.shape
prepimg_deep_size = cv2.resize(img, (model_width, model_height))
prepimg_deep = cv2.cvtColor(prepimg_deep_size, cv2.COLOR_BGR2RGB)
prepimg_deep = np.expand_dims(prepimg_deep, axis=0)
prepimg_deep = prepimg_deep.astype(np.float32)
prepimg_deep /= 255.0
prepimg_deep -= [[[0.5, 0.5, 0.5]]]
prepimg_deep /= [[[0.5, 0.5, 0.5]]]
# Run model
interpreter.set_tensor(input_details, prepimg_deep)
interpreter.invoke()
# Get results
predictions = interpreter.get_tensor(bisenetv2_predictions)
table = {'hair': 17, 'upper_lip': 12, 'lower_lip': 13}
part = table['hair']
image = hair(prepimg_deep_size, predictions, part, color)
imdraw = cv2.resize(image, (width, height))
image = Image.fromarray(cv2.cvtColor(imdraw, cv2.COLOR_BGR2RGB))
bio = BytesIO()
bio.name = 'hair_seg.jpg'
image.save(bio, 'JPEG')
return bio
def __init__(self, config):
self.config = config
self.model_name = "OFMClassifier_edgetpu.tflite"
if os.path.isfile(config.CLASSIFIER_MODEL_PATH):
self.model_path = config.CLASSIFIER_MODEL_PATH
else:
self.model_path = 'data/classifiers/edgetpu/'
if not os.path.isdir(self.model_path):
os.makedirs(self.model_path)
self.model_path = self.model_path + self.model_name
# Frames Per Second
self.fps = None
if not os.path.isfile(self.model_path):
url = "https://raw.githubusercontent.com/neuralet/neuralet-models/master/edge-tpu/OFMClassifier/OFMClassifier_edgetpu.tflite"
print("model does not exist under: ", self.model_path, "downloading from ", url)
wget.download(url, self.model_path)
# Load TFLite model and allocate tensors
self.interpreter = Interpreter(self.model_path, experimental_delegates=[load_delegate("libedgetpu.so.1")])
self.interpreter.allocate_tensors()
# Get the model input and output tensor details
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()
def __init__(self, model_name: str) -> None:
"""Initialize a MoveNet pose estimation model.
Args:
model_name: Name of the TFLite MoveNet model.
"""
# Append TFLITE extension to model_name if there's no extension
_, ext = os.path.splitext(model_name)
if not ext:
model_name += '.tflite'
# Initialize model
interpreter = Interpreter(model_path=model_name, num_threads=4)
interpreter.allocate_tensors()
self._input_index = interpreter.get_input_details()[0]['index']
self._output_index = interpreter.get_output_details()[0]['index']
self._input_height = interpreter.get_input_details()[0]['shape'][1]
self._input_width = interpreter.get_input_details()[0]['shape'][2]
self._interpreter = interpreter
self._crop_region = None
# Load the label map
with open(PATH_TO_LABELS, 'r') as f:
labels = [line.strip() for line in f.readlines()]
# Have to do a weird fix for label map if using the COCO "starter model" from
# https://www.tensorflow.org/lite/models/object_detection/overview
# First label is '???', which has to be removed.
if labels[0] == '???':
del (labels[0])
# Load the Tensorflow Lite model.
# If using Edge TPU, use special load_delegate argument
if use_TPU:
interpreter = Interpreter(
model_path=PATH_TO_CKPT,
experimental_delegates=[load_delegate('libedgetpu.so.1.0')])
print(PATH_TO_CKPT)
else:
interpreter = Interpreter(model_path=PATH_TO_CKPT)
interpreter.allocate_tensors()
# Get model details
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
floating_model = (input_details[0]['dtype'] == np.float32)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
'--model', help='File path of .tflite file.', required=True)
parser.add_argument(
'--labels', help='File path of labels file.', required=True)
parser.add_argument(
'--threshold',
help='Score threshold for detected objects.',
required=False,
type=float,
default=0.4)
args = parser.parse_args()
labels = load_labels(args.labels)
interpreter = Interpreter(args.model)
interpreter.allocate_tensors()
_, input_height, input_width, _ = interpreter.get_input_details()[0]['shape']
with picamera.PiCamera(
resolution=(CAMERA_WIDTH, CAMERA_HEIGHT), framerate=30) as camera:
camera.start_preview()
try:
stream = io.BytesIO()
annotator = Annotator(camera)
for _ in camera.capture_continuous(
stream, format='jpeg', use_video_port=True):
stream.seek(0)
image = Image.open(stream).convert('RGB').resize(
(input_width, input_height), Image.ANTIALIAS)
start_time = time.monotonic()
results = detect_objects(interpreter, image, args.threshold)
elapsed_ms = (time.monotonic() - start_time) * 1000
annotator.clear()
annotate_objects(annotator, results, labels)
try:
print(results[0]['class_id'])
if results[0]['class_id'] in [46.0, 16.0, 17.0]:
if results[0]['class_id'] == 46.0:
print("Cup!!!!")
blink.found_cup()
if results[0]['class_id'] == 16.0:
print("Cat !!!!")
blink.found_cat()
if results[0]['class_id'] == 17.0:
print("Dog !!!!")
blink.found_dog()
except:
print("")
annotator.text([5, 0], '%.1fms' % (elapsed_ms))
annotator.update()
stream.seek(0)
stream.truncate()
finally:
camera.stop_preview()
PATH_TO_LABELS = '../data/Sample_TFLite_model/labelmap.txt'
# Load the label map
with open(PATH_TO_LABELS, 'r') as f:
labels = [line.strip() for line in f.readlines()]
# Have to do a weird fix for label map if using the COCO "starter model" from
# https://www.tensorflow.org/lite/models/object_detection/overview
# First label is '???', which has to be removed.
if labels[0] == '???':
del (labels[0])
print('setup path name and label map ok')
#%%
# Load the Tensorflow Lite model.
interpreter = Interpreter(model_path=PATH_TO_CKPT)
interpreter.allocate_tensors()
# Get model details
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
floating_model = (input_details[0]['dtype'] == np.float32)
input_mean = 127.5
input_std = 127.5
print(f'{width},{height}')
# %%
import Proximity_Sensor
from tflite_runtime.interpreter import Interpreter
import numpy as np
# Create objects
adc = ADS1015.ADS1015()
proximity = Proximity_Sensor.VCNL4010()
Min_Force = 15500
Max_Force = 28000
Min_Proximity = 2100
Max_Proximity = 16000
# Instantiate TF Lite Model
interpreter = Interpreter(model_path = "my_tflite_model_4.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Create Empty Data Storage
Raw_Data = []
Predictions = []
while True:
# Scale 0-1 according to projected min and max values
if adc.read_adc(0) > Max_Force:
Force = 1
elif adc.read_adc(0) < Min_Force:
Force = 0
parser.add_argument("--camera_height",
type=int,
default=480,
help="height.")
parser.add_argument("--vidfps", type=int, default=30, help="Frame rate.")
parser.add_argument("--num_threads", type=int, default=4, help="Threads.")
args = parser.parse_args()
model = args.model
usbcamno = args.usbcamno
image_width = args.camera_width
image_height = args.camera_height
vidfps = args.vidfps
num_threads = args.num_threads
interpreter = Interpreter(model_path=model)
try:
interpreter.set_num_threads(num_threads)
except:
print(
"WARNING: The installed PythonAPI of Tensorflow/Tensorflow Lite runtime does not support Multi-Thread processing."
)
print("WARNING: It works in single thread mode.")
print(
"WARNING: If you want to use Multi-Thread to improve performance on aarch64/armv7l platforms, please refer to one of the below to implement a customized Tensorflow/Tensorflow Lite runtime."
)
print("https://github.com/PINTO0309/Tensorflow-bin.git")
print("https://github.com/PINTO0309/TensorflowLite-bin.git")
pass
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
def init_model(self):
print("[!] Loading {} ..".format(str(self.args["model"])))
self.interpreter = Interpreter(self.args["model"])
print("[*] Done")
self.interpreter.allocate_tensors()
_, height, width, _ = self.interpreter.get_input_details()[0]['shape']
def object_detection(MODEL_NAME, GRAPH_NAME, LABELMAP_NAME,
min_conf_threshold):
# Grab global references
global videostream, outputFrame, lock, imW, imH
# MODEL_NAME = args.modeldir
# GRAPH_NAME = args.graph
# LABELMAP_NAME = args.labels
# min_conf_threshold = args.threshold
# resW, resH = args.resolution.split('x')
# resW, resH = resolution.split('x')
# imW, imH = int(resW), int(resH)
# Get path to current working directory
CWD_PATH = os.getcwd()
# Path to .tflite file, which contains the model that is used for object detection
PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, GRAPH_NAME)
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, MODEL_NAME, LABELMAP_NAME)
# Load the label map
with open(PATH_TO_LABELS, 'r') as f:
labels = [line.strip() for line in f.readlines()]
# If using the COCO "starter model" from https://www.tensorflow.org/lite/models/object_detection/overview
# Have to remove '???' label
if labels[0] == '???':
del (labels[0])
# Load the Tensorflow Lite model and get details
interpreter = Interpreter(model_path=PATH_TO_CKPT)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
height = input_details[0]['shape'][1]
width = input_details[0]['shape'][2]
floating_model = (input_details[0]['dtype'] == np.float32)
input_mean = 127.5
input_std = 127.5
# Initialize frame rate calculation
frame_rate_calc = 1
freq = cv2.getTickFrequency()
# Loop through frames from the video stream
while True:
# Start timer (for calculating frame rate)
t1 = cv2.getTickCount()
# Grab frame from video stream
frame1 = videostream.read()
# Acquire frame and resize to expected shape [1xHxWx3]
# frame = frame1.copy()
frame = cv2.flip(frame1, -1)
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame_resized = cv2.resize(frame_rgb, (width, height))
input_data = np.expand_dims(frame_resized, axis=0)
# Normalize pixel values if using a floating model (i.e. if model is non-quantized)
if floating_model:
input_data = (np.float32(input_data) - input_mean) / input_std
# Perform the actual detection by running the model with the image as input
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
# Retrieve detection results
boxes = interpreter.get_tensor(output_details[0]['index'])[
0] # Bounding box coordinates of detected objects
classes = interpreter.get_tensor(
output_details[1]['index'])[0] # Class index of detected objects
scores = interpreter.get_tensor(
output_details[2]['index'])[0] # Confidence of detected objects
#num = interpreter.get_tensor(output_details[3]['index'])[0] # Total number of detected objects (inaccurate and not needed)
# Loop over all detections and draw detection box if confidence is above minimum threshold
for i in range(len(scores)):
if ((scores[i] > min_conf_threshold) and (scores[i] <= 1.0)):
# Get bounding box coordinates and draw box
# Interpreter can return coordinates that are outside of image dimensions, need to force them to be within image using max() and min()
ymin = int(max(1, (boxes[i][0] * imH)))
xmin = int(max(1, (boxes[i][1] * imW)))
ymax = int(min(imH, (boxes[i][2] * imH)))
xmax = int(min(imW, (boxes[i][3] * imW)))
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (10, 255, 0),
2)
# Draw label
object_name = labels[int(
classes[i]
)] # Look up object name from "labels" array using class index
label = '%s: %d%%' % (object_name, int(scores[i] * 100)
) # Example: 'person: 72%'
labelSize, baseLine = cv2.getTextSize(label,
cv2.FONT_HERSHEY_SIMPLEX,
0.7, 2) # Get font size
label_ymin = max(
ymin, labelSize[1] + 10
) # Make sure not to draw label too close to top of window
cv2.rectangle(
frame, (xmin, label_ymin - labelSize[1] - 10),
(xmin + labelSize[0], label_ymin + baseLine - 10),
(255, 255, 255),
cv2.FILLED) # Draw white box to put label text in
cv2.putText(frame, label, (xmin, label_ymin - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0),
2) # Draw label text
# Draw framerate in corner of frame
cv2.putText(frame, 'FPS: {0:.2f}'.format(frame_rate_calc), (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 1, cv2.LINE_AA)
# All the results have been drawn on the frame, so it's time to display it.
# cv2.imshow('Object detector', frame)
# Acquire the lock, set the output frame, and release the lock
with lock:
outputFrame = frame.copy()
# Calculate framerate
t2 = cv2.getTickCount()
time1 = (t2 - t1) / freq
frame_rate_calc = 1 / time1
def __init__(
self,
model_path: str,
options: ObjectDetectorOptions = ObjectDetectorOptions()
) -> None:
"""Initialize a TFLite object detection model.
Args:
model_path: Path to the TFLite model.
options: The config to initialize an object detector. (Optional)
Raises:
ValueError: If the TFLite model is invalid.
OSError: If the current OS isn't supported by EdgeTPU.
"""
# Load metadata from model.
displayer = metadata.MetadataDisplayer.with_model_file(model_path)
# Save model metadata for preprocessing later.
model_metadata = json.loads(displayer.get_metadata_json())
process_units = model_metadata['subgraph_metadata'][0][
'input_tensor_metadata'][0]['process_units']
mean = 127.5
std = 127.5
for option in process_units:
if option['options_type'] == 'NormalizationOptions':
mean = option['options']['mean'][0]
std = option['options']['std'][0]
self._mean = mean
self._std = std
# Load label list from metadata.
file_name = displayer.get_packed_associated_file_list()[0]
label_map_file = displayer.get_associated_file_buffer(
file_name).decode()
label_list = list(filter(len, label_map_file.splitlines()))
self._label_list = label_list
# Initialize TFLite model.
if options.enable_edgetpu:
if edgetpu_lib_name() is None:
raise OSError(
"The current OS isn't supported by Coral EdgeTPU.")
interpreter = Interpreter(
model_path=model_path,
experimental_delegates=[load_delegate(edgetpu_lib_name())],
num_threads=options.num_threads)
else:
interpreter = Interpreter(model_path=model_path,
num_threads=options.num_threads)
interpreter.allocate_tensors()
input_detail = interpreter.get_input_details()[0]
# From TensorFlow 2.6, the order of the outputs become undefined.
# Therefore we need to sort the tensor indices of TFLite outputs and to know
# exactly the meaning of each output tensor. For example, if
# output indices are [601, 599, 598, 600], tensor names and indices aligned
# are:
# - location: 598
# - category: 599
# - score: 600
# - detection_count: 601
# because of the op's ports of TFLITE_DETECTION_POST_PROCESS
# (https://github.com/tensorflow/tensorflow/blob/a4fe268ea084e7d323133ed7b986e0ae259a2bc7/tensorflow/lite/kernels/detection_postprocess.cc#L47-L50).
sorted_output_indices = sorted(
[output['index'] for output in interpreter.get_output_details()])
self._output_indices = {
self._OUTPUT_LOCATION_NAME: sorted_output_indices[0],
self._OUTPUT_CATEGORY_NAME: sorted_output_indices[1],
self._OUTPUT_SCORE_NAME: sorted_output_indices[2],
self._OUTPUT_NUMBER_NAME: sorted_output_indices[3],
}
self._input_size = input_detail['shape'][2], input_detail['shape'][1]
self._is_quantized_input = input_detail['dtype'] == np.uint8
self._interpreter = interpreter
self._options = options
def __init__(self,
weights='yolov5s.pt',
device=torch.device('cpu'),
dnn=False,
data=None,
fp16=False):
# Usage:
# PyTorch: weights = *.pt
# TorchScript: *.torchscript
# ONNX Runtime: *.onnx
# ONNX OpenCV DNN: *.onnx with --dnn
# OpenVINO: *.xml
# CoreML: *.mlmodel
# TensorRT: *.engine
# TensorFlow SavedModel: *_saved_model
# TensorFlow GraphDef: *.pb
# TensorFlow Lite: *.tflite
# TensorFlow Edge TPU: *_edgetpu.tflite
from models.experimental import attempt_download, attempt_load # scoped to avoid circular import
super().__init__()
w = str(weights[0] if isinstance(weights, list) else weights)
pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs = self.model_type(
w) # get backend
w = attempt_download(w) # download if not local
fp16 &= (pt or jit or onnx or engine) and device.type != 'cpu' # FP16
stride, names = 32, [f'class{i}'
for i in range(1000)] # assign defaults
if data: # assign class names (optional)
with open(data, errors='ignore') as f:
names = yaml.safe_load(f)['names']
if pt: # PyTorch
model = attempt_load(weights if isinstance(weights, list) else w,
device=device)
stride = max(int(model.stride.max()), 32) # model stride
names = model.module.names if hasattr(
model, 'module') else model.names # get class names
model.half() if fp16 else model.float()
self.model = model # explicitly assign for to(), cpu(), cuda(), half()
elif jit: # TorchScript
LOGGER.info(f'Loading {w} for TorchScript inference...')
extra_files = {'config.txt': ''} # model metadata
model = torch.jit.load(w, _extra_files=extra_files)
model.half() if fp16 else model.float()
if extra_files['config.txt']:
d = json.loads(extra_files['config.txt']) # extra_files dict
stride, names = int(d['stride']), d['names']
elif dnn: # ONNX OpenCV DNN
LOGGER.info(f'Loading {w} for ONNX OpenCV DNN inference...')
check_requirements(('opencv-python>=4.5.4', ))
net = cv2.dnn.readNetFromONNX(w)
elif onnx: # ONNX Runtime
LOGGER.info(f'Loading {w} for ONNX Runtime inference...')
cuda = torch.cuda.is_available()
check_requirements(
('onnx', 'onnxruntime-gpu' if cuda else 'onnxruntime'))
import onnxruntime
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'
] if cuda else ['CPUExecutionProvider']
session = onnxruntime.InferenceSession(w, providers=providers)
meta = session.get_modelmeta().custom_metadata_map # metadata
if 'stride' in meta:
stride, names = int(meta['stride']), eval(meta['names'])
elif xml: # OpenVINO
LOGGER.info(f'Loading {w} for OpenVINO inference...')
check_requirements(
('openvino', )
) # requires openvino-dev: https://pypi.org/project/openvino-dev/
from openvino.runtime import Core, Layout, get_batch
ie = Core()
if not Path(w).is_file(): # if not *.xml
w = next(Path(w).glob(
'*.xml')) # get *.xml file from *_openvino_model dir
network = ie.read_model(model=w,
weights=Path(w).with_suffix('.bin'))
if network.get_parameters()[0].get_layout().empty:
network.get_parameters()[0].set_layout(Layout("NCHW"))
batch_dim = get_batch(network)
if batch_dim.is_static:
batch_size = batch_dim.get_length()
executable_network = ie.compile_model(
network,
device_name="CPU") # device_name="MYRIAD" for Intel NCS2
output_layer = next(iter(executable_network.outputs))
meta = Path(w).with_suffix('.yaml')
if meta.exists():
stride, names = self._load_metadata(meta) # load metadata
elif engine: # TensorRT
LOGGER.info(f'Loading {w} for TensorRT inference...')
import tensorrt as trt # https://developer.nvidia.com/nvidia-tensorrt-download
check_version(trt.__version__, '7.0.0',
hard=True) # require tensorrt>=7.0.0
Binding = namedtuple('Binding',
('name', 'dtype', 'shape', 'data', 'ptr'))
logger = trt.Logger(trt.Logger.INFO)
with open(w, 'rb') as f, trt.Runtime(logger) as runtime:
model = runtime.deserialize_cuda_engine(f.read())
bindings = OrderedDict()
fp16 = False # default updated below
for index in range(model.num_bindings):
name = model.get_binding_name(index)
dtype = trt.nptype(model.get_binding_dtype(index))
shape = tuple(model.get_binding_shape(index))
data = torch.from_numpy(np.empty(
shape, dtype=np.dtype(dtype))).to(device)
bindings[name] = Binding(name, dtype, shape, data,
int(data.data_ptr()))
if model.binding_is_input(index) and dtype == np.float16:
fp16 = True
binding_addrs = OrderedDict(
(n, d.ptr) for n, d in bindings.items())
context = model.create_execution_context()
batch_size = bindings['images'].shape[0]
elif coreml: # CoreML
LOGGER.info(f'Loading {w} for CoreML inference...')
import coremltools as ct
model = ct.models.MLModel(w)
else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)
if saved_model: # SavedModel
LOGGER.info(
f'Loading {w} for TensorFlow SavedModel inference...')
import tensorflow as tf
keras = False # assume TF1 saved_model
model = tf.keras.models.load_model(
w) if keras else tf.saved_model.load(w)
elif pb: # GraphDef https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt
LOGGER.info(
f'Loading {w} for TensorFlow GraphDef inference...')
import tensorflow as tf
def wrap_frozen_graph(gd, inputs, outputs):
x = tf.compat.v1.wrap_function(
lambda: tf.compat.v1.import_graph_def(gd, name=""),
[]) # wrapped
ge = x.graph.as_graph_element
return x.prune(tf.nest.map_structure(ge, inputs),
tf.nest.map_structure(ge, outputs))
gd = tf.Graph().as_graph_def() # graph_def
with open(w, 'rb') as f:
gd.ParseFromString(f.read())
frozen_func = wrap_frozen_graph(gd,
inputs="x:0",
outputs="Identity:0")
elif tflite or edgetpu: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python
try: # https://coral.ai/docs/edgetpu/tflite-python/#update-existing-tf-lite-code-for-the-edge-tpu
from tflite_runtime.interpreter import Interpreter, load_delegate
except ImportError:
import tensorflow as tf
Interpreter, load_delegate = tf.lite.Interpreter, tf.lite.experimental.load_delegate,
if edgetpu: # Edge TPU https://coral.ai/software/#edgetpu-runtime
LOGGER.info(
f'Loading {w} for TensorFlow Lite Edge TPU inference...'
)
delegate = {
'Linux': 'libedgetpu.so.1',
'Darwin': 'libedgetpu.1.dylib',
'Windows': 'edgetpu.dll'
}[platform.system()]
interpreter = Interpreter(
model_path=w,
experimental_delegates=[load_delegate(delegate)])
else: # Lite
LOGGER.info(
f'Loading {w} for TensorFlow Lite inference...')
interpreter = Interpreter(
model_path=w) # load TFLite model
interpreter.allocate_tensors() # allocate
input_details = interpreter.get_input_details() # inputs
output_details = interpreter.get_output_details() # outputs
elif tfjs:
raise Exception(
'ERROR: YOLOv5 TF.js inference is not supported')
else:
raise Exception(f'ERROR: {w} is not a supported format')
self.__dict__.update(locals()) # assign all variables to self
