Object Detection Model Based on Open Image Dataset For Coral Tpu? about pinto_model_zoo HOT 13 CLOSED

### tensorflow-gpu==1.15.2

import tensorflow as tf
import tensorflow_datasets as tfds
import numpy as np

def representative_dataset_gen():
  for data in raw_test_data.take(100):
    image = data['image'].numpy()
    image = tf.image.resize(image, (300, 300))
    image = image[np.newaxis,:,:,:]
    image = image - 127.5
    image = image * 0.007843
    yield [image]

tf.compat.v1.enable_eager_execution()

raw_test_data, info = tfds.load(name="voc/2007", with_info=True, split="validation", data_dir="~/TFDS", download=False)

# Integer Quantization - Input/Output=float32
graph_def_file="export/tflite_graph.pb"
input_arrays=["normalized_input_image_tensor"]
output_arrays=['TFLite_Detection_PostProcess','TFLite_Detection_PostProcess:1', 
               'TFLite_Detection_PostProcess:2','TFLite_Detection_PostProcess:3']
input_tensor={"normalized_input_image_tensor":[1,300,300,3]}

converter = tf.lite.TFLiteConverter.from_frozen_graph(graph_def_file, input_arrays, output_arrays,input_tensor)
converter.allow_custom_ops = True
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset_gen
tflite_quant_model = converter.convert()
with open('ssd_mobilenet_v2_oid_v4_300x300_full_integer_quant.tflite', 'wb') as w:
    w.write(tflite_quant_model)
print("Full Integer Quantization complete! - ssd_mobilenet_v2_oid_v4_300x300_full_integer_quant.tflite")

def representative_dataset_gen():
  for data in raw_test_data.take(100):
    image = data['image'].numpy()
    image = tf.image.resize(image, (300, 300))
    image = image[np.newaxis,:,:,:]
    #image = image - 127.5
    #image = image * 0.007843
    yield [image]

def representative_dataset_gen():
  for data in raw_test_data.take(100):
    image = data['image'].numpy()
    image = tf.image.resize(image, (300, 300))
    image = image[np.newaxis,:,:,:]
    image = image - 127.5
    #image = image * 0.007843
    yield [image]

import detect_common as common
from PIL import Image
import tflite_runtime.interpreter as tflite
from glob import glob
import pandas as pd

model = 'ssd_mobilenet_v2_oid_v4_300x300_full_integer_quant_edgetpu.tflite'
interpreter = common.make_interpreter(model)
interpreter.allocate_tensors()
label_url = 'https://storage.googleapis.com/openimages/2018_04/class-descriptions-boxable.csv'
df = pd.read_csv(label_url)
labels = [row[1] for i, row in df.iterrows()]
img = Image.open('grace_hopper.bmp')
common.set_input(interpreter, img)
interpreter.invoke()
classes = common.output_tensor(interpreter, 1)
scores = common.output_tensor(interpreter, 2)
for i in range(len(classes)):
    print(classes[i], scores[i])

"""Common utilities."""
import numpy as np
from PIL import Image
import tflite_runtime.interpreter as tflite

EDGETPU_SHARED_LIB = 'libedgetpu.so.1'

def make_interpreter(model_file):
    model_file, *device = model_file.split('@')
    return tflite.Interpreter(
      model_path=model_file,
      experimental_delegates=[
          tflite.load_delegate(EDGETPU_SHARED_LIB,
                               {'device': device[0]} if device else {})
      ])

def set_input(interpreter, image, resample=Image.NEAREST):
    """Copies data to input tensor."""
    print(input_image_size(interpreter)[0:2])
    image = image.resize((input_image_size(interpreter)[0:2]), resample)
    image = np.asarray(image)
    image = image - 127.5
    image = image * 0.007843
    input_tensor(interpreter)[:, :] = image

def input_image_size(interpreter):
    """Returns input image size as (width, height, channels) tuple."""
    _, height, width, channels = interpreter.get_input_details()[0]['shape']
    return width, height, channels

def input_tensor(interpreter):
    """Returns input tensor view as numpy array of shape (height, width, 3)."""
    tensor_index = interpreter.get_input_details()[0]['index']
    return interpreter.tensor(tensor_index)()[0]

def output_tensor(interpreter, i):
    """Returns dequantized output tensor if quantized before."""
    output_details = interpreter.get_output_details()[i]
    output_data = np.squeeze(interpreter.tensor(output_details['index'])())
    if 'quantization' not in output_details:
        return output_data
    scale, zero_point = output_details['quantization']
    if scale == 0:
        return output_data - zero_point
    return scale * (output_data - zero_point)