Inferenza TF Lite su CPU e TPU

Per questa prova e' stato selezionato il modello di esempio da questo link riguardante il dataset 900+ birds iNaturalist 2017

 

Per prima cosa c'e' da sottolineare che i modelli per CPU non sono compatibili con le TPU e viceversa. Inoltre l'immagine con cui si vuole fare inferenza deve essere dello stesso tipo (float32,uint8) e delle stesse dimensioni del modello.

CPU

python3 esempio.py --model_file mobilenet_v2_1.0_224_inat_bird_quant.tflite --label_file inat_bird_labels.txt --image ./images/th-1232548430.jpg
 

Risultato

0.831373: Cyanistes caeruleus (Eurasian Blue Tit)
0.027451: Parus major (Great Tit)
0.003922: Coereba flaveola (Bananaquit)
0.003922: Vireo philadelphicus (Philadelphia Vireo)
0.003922: Myiozetetes similis (Social Flycatcher)

 

import argparse

import time

import numpy as np

from PIL import Image

import tensorflow as tf

def load_labels(filename):

with open(filename, 'r') as f:

return [line.strip() for line in f.readlines()]

if __name__ == '__main__':

parser = argparse.ArgumentParser()

parser.add_argument(

'-i',

'--image',

default='/tmp/grace_hopper.bmp',

help='image to be classified')

parser.add_argument(

'-m',

'--model_file',

default='/tmp/mobilenet_v1_1.0_224_quant.tflite',

help='.tflite model to be executed')

parser.add_argument(

'-l',

'--label_file',

default='/tmp/labels.txt',

help='name of file containing labels')

parser.add_argument(

'--input_mean',

default=127.5, type=float,

help='input_mean')

parser.add_argument(

'--input_std',

default=127.5, type=float,

help='input standard deviation')

parser.add_argument(

'--num_threads', default=None, type=int, help='number of threads')

parser.add_argument(

'-e', '--ext_delegate', help='external_delegate_library path')

parser.add_argument(

'-o',

'--ext_delegate_options',

help='external delegate options, \

format: "option1: value1; option2: value2"')

args = parser.parse_args()

ext_delegate = None

ext_delegate_options = {}

# parse extenal delegate options

if args.ext_delegate_options is not None:

options = args.ext_delegate_options.split(';')

for o in options:

kv = o.split(':')

if (len(kv) == 2):

ext_delegate_options[kv[0].strip()] = kv[1].strip()

else:

raise RuntimeError('Error parsing delegate option: ' + o)

# load external delegate

if args.ext_delegate is not None:

print('Loading external delegate from {} with args: {}'.format(

args.ext_delegate, ext_delegate_options))

ext_delegate = [

tflite.load_delegate(args.ext_delegate, ext_delegate_options)

]

interpreter = tf.lite.Interpreter(

model_path=args.model_file,

experimental_delegates=ext_delegate,

num_threads=args.num_threads)

interpreter.allocate_tensors()

input_details = interpreter.get_input_details()

output_details = interpreter.get_output_details()

# check the type of the input tensor

floating_model = input_details[0]['dtype'] == np.float32

# NxHxWxC, H:1, W:2

height = input_details[0]['shape'][1]

width = input_details[0]['shape'][2]

img = Image.open(args.image).resize((width, height))

# add N dim

input_data = np.expand_dims(img, axis=0)

if floating_model:

input_data = (np.float32(input_data) - args.input_mean) / args.input_std

interpreter.set_tensor(input_details[0]['index'], input_data)

start_time = time.time()

interpreter.invoke()

stop_time = time.time()

output_data = interpreter.get_tensor(output_details[0]['index'])

results = np.squeeze(output_data)

top_k = results.argsort()[-5:][::-1]

labels = load_labels(args.label_file)

for i in top_k:

if floating_model:

print('{:08.6f}: {}'.format(float(results[i]), labels[i]))

else:

print('{:08.6f}: {}'.format(float(results[i] / 255.0), labels[i]))

print('time: {:.3f}ms'.format((stop_time - start_time) * 1000))

 

GPU

python3 inferenza.py (attenzione python e basta genera errore su modulo pathlib)

 

Risultato

Cyanistes caeruleus (Eurasian Blue Tit): 0.81250
 

======================================

import os
import pathlib
from pycoral.utils import edgetpu
from pycoral.utils import dataset
from pycoral.adapters import common
from pycoral.adapters import classify
from PIL import Image

# Specify the TensorFlow model, labels, and image
script_dir = pathlib.Path(__file__).parent.absolute()
model_file = os.path.join(script_dir, 'mobilenet_v2_1.0_224_quant_edgetpu.tflite')
label_file = os.path.join(script_dir, 'imagenet_labels.txt')
image_file = os.path.join(script_dir, 'parrot.jpg')

# Initialize the TF interpreter
interpreter = edgetpu.make_interpreter(model_file)
interpreter.allocate_tensors()

# Resize the image
size = common.input_size(interpreter)
image = Image.open(image_file).convert('RGB').resize(size, Image.ANTIALIAS)

# Run an inference
common.set_input(interpreter, image)
interpreter.invoke()
classes = classify.get_classes(interpreter, top_k=1)

# Print the result
labels = dataset.read_label_file(label_file)
for c in classes:
  print('%s: %.5f' % (labels.get(c.id, c.id), c.score)) 

======================================