a Sic6@sdZddlZddlZddlZddlmZddlZddlmZddl Z ddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlm Z!ddlm"Z"ddlm#Z$ddlm%Z&ddl'm(Z(ddl)m*Z+dZ,ej-Z-ej.Z.zddl/m0Z1Wne2yHdZ1Yn0e"j3e"j4e"j5e"j6e"j7e"j8e"j9e"j:e"j;e"je"j?d Z@dZAe"jd?ZTd@dAZUdBdCZVe"j3fdDdEZWdFdGZXe"j3fdHdIZYdJdKZZdLdMZ[dNdOZ\e"j3e"j3fdPdQZ]dRdSZ^dTdUZ_dVdWZ`dS)Zz+Functions used by multiple converter files.N)logging)range) config_pb2)graph_debug_info_pb2)meta_graph_pb2)'conversion_metadata_schema_py_generated)schema_py_generated) schema_util)tflite_keras_util)convert_op_hints_to_stubs)find_all_hinted_output_nodes)flatbuffer_utils)function)convert_to_constants)dtypes)error_interpolation) graph_util) tf_optimizer)export_meta_graphZCONVERSION_METADATA)xla_computation) r sTFL3cCs&t|}|dur"td|t|S)aConverts tflite enum type (eg: 0) to tf type (eg: tf.float32). Args: tflite_enum_type: tflite enum type (eg: 0, that corresponds to float32) Raises: ValueError: If an invalid tflite enum type is provided. Returns: tf type (eg: tf.float32) Nz>Unsupported enum {}. The valid map of enum to tf types is : {})_MAP_TFLITE_ENUM_TO_TF_TYPESget ValueErrorformat)Ztflite_enum_typetf_typer'W/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/lite/python/util.py$_convert_tflite_enum_type_to_tf_typeVs r)cCs|rd|jSdS)z=Converts tf.dtype (eg: tf.float32) to str (eg: "tf.float32").ztf.N)name)r&r'r'r(get_tf_type_namejsr+cCsZt|jd}t|dkr4tdt|dt|dkrR|ddkrR|jS|dS)zWReturns name of the input tensor. Args: tensor: tf.Tensor Returns: str :rz1Tensor name invalid. Expect 0 or 1 colon, got {0}r0r)six ensure_strr*splitlenr$r%)tensorpartsr'r'r(get_tensor_nameos   r4cCsi}|D]}|D]}||t|<qq g}g}|D]L}t|tjs\tdt||| |}|durz| |q8| |q8|rtdd ||S)aeGets the Tensors associated with the `tensor_names` in the provided graph. Args: graph: TensorFlow Graph. tensor_names: List of strings that represent names of tensors in the graph. Returns: A list of Tensor objects in the same order the names are provided. Raises: ValueError: tensor_names contains an invalid tensor name. zInvalid type for a tensor name in the provided graph. Expected type for a tensor name is 'str', instead got type '{}' for tensor name '{}'Nz Invalid tensors '{}' were found.,) get_operationsvaluesr4 isinstancer. string_typesr$r%typer#appendjoin)graph tensor_namesZtensor_name_to_tensoropr2tensorsZinvalid_tensorsr*r'r'r(get_tensors_from_tensor_namess(      rAc Cs|rdd|D}|D]\}}||vr8td||dur||}z||Wqty}z*d||j|t|}t|WYd}~qd}~00qdS)aSets Tensor shape for each tensor if the shape is defined. Args: tensors: TensorFlow ops.Tensor. shapes: Dict of strings representing input tensor names to list of integers representing input shapes (e.g., {"foo": : [1, 16, 16, 3]}). Raises: ValueError: `shapes` contains an invalid tensor. `shapes` contains an invalid shape for a valid tensor. cSsi|]}t||qSr'r4.0r2r'r'r( sz%set_tensor_shapes..z/Invalid tensor '{}' found in tensor shapes map.Nz@The shape of tensor '{0}' cannot be changed from {1} to {2}. {3})itemsr$r% set_shapeshapestr)r@shapesZtensor_names_to_tensorr*rHr2errormessager'r'r(set_tensor_shapess$ rMcCs*t}|jj}|D]}|j|q|S)zCreates a tf.compat.v1.ConfigProto for configuring Grappler. Args: optimizers_list: List of strings that represents the list of optimizers. Returns: tf.ConfigProto. ) _config_pb2 ConfigProto graph_optionsrewrite_options optimizersr;)Zoptimizers_listconfigrQ optimizerr'r'r(get_grappler_configs rUc Cst||d}t}|D]@}|j|j|j_|jj|j|j_|j|jj|j q|D]@}|j|j |j_|jj|j |j_|j |jj|j q^|j d|t }||D]}|jj|jq|jd|t||S)aApply standard TensorFlow optimizations to the graph_def. Args: graph_def: Frozen GraphDef to be optimized. input_arrays: List of arrays that are considered inputs of the graph. output_arrays: List of arrays that are considered outputs of the graph. config: tf.ConfigProto. graph: TensorFlow Graph. Required when Eager mode is enabled. (default None) Returns: A new, optimized GraphDef. ) graph_defr=Z not_used_keytrain_op)_export_meta_graph_meta_graph_pb2 SignatureDefr*inputsdtypeas_datatype_enum tensor_shapeCopyFromrHas_protooutputs signature_def CollectionDef node_listvaluer;collection_defr OptimizeGraph) rV input_arrays output_arraysrSr= meta_graph signaturearrayfetch_collectionr'r'r(run_graph_optimizationss   rncCs>t|rtddd|D}t||||}t|d}|S)Nz.Try to convert op hints, needs unfrozen graph.cSsg|] }t|qSr'rBrCr'r'r( z0_convert_op_hints_if_present..)rV)is_frozen_graphr$ tf_graph_utilconvert_variables_to_constantsr )sessrVoutput_tensorshinted_outputs_nodesrir'r'r(_convert_op_hints_if_presents  rwcCsrt|j}tdg}t|||||jd}t|}|rDt||||St|shdd|D}t |||S|jSdS)aReturns a frozen GraphDef. Runs a Grappler pass and freezes a graph with Variables in it. Otherwise the existing GraphDef is returned. The Grappler pass is only run on models that are frozen in order to inline the functions in the graph. If OpHints is present, it will try to convert the OpHint graph. Args: sess: TensorFlow Session. input_tensors: List of input tensors. output_tensors: List of output tensors (only .name is used from this). Returns: Frozen GraphDef. r)r=cSsg|]}|jddqS)r,r)r*r0rCr'r'r(ro4rpz freeze_graph..N) _convert_to_constants disable_lower_using_switch_mergerVrUrnr=r rwrqrrrs)rt input_tensorsrurVrSrvoutput_node_namesr'r'r( freeze_graphs$  r|cCs>|jD].}t|jds2t|jdr dSq dS)zDetermines if the graph is frozen. Determines if a graph has previously been frozen by checking for any operations of type Variable*. If variables are found, the graph is not frozen. Args: sess: TensorFlow Session. Returns: Bool. VariableZ VariableOpFT)r=r6r.r/r: startswithendswith)rtr?r'r'r(rq;s rqcsfdd}|S)a=Returns a method to retrieve the `GraphDebugInfo` from the original graph. Args: original_graph: The original `Graph` containing all the op stack traces. Returns: A function which retrieves the stack traces from the original graph and converts them to a `GraphDebugInfo` for a given set of nodes. c ssdSg}|D]|\}}z\|s4|||fn>|}t|tjrb|||j|fntj dWqWqt yYqYq0qt |S)CFunction to create `GraphDebugInfo` for the given `original_nodes`.Nz9Use '@tf.function' or '@defun' to decorate the function. ) r;get_operation_by_name _get_functionr8r_EagerDefinedFunctionr=sysstderrwriteKeyError_error_interpolationcreate_graph_debug_info_def)original_nodesZ useful_opsfuncr*Zsub_funcoriginal_graphr'r(fYs&     z build_debug_info_func..fr')rrr'rr(build_debug_info_funcNs rcsfdd}|S)a:Returns a method to retrieve the `GraphDebugInfo` from the original graph. Args: saved_debug_info: The `GraphDebugInfo` containing all the debug info. Returns: A function which retrieves the stack traces from the original graph and converts them to a `GraphDebugInfo` for a given set of nodes. csTsdSt}j|jdd<|D]*\}}|d|}|j|j|q$|S)rN@)rGraphDebugInfofilestracesr_)routput_debug_infornodeZ debug_keysaved_debug_infor'r(rs   z"convert_debug_info_func..fr')rrr'rr(convert_debug_info_funcus rcCs|sdSt}|jD]f}|jj}|jj}|s>|d|jfqtt|D].}|t|kr^dn||}||||fqJq||S)aIReturns the debug info for the original nodes in the `converted_graph`. Args: nodes_to_debug_info_func: The method to collect the op debug info for the nodes. converted_graph: A `GraphDef` after optimization and transformation. Returns: `GraphDebugInfo` for all the original nodes in `converted_graph`. N) setrexperimental_debug_infooriginal_node_namesoriginal_func_namesaddr*rr1)Znodes_to_debug_info_funcconverted_graphrrZ debug_nodesZ debug_funcsiZ debug_funcr'r'r(get_debug_infos  rPFcCsd}g}|}t|D]4} t|d|kr:||d|}|d| f7}qt|t|krh||dd|} |durd|d}|durd j|d } nd} |rd jtjj d } nd} d } | j|t|| | | d}d}|j||| d}||fS)aReturns strings representing a C constant array containing `data`. Args: data: Byte array that will be converted into a C constant. array_name: String to use as the variable name for the constant array. max_line_width: The longest line length, for formatting purposes. include_guard: Name to use for the include guard macro definition. include_path: Optional path to include in the source file. use_tensorflow_license: Whether to include the standard TensorFlow Apache2 license in the generated files. Returns: Text that can be compiled as a C source file to link in the data as a literal array of values. Text that can be used as a C header file to reference the literal array. z r z 0x%02x,rNZTENSORFLOW_LITE_UTIL_Z_DATA_H_z#include "{include_path}" ) include_patha /* Copyright {year} The TensorFlow Authors. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ==============================================================================*/ )yeara{license_text} // This is a TensorFlow Lite model file that has been converted into a C data // array using the tensorflow.lite.util.convert_bytes_to_c_source() function. // This form is useful for compiling into a binary for devices that don't have a // file system. {include_line} // We need to keep the data array aligned on some architectures. #ifdef __has_attribute #define HAVE_ATTRIBUTE(x) __has_attribute(x) #else #define HAVE_ATTRIBUTE(x) 0 #endif #if HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__)) #define DATA_ALIGN_ATTRIBUTE __attribute__((aligned(4))) #else #define DATA_ALIGN_ATTRIBUTE #endif const unsigned char {array_name}[] DATA_ALIGN_ATTRIBUTE = {{ {array_values}}}; const int {array_name}_len = {array_length}; ) array_nameZ array_length array_values license_text include_linea {license_text} // This is a TensorFlow Lite model file that has been converted into a C data // array using the tensorflow.lite.util.convert_bytes_to_c_source() function. // This form is useful for compiling into a binary for devices that don't have a // file system. #ifndef {include_guard} #define {include_guard} extern const unsigned char {array_name}[]; extern const int {array_name}_len; #endif // {include_guard} )r include_guardr) bytearrayr1r;r<upperr%datetimedatetodayr)datarmax_line_widthrrZuse_tensorflow_licenseZ starting_pad array_linesZ array_linererrrZsource_template source_textZheader_templateZ header_textr'r'r(convert_bytes_to_c_sourcesL   rcCs(tj|d}tj|}t|}|S)z@Converts a tflite model from a bytearray into a parsable object.r) schema_fbModelZGetRootAsModelZModelT InitFromObjcopydeepcopy)Zmodel_bytearray model_objectr'r'r('_convert_model_from_bytearray_to_object)s  rcCs.td}||}|j|tdt|S)z@Converts a tflite model from a parsable object into a bytearray.i)Zfile_identifier) flatbuffersBuilderPackFinish_TFLITE_FILE_IDENTIFIERbytesOutput)rbuilderZ model_offsetr'r'r('_convert_model_from_object_to_bytearray1s  rcCs<g}t|jD](\}}t|}|tjjkr||q|SzReturns the quantize op idx.) enumerate operatorCodesr #get_builtin_code_from_operator_coderBuiltinOperatorQUANTIZEr;modelquant_opcode_idxsidxopcode builtin_coder'r'r(get_quantize_opcode_idx:s    rcCs<g}t|jD](\}}t|}|tjjkr||q|Sr)rrr rrrZ DEQUANTIZEr;rr'r'r(get_dequantize_opcode_idxDs    rcCs8tt|D]&}||j|vr |||j||_q dS)z4Update the tensors in the SignatureDef's TensorMaps.N)rr1 tensorIndex)Z tensor_mapsZmap_old_to_new_tensorsrr'r'r(_update_signature_def_tensorsNs rc s^|sdSt|jdkr$tddS|jd}|j}|j}td|t|t|t|krxtd|t|d=ntdid}tt|D]"}||vr|d7}q|||<qtd fd d }||j ||j |D]}||j ||j q|j r2|j d} t | j t | j t|d d D]}||q>td dS)zRemove tensors from model.NrzSkipping the removal of dangled tensors since the model has multiple subgraphs and tensors can be used in the different subgraph(s)rz Removing tensors at indices : %sz3Removing tensors only at the end of the tensor listz,Removing tensors requires updating the modelzOld to new tensors map: %scs&t|D]\}}|d||<qdS)N)rr#)Z tensor_idxsrtiZd_old_to_new_tensorsr'r(update_tensorsusz2_remove_tensors_from_model..update_tensorsT)reversez#Removed tensors marked for deletion)r1 subgraphsrinfor@ operatorsdebugminr__str__r[ra signatureDefsrsortedpop) rremove_tensors_idxssubgraphr@rZ left_shift_byrrr?rbr'rr(_remove_tensors_from_modelVsB              rcCsN|tjkrdS|js&t|dd|dSt|jD]\}}t||j||q0dS)zModify model input type.Nrr)rfloat32r%_modify_model_input_type_per_subgraphr subgraphIndex)rinference_input_typesignature_indexrbr'r'r(_modify_model_input_types rc Cs|j|}|j}|j}t|}|rV|sV|jD]$}t||j} | tjkr,t dq,dSg} |D]} | j |vr^| jd|jvr^|| jd|| j d} } t| j}|tjkr||krq^nt d | j t|t| j}|tvrt d | j tddtDt|n4t|}||vrDt d td d|Dt|| | q^t|jt| krntd |tjkr| D]b} || j dj}t}|jdg|_|jdd g|_||| jd_tjj|| jd_q~n|tvrt}| D]} | j d|j|j| jdk<|dkrl|j|}t t|jD]0}|j|j!| jdkr:| j d|j|_!q:|"| jd|#| qt$||nt d t|dS) z%Modify model input type per subgraph.zModel input is not dequantized.NrzvInitial model input type must be tf.float32. Expected type for tensor with name '{}' is tf.float32, instead type is {}zqInitial model input is not quantized. Expected type for tensor with name '{}' should be in {}, instead type is {}css|]}t|VqdSNr+rDtr'r'r( rpz8_modify_model_input_type_per_subgraph..zOUnsupported `inference_input_type` value. Expected to be in {}, instead got {}.css|]}t|VqdSrrrr'r'r(rrpzFor model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.z,Unsupported `inference_input_type` value {}.)%rr@rrr[r)r:rrr$ opcodeIndexrar%r*r+_MAP_QUANT_TO_IO_TYPEStuplekeysr;r1rwarninguint8 quantizationrQuantizationParametersTscale zeroPoint TensorTypeUINT8rrrrrremover)rsubgraph_indexrrrr@rr input_idx input_typeZinput_quant_opsr? float_tensor quant_tensor float_type quant_typeinference_io_typesint8_quantizationuint8_quantizationrrbrr'r'r(rs                rcCsN|tjkrdS|js&t|dd|dSt|jD]\}}t||j||q0dS)zModify model output type.Nrr)rrr&_modify_model_output_type_per_subgraphrr)rinference_output_typerrbr'r'r(_modify_model_output_types r c Cs.|j|}|j}|j}t|}|rV|sV|jD]$}t||j} | tjkr,t dq,dSg} |D]} | j |vr^| jd|jvr^|| j d|| jd} } t| j}|tjkr||krq^nt d | j t|t| j}|tvrt d | j tddtDt|n4t|}||vrDt d td d|Dt|| | q^t|jt| krntd |tjkrfd }t|jD],\}}t|}|tjjkr|}qq|d krt}tjj|_tjj|_ |j|t|jd }| D]h} || _ || j dj!}t"}|j#dg|_#|j$dd g|_$||| jd_!tj%j&|| jd_qn|tvrt'}| D]} | j d|j|j| jdk<|dkr|j(|}t)t|jD]0}|j|j*| jdkr| j d|j|_*q|+| jd|,| qzt-||nt d t|dS)z&Modify model output type per subgraph.z Model output is not dequantized.NrzwInitial model output type must be tf.float32. Expected type for tensor with name '{}' is tf.float32, instead type is {}ztInitial model output is not dequantized. Expected type for tensor with name '{}' should be in {}, instead type is {}css|]}t|VqdSrrrr'r'r(r+rpz9_modify_model_output_type_per_subgraph..zPUnsupported `inference_output_type` value. Expected to be in {}, instead got {}.css|]}t|VqdSrrrr'r'r(r4rpzFor model outputs containing unsupported operations which cannot be quantized, the `inference_output_type` attribute will default to the original type.rrrz-Unsupported `inference_output_type` value {}.).rr@rrrar)r:rrr$rr[r%r*r+rrrr;r1rrrrrr rrrrZ OperatorCodeTZ builtinCodeZdeprecatedBuiltinCoderrrrrrrrrrrrr)rrrr rr@rdequant_opcode_idxsoutput output_typeZoutput_dequant_opsr?rrrrrZquant_opcode_idxrrrZquant_oprrrrbrr'r'r(r s                       r cCs<|jst|dddSt|jD]\}}t||j|q dS)zAFinds back to back quantize ops and remove the first quantize op.rrN)r+_remove_redundant_quantize_ops_per_subgraphrr)rrrbr'r'r(_remove_redundant_quantize_opsls rcCs|j|}|j}|j}t|}t|}g}i} i} |D]} | j|vr|| || jd} || jd} t | j }t | j }|t j kr|t j kr| | | jd<| j|vr6| jd|jvr6| | | jd<q6|D]v} | jd}|| vr| |}|j r*|j d}|jD]$}|j| jdkr| jd|_q| jd|jd<|| q|D]} | jd}|| vrJ| |}| jd|j|j|jdk<|dkr|j |}|jD]$}|j|jdkr| jd|_q|| ||qJdS)z+Remove redundant quantize ops per subgraph.rN)rr@rrrrr;r[rar)r:rrrrr)rrrrr@rrr Z all_quant_opsZredundant_quant_tensorsZoutput_dequant_tensorsr? input_tensor output_tensorrroutput_tensor_idxZ requantize_oprbr Z dequant_opr'r'r(rxsX                rcCsD|tjkr|tjkr|St|}t||t||t|t|S)aModify the input/output type of a tflite model. Args: model: A tflite model. inference_input_type: tf.DType representing modified input type. (default tf.float32. If model input is int8 quantized, it must be in {tf.float32, tf.int8,tf.uint8}, else if model input is int16 quantized, it must be in {tf.float32, tf.int16}, else it must be tf.float32) inference_output_type: tf.DType representing modified output type. (default tf.float32. If model output is int8 dequantized, it must be in {tf.float32, tf.int8,tf.uint8}, else if model output is int16 dequantized, it must be in {tf.float32, tf.int16}, else it must be tf.float32) Returns: A tflite model with modified input/output type. Raises: ValueError: If `inference_input_type`/`inference_output_type` is unsupported or a supported integer type is specified for a model whose input/output is not quantized/dequantized. RuntimeError: If the modification was unsuccessful. )rrrrr rr)rrr rr'r'r(modify_model_io_types   rcCsb|r |jsgSt}|jD]>}|jD]2}|js0q$|jjsH|tjj q$|tjj q$qt |S)zGet sparsity modes used in a tflite model. The sparsity modes are listed in conversion_metadata.fbs file. Args: model_object: A tflite model in object form. Returns: The list of sparsity modes used in the model. ) metadatarrr@sparsityZblockMaprconversion_metadata_fbZModelOptimizationModeZRANDOM_SPARSITYZBLOCK_SPARSITYlist)rresultrr2r'r'r(get_sparsity_modess   rcCsztd}|||t}||_|jss                     + * ('! x   1\l ; ( '