a Sic@sdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl Z ddl m Z ddl m ZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lm Z!ddlm"Z#ddlm$Z$ddlm%Z&ddlm'Z(ddlm)Z*ddlm+Z+ddlm,Z,ddl-m.Z.ddl-m/Z/ddl-m0Z0ddl1m2Z3ddl4m5Z5ddl4m6Z6ddl4m7Z7ddl8m9Z9ddl:m;Z;ddl:mZ>dd l?m@ZAdd!lBmCZCdd"lBmDZEdd#lBmFZGdd$lBmHZIdd%lBmJZKdd&lBmLZMdd'lBmNZOdd(lBmPZQdd)lBmRZSdd*lBmTZUdd+lBmVZWdd,lBmXZYdd-lBmZZ[dd.lBm\Z]dd/lBm^Z_dd0lBm`Zadd1lBmbZcdd2ldmeZedd3lfmgZgdd4lfmhZhdd5limjZkdd6llmmZndd7lompZpdd8lomqZrdd9lomsZtdd:lumvZwdd;lumxZyddl}m~Zdd?lmZdd@lmZddAlmZddBlmZddClmZddDlmZddElmZddFlmZddGlmZddHlmZddIlmZedJGdKdLdLejZedMGdNdOdOeZedPGdQdRdReZGdSdTdTeZGdUdVdVeZdWdXZGdYdZdZeZGd[d\d\eZGd]d^d^eZGd_d`d`eZGdadbdbeZedcgddGdedfdfeZGdgdhdheZGdidjdjeZGdkdldleZGdmdndneZedcgddGdodpdpeZedqgddGdrdsdseZdS)tz-TensorFlow Lite tooling helper functionality.N)logging)PY2) text_format) DecodeError) graph_pb2)audio_microfrontend_op)'conversion_metadata_schema_py_generated)lite_constants)convert_graphdef)convert_graphdef_with_arrays)convert_jax_hlo)convert_saved_model)ConverterError)deduplicate_readonly_buffers) mlir_quantize) mlir_sparsify)OpsSet) toco_convert) Component) convert_phase) SubComponent)freeze_saved_model) Interpreter) load_delegate)OpResolverType)metrics)convert_op_hints_to_stubs)is_ophint_converted)OpHint) calibrator)_xla_computation)build_debug_info_func)convert_debug_info_func) freeze_graph)get_debug_info)get_grappler_config)get_sparsity_modes)get_tensor_name)get_tensors_from_tensor_names)get_tf_type_name)is_frozen_graph)model_input_signature)modify_model_io_type)populate_conversion_metadata)run_graph_optimizations)set_tensor_shapes)trace_model_call)flatbuffer_utils)QuantizationDebugger)QuantizationDebugOptions) saved_model)session)context) def_function)function)convert_to_constants)dtypes)ops)versions) NotFoundError)import_graph_def)gfile) loader_impl) save_options)signature_constants) tag_constants)load)!parse_saved_model_with_debug_info) deprecation) keras_deps) tf_exportz lite.Optimizec@s(eZdZdZdZdZdZdZddZdS) OptimizeaEnum defining the optimizations to apply when generating a tflite model. DEFAULT Default optimization strategy that quantizes model weights. Enhanced optimizations are gained by providing a representative dataset that quantizes biases and activations as well. Converter will do its best to reduce size and latency, while minimizing the loss in accuracy. OPTIMIZE_FOR_SIZE Deprecated. Does the same as DEFAULT. OPTIMIZE_FOR_LATENCY Deprecated. Does the same as DEFAULT. EXPERIMENTAL_SPARSITY Experimental flag, subject to change. Enable optimization by taking advantage of the sparse model weights trained with pruning. The converter will inspect the sparsity pattern of the model weights and do its best to improve size and latency. The flag can be used alone to optimize float32 models with sparse weights. It can also be used together with the DEFAULT optimization mode to optimize quantized models with sparse weights. DEFAULTOPTIMIZE_FOR_SIZEOPTIMIZE_FOR_LATENCYEXPERIMENTAL_SPARSITYcCs t|jSN)strvalueselfrSW/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/lite/python/lite.py__str__szOptimize.__str__N) __name__ __module__ __qualname____doc__rJrKrLrMrUrSrSrSrTrIds ! rIzlite.RepresentativeDatasetc@seZdZdZddZdS)RepresentativeDatasetaRepresentative dataset used to optimize the model. This is a generator function that provides a small dataset to calibrate or estimate the range, i.e, (min, max) of all floating-point arrays in the model (such as model input, activation outputs of intermediate layers, and model output) for quantization. Usually, this is a small subset of a few hundred samples randomly chosen, in no particular order, from the training or evaluation dataset. cCs ||_dS)ahCreates a representative dataset. Args: input_gen: A generator function that generates input samples for the model and has the same order, type and shape as the inputs to the model. Usually, this is a small subset of a few hundred samples randomly chosen, in no particular order, from the training or evaluation dataset. N) input_gen)rRr[rSrSrT__init__s zRepresentativeDataset.__init__NrVrWrXrYr\rSrSrSrTrZs rZzlite.TargetSpecc@seZdZdZdddZdS) TargetSpecaSpecification of target device used to optimize the model. Attributes: supported_ops: Experimental flag, subject to change. Set of `tf.lite.OpsSet` options, where each option represents a set of operators supported by the target device. (default {tf.lite.OpsSet.TFLITE_BUILTINS})) supported_types: Set of `tf.dtypes.DType` data types supported on the target device. If initialized, optimization might be driven by the smallest type in this set. (default set()) experimental_select_user_tf_ops: Experimental flag, subject to change. Set of user's TensorFlow operators' names that are required in the TensorFlow Lite runtime. These ops will be exported as select TensorFlow ops in the model (in conjunction with the tf.lite.OpsSet.SELECT_TF_OPS flag). This is an advanced feature that should only be used if the client is using TF ops that may not be linked in by default with the TF ops that are provided when using the SELECT_TF_OPS path. The client is responsible for linking these ops into the target runtime. experimental_supported_backends: Experimental flag, subject to change. Set containing names of supported backends. Currently only "GPU" is supported, more options will be available later. NcCsT|durtjh}||_|dur$t}||_|dur8t}||_||_g|_d|_dSrN) rTFLITE_BUILTINS supported_opssetsupported_typesexperimental_select_user_tf_opsexperimental_supported_backends#_experimental_custom_op_registerers)_experimental_supported_accumulation_type)rRr`rbrcrdrSrSrTr\szTargetSpec.__init__)NNNNr]rSrSrSrTr^s r^c@seZdZdZd6ddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ ddZddZddZddZd d!Zd"d#Zd7d$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5ZdS)8QuantizationModezDQuantizationMode determines the quantization type from user options.FNc Csl||_tjtjfD]} | |jvrtd| q||_||_||_| ||_ ||_ ||_ ||_ |dS)NzZOptimization option %s is deprecated, please use optimizations=[Optimize.DEFAULT] instead.)_optimizationsrIrKrLrwarning _target_spec_representative_dataset _graph_def_validate_int8_required_disable_per_channel#_enable_new_dynamic_range_quantizer_experimental_low_bit_qat$_full_integer_quantization_bias_type-_validate_full_integer_quantization_bias_type) rR optimizations target_specrepresentative_dataset graph_defdisable_per_channel(experimental_new_dynamic_range_quantizerZexperimental_low_bit_qatZ#full_integer_quantization_bias_typeZdeprecated_optimizationrSrSrTr\s$  zQuantizationMode.__init__cCs.|o,|jduo,| o,| o,|SrN)is_any_optimization_enabledrk_is_int16x8_target_requiredis_allow_float_is_int8_target_requiredrQrSrSrT'is_post_training_int8_only_quantization sz8QuantizationMode.is_post_training_int8_only_quantizationcCs2|o0|jduo0| o0|o0|tjkSrN)ryrkrzr{_smallest_supported_type_dtypesint8rQrSrSrT6is_post_training_int8_quantization_with_float_fallbacks zGQuantizationMode.is_post_training_int8_quantization_with_float_fallbackcCs|p|SrN)r}rrQrSrSrT"is_post_training_int8_quantizationsz3QuantizationMode.is_post_training_int8_quantizationcCs$|o"|jduo"|o"| SrNryrkrzr{rQrSrSrT*is_post_training_int16x8_only_quantizationsz;QuantizationMode.is_post_training_int16x8_only_quantizationcCs"|o |jduo |o |SrNrrQrSrSrT9is_post_training_int16x8_quantization_with_float_fallback%szJQuantizationMode.is_post_training_int16x8_quantization_with_float_fallbackcCs|p|SrN)rrrQrSrSrT%is_post_training_int16x8_quantization+sz6QuantizationMode.is_post_training_int16x8_quantizationcCs|p|SrN)rrrQrSrSrT%is_post_training_integer_quantization/sz6QuantizationMode.is_post_training_integer_quantizationcCs|o|o|jSrN)ry#is_quantization_aware_trained_modelrprQrSrSrT"is_low_bit_quantize_aware_training3s z3QuantizationMode.is_low_bit_quantize_aware_trainingcCs|o|o| SrN)ryrrrQrSrSrTis_quantization_aware_training8s z/QuantizationMode.is_quantization_aware_trainingcCs|p|p|SrN)rrrrQrSrSrTis_integer_quantization=s z(QuantizationMode.is_integer_quantizationcCs*|o(|jduo(| o(|tjkSrN)ryrkrr~rrrQrSrSrT+is_post_training_dynamic_range_quantizationBs z|jr |jS|tjkr tjS|tjkr4tjStjSdSrN)rqrrrint64rint32rrQrSrSrT bias_type]szQuantizationMode.bias_typecCs|r4|}|dur|n|tjdd||dS|rVtjtjdd|j|jdS|rtjtjdd|j j | |jdS|dur|ntj|dd| dSdS)zFlags to the converter.NF)inference_typeinference_input_typepost_training_quantizequantize_to_float16disable_infer_tensor_rangeuse_fake_quant_num_bitsT)rrrr disable_per_channel_quantization#enable_mlir_dynamic_range_quantizer)rrrraccumulation_typeallow_bfloat16r)rrrrr) rrrrrrrnrorrjrfr)rRZ inference_tyZinference_input_tyZis_low_bit_qatrSrSrTconverter_flagshsB   z QuantizationMode.converter_flagscCs|s dSt|jjtjhkrNt|jjtksNt|jjtjhksNt dt|jjtjhkrntjh|j_|j s| st d|j rt |j t st |j |_ dS)zAInt8 mode requires certain parameters to exist and be compatible.NzAs full integer quantization has been enabled by setting `target_spec.supported_ops`={tf.lite.OpsSet.TFLITE_BUILTINS_INT8}, thus `target_spec.supported_types` should be left uninitizalized or set to {tf.int8}.zLFor full integer quantization, a `representative_dataset` must be specified.)r|rarjr`rTFLITE_BUILTINS_INT8rbrr ValueErrorrkr isinstancerZrQrSrSrTrms*  z(QuantizationMode._validate_int8_requiredcCs~|j}|sdS|tjkr$td|tjkrJ|tjkrJtd||tjkrz|tjkrz|tjkrztd|dS)z3Validates bias type for full interger quantization.NzV`full_integer_quantization_bias_type` is only supported for full integer quantization.zRExpected bias type to be `dtypes.int32` for Int8Quant. Current setting bias type: zeExpected bias type to be `dtypes.int32` or `dtypes.int64` for Int16Quant. Current setting bias type: ) rqrrrrrrrr)rRrrSrSrTrrs2z>QuantizationMode._validate_full_integer_quantization_bias_typecCs*tjt|jjvp(t|jjttjgkSrN)rrrarjr`rbrrrQrSrSrTr|s z)QuantizationMode._is_int8_target_requiredcCstjt|jjvSrN)r;EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8rarjr`rQrSrSrTrzs z,QuantizationMode._is_int16x8_target_requiredcCs$tjt|jjvp"tjt|jjvSrN)rr_rarjr` SELECT_TF_OPSrQrSrSrTr{szQuantizationMode.is_allow_floatcCs tt|jtjtjtjgSrN)boolrarh intersectionrIrLrKrJrQrSrSrTrys  z,QuantizationMode.is_any_optimization_enabledcCs&|jjrt|jjdddStjSdS)NcSs|jSrN)r)xrSrSrTz;QuantizationMode._smallest_supported_type..)key)rjrbminrrrQrSrSrTr~sz)QuantizationMode._smallest_supported_typecCsbthd}|jr^|jjD]}|j|vrdSq|jjjD]"}|jD]}|j|vrDdSqDq:dS)z@Checks if the graph contains any training-time quantization ops.>!FakeQuantWithMinMaxVarsPerChannelFakeQuantWithMinMaxArgsQuantizeAndDequantizeV3QuantizeAndDequantizeV2FakeQuantWithMinMaxVarsTF) frozensetrlnodeoplibraryr8node_def)rRZtraining_quant_opsrr8rSrSrTrs      z4QuantizationMode.is_quantization_aware_trained_model)FFFN)NN)rVrWrXrYr\r}rrrrrrrrrrrrrrrrmrrr|rzr{ryr~rrSrSrSrTrgs< "  5rgc@seZdZdZejjZddZd%ddZ ddZ d d Z d d Z d dZ d&ddZddZddZddZeddZddZd'ddZddZeejd(d!d"Zd#d$ZdS))TFLiteConverterBasezGConverter subclass to share functionality between V1 and V2 converters.cCst|_d|_t|_d|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_g|_t|_i|_d|_d|_d|_d|_d|_d|_d|_t|_t|j_ t!|j_"t#j$|jj _%|&|jj _'d|_(d|_)d|_*d|_+d|_,dS)NFTr)-rarsrur^rtallow_custom_opsexperimental_new_converterexperimental_new_quantizer&experimental_enable_resource_variables_experimental_calibrate_onlyZ_experimental_sparsify_model!_experimental_disable_per_channel _debug_infosaved_model_dir_saved_model_tags_saved_model_version_saved_model_exported_namesrTFLiteConverterMetrics_tflite_metrics_collected_converter_params(_experimental_disable_batchmatmul_unfold#_experimental_lower_tensor_list_ops8_experimental_default_to_single_batch_in_tensor_list_ops)_experimental_unfold_large_splat_constant"_experimental_tf_quantization_mode1_experimental_full_integer_quantization_bias_typeexclude_conversion_metadataconversion_metdata_fbConversionMetadataT _metadata EnvironmentT environmentConversionOptionsToptionsr< __version__tensorflowVersion_get_original_model_type modelType)_experimental_enable_dynamic_update_slice _experimental_preserve_assert_op)_experimental_guarantee_all_funcs_one_userxrprQrSrSrTr\sD     zTFLiteConverterBase.__init__NcCsF|sg}|js|dttjgt|jjk}|r>|dt|S)zCreates a tf.compat.v1.ConfigProto for configuring Grappler. Args: optimizers: List of strings that represents the list of optimizers. Returns: tf.ConfigProto. constfoldlayout)rappendrarrrtr`_get_grappler_config)rR optimizersZis_only_flex_enabledrSrSrT_grappler_config5s   z$TFLiteConverterBase._grappler_configc Csdd|jjD}dd|jjD}t|jtsQs z1TFLiteConverterBase._quantize..cSsg|]}t|ts|qSrSrrrSrSrTrUs )input_data_typeoutput_data_type)rwN)rtrerrurZ _calibratorZadd_intermediate_tensorsZ Calibratorrr calibrater[rr_mlir_quantizerZcalibrate_and_quantize) rRresult input_type output_typerrZ allow_floatZcustom_op_registerers_by_nameZcustom_op_registerers_by_funcZcalibrate_quantizeZ calibratedrSrSrT _quantizeMsN   zTFLiteConverterBase._quantizecCs|jSrN)rrQrSrSrT_is_unknown_shapes_allowed|sz.TFLiteConverterBase._is_unknown_shapes_allowedcCsttj|j|j|jj|j|jj|jj|j |j |j |j |j |j|j|j|jd}|jrp||j|j|j|jd|S)zHReturns the base converter args. Returns: {key str: val} ) input_formatr debug_info target_opsenable_mlir_converterselect_user_tf_opssupported_backendsunfold_batchmatmullower_tensor_list_opsunfold_large_splat_constant*default_to_single_batch_in_tensor_list_opstf_quantization_moderenable_dynamic_update_slicepreserve_assert_opguarantee_all_funcs_one_use)rsaved_model_versionsaved_model_tagssaved_model_exported_names) constantsTENSORFLOW_GRAPHDEFrrrtr`rrcrdrrrrrrrrrrupdaterrr)rRargsrSrSrT_get_base_converter_argss2#z,TFLiteConverterBase._get_base_converter_argscCs@|jd}|jjjD]&}|jdds4|jddrdSqdS)Nr _implementsapi_implementsTF) meta_graphsrvrr8attrget)rRsaved_model_proto meta_graphr8rSrSrT'_contains_function_with_implements_attrs z;TFLiteConverterBase._contains_function_with_implements_attrFcCs|jsd|_dS|jrzt|j\}}WntyBd|_YdS0|s\||s\d|_dS|jshg|_|j|_|jdkrd|_t ddS|jdvrt d |jdS)zParses SavedModel arguments from the given Keras/RNN SavedModel. Args: always_enable_saved_model_import: Bool. When the value is true, it enables MLIR saved model import path regardless of checking the conditions. Nrz"SavedModel schema version is zero.)rz,SavedModel file format({0}) is not supported) rr"_parse_saved_model_with_debug_infoOSErrorrrsaved_model_schema_versionrrrirformat)rR always_enable_saved_model_importr_rSrSrT_parse_saved_model_argss4     z+TFLiteConverterBase._parse_saved_model_argscCs tj|jvSrN)rIrMrsrQrSrSrT_sparsify_modelsz#TFLiteConverterBase._sparsify_modelcCs|jdSrN)r"increase_counter_converter_attemptrQrSrSrT#_increase_conversion_attempt_metricsz7TFLiteConverterBase._increase_conversion_attempt_metriccCs|jdSrN)r"increase_counter_converter_successrQrSrSrT#_increase_conversion_success_metricsz7TFLiteConverterBase._increase_conversion_success_metriccCs|tjjkrtd||_dS)zStores the original model type.z,The original model type should be specified.N)r ModelTypeNONEr_original_model_type)cls model_typerSrSrT_set_original_model_types z,TFLiteConverterBase._set_original_model_typecCstj}tjjt_|S)zAOne-time getter to return original model type and set it to NONE.)rr rrr)rRr"rSrSrTrs z,TFLiteConverterBase._get_original_model_typec s|j}||t|j|j|j||j|j|j |j }||j j j |j j j|j j j||||||||d |||||jjr|d|jjiddfdd}|D]\}}|j|||q|j|j|j j_ t!j"|jj#v|j j_$t%t!j"gt%|jj#k|j j_&g|j j_'|r`|j jj'(t)j*j+|r~|j jj'(t)j*j,|-r|j jj'(t)j*j.|/r|j jj'(t)j*j0|r|j jj'(t)j*j1dS)z!Set conversion parameter metrics.) tf_version api_versionZoriginal_model_formatZoptimization_defaultZ(optimization_post_training_dynamic_rangeZ"optimization_post_training_float16Z+optimization_post_training_integer_quantizeZoptimization_qatZoptimization_low_bit_qatZoptimization_sparsifyrrcSs t|tjrt|jSt|SrN)renumEnumrOrPpprintpformat)elemrSrSrTformat_element&s  zJTFLiteConverterBase._save_conversion_params_metric..format_elementcs@t|tttfr8|sdSfdd|D}dt|S|S)NNonecsg|] }|qSrSrSrr+rSrTr/rz\TFLiteConverterBase._save_conversion_params_metric..format_param..,)rlisttuplerajoinsorted)paramZ string_listr-rSrT format_param+s zHTFLiteConverterBase._save_conversion_params_metric..format_paramN)2rrrrgrsrtrurrxrprrrr apiVersionrryrrrrrrrrrfitemsrset_converter_paramset_export_requiredrrallowCustomOpsrrr`enableSelectTfOpsraforceSelectTfOpsmodelOptimizationModesrrModelOptimizationMode PTQ_FLOAT16PTQ_DYNAMIC_RANGErPTQ_FULL_INTEGERr PTQ_INT16QUANTIZATION_AWARE_TRAINING) rRrvrrconverter_kwargs quant_moder4rrPrSr-rT_save_conversion_params_metricsz                 z2TFLiteConverterBase._save_conversion_params_metriccCs|j|dSrN)rset_converter_latency)rRrPrSrSrT_set_conversion_latency_metricTsz2TFLiteConverterBase._set_conversion_latency_metricTc Cs|r|j|j}}|rn|r*|r*|ntj}|r<|r<|ntj}|}|} |} | ||||| | }|rv|ntj} |r|ntj} |r|j r|r| tj tj tjfvr| tj tj tjfvst || | }|rt|}z t|}Wnty tdYn0|S)z&Apply optimizations on a TFLite model.z]Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded)rrinference_output_typerrrrrr{rrruint8_modify_model_io_typer_mlir_sparsify_deduplicate_readonly_buffers Exceptionrri) rRmodelrDquant_ioZin_typeout_typeZ q_in_typeZ q_out_typeZq_activations_typeZ q_bias_typeZ q_allow_floatZ m_in_typeZ m_out_typerSrSrT_optimize_tflite_modelWs@    z*TFLiteConverterBase._optimize_tflite_modelc Os||t}||g|Ri|}t|d}|rJ||t||j|j rl|St |}t |}|j jj|t||j }t |S)a,Wraps around convert function to export metrics. Args: convert_func: The convert function to wrap. *args: Positional arguments of the convert function. **kwargs: The keyword arguments of the convert function. Returns: The decorator to wrap the convert function. i)rrEtime process_timerrGroundrexport_metricsrr1convert_bytearray_to_object_get_sparsity_modesrrr<extend_populate_conversion_metadataconvert_object_to_bytearray) rR convert_funcrkwargs start_timerZelapsed_time_ms model_objectZsparsity_modesrSrSrT_convert_and_export_metrics~s    z/TFLiteConverterBase._convert_and_export_metrics)N)F)NNN)T)rVrWrXrYrrrr r\rrrrrrrrr classmethodr#rrErGrrOPTIMIZE_TFLITE_MODELrQr_rSrSrSrTrs.- /3 #  ` &rcstfdd}|S)z8The decorator around convert function to export metrics.cs|jg|Ri|SrN)r_)rRrr\r[rSrTwrappersz _export_metrics..wrapper) functoolswraps)r[rcrSrbrT_export_metricssrfcszeZdZdZfddZddZeeje j ddZ eeje j dd Z eeje jd d Zd d ZddZZS)TFLiteConverterBaseV2z@Converter subclass to share functionality between V2 converters.cs,tt|tj|_tj|_d|jj_ dS)z Constructor for TFLiteConverter.rN) superrgr\rrrrHrrr5rQ __class__rSrTr\szTFLiteConverterBaseV2.__init__cCstjg}|rh|r&|tjg}n|tjtjg}|j|vsJ|j|vrdd|D}t d |n|j|vs||j|vrt ddS)z>Validate inference_input_type and inference_output_type flags.cSsg|]}d|jqS)ztf.name)rtrSrSrTrrzPTFLiteConverterBaseV2._validate_inference_input_output_types..zAThe inference_input_type and inference_output_type must be in {}.zFThe inference_input_type and inference_output_type must be tf.float32.N) rrrrrrrIrrHrr)rRrD default_types all_typesZall_types_namesrSrSrT&_validate_inference_input_output_typess   z.csg|]}j|jqSrS)rroutputsrlrtrurSrTrs) _opsGraph _loader_implSavedModelLoader load_graphget_meta_graph_def_from_tagsrvrw_signature_constants!DEFAULT_SERVING_SIGNATURE_DEF_KEYrsrx)rRrrr4rrv input_tensorsoutput_tensorsrSrurT_load_saved_models    z'TFLiteConverterBaseV2._load_saved_modelc Cs||t|j|j|j||j|j|j|j|_ | |j | s|D]`}|j }d|ddvr|tdt||qH|rH|ddurH|j }d|d<||qH|jdust|jdstt|jdj||_ntt|jj||_dS)zValidate the input parameters. Args: graph_def: The TensorFlow GraphDef. input_tensors: List of input tensors. Raise: ValueError: Input shape is not specified. Invalid quantization parameters. NrRNone is only supported in the 1st dimension. Tensor '{0}' has invalid shape '{1}'.rgraph_debug_info)rErgrsrtrurrxrpr _quant_moderprshapeas_listrr_get_tensor_name set_shape_trackable_objhasattr_get_debug_info_build_debug_info_func_funcsrvr_convert_debug_info_funcr)rRrvrtensor shape_listrrSrSrT_validate_inputss@         z&TFLiteConverterBaseV2._validate_inputscCs*|}|jjjr&t|||||jd}|S)a*Run a Grappler pass to optimize the TensorFlow graph. Args: graph_def: Frozen GraphDef to be optimized. input_tensors: List of input tensors. output_tensors: List of output tensors. frozen_func: TensorFlow Graph. Returns: The optimized TensorFlow graph. )configrv)r graph_optionsrewrite_optionsr_run_graph_optimizationsrv)rRrvrr frozen_funcZgrappler_configrSrSrT_optimize_tf_models z(TFLiteConverterBaseV2._optimize_tf_modelc Cs~||t|j|j|j||j|j|j|j}| |d|j i}| | | | tfi|}|j|||jdS)zHelper method that converts saved model. Args: graph_def: GraphDef object for the model, used only for stats. Returns: The converted TFLite model. enable_tflite_resource_variablesrO)rErgrsrtrurrxrprrprrrr_convert_saved_modelrQr)rRrvrDrCrrSrSrT_convert_from_saved_model.s$   z/TFLiteConverterBaseV2._convert_from_saved_modelcCsj||||}||j|js6tdn tdt f|||d|}|j ||j|j dS)aConverts a TensorFlow GraphDef based on instance variables. Args: graph_def: Frozen TensorFlow GraphDef. input_tensors: List of input tensors. output_tensors: List of output tensors. Returns: The converted data in serialized format. Raises: ValueError: No concrete functions is specified. Multiple concrete functions are specified. Input shape is not specified. Invalid quantization parameters. {Please consider switching to the new converter by setting experimental_new_converter=True. The old converter is deprecated.z~Using new converter: If you encounter a problem please file a bug. You can opt-out by setting experimental_new_converter=False input_datarrr) rrrrrrrriinfo_convert_graphdefrQr)rRrvrrrCrrSrSrTconvertLs$   zTFLiteConverterBaseV2.convert)rVrWrXrYr\rprrPREPARE_TF_MODELrLOAD_SAVED_MODELrVALIDATE_INPUTSrOPTIMIZE_TF_MODELrrr __classcell__rSrSrirTrgs     .  rgcs2eZdZdZdfdd ZefddZZS)TFLiteSavedModelConverterV2Converts the given SavedModel into TensorFlow Lite model. Attributes: saved_model_dir: Directory of the SavedModel. Ncs6tt|||_||_||_||_|jdddS)aConstructor for TFLiteConverter. Args: saved_model_dir: Directory of the SavedModel. saved_model_tags: Set of tags identifying the MetaGraphDef within the SavedModel to analyze. All tags in the tag set must be present. (default {tf.saved_model.SERVING}). saved_model_exported_names: Names to be exported when the saved model import path is on. trackable_obj: tf.AutoTrackable object associated with `funcs`. A reference to this object needs to be maintained so that Variables do not get garbage collected since functions have a weak reference to Variables. This is only required when the tf.AutoTrackable object is not maintained by the user (e.g. `from_saved_model`). TrN)rhrr\rrrrr)rRrrr trackable_objrirSrTr\}s z$TFLiteSavedModelConverterV2.__init__cs||j|j\}}}|jdus&|js`t|jddd|jtj\}}}}d|_tt| |||S|j durt t |j dj||_nt t|j j||_||S)JConverts a TensorFlow GraphDef based on instance variables. Returns: The converted data in serialized format. Raises: ValueError: No concrete functions is specified. Multiple concrete functions are specified. Input shape is not specified. Invalid quantization parameters. Nr)rrrr_freeze_saved_modelrrrhrrrrrrrvrrrr)rRrvrrrrirSrTrs.    z#TFLiteSavedModelConverterV2.convert)NNNrVrWrXrYr\rfrrrSrSrirTrvsrcsjeZdZdZd fdd Zeejej ddZ eejej ddZ fd d Z efd d ZZS)TFLiteKerasModelConverterV2z:Converts the given Keras model into TensorFlow Lite model.Ncs$tt|||_||_d|_dS)aConstructor for TFLiteConverter. Args: keras_model: tf.Keras.Model. trackable_obj: tf.AutoTrackable object associated with `funcs`. A reference to this object needs to be maintained so that Variables do not get garbage collected since functions have a weak reference to Variables. This is only required when the tf.AutoTrackable object is not maintained by the user (e.g. `from_saved_model`). TN)rhrr\ _keras_modelr!experimental_lower_to_saved_model)rR keras_modelrrirSrTr\s z$TFLiteKerasModelConverterV2.__init__cCsztj|j|tjdddWnty2YdS0||_ttj g|_ t j g|_ |j|jd|jr||j|j \}}}t|j|j |_|||fSdS)aSave Keras model to the SavedModel format. Args: output_dir: The output directory to save the SavedModel. Returns: graph_def: The frozen GraphDef. input_tensors: List of input tensors. output_tensors: List of output tensors. Tsave_debug_info)rNNNr) _saved_modelsaver _save_options SaveOptionsrMrra_tag_constantsSERVINGrrrrrrr_loadr)rR output_dirrvrrrSrSrT_convert_keras_to_saved_models,     z9TFLiteKerasModelConverterV2._convert_keras_to_saved_modelcCsxd}t|jjtjs"t|jdd}t|j|}|}|g|_t j |jddd\}}dd|j D}|j }||||fS) zFreeze Keras model to frozen graph. Returns: graph_def: The frozen GraphDef. input_tensors: List of input tensors. output_tensors: List of output tensors. frozen_func: The frozen ConcreteFunction. NT)keep_original_batch_sizerFlower_control_flowcSsg|]}|jtjkr|qSrSdtyperresourcerrrSrSrTrs zCTFLiteKerasModelConverterV2._freeze_keras_model..) rrcall _def_functionFunction_model_input_signature_trace_model_callget_concrete_functionr_convert_to_constants*convert_variables_to_constants_v2_as_graphrsrx)rRinput_signaturefunc concrete_funcrrvrrrSrSrT_freeze_keras_models"   z/TFLiteKerasModelConverterV2._freeze_keras_modelc sdt}zH||\}}}|jrBtt||||Wt|dSWt|dnt|d0dSzjConverts a Keras model as a saved model. Returns: The converted data in serialized format. TN) tempfilemkdtemprrrhrrshutilrmtree)rRtemp_dirrvrrrirSrT_convert_as_saved_models z3TFLiteKerasModelConverterV2._convert_as_saved_modelcsD|}|r|S|\}}}}|||||}tt||||S)aConverts a keras model based on instance variables. Returns: The converted data in serialized format. Raises: ValueError: Multiple concrete functions are specified. Input shape is not specified. Invalid quantization parameters. )rrrrhrrrRsaved_model_convert_resultrvrrrrirSrTr.s  z#TFLiteKerasModelConverterV2.convert)N)rVrWrXrYr\rrrrCONVERT_KERAS_TO_SAVED_MODELrFREEZE_KERAS_MODELrrrfrrrSrSrirTrs "  & rcsfeZdZdZd fdd Zeejej ddZ eejej ddZ d d Z efd d ZZS)TFLiteFrozenGraphConverterV2z;Converts the given frozen graph into TensorFlow Lite model.Ncs$tt|||_||_d|_dS)Constructor for TFLiteConverter. Args: funcs: List of TensorFlow ConcreteFunctions. The list should not contain duplicate elements. trackable_obj: tf.AutoTrackable object associated with `funcs`. A reference to this object needs to be maintained so that Variables do not get garbage collected since functions have a weak reference to Variables. This is only required when the tf.AutoTrackable object is not maintained by the user (e.g. `from_saved_model`). TN)rhrr\rrrrRfuncsrrirSrTr\Ls z%TFLiteFrozenGraphConverterV2.__init__cCsft|jdkrtdt|jdkr,tdtj|jddd\}}dd|jD}|j}||||fS) aBConvert the given ConcreteFunction to frozen graph. Returns: graph_def: The frozen GraphDef. input_tensors: List of input tensors. output_tensors: List of output tensors. frozen_func: The frozen ConcreteFunction. Raises: ValueError: none or multiple ConcreteFunctions provided. r!No ConcreteFunction is specified.rznThis converter can only convert a single ConcreteFunction. Converting multiple functions is under development.FrcSsg|]}|jtjkr|qSrSrrrSrSrTrys zJTFLiteFrozenGraphConverterV2._freeze_concrete_function..)lenrrrrrsrx)rRrrvrrrSrSrT_freeze_concrete_function]s z6TFLiteFrozenGraphConverterV2._freeze_concrete_functioncCs,t|jdkrtd|js dS|jr:t|jtjtj fr>dSi}g}znt|jdkrp|jd|t j <t j g}n&|jD]}|||j j <||j j qvtj|j||tjdddWntyYdS0||_ttjg|_||_|jdd|jr(||j|j\}}}t|j|j|_|||fSdS) aSave concrete functions to the SavedModel format. Args: output_dir: The output directory to save the SavedModel. Returns: graph_def: The frozen GraphDef. input_tensors: List of input tensors. output_tensors: List of output tensors. rrrrTr) signaturesrr)rrrrrr _functionConcreteFunctionrrrrrvrlrrrrrrMrrarrrrrrr)rRrrsignature_keysrrvrrrSrSrT*_convert_concrete_functions_to_saved_modelsP         zGTFLiteFrozenGraphConverterV2._convert_concrete_functions_to_saved_modelc Csft}zJ||\}}}|jrD|||||Wt|dSWt|dnt|d0dS)zConverts the given concrete functions as a saved model format. Returns: The converted data in serialized format. TN)rrrrrrrr)rRrrvrrrSrSrTrs   z4TFLiteFrozenGraphConverterV2._convert_as_saved_modelcsJ|jr|}|r|S|\}}}}|||||}tt||||Sr)rrrrrhrrrrirSrTrs z$TFLiteFrozenGraphConverterV2.convert)N)rVrWrXrYr\rrrrFREEZE_CONCRETE_FUNCTIONr)CONVERT_CONCRETE_FUNCTIONS_TO_SAVED_MODELrrrfrrrSrSrirTrIs ! <rcs,eZdZdZfddZeddZZS)TFLiteJaxConverterV2z8Converts the given jax model into TensorFlow Lite model.cstt|||_||_dS)aConstructor for TFLiteConverter. Args: serving_funcs: A list functions of the serving func of the jax module, the model params should already be inlined. (e.g., `serving_func = functools.partial(model, params=params)`) inputs: Array of input tensor placeholders tuple,s like `jnp.zeros`. For example, wrapped in an array like "[('input1', input1), ('input2', input2)]]". Jax function is polymorphic, for example: ```python def add(a, b): return a + b ``` Will yield different computations if different input signatures are passed in: Pass `add(10.0, 20.0)` will yield a scalar `add` while pass `add(np.random((100, 1)), np.random(100, 100))` will yield a broadcasting add. We will need the input information to do tracing for the converter to properly convert the model. So it's important to pass in the desired `input placeholders` with the correct input shape/type. In the converted tflite model: Currently: the function name will be default to main, the output names will be the traced outputs. The output ordering shall match the serving function. N)rhrr\_serving_funcs_inputs)rR serving_funcsrsrirSrTr\szTFLiteJaxConverterV2.__init__c Cs|ts td|jstd|js(tdt|jt|jkr\dt|jt|j}t|t|jtt fsttdt|jdkrtdt|jdtt fstd g}g}|jdD]\}}| || |qz"t|jdd d }|| }Wnt ytd Yn0||d d}| |t|j|j|jd} || | | tfi|} |j| | |jdS)aConverts a Jax serving func based on instance variables. Returns: The converted data in serialized format. Raises: ImportError: If cannot import the xla_computation from jax. ValueError: No serving function is specified. Input tensors are not specified. The truth value of an array with more than one element is ambiguous. Failed to convert the given Jax function to hlo. z'Cannot import xla_computation from jax.zNo serving func is specified.z Input tensors are not specified.z?Input tensor mapping len {} does not match serving func len {}.zAInput tensors should be pass in a tuple list wrapped in an array.rz/Currently only support single serving function.rz,The input placeholders are not a dictionary.cpu)backendz0Failed to convert the given Jax function to hlo.T) input_content input_namesis_proto_formatNr)r ImportErrorrrrrrrr0r/rZas_serialized_hlo_module_protorMrrrgrsrtrurpr_convert_jax_hlorQr) rRmsgrZordered_inputs input_namerZxla_compuationZ hlo_protorCrDrrSrSrTr sZ     zTFLiteJaxConverterV2.convertrrSrSrirTrs rzlite.TFLiteConverter)v1csbeZdZdZdfdd ZedddZedddZed d Zed d Z fd dZ Z S)TFLiteConverterV2a Converts a TensorFlow model into TensorFlow Lite model. Attributes: optimizations: Experimental flag, subject to change. Set of optimizations to apply. e.g {tf.lite.Optimize.DEFAULT}. (default None, must be None or a set of values of type `tf.lite.Optimize`) representative_dataset: A generator function used for integer quantization where each generated sample has the same order, type and shape as the inputs to the model. Usually, this is a small subset of a few hundred samples randomly chosen, in no particular order, from the training or evaluation dataset. This is an optional attribute, but required for full integer quantization, i.e, if `tf.int8` is the only supported type in `target_spec.supported_types`. Refer to `tf.lite.RepresentativeDataset`. (default None) target_spec: Experimental flag, subject to change. Specifications of target device, including supported ops set, supported types and a set of user's defined TensorFlow operators required in the TensorFlow Lite runtime. Refer to `tf.lite.TargetSpec`. inference_input_type: Data type of the input layer. Note that integer types (tf.int8 and tf.uint8) are currently only supported for post training integer quantization and quantization aware training. (default tf.float32, must be in {tf.float32, tf.int8, tf.uint8}) inference_output_type: Data type of the output layer. Note that integer types (tf.int8 and tf.uint8) are currently only supported for post training integer quantization and quantization aware training. (default tf.float32, must be in {tf.float32, tf.int8, tf.uint8}) allow_custom_ops: Boolean indicating whether to allow custom operations. When False, any unknown operation is an error. When True, custom ops are created for any op that is unknown. The developer needs to provide these to the TensorFlow Lite runtime with a custom resolver. (default False) exclude_conversion_metadata: Whether not to embed the conversion metadata into the converted model. (default False) experimental_new_converter: Experimental flag, subject to change. Enables MLIR-based conversion. (default True) experimental_new_quantizer: Experimental flag, subject to change. Enables MLIR-based quantization conversion instead of Flatbuffer-based conversion. (default True) experimental_enable_resource_variables: Experimental flag, subject to change. Enables [resource variables](https://tensorflow.org/guide/migrate/tf1_vs_tf2#resourcevariables_instead_of_referencevariables) to be converted by this converter. This is only allowed if the from_saved_model interface is used. (default True) Example usage: ```python # Converting a SavedModel to a TensorFlow Lite model. converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) tflite_model = converter.convert() # Converting a tf.Keras model to a TensorFlow Lite model. converter = tf.lite.TFLiteConverter.from_keras_model(model) tflite_model = converter.convert() # Converting ConcreteFunctions to a TensorFlow Lite model. converter = tf.lite.TFLiteConverter.from_concrete_functions([func], model) tflite_model = converter.convert() # Converting a Jax model to a TensorFlow Lite model. converter = tf.lite.TFLiteConverter.experimental_from_jax([func], [[ ('input1', input1), ('input2', input2)]) tflite_model = converter.convert() ``` Ncstt|||dS)rN)rhrr\rrirSrTr\s zTFLiteConverterV2.__init__cCs`ttjj|dur td|D]0}t|tj s$d}t|t j rL|d7}t |q$|||S)aCreates a TFLiteConverter object from ConcreteFunctions. Args: funcs: List of TensorFlow ConcreteFunctions. The list should not contain duplicate elements. Currently converter can only convert a single ConcreteFunction. Converting multiple functions is under development. trackable_obj: An `AutoTrackable` object (typically `tf.module`) associated with `funcs`. A reference to this object needs to be maintained so that Variables do not get garbage collected since functions have a weak reference to Variables. Returns: TFLiteConverter object. Raises: Invalid input type. NzPlease consider providing the trackable_obj argument in the from_concrete_functions. Providing without the trackable_obj argument is deprecated and it will use the deprecated conversion path.z2This function takes in a list of ConcreteFunction.zI To get the ConcreteFunction from a Function, call get_concrete_function.) rr#rrTF_CONCRETE_FUNCTIONSrrirrrrrr)r!rrrmessagerSrSrTfrom_concrete_functionss   z)TFLiteConverterV2.from_concrete_functionsc CsttjjtsVd}|r.cSsg|] \}}|qSrSrS)rrlrrSrSrTr;rN)r#r.r1rQrSrSrTr&2sz&TFLiteConverterBaseV1.get_input_arrayscCs|jduo|jS)z\Checks if the input and output tensors have been initialized. Returns: Bool. N)r.r/rQrSrSrTr#=sz(TFLiteConverterBaseV1._has_valid_tensorscCsH|std|jD],}|j}|ddur||d<||qdS)a Sets the first dimension of the input tensor to `batch_size`. Args: batch_size: Batch size for the model. Replaces the first dimension of an input size array if undefined. (default 1) Raises: ValueError: input_tensor is not defined. zOThe batch size cannot be set for this model. Please use input_shapes parameter.rN)r#rr.rrr)rRr"rrrSrSrTr$Es    z%TFLiteConverterBaseV1._set_batch_sizecs8t|jrdStt|s dS|jr4tddSdS)NFz`conversion_summary_dir` does not work with unknown shapes. Graphs with unknown shapes might be different than when this flag is disabled.T)_is_ophint_convertedrlrhr rrrrirQrirSrTrYs z0TFLiteConverterBaseV1._is_unknown_shapes_allowedc sL|j|j|j|j|j|j|j|j|j dt t | |j |j|jdS)N)rrrrrrrr)rrrrrrrrrrrhr rErlrrrQrirSrTrEks" z4TFLiteConverterBaseV1._save_conversion_params_metric)rVrWrXrYr\rrr!rrrrrrrrrr&r#r$rrErrSrSrirTr Js    0  "H  r cs2eZdZdZdfdd ZefddZZS)TFLiteSavedModelConverterrNcstt||||_||_||_tj}t|jdkr>t d|jd}t |jddd|j|}|d|_ |d|_ |d|_ |dS)aLConstructor for TFLiteConverter. Args: saved_model_dir: Directory of the SavedModel. saved_model_tags: Set of tags identifying the MetaGraphDef within the SavedModel to analyze. All tags in the tag set must be present. (default {tf.saved_model.SERVING}). saved_model_exported_names: Names to be exported when the saved model import path is on. experimental_debug_info_func: An experimental function to retrieve the graph debug info for a set of nodes from the `graph_def`. Raises: ValueError: Invalid arguments. rrrNr)rhr5r\rrrrrrrrrlr.r/r)rRrrrrrrrirSrTr\s&     z"TFLiteSavedModelConverter.__init__cstt|Sr))rhr5rrQrirSrTrs z!TFLiteSavedModelConverter.convert)NrrSrSrirTr5|s  (r5csTeZdZdZd fdd Zeejej ddZ fddZ e fd d Z ZS) TFLiteKerasModelConverterz9Converts the given SavedModel into TensorFlow Lite model.Ncs$tt|jddtr|s"|r*tdt||}t|}| }t j |dd} t | j |||_| j|_| j |_| j|_t| j|_dStt||}t} |rt| j|} n|j } |rt| j|} n|j} t | |t| | | } ||_| |_| |_| |_t| j|_dS)awConstructor for TFLiteConverter. Args: model_file: Full filepath of HDF5 file containing the tf.keras model. input_arrays: List of input tensors to freeze graph with. Uses input arrays from SignatureDef when none are provided. (default None) input_shapes: Dict of strings representing input tensor names to list of integers representing input shapes (e.g., {"foo" : [1, 16, 16, 3]}). Automatically determined when input shapes is None (e.g., {"foo" : None}). (default None) output_arrays: List of output tensors to freeze graph with. Uses output arrays from SignatureDef when none are provided. (default None) custom_objects: Dict mapping names (strings) to custom classes or functions to be considered during model deserialization. (default None) Raises: ValueError: Invalid arguments. Nrz`input_arrays` and `output_arrays` are unsupported with Eager mode. If your model requires any of these parameters, please use disable_eager_execution().Fr)rhr7r\r6rrrGget_load_model_functionrrr!convert_variables_to_constants_v2_set_tensor_shapesrsrrv as_graph_defrlr.rxr/rrget_clear_session_functionget_get_session_function_get_tensors_from_tensor_names _freeze_graph)rR model_file input_arrays input_shapesr,custom_objectsrr8rrsessrrrvrirSrTr\sR       z"TFLiteKerasModelConverter.__init__cCsz|jj|ddWnty(YdS0ttjg}tj}t|ddd||\}}}}||_ ||_ |g|_ | |j r||_ ||_||_t||_dS)zvSave Keras model to Saved Model format. Args: output_dir: The output directory to save the SavedModel. tf) save_formatN)rrrMrarrrrrrrrrrlr.r/rr)rRrrrrvrrZ sess_graphrSrSrTr s$   z-TFLiteKerasModelConverter._freeze_keras_modelc sXt}z<|||jr6tt|Wt|dSWt|dnt|d0dSr) rrrrrhr7rrr)rRrrirSrTr# s  z1TFLiteKerasModelConverter._convert_as_saved_modelcs|}|r|Stt|S)aHConverts a Keras model based on instance variables. Returns: The converted data in serialized format. Either a TFLite Flatbuffer or a Graphviz graph depending on value in `output_format`. Raises: ValueError: Input shape is not specified. None value for dimension in input_tensor. )rrhr7r)rRrrirSrTr1 s z!TFLiteKerasModelConverter.convert)NNNN)rVrWrXrYr\rrrrrrrrfrrrSrSrirTr7sI   r7cs2eZdZdZdfdd ZefddZZS)TFLiteFrozenGraphConverterz?Converts the given frozen graph def into TensorFlow Lite model.Ncsttt||||_||_||_d|_|s<||_||_ |durV|durVt d|durp|durpt ddS)aConstructor for TFLiteConverter. Args: graph_def: Frozen TensorFlow GraphDef. input_tensors: List of input tensors. Type and shape are computed using `foo.shape` and `foo.dtype`. output_tensors: List of output tensors (only .name is used from this). input_arrays_with_shape: Tuple of strings representing input tensor names and list of integers representing input shapes (e.g., [("foo", [1, 16, 16, 3])]). Use only when graph cannot be loaded into TensorFlow and when `input_tensors` and `output_tensors` are None. (default None) output_arrays: List of output tensors to freeze graph with. Use only when graph cannot be loaded into TensorFlow and when `input_tensors` and `output_tensors` are None. (default None) experimental_debug_info_func: An experimental function to retrieve the graph debug info for a set of nodes from the `graph_def`. Raises: ValueError: Invalid arguments. Nzsinput_arrays_with_shape will be ignored when both the given input_tensors and input_arrays_with_shape are not None.z`output_arrays will be ignored when both the given output_tensors and output_arrays are not None.) rhrHr\rlr.r/r3r#r1r2rrirRrvrrr+r,rrirSrTr\H s  z#TFLiteFrozenGraphConverter.__init__cs0|s"|jr|js"|js"tdtt|S)r)zIf input_tensors and output_tensors are None, both input_arrays_with_shape and output_arrays|control_output_arrays must be defined.)r#r1r2r3rrhrHrrQrirSrTry s  z"TFLiteFrozenGraphConverter.convert)NNNrrSrSrirTrHE s1rHcsdeZdZdZdfdd ZeddZedddZedd d Zedd d Z fd dZ Z S)ra Convert a TensorFlow model into `output_format`. This is used to convert from a TensorFlow GraphDef, SavedModel or tf.keras model into either a TFLite FlatBuffer or graph visualization. Attributes: optimizations: Experimental flag, subject to change. Set of optimizations to apply. e.g {tf.lite.Optimize.DEFAULT}. (default None, must be None or a set of values of type `tf.lite.Optimize`) representative_dataset: A generator function used for integer quantization where each generated sample has the same order, type and shape as the inputs to the model. Usually, this is a small subset of a few hundred samples randomly chosen, in no particular order, from the training or evaluation dataset. This is an optional attribute, but required for full integer quantization, i.e, if `tf.int8` is the only supported type in `target_spec.supported_types`. Refer to `tf.lite.RepresentativeDataset`. (default None) target_spec: Experimental flag, subject to change. Specifications of target device, including supported ops set, supported types and a set of user's defined TensorFlow operators required in the TensorFlow Lite runtime. Refer to `tf.lite.TargetSpec`. inference_type: Data type of numeric arrays, excluding the input layer. (default tf.float32, must be in {tf.float32, tf.int8, tf.uint8}) inference_input_type: Data type of the numeric arrays in the input layer. If `inference_input_type` is in {tf.int8, tf.uint8}, then `quantized_input_stats` must be provided. (default is the value assigned to `inference_type`, must be in {tf.float32, tf.int8, tf.uint8}) inference_output_type: Data type of the numeric arrays in the output layer. (default is the value assigned to `inference_type`, must be in {tf.float32, tf.int8, tf.uint8}) quantized_input_stats: Map of input tensor names to a tuple of floats representing the mean and standard deviation of the training data. (e.g., {"foo" : (0., 1.)}). Required if `inference_input_type` is tf.int8 or tf.uint8. (default None) default_ranges_stats: Tuple of integers (min, max) representing range values for all numeric arrays without a specified range. Intended for experimenting with quantization via "dummy quantization". (default None) allow_custom_ops: Boolean indicating whether to allow custom operations. When False any unknown operation is an error. When True, custom ops are created for any op that is unknown. The developer will need to provide these to the TensorFlow Lite runtime with a custom resolver. (default False) drop_control_dependency: Boolean indicating whether to drop control dependencies silently. This is due to TFLite not supporting control dependencies. (default True) reorder_across_fake_quant: Boolean indicating whether to reorder FakeQuant nodes in unexpected locations. Used when the location of the FakeQuant nodes is preventing graph transformations necessary to convert the graph. Results in a graph that differs from the quantized training graph, potentially causing differing arithmetic behavior. (default False) change_concat_input_ranges: Boolean to change behavior of min/max ranges for inputs and outputs of the concat operator for quantized models. Changes the ranges of concat operator overlap when true. (default False) output_format: Output file format. (default tf.compat.v1.lite.constants.TFLITE, must be in {tf.compat.v1.lite.constants.TFLITE, tf.compat.v1.lite.constants.GRAPHVIZ_DOT}) dump_graphviz_dir: Full filepath of folder to dump the graphs at various stages of processing GraphViz .dot files. Preferred over `output_format=tf.compat.v1.lite.constants.GRAPHVIZ_DOT` in order to keep the requirements of the output file. (default None) dump_graphviz_video: Boolean indicating whether to dump the GraphViz .dot files after every graph transformation. Requires the `dump_graphviz_dir` flag to be specified. (default False) conversion_summary_dir: Full path of the directory to store conversion logs. (default None) exclude_conversion_metadata: Whether not to embed the conversion metadata into the converted model. (default False) target_ops: Deprecated. Please use `target_spec.supported_ops` instead. post_training_quantize: Deprecated. Please use `optimizations` instead and set it to `{tf.lite.Optimize.DEFAULT}`. (default False) experimental_new_converter: Experimental flag, subject to change. Enables MLIR-based conversion. (default True) experimental_new_quantizer: Experimental flag, subject to change. Enables MLIR-based quantization conversion instead of Flatbuffer-based conversion. (default True) Example usage: ```python # Converting a GraphDef from session. converter = tf.compat.v1.lite.TFLiteConverter.from_session( sess, in_tensors, out_tensors) tflite_model = converter.convert() open("converted_model.tflite", "wb").write(tflite_model) # Converting a GraphDef from file. converter = tf.compat.v1.lite.TFLiteConverter.from_frozen_graph( graph_def_file, input_arrays, output_arrays) tflite_model = converter.convert() open("converted_model.tflite", "wb").write(tflite_model) # Converting a SavedModel. converter = tf.compat.v1.lite.TFLiteConverter.from_saved_model( saved_model_dir) tflite_model = converter.convert() open("converted_model.tflite", "wb").write(tflite_model) # Converting a tf.keras model. converter = tf.compat.v1.lite.TFLiteConverter.from_keras_model_file( keras_model) tflite_model = converter.convert() open("converted_model.tflite", "wb").write(tflite_model) ``` Ncstt|||||||dS)aConstructor for TFLiteConverter. Args: graph_def: Frozen TensorFlow GraphDef. input_tensors: List of input tensors. Type and shape are computed using `foo.shape` and `foo.dtype`. output_tensors: List of output tensors (only .name is used from this). input_arrays_with_shape: Tuple of strings representing input tensor names and list of integers representing input shapes (e.g., [("foo" : [1, 16, 16, 3])]). Use only when graph cannot be loaded into TensorFlow and when `input_tensors` and `output_tensors` are None. (default None) output_arrays: List of output tensors to freeze graph with. Use only when graph cannot be loaded into TensorFlow and when `input_tensors` and `output_tensors` are None. (default None) experimental_debug_info_func: An experimental function to retrieve the graph debug info for a set of nodes from the `graph_def`. Raises: ValueError: Invalid arguments. N)rhrr\rIrirSrTr\ szTFLiteConverter.__init__cCs0ttjjt|||}||||t|jdS)aUCreates a TFLiteConverter class from a TensorFlow Session. Args: sess: TensorFlow Session. input_tensors: List of input tensors. Type and shape are computed using `foo.shape` and `foo.dtype`. output_tensors: List of output tensors (only .name is used from this). Returns: TFLiteConverter class. r8)rr#rr TF_SESSIONr@rrv)r!rErrrvrSrSrT from_session s zTFLiteConverter.from_sessionc s\ttjjt*t }t |sBt d |t |d}|}Wdn1sl0Yzt}||WntjtfyzHtdt|tstrt|d}n t|d}t}t||Wn(tjtfyt d |Yn0Yn0d} zt|dd WntyFd } Yn0| rt |s`t!d t"|j#|} t"|j#|} t$| ||j%| | WdWdSst!d t&|t&'krt!d fdd|D} ||dd| |dWdWdSWdn1s.0YWdn1sN0YdS)adCreates a TFLiteConverter class from a file containing a frozen GraphDef. Args: graph_def_file: Full filepath of file containing frozen GraphDef. input_arrays: List of input tensors to freeze graph with. output_arrays: List of output tensors to freeze graph with. input_shapes: Dict of strings representing input tensor names to list of integers representing input shapes (e.g., {"foo" : [1, 16, 16, 3]}). Automatically determined when input shapes is None (e.g., {"foo" : None}). (default None) Returns: TFLiteConverter class. Raises: IOError: File not found. Unable to parse input file. ValueError: The graph is not frozen. input_arrays or output_arrays contains an invalid tensor name. input_shapes is not correctly defined when required zFile '{0}' does not exist.rbNz(Ignore 'tcmalloc: large alloc' warnings.zutf-8z Unable to parse input file '{}'.TrkFz.Please freeze the graph using freeze_graph.py.z,input_shapes must be defined for this model.z?input_shapes must contain a value for each item in input_array.csg|]}||fqSrSrS)rrlrCrSrTr sz5TFLiteConverter.from_frozen_graph..)rrr+r,)(rr#rr TF_GRAPH_DEFryrz as_default_sessionSessionr?ExistsIOErrorrGFileread _graph_pb2GraphDefParseFromString _text_format ParseErrorrprintrrOrsix ensure_binary ensure_textMerge_import_graph_def_NotFoundError_is_frozen_graphrr?rvr;rvrakeys) r!graph_def_filerBr,rCrEf file_contentrvZload_model_in_sessionrrr+rSrNrTfrom_frozen_graph6 sn  &     * z!TFLiteConverter.from_frozen_graphc Cs~ttjj|dur"ttjg}|dur0tj }t |||g}|j rH|St ||||||}||d|d|dt |ddS)a Creates a TFLiteConverter class from a SavedModel. Args: saved_model_dir: SavedModel directory to convert. input_arrays: List of input tensors to freeze graph with. Uses input arrays from SignatureDef when none are provided. (default None) input_shapes: Dict of strings representing input tensor names to list of integers representing input shapes (e.g., {"foo" : [1, 16, 16, 3]}). Automatically determined when input shapes is None (e.g., {"foo" : None}). (default None) output_arrays: List of output tensors to freeze graph with. Uses output arrays from SignatureDef when none are provided. (default None) tag_set: Set of tags identifying the MetaGraphDef within the SavedModel to analyze. All tags in the tag set must be present. (default {tf.saved_model.SERVING}) signature_key: Key identifying SignatureDef containing inputs and outputs. (default tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY) Returns: TFLiteConverter class. Nrrr)rvrrr)rr#rrrrarrrrr5rrr) r!rrBrCr,rrrrrSrSrTr s*  z TFLiteConverter.from_saved_modelcCsttjjt|||||S)aCreates a TFLiteConverter class from a tf.keras model file. Args: model_file: Full filepath of HDF5 file containing the tf.keras model. input_arrays: List of input tensors to freeze graph with. Uses input arrays from SignatureDef when none are provided. (default None) input_shapes: Dict of strings representing input tensor names to list of integers representing input shapes (e.g., {"foo" : [1, 16, 16, 3]}). Automatically determined when input shapes is None (e.g., {"foo" : None}). (default None) output_arrays: List of output tensors to freeze graph with. Uses output arrays from SignatureDef when none are provided. (default None) custom_objects: Dict mapping names (strings) to custom classes or functions to be considered during model deserialization. (default None) Returns: TFLiteConverter class. )rr#rrrr7)r!rArBrCr,rDrSrSrTfrom_keras_model_file s z%TFLiteConverter.from_keras_model_filecstt|Sr6)rhrrrQrirSrTr s zTFLiteConverter.convert)NNN)N)NNNNN)NNNN) rVrWrXrYr\r`rKrhrrjrrrSrSrirTr s0o!  ` 3 rzlite.TocoConverterc@sveZdZdZeeddddZeedddddZeedd dd d Z eedd dd dZ dS) TocoConverterzConvert a TensorFlow model into `output_format`. This class has been deprecated. Please use `lite.TFLiteConverter` instead. Nz0Use `lite.TFLiteConverter.from_session` instead.cCst|||S)z8Creates a TocoConverter class from a TensorFlow Session.)rrK)r!rErrrSrSrTrK szTocoConverter.from_sessionz5Use `lite.TFLiteConverter.from_frozen_graph` instead.cCst||||S)zDCreates a TocoConverter class from a file containing a frozen graph.)rrh)r!rerBr,rCrSrSrTrh s zTocoConverter.from_frozen_graphz4Use `lite.TFLiteConverter.from_saved_model` instead.cCst||||||S)z0Creates a TocoConverter class from a SavedModel.)rr)r!rrBrCr,rrrSrSrTr s zTocoConverter.from_saved_modelz9Use `lite.TFLiteConverter.from_keras_model_file` instead.cCst||||S)z9Creates a TocoConverter class from a tf.keras model file.)rrj)r!rArBrCr,rSrSrTrj$ s z#TocoConverter.from_keras_model_file)N)NNNNN)NNN) rVrWrXrYr` _deprecation deprecatedrKrhrrjrSrSrSrTrk s<   rk)rYr&rdr(rrrRrabslrr]rgoogle.protobufrrZZgoogle.protobuf.messagertensorflow.core.frameworkrrWZ5tensorflow.lite.experimental.microfrontend.python.opsrtensorflow.lite.pythonrrr rZtensorflow.lite.python.convertr rr r0r rr rrrrLrrrrKrr$tensorflow.lite.python.convert_phaserrrZ*tensorflow.lite.python.convert_saved_modelrrZ"tensorflow.lite.python.interpreterrrrtensorflow.lite.python.metricsrtensorflow.lite.python.op_hintrrr4rZtensorflow.lite.python.optimizerrZtensorflow.lite.python.utilr r!rr"rr#r@r$rr%rr&rWr'rr(r?r)r r*rcr+rr,rJr-rYr.rr/r;r0rtensorflow.lite.toolsr1Z8tensorflow.lite.tools.optimize.debugging.python.debuggerr2r3tensorflow.pythonr4rtensorflow.python.clientr5rQtensorflow.python.eagerr6r7rr8rtensorflow.python.frameworkr9rr:rr;ryr<'tensorflow.python.framework.errors_implr=rb$tensorflow.python.framework.importerr>ratensorflow.python.platformr?Ztensorflow.python.saved_modelr@r{rArrBrrCrZ"tensorflow.python.saved_model.loadrDrZ)tensorflow.python.saved_model.loader_implrErtensorflow.python.utilrFrlrG tensorflow.python.util.tf_exportrH _tf_exportr'rIrrZr^rgrrfrgrrrrrr r5r7rHrrkrSrSrSrTs                                                                       ;/ OJ $m q4? K l