BVhdZddlZddlZddlZddlZddlZddlZddlZejje djejjddsddlmZddlmZddlmZnddlmZddlmZd Zejje djejjd dZd ZGd d ZedddZGddZedej:Gddej<Zej@fdZ!edGddZ"Gdde"Z#y)zPython TF-Lite interpreter.Ntflite_runtime interpreter)&_pywrap_tensorflow_interpreter_wrapper)metrics) tf_export)metrics_portablec ~~dS)Nc|SN)xs R/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/lite/python/interpreter.pyz_tf_export..'sQr )r kwargss r _tf_exportr%s  6 rai_edge_literta Warning: tf.lite.Interpreter is deprecated and is scheduled for deletion in TF 2.20. Please use the LiteRT interpreter from the ai_edge_litert package. See the [migration guide](https://ai.google.dev/edge/litert/migration) for details. c$eZdZdZddZdZdZy)Delegatea(Python wrapper class to manage TfLiteDelegate objects. The shared library is expected to have two functions, tflite_plugin_create_delegate and tflite_plugin_destroy_delegate, which should implement the API specified in tensorflow/lite/delegates/external/external_delegate_interface.h. Ncptjdk7r tdtjj ||_tjtjtjtjtjtjdtjg|j j_ tj|j j_|xsi}tjt|z}tjt|z}t!|j#D]B\}\}}t%|j'd||<t%|j'd||<DGdd}|} tjdtj| j(} |j j||t|| |_|j*t-| j.y)aLoads delegate from the shared library. Args: library: Shared library name. options: Dictionary of options that are required to load the delegate. All keys and values in the dictionary should be serializable. Consult the documentation of the specific delegate for required and legal options. (default None) Raises: RuntimeError: This is raised if the Python implementation is not CPython. CPythonz_Delegates are currently only supported into CPythondue to missing immediate reference counting.Nutf-8ceZdZdZdZy).Delegate.__init__..ErrorMessageCapturecd|_y)N)messageselfs r__init__z7Delegate.__init__..ErrorMessageCapture.__init__hs  rc|xjt|tr |z c_y|jdz c_y)Nr)r isinstancestrdecode)rr s rreportz5Delegate.__init__..ErrorMessageCapture.reportks) Z3/F QXXg5FF rN)__name__ __module__ __qualname__r r%r rrErrorMessageCapturerfs Grr))platformpython_implementation RuntimeErrorctypespydll LoadLibrary_libraryPOINTERc_char_pc_int CFUNCTYPEtflite_plugin_create_delegateargtypesc_void_prestypelen enumerateitemsr#encoder% _delegate_ptr ValueErrorr) rlibraryoptions options_keysoptions_valuesidxkeyvaluer)captureerror_capturer_cbs rr zDelegate.__init__As %%'94 H IILL,,W5DMv'v'v/<DMM//8 ;A//DMM//7mGOOc'l25LooG 47N&w}}77\c5c(//'2l3J--g6nS7GG"#G?((v?ODDnc'l4EGD ! w ''"rc|jWtjg|jj_|jj|j d|_yyr )r0r-r7tflite_plugin_destroy_delegater6r=rs r__del__zDelegate.__del__vsK }} ?E>Odmm22; mm2243E3EFdm!rc|jS)zReturns the native TfLiteDelegate pointer. It is not safe to copy this pointer because it needs to be freed. Returns: TfLiteDelegate * )r=rs r_get_native_delegate_pointerz%Delegate._get_native_delegate_pointer~s   rr )r&r'r(__doc__r rJrLr rrrr8s3(jrrzlite.experimental.load_delegatec  t||}|S#t$r)}tdj|t|d}~wwxYw)acReturns loaded Delegate object. Example usage: ``` import tensorflow as tf try: delegate = tf.lite.experimental.load_delegate('delegate.so') except ValueError: // Fallback to CPU if delegate: interpreter = tf.lite.Interpreter( model_path='model.tflite', experimental_delegates=[delegate]) else: interpreter = tf.lite.Interpreter(model_path='model.tflite') ``` This is typically used to leverage EdgeTPU for running TensorFlow Lite models. For more information see: https://coral.ai/docs/edgetpu/tflite-python/ Args: library: Name of shared library containing the [TfLiteDelegate](https://www.tensorflow.org/lite/performance/delegates). options: Dictionary of options that are required to load the delegate. All keys and values in the dictionary should be convertible to str. Consult the documentation of the specific delegate for required and legal options. (default None) Returns: Delegate object. Raises: ValueError: Delegate failed to load. RuntimeError: If delegate loading is used on unsupported platform. z"Failed to load delegate from {} {}N)rr>formatr#)r?r@delegatees r load_delegaterRsQP)H /  :AAQ s  A$=Ac*eZdZdZddZdZdZdZy)SignatureRunneraJSignatureRunner class for running TFLite models using SignatureDef. This class should be instantiated through TFLite Interpreter only using get_signature_runner method on Interpreter. Example, signature = interpreter.get_signature_runner("my_signature") result = signature(input_1=my_input_1, input_2=my_input_2) print(result["my_output"]) print(result["my_second_output"]) All names used are this specific SignatureDef names. Notes: No other function on this object or on the interpreter provided should be called while this object call has not finished. Nc|s td|s td||_|j|_||_|j }||vr td|||_|j dj |_|j d|_|jj|j|_ y)zConstructor. Args: interpreter: Interpreter object that is already initialized with the requested model. signature_key: SignatureDef key to be used. zNone interpreter provided.zNone signature_key provided.zInvalid signature_key provided.outputsinputsN) r> _interpreter_interpreter_wrapper_signature_key_get_full_signature_list_signature_defr;_outputs_inputsGetSubgraphIndexFromSignature_subgraph_index)rr signature_keysignature_defss rr zSignatureRunner.__init__s  3 44  5 66#D + 8 8D'D 99;NN* 8 99(7D'' 288:DM&&x0DL !!??    ! rc xt|t|jk7r-tdt|jdt||jD]\}}||jvrtd|z|jj |j|t j|jt jd|j|jj|j|jD]9\}}|jj|j|||j;|jj|ji}|jD].\}}|jj||j||<0|S)aqRuns the SignatureDef given the provided inputs in arguments. Args: **kwargs: key,value for inputs to the model. Key is the SignatureDef input name. Value is numpy array with the value. Returns: dictionary of the results from the model invoke. Key in the dictionary is SignatureDef output name. Value is the result Tensor. zGInvalid number of inputs provided for running a SignatureDef, expected z vs provided z(Invalid Input name (%s) for SignatureDefdtypeF)r9r^r>r;rYResizeInputTensornparrayshapeint32r`AllocateTensors SetTensorInvoker] GetTensor)rr input_namerEresult output_name output_indexs r__call__zSignatureRunner.__call__s 6{c$,,'' *-dll*;S[ J KK $\\^' E 4<< 'C#$% % 11 ,,z "BHHU[[$I %%' ' --d.B.BC#\\^@ E ))$,,z*BE*.*>*>@@ $$T%9%9: F%)]].! \ 55?? ,,.f[. Mrci}|jjD].\}}|jj||j||<0|S)a Gets input tensor details. Returns: A dictionary from input name to tensor details where each item is a dictionary with details about an input tensor. Each dictionary contains the following fields that describe the tensor: + `name`: The tensor name. + `index`: The tensor index in the interpreter. + `shape`: The shape of the tensor. + `shape_signature`: Same as `shape` for models with known/fixed shapes. If any dimension sizes are unknown, they are indicated with `-1`. + `dtype`: The numpy data type (such as `np.int32` or `np.uint8`). + `quantization`: Deprecated, use `quantization_parameters`. This field only works for per-tensor quantization, whereas `quantization_parameters` works in all cases. + `quantization_parameters`: A dictionary of parameters used to quantize the tensor: ~ `scales`: List of scales (one if per-tensor quantization). ~ `zero_points`: List of zero_points (one if per-tensor quantization). ~ `quantized_dimension`: Specifies the dimension of per-axis quantization, in the case of multiple scales/zero_points. + `sparsity_parameters`: A dictionary of parameters used to encode a sparse tensor. This is empty if the tensor is dense. )r^r;rX_get_tensor_detailsr`)rrpro tensor_indexs rget_input_detailsz!SignatureRunner.get_input_details sW4F$(LL$6$6$8. L,,@@ ,,.fZ. Mrci}|jD].\}}|jj||j||<0|S)aGets output tensor details. Returns: A dictionary from input name to tensor details where each item is a dictionary with details about an output tensor. The dictionary contains the same fields as described for `get_input_details()`. )r]rXrur`)rrprqrvs rget_output_detailsz"SignatureRunner.get_output_details,sNF%)]].! \ --AA ,,.f[. Mr)NN)r&r'r(rMr rsrwryr rrrTrTs "4&P@ rrTz lite.experimental.OpResolverTypec eZdZdZdZdZdZdZy)OpResolverTypea Different types of op resolvers for Tensorflow Lite. * `AUTO`: Indicates the op resolver that is chosen by default in TfLite Python, which is the "BUILTIN" as described below. * `BUILTIN`: Indicates the op resolver for built-in ops with optimized kernel implementation. * `BUILTIN_REF`: Indicates the op resolver for built-in ops with reference kernel implementation. It's generally used for testing and debugging. * `BUILTIN_WITHOUT_DEFAULT_DELEGATES`: Indicates the op resolver for built-in ops with optimized kernel implementation, but it will disable the application of default TfLite delegates (like the XNNPACK delegate) to the model graph. Generally this should not be used unless there are issues with the default configuration. rN)r&r'r(rMAUTOBUILTIN BUILTIN_REF!BUILTIN_WITHOUT_DEFAULT_DELEGATESr rrr{r{;s$  $ '+'(#rr{ctjdtjdtjdtjdij |dS)z-Get a integer identifier for the op resolver.r|r}r~N)r{rrrrget)op_resolver_types r_get_op_resolver_idrZsI1a  !66   C$  rzlite.InterpreterceZdZdZddddej dddfdZdZdZdZ dZ d Z d Z d Z d Zdd ZdZdZddZdZdZdZddZddZdZdZdZdZy) Interpretera7Interpreter interface for running TensorFlow Lite models. Models obtained from `TfLiteConverter` can be run in Python with `Interpreter`. As an example, let's generate a simple Keras model and convert it to TFLite (`TfLiteConverter` also supports other input formats with `from_saved_model` and `from_concrete_function`) >>> x = np.array([[1.], [2.]]) >>> y = np.array([[2.], [4.]]) >>> model = tf.keras.models.Sequential([ ... tf.keras.layers.Dropout(0.2), ... tf.keras.layers.Dense(units=1, input_shape=[1]) ... ]) >>> model.compile(optimizer='sgd', loss='mean_squared_error') >>> model.fit(x, y, epochs=1) >>> converter = tf.lite.TFLiteConverter.from_keras_model(model) >>> tflite_model = converter.convert() `tflite_model` can be saved to a file and loaded later, or directly into the `Interpreter`. Since TensorFlow Lite pre-plans tensor allocations to optimize inference, the user needs to call `allocate_tensors()` before any inference. >>> interpreter = tf.lite.Interpreter(model_content=tflite_model) >>> interpreter.allocate_tensors() # Needed before execution! Sample execution: >>> output = interpreter.get_output_details()[0] # Model has single output. >>> input = interpreter.get_input_details()[0] # Model has single input. >>> input_data = tf.constant(1., shape=[1, 1]) >>> interpreter.set_tensor(input['index'], input_data) >>> interpreter.invoke() >>> interpreter.get_tensor(output['index']).shape (1, 1) Use `get_signature_runner()` for a more user-friendly inference API. NFc tstjtt |dsg|_|} |r;|t jk(s|t jk(rtjdt| } | tdj||+t|ts td|dkr td|r|s|j D cgc]} t| ts| } } |j D cgc]} t| tr| } } tj || | | ||t|xsd||_|j"stdj||r|s|j D cgc]} t| ts| } } |j D cgc]} t| tr| } } ||_tj&|| | | ||t|xsd||_n|s |s td td g|_|rA||_|j(D]+}|j"j+|j--|j/|_t3j4|_|j6j9ycc} wcc} wcc} wcc} w) a Constructor. Args: model_path: Path to TF-Lite Flatbuffer file. model_content: Content of model. experimental_delegates: Experimental. Subject to change. List of [TfLiteDelegate](https://www.tensorflow.org/lite/performance/delegates) objects returned by lite.load_delegate(). num_threads: Sets the number of threads used by the interpreter and available to CPU kernels. If not set, the interpreter will use an implementation-dependent default number of threads. Currently, only a subset of kernels, such as conv, support multi-threading. num_threads should be >= 1. experimental_op_resolver_type: The op resolver used by the interpreter. It must be an instance of OpResolverType. By default, we use the built-in op resolver which corresponds to tflite::ops::builtin::BuiltinOpResolver in C++. experimental_preserve_all_tensors: If true, then intermediate tensors used during computation are preserved for inspection, and if the passed op resolver type is AUTO or BUILTIN, the type will be changed to BUILTIN so that Tensorflow Lite default delegates are applied. If false, getting intermediate tensors could result in undefined values or None, especially when the graph is successfully modified by the Tensorflow Lite default delegate. experimental_disable_delegate_clustering: If true, don't perform delegate clustering during delegate graph partitioning phase. Disabling delegate clustering will make the execution order of ops respect the explicitly-inserted control dependencies in the graph (inserted via `with tf.control_dependencies()`) since the TF Lite converter will drop control dependencies by default. Most users shouldn't turn this flag to True if they don't insert explicit control dependencies or the graph execution order is expected. For automatically inserted control dependencies (with `tf.Variable`, `tf.Print` etc), the user doesn't need to turn this flag to True since they are respected by default. Note that this flag is currently experimental, and it might be removed/updated if the TF Lite converter doesn't drop such control dependencies in the model. Default is False. experimental_default_delegate_latest_features: If true, default delegates may enable all flag protected features. Default is False; Raises: ValueError: If the interpreter was unable to create. _custom_op_registerersaCWarning: Enabling `experimental_preserve_all_tensors` with the BUILTIN or AUTO op resolver is intended for debugging purposes only. Be aware that this can significantly increase memory usage by storing all intermediate tensors. If you encounter memory problems or are not actively debugging, consider disabling this option.Nz+Unrecognized passed in op resolver type: {}z!type of num_threads should be intr|znum_threads should >= 1zFailed to open {}z2`model_path` or `model_content` must be specified.z3Can't both provide `model_path` and `model_content`)_IS_LITERT_PACKAGEwarningswarn_INTERPRETER_DELETION_WARNINGhasattrrr{rrrr>rOr"intr#rYCreateWrapperFromFilerX_model_contentCreateWrapperFromBuffer _delegatesModifyGraphWithDelegaterLget_signature_list_signature_defsr TFLiteMetrics_metrics%increase_counter_interpreter_creation)r model_path model_contentexperimental_delegates num_threadsexperimental_op_resolver_type!experimental_preserve_all_tensors(experimental_disable_delegate_clustering-experimental_default_delegate_latest_featuresactual_resolver_typeop_resolver_idr custom_op_registerers_by_namecustom_op_registerers_by_funcrPs rr zInterpreter.__init__sl mm12 41 2$&d!8(%)<)<<%)?)??mm L))=>N DKK ') **  S )<== q233-00'Jq#4F!'#'00' 1c8J!'#'/DD   ' ' + 2 kQ  7 d  ,33J?@@ z00'Jq#4F!'#'00' 1c8J!'#' *d.FF   ' ' + 2 kQ  7 d: K LL M NN DO.dooo5( 11  1 1 3 55 224D))+DMMM779s'' ''s0J-.J-J2J2J7J7.J<J<c d|_d|_yr )rXrrs rrJzInterpreter.__del__s DDOrcV|j|jjSr ) _ensure_saferXrkrs rallocate_tensorszInterpreter.allocate_tensors(s#    , , ..rcFtj|jdk(S)zReturns true if there exist no numpy array buffers. This means it is safe to run tflite calls that may destroy internally allocated memory. This works, because in the wrapper.cc we have made the numpy base be the self._interpreter. r})sys getrefcountrXrs r _safe_to_runzInterpreter._safe_to_run,s ??4,, - 22rc:|js tdy)aBMakes sure no numpy arrays pointing to internal buffers are active. This should be called from any function that will call a function on _interpreter that may reallocate memory e.g. invoke(), ... Raises: RuntimeError: If there exist numpy objects pointing to internal memory then we throw. zThere is at least 1 reference to internal data in the interpreter in the form of a numpy array or slice. Be sure to only hold the function returned from tensor() if you are using raw data access.N)rr,rs rrzInterpreter._ensure_safe8s'       rc|jj|Dcgc]}|dk7r|j|dd}}|jj|Dcgc]}|dk7r|j|dd}}t ||jj ||jj||jj|||d}|Scc}wcc}w)a-Gets a dictionary with arrays of ids for tensors involved with an op. Args: op_index: Operation/node index of node to query. Returns: a dictionary containing the index, op name, and arrays with lists of the indices and types for the inputs and outputs of the op/nodes. rsubgraph_indexre)indexop_namerWrV operand_types result_types)rX NodeInputsru NodeOutputsrNodeName)rop_index tensor_idxrrdetailss r_get_op_detailszInterpreter._get_op_detailsIs++66x@      A >wGM++77A      A >wGL X$$--h7##..x8$$00:&$ G N% s "C""C'c t|}t|}|jj||}|jj||}|jj ||}|jj ||}|jj ||}|jj||}|jj||} |s td|||||||d|d|dd| d} | S)aGets tensor details. Args: tensor_index: Tensor index of tensor to query. subgraph_index: Index of the subgraph. Returns: A dictionary containing the following fields of the tensor: 'name': The tensor name. 'index': The tensor index in the subgraph. 'shape': The shape of the tensor. 'quantization': Deprecated, use 'quantization_parameters'. This field only works for per-tensor quantization, whereas 'quantization_parameters' work in all cases. 'quantization_parameters': The parameters used to quantize the tensor: 'scales': List of scales (one if per-tensor quantization) 'zero_points': List of zero_points (one if per-tensor quantization) 'quantized_dimension': Specifies the dimension of per-axis quantization, in the case of multiple scales/zero_points. Raises: ValueError: If tensor_index is invalid. zCould not get tensor detailsrr|r})scales zero_pointsquantized_dimension)namerrishape_signaturere quantizationquantization_parameterssparsity_parameters) rrX TensorName TensorSizeTensorSizeSignature TensorTypeTensorQuantizationTensorQuantizationParametersTensorSparsityParametersr>) rrvr tensor_name tensor_sizetensor_size_signature tensor_typetensor_quantizationtensor_quantization_paramstensor_sparsity_paramsrs rruzInterpreter._get_tensor_detailsgs%0|$L(N##..|^LK##..|^LK --AAn&##..|^LK++>>n&!%!2!2!O!On"&!..GGn&  5 660+035a8#=a#@$ 6 G Nrct|jjDcgc]}|j|c}Scc}w)zGets op details for every node. Returns: A list of dictionaries containing arrays with lists of tensor ids for tensors involved in the op. )rangerXNumNodesr)rrCs r_get_ops_detailszInterpreter._get_ops_detailss@.343D3D3M3M3O-P &)S!  sAc6|jjS)z-Returns the number of subgraphs in the model.)rX NumSubgraphsrs r num_subgraphszInterpreter.num_subgraphss    ) ) ++rc*g}|jj}|dks||k\rtd|d|dt|jj |D]$} |j |j ||&|S#t$rY4wxYw)aGets tensor details for every tensor with valid tensor details from a subgraph. Tensors where required information about the tensor is not found are not added to the list. This includes temporary tensors without a name. Args: subgraph_index: Index of the subgraph to fetch the tensor. Returns: A list of dictionaries containing tensor information. rz subgraph_index is out of range: z for the model, which has z subgraphs.)rXrr>r NumTensorsappendru)rrtensor_detailsrrCs rget_tensor_detailszInterpreter.get_tensor_detailssN%%224M^}<  ,^,<=%k 3  T&&11.AB  d66sNKL    s!!B BBc~|jjDcgc]}|j|dc}Scc}w)aGets model input tensor details. Returns: A list in which each item is a dictionary with details about an input tensor. Each dictionary contains the following fields that describe the tensor: + `name`: The tensor name. + `index`: The tensor index in the interpreter. + `shape`: The shape of the tensor. + `shape_signature`: Same as `shape` for models with known/fixed shapes. If any dimension sizes are unknown, they are indicated with `-1`. + `dtype`: The numpy data type (such as `np.int32` or `np.uint8`). + `quantization`: Deprecated, use `quantization_parameters`. This field only works for per-tensor quantization, whereas `quantization_parameters` works in all cases. + `quantization_parameters`: A dictionary of parameters used to quantize the tensor: ~ `scales`: List of scales (one if per-tensor quantization). ~ `zero_points`: List of zero_points (one if per-tensor quantization). ~ `quantized_dimension`: Specifies the dimension of per-axis quantization, in the case of multiple scales/zero_points. + `sparsity_parameters`: A dictionary of parameters used to encode a sparse tensor. This is empty if the tensor is dense. rr)rX InputIndicesruris rrwzInterpreter.get_input_detailssC8""//1     1 5  :c<|jj||y)aSets the value of the input tensor. Note this copies data in `value`. If you want to avoid copying, you can use the `tensor()` function to get a numpy buffer pointing to the input buffer in the tflite interpreter. Args: tensor_index: Tensor index of tensor to set. This value can be gotten from the 'index' field in get_input_details. value: Value of tensor to set. Raises: ValueError: If the interpreter could not set the tensor. N)rXrl)rrvrEs r set_tensorzInterpreter.set_tensors   e4rc|jtj|tj}|jj |||y)aResizes an input tensor. Args: input_index: Tensor index of input to set. This value can be gotten from the 'index' field in get_input_details. tensor_size: The tensor_shape to resize the input to. strict: Only unknown dimensions can be resized when `strict` is True. Unknown dimensions are indicated as `-1` in the `shape_signature` attribute of a given tensor. (default False) Raises: ValueError: If the interpreter could not resize the input tensor. Usage: ``` interpreter = Interpreter(model_content=tflite_model) interpreter.resize_tensor_input(0, [num_test_images, 224, 224, 3]) interpreter.allocate_tensors() interpreter.set_tensor(0, test_images) interpreter.invoke() ``` rdN)rrgrhrjrXrf)r input_indexrstricts rresize_tensor_inputzInterpreter.resize_tensor_inputs>. ((;bhh7K'' [&Irc~|jjDcgc]}|j|dc}Scc}w)zGets model output tensor details. Returns: A list in which each item is a dictionary with details about an output tensor. The dictionary contains the same fields as described for `get_input_details()`. rr)rX OutputIndicesrurs rryzInterpreter.get_output_detailssC""002     1 5  rc|jj}|jD]C\}}t|dj |d<t|dj |d<E|S)aGets the list of SignatureDefs in the model. Example, ``` signatures = interpreter.get_signature_list() print(signatures) # { # 'add': {'inputs': ['x', 'y'], 'outputs': ['output_0']} # } Then using the names in the signature list you can get a callable from get_signature_runner(). ``` Returns: A list of SignatureDef details in a dictionary structure. It is keyed on the SignatureDef method name, and the value holds a dictionary of inputs and outputs. rWrV)rXGetSignatureDefsr;listkeys)rfull_signature_defs_ signature_defs rrzInterpreter.get_signature_list(sz*++<<>/557G= $]8%<%A%A%C DmH!%mI&>&C&C&E!FmIG rc6|jjS)aGets list of SignatureDefs in the model. Example, ``` signatures = interpreter._get_full_signature_list() print(signatures) # { # 'add': {'inputs': {'x': 1, 'y': 0}, 'outputs': {'output_0': 4}} # } Then using the names in the signature list you can get a callable from get_signature_runner(). ``` Returns: A list of SignatureDef details in a dictionary structure. It is keyed on the SignatureDef method name, and the value holds dictionary of inputs and outputs. )rXrrs rr[z$Interpreter._get_full_signature_listCs*    - - //rc|ct|jdk7r-tdjt|jt t |j}t ||S)aGets callable for inference of specific SignatureDef. Example usage, ``` interpreter = tf.lite.Interpreter(model_content=tflite_model) interpreter.allocate_tensors() fn = interpreter.get_signature_runner('div_with_remainder') output = fn(x=np.array([3]), y=np.array([2])) print(output) # { # 'quotient': array([1.], dtype=float32) # 'remainder': array([1.], dtype=float32) # } ``` None can be passed for signature_key if the model has a single Signature only. All names used are these specific SignatureDef names. Args: signature_key: Signature key for the SignatureDef, it can be None if and only if the model has a single SignatureDef. The Default value is None. Returns: This returns a callable that can run inference for SignatureDef defined by argument 'signature_key'. The callable will take key arguments corresponding to the arguments of the SignatureDef, that should have numpy values. The callable will return dictionary that maps from output names to numpy values of the computed results. Raises: ValueError: If passed signature_key is invalid. r|zwSignatureDef signature_key is None and model has {0} Signatures. None is only allowed when the model has 1 SignatureDef)rra)r9rr>rOnextiterrT)rras rget_signature_runnerz Interpreter.get_signature_runnerZsnJ T ! ! "a ' EEKVD(()F+, , T$"6"678 t= IIrc:|jj||S)aGets the value of the output tensor (get a copy). If you wish to avoid the copy, use `tensor()`. This function cannot be used to read intermediate results. Args: tensor_index: Tensor index of tensor to get. This value can be gotten from the 'index' field in get_output_details. subgraph_index: Index of the subgraph to fetch the tensor. Default value is 0, which means to fetch from the primary subgraph. Returns: a numpy array. )rXrn)rrvrs r get_tensorzInterpreter.get_tensors    & &|^ DDrcfdS)ajReturns function that gives a numpy view of the current tensor buffer. This allows reading and writing to these tensors w/o copies. This more closely mirrors the C++ Interpreter class interface's tensor() member, hence the name. Be careful not to hold these output references through calls to `allocate_tensors()` and `invoke()`. This function cannot be used to read intermediate results. Usage: ``` interpreter.allocate_tensors() input = interpreter.tensor(interpreter.get_input_details()[0]["index"]) output = interpreter.tensor(interpreter.get_output_details()[0]["index"]) for i in range(10): input().fill(3.) interpreter.invoke() print("inference %s" % output()) ``` Notice how this function avoids making a numpy array directly. This is because it is important to not hold actual numpy views to the data longer than necessary. If you do, then the interpreter can no longer be invoked, because it is possible the interpreter would resize and invalidate the referenced tensors. The NumPy API doesn't allow any mutability of the underlying buffers. WRONG: ``` input = interpreter.tensor(interpreter.get_input_details()[0]["index"])() output = interpreter.tensor(interpreter.get_output_details()[0]["index"])() interpreter.allocate_tensors() # This will throw RuntimeError for i in range(10): input.fill(3.) interpreter.invoke() # this will throw RuntimeError since input, output ``` Args: tensor_index: Tensor index of tensor to get. This value can be gotten from the 'index' field in get_output_details. Returns: A function that can return a new numpy array pointing to the internal TFLite tensor state at any point. It is safe to hold the function forever, but it is not safe to hold the numpy array forever. cPjjjSr )rXtensorrrvsrrz$Interpreter.tensor..s 4$$++D,=,=|Lrr rs``rrzInterpreter.tensors ` MLrcX|j|jjy)aInvoke the interpreter. Be sure to set the input sizes, allocate tensors and fill values before calling this. Also, note that this function releases the GIL so heavy computation can be done in the background while the Python interpreter continues. No other function on this object should be called while the invoke() call has not finished. Raises: ValueError: When the underlying interpreter fails raise ValueError. N)rrXrmrs rinvokezInterpreter.invokes" rc6|jjSr )rXResetVariableTensorsrs rreset_all_variableszInterpreter.reset_all_variabless    1 1 33rc6|jjS)a}Returns a pointer to the underlying tflite::Interpreter instance. This allows extending tflite.Interpreter's functionality in a custom C++ function. Consider how that may work in a custom pybind wrapper: m.def("SomeNewFeature", ([](py::object handle) { auto* interpreter = reinterpret_cast(handle.cast()); ... })) and corresponding Python call: SomeNewFeature(interpreter.native_handle()) Note: This approach is fragile. Users must guarantee the C++ extension build is consistent with the tflite.Interpreter's underlying C++ build. )rXrrs r_native_handlezInterpreter._native_handles&    ( ( **r)r)Fr )r&r'r(rMr{rr rJrrrrrurrrrwrrryrr[rrrrrrr rrrrhs&T!$2$7$7(-/449K:Z/ 3"<8v ,8>5$J: 60.-J^E"0Md 4+rrc$eZdZdZdfd ZxZS)InterpreterWithCustomOpsarInterpreter interface for TensorFlow Lite Models that accepts custom ops. The interface provided by this class is experimental and therefore not exposed as part of the public API. Wraps the tf.lite.Interpreter class and adds the ability to load custom ops by providing the names of functions that take a pointer to a BuiltinOpResolver and add a custom op. c B|xsg|_tt|di|y)aConstructor. Args: custom_op_registerers: List of str (symbol names) or functions that take a pointer to a MutableOpResolver and register a custom op. When passing functions, use a pybind function that takes a uintptr_t that can be recast as a pointer to a MutableOpResolver. **kwargs: Additional arguments passed to Interpreter. Raises: ValueError: If the interpreter was unable to create. Nr )rsuperr r )rcustom_op_registerersr __class__s rr z!InterpreterWithCustomOps.__init__s%#8"=2D "D2rsW"   ww!!$--GGLL!=13x4F\8WW%%h/2;;GGLL!=1!NNb -.,/,^D ./(TYY( 0(:*8)<)<   I +I + I +X={=r