def main(_):
writer = ImageClassifierWriter.create_for_inference(
writer_utils.load_file(flags.FLAGS.model_file), [127.5], [127.5],
[flags.FLAGS.label_file])
writer_utils.save_file(writer.populate(), flags.FLAGS.output_file)
print(writer.get_metadata_json())
async def create_upload_file(type: str,
format: str,
background_tasks: BackgroundTasks,
model: UploadFile = File(...),
dataset: UploadFile = File(default=None)):
print("uploading", flush=True)
global labels, datapath, instanceReady
instanceReady = False
if (type != 'audio' or format != 'tflite'):
return {'format not supported'}
model_dir = tempfile.mkdtemp()
print("### Created " + model_dir)
data_dir = tempfile.mkdtemp()
unzipFile(model, model_dir)
background_tasks.add_task(cleanup_files, model_dir, data_dir)
with open(model_dir + '/metadata.json') as json_file:
data = json.load(json_file)
labels = data['wordLabels']
print("Generating lables.txt")
labels_path = model_dir + '/labels.txt'
with open(labels_path, 'w') as f:
for idx, label in enumerate(labels):
f.write("{} {}\n".format(idx, label))
print('Labels:' + ', '.join(labels), flush=True)
# specify path to original model and load
tfjs_model_json_path = model_dir + '/model.json'
model = tfjs.converters.load_keras_model(tfjs_model_json_path)
# construct the new model by combining preproc and main classifier
combined_model = tf.keras.Sequential(name='combined_model')
combined_model.add(preproc_model)
combined_model.add(model)
combined_model.build([None, input_length])
# save the model as a tflite file
tflite_output_path = model_dir + '/soundclassifier.tflite'
converter = tf.lite.TFLiteConverter.from_keras_model(combined_model)
with open(tflite_output_path, 'wb') as f:
f.write(converter.convert())
# add metadata to model
save_to_path = model_dir + '/soundclassifier_with_metadata.tflite'
channels = 1
tm_sample_rate = 44100
writer = AudioClassifierWriter.create_for_inference(
writer_utils.load_file(tflite_output_path), tm_sample_rate, channels,
[labels_path])
writer_utils.save_file(writer.populate(), save_to_path)
return returnFile('soundclassifier_with_metadata.tflite', model_dir,
data_dir, False)
def _export_tflite(
self,
tflite_filepath: str,
quantization_config: configs.QuantizationConfigType = 'default',
with_metadata: bool = True,
export_metadata_json_file: bool = False) -> None:
"""Converts the retrained model to tflite format and saves it.
Args:
tflite_filepath: File path to save tflite model.
quantization_config: Configuration for post-training quantization. If
'default', sets the `quantization_config` by default according to
`self.model_spec`. If None, exports the float tflite model without
quantization.
with_metadata: Whether the output tflite model contains metadata.
export_metadata_json_file: Whether to export metadata in json file. If
True, export the metadata in the same directory as tflite model.Used
only if `with_metadata` is True.
"""
if quantization_config == 'default':
quantization_config = self.model_spec.get_default_quantization_config(
self.representative_data)
self.model_spec.export_tflite(self.model, tflite_filepath,
quantization_config)
if with_metadata:
with tempfile.TemporaryDirectory() as temp_dir:
tf.compat.v1.logging.info(
'Label file is inside the TFLite model with metadata.')
label_filepath = os.path.join(temp_dir, 'labelmap.txt')
self._export_labels(label_filepath)
writer = metadata_writer.MetadataWriter.create_for_inference(
writer_utils.load_file(tflite_filepath),
[self.model_spec.config.mean_rgb],
[self.model_spec.config.stddev_rgb], [label_filepath])
writer_utils.save_file(writer.populate(), tflite_filepath)
if export_metadata_json_file:
metadata_json = writer.get_populated_metadata_json()
export_json_path = os.path.splitext(
tflite_filepath)[0] + '.json'
with open(export_json_path, 'w') as f:
f.write(metadata_json)
def __init__(self, tflite_filepath, **kwargs):
self._model = writer_utils.load_file(tflite_filepath)
self._general_md = md_info.GeneralMd(**kwargs)
self._inputs = []
self._outputs = []
from tflite_support.metadata_writers import object_detector
from tflite_support.metadata_writers import writer_utils
writer = object_detector.MetadataWriter.create_for_inference(
writer_utils.load_file("od_model.tflite"),
input_norm_mean=[0],
input_norm_std=[255],
label_file_paths=["class-names.txt"])
writer_utils.save_file(writer.populate(), "detect.tflite")
from tflite_support.metadata_writers import image_classifier
from tflite_support.metadata_writers import writer_utils
ImageClassifierWriter = image_classifier.MetadataWriter
_MODEL_PATH = "./model.tflite"
# Task Library expects label files that are in the same format as the one below.
_LABEL_FILE = "./label.txt"
_SAVE_TO_PATH = "./model_metadata_added.tflite"
# Normalization parameters is required when reprocessing the image. It is
# optional if the image pixel values are in range of [0, 255] and the input
# tensor is quantized to uint8. See the introduction for normalization and
# quantization parameters below for more details.
# https://www.tensorflow.org/lite/convert/metadata#normalization_and_quantization_parameters)
_INPUT_NORM_MEAN = 0.0
_INPUT_NORM_STD = 1.0
# Create the metadata writer.
writer = ImageClassifierWriter.create_for_inference(
writer_utils.load_file(_MODEL_PATH), [_INPUT_NORM_MEAN], [_INPUT_NORM_STD],
[_LABEL_FILE])
# Verify the metadata generated by metadata writer.
print(writer.get_metadata_json())
# Populate the metadata into the model.
writer_utils.save_file(writer.populate(), _SAVE_TO_PATH)
print("Activate Multi GPU")
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
strategy = tf.distribute.MirroredStrategy(cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())
except RuntimeError as e:
print(e)
else:
try:
print("Activate Sigle GPU")
tf.config.experimental.set_memory_growth(gpus[0], True)
strategy = tf.distribute.experimental.CentralStorageStrategy()
except RuntimeError as e:
print(e)
label_file_paths='/data/datasets/traffic_sign/labels.txt'
path = "/home/barcelona/tensorflow/models/research/object_detection/custom/models/traffic_sign/21_06_18"
saved_model_dir = f"{path}/saved_model"
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir, signature_keys=['serving_default'])
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.experimental_new_converter = True
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS]
tflite_model = converter.convert()
with tf.io.gfile.GFile(f'{path}/custom.tflite', 'wb') as f:
f.write(tflite_model)
writer = object_detector.MetadataWriter.create_for_inference(writer_utils.load_file(f'{path}/custom.tflite'), input_norm_mean=[0], input_norm_std=[255], label_file_paths=[label_file_paths])
writer_utils.save_file(writer.populate(), f'{path}/custom.tflite')