a Sic@s&dZddlZddlZddlZddlZddlZddlZej e d ej ddszddl mZddlmZddlmZn ddlmZddlmZd d ZGd d d eZed dddZGdddeZedejGdddejZejfddZedGdddeZ Gddde Z!dS)zPython TF-Lite interpreter.Ntflite_runtime interpreter)&_pywrap_tensorflow_interpreter_wrapper)metrics) tf_export)metrics_portablecOs ~~ddS)NcSs|SN)xr r ^/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/lite/python/interpreter.py&z_tf_export..r )r kwargsr r r _tf_export$src@s*eZdZdZd ddZddZddZdS) DelegateaPython wrapper class to manage TfLiteDelegate objects. The shared library is expected to have two functions: TfLiteDelegate* tflite_plugin_create_delegate( char**, char**, size_t, void (*report_error)(const char *)) void tflite_plugin_destroy_delegate(TfLiteDelegate*) The first one creates a delegate object. It may return NULL to indicate an error (with a suitable error message reported by calling report_error()). The second one destroys delegate object and must be called for every created delegate object. Passing NULL as argument value is allowed, i.e. tflite_plugin_destroy_delegate(tflite_plugin_create_delegate(...)) always works. Nc Cstdkrtdtj||_ttjttjtj t dtjg|jj _ tj |jj _|pbi}tjt|}tjt|}t|D]0\}\}}t|d||<t|d||<qGdddt}|} t dtj| j} |j ||t|| |_|jdurt| jdS)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-8c@seZdZddZddZdS)z.Delegate.__init__..ErrorMessageCapturecSs d|_dS)N)messageselfr r r __init__dsz7Delegate.__init__..ErrorMessageCapture.__init__cSs&|jt|tr|n|d7_dS)Nr)r isinstancestrdecode)rr r r r reportgsz5Delegate.__init__..ErrorMessageCapture.reportN)__name__ __module__ __qualname__rrr r r r ErrorMessageCapturebsr)platformpython_implementation RuntimeErrorctypespydll LoadLibrary_libraryPOINTERc_char_pc_int CFUNCTYPEZtflite_plugin_create_delegateargtypesc_void_prestypelen enumerateitemsrencodeobjectr _delegate_ptr ValueErrorr) rlibraryoptionsZ options_keysZoptions_valuesidxkeyvaluercaptureZerror_capturer_cbr r r r>s,      zDelegate.__init__cCs0|jdur,tjg|jj_|j|jd|_dSr)r&r#r,Ztflite_plugin_destroy_delegater+r3rr r r __del__rs zDelegate.__del__cCs|jS)zReturns the native TfLiteDelegate pointer. It is not safe to copy this pointer because it needs to be freed. Returns: TfLiteDelegate * )r3rr r r _get_native_delegate_pointerzsz%Delegate._get_native_delegate_pointer)N)rrr__doc__rr;r<r r r r r,s 4rzlite.experimental.load_delegatec CsLzt||}Wn8tyF}z td|t|WYd}~n d}~00|S)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)rr4formatr)r5r6delegateer r r load_delegates(rAc@s2eZdZdZd ddZddZddZd d ZdS) 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. NcCs~|s td|std||_|j|_||_|}||vrDtd|||_|jd|_|jd|_|j |j|_ dS)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) r4 _interpreter_interpreter_wrapperZ_signature_key_get_full_signature_listZ_signature_defr0_outputs_inputsZGetSubgraphIndexFromSignature_subgraph_index)rr signature_keyZsignature_defsr r r rs"  zSignatureRunner.__init__cKst|t|jkr,tdt|jt|f|D]F\}}||jvrRtd||j|j|tj|jtj dd|j q4|j |j |D] \}}|j |j|||j q|j |j i}|jD]\}}|j||j ||<q|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. zXInvalid number of inputs provided for running a SignatureDef, expected %s vs provided %sz(Invalid Input name (%s) for SignatureDefdtypeF)r.rIr4r0rFResizeInputTensornparrayshapeint32rJAllocateTensors SetTensorInvokerH GetTensor)rr input_namer9result output_name output_indexr r r __call__s6   zSignatureRunner.__call__cCs,i}|jD]\}}|j|||<q|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. )rIr0rE_get_tensor_details)rrXrW tensor_indexr r r get_input_detailssz!SignatureRunner.get_input_detailscCs(i}|jD]\}}|j|||<q |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()`. )rHrEr\)rrXrYr]r r r get_output_details'sz"SignatureRunner.get_output_details)NN)rrrr=rr[r^r_r r r r rBs  (rBz lite.experimental.OpResolverTypec@s eZdZdZdZdZdZdZdS)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)rrrr=AUTOBUILTIN BUILTIN_REF!BUILTIN_WITHOUT_DEFAULT_DELEGATESr r r r r`5s r`cCs$tjdtjdtjdtjdi|dS)z-Get a integer identifier for the op resolver.rarbrcN)r`rdrerfrgget)Zop_resolver_typer r r _get_op_resolver_idTsrizlite.Interpreterc@seZdZdZddddejdfddZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZddZddZd/ddZddZddZd d!Zd0d"d#Zd1d%d&Zd'd(Zd)d*Zd+d,Zd-d.ZdS)2 Interpretera6Interpreter interface for running TensorFlow Lite models. Models obtained from `TfLiteConverter` can be run in Python with `Interpreter`. As an example, lets 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 Cst|dsg|_|}|r2|tjks,|tjkr2tj}t|}|durPtd||r|sdd|jD} dd|jD} t ||| | ||_ |j std|n^|r|sdd|jD} d d|jD} ||_ t ||| | ||_ n|s|std ntd |dur= -1. Setting num_threads to 0 has the effect to disable multithreading, which is equivalent to setting num_threads to 1. If set to the value -1, the number of threads used will be implementation-defined and platform-dependent. 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_WITHOUT_DEFAULT_DELEGATES so that no 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. Raises: ValueError: If the interpreter was unable to create. _custom_op_registerersNz+Unrecognized passed in op resolver type: {}cSsg|]}t|tr|qSr rr.0r r r r sz(Interpreter.__init__..cSsg|]}t|ts|qSr rlrmr r r roszFailed to open {}cSsg|]}t|tr|qSr rlrmr r r roscSsg|]}t|ts|qSr rlrmr r r rosz2`model_path` or `model_content` must be specified.z3Can't both provide `model_path` and `model_content`z!type of num_threads should be intraznum_threads should >= 1)hasattrrkr`rdrergrir4r>rFZCreateWrapperFromFilerEZ_model_contentZCreateWrapperFromBufferrintZ SetNumThreads _delegatesZModifyGraphWithDelegater<get_signature_list_signature_defsr TFLiteMetrics_metrics%increase_counter_interpreter_creation) r model_pathZ model_contentZexperimental_delegates num_threadsZexperimental_op_resolver_typeZ!experimental_preserve_all_tensorsZactual_resolver_typeZop_resolver_idcustom_op_registerers_by_namecustom_op_registerers_by_funcr?r r r rsx&         zInterpreter.__init__cCsd|_d|_dSr)rErrrr r r r;szInterpreter.__del__cCs||jSr) _ensure_saferErSrr r r allocate_tensorsszInterpreter.allocate_tensorscCst|jdkS)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. rb)sys getrefcountrErr r r _safe_to_runs zInterpreter._safe_to_runcCs|stddS)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"rr r r r|s zInterpreter._ensure_safecCs>t|}|j|}|j|}|j|}||||d}|S)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 for the inputs and outputs of the op/node. )indexop_namerDrC)rqrEZNodeNameZ NodeInputsZ NodeOutputs)rZop_indexr op_inputs op_outputsdetailsr r r _get_op_details s    zInterpreter._get_op_detailsc Cst|}|j|}|j|}|j|}|j|}|j|}|j|}|j|}|sht d|||||||d|d|dd|d} | S)aGets tensor details. Args: tensor_index: Tensor index of tensor to query. Returns: A dictionary containing the following fields of the tensor: 'name': The tensor name. 'index': The tensor index in the interpreter. 'shape': The shape of the tensor. 'quantization': Deprecated, use 'quantization_parameters'. This field only works for per-tensor quantization, whereas 'quantization_parameters' works 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 detailsrrarb)scales zero_pointsZquantized_dimension)namerrQZshape_signaturerM quantizationZquantization_parametersZsparsity_parameters) rqrEZ TensorNameZ TensorSizeZTensorSizeSignature TensorTypeZTensorQuantizationZTensorQuantizationParametersZTensorSparsityParametersr4) rr] tensor_name tensor_sizeZtensor_size_signature tensor_typeZtensor_quantizationZtensor_quantization_paramsZtensor_sparsity_paramsrr r r r\8s6     zInterpreter._get_tensor_detailscsfddtjDS)zGets op details for every node. Returns: A list of dictionaries containing arrays with lists of tensor ids for tensors involved in the op. csg|]}|qSr )r)rnr7rr r rovsz0Interpreter._get_ops_details..)rangerEZNumNodesrr rr _get_ops_detailsos  zInterpreter._get_ops_detailsc CsDg}t|jD],}z|||Wqty<Yq0q|S)a#Gets tensor details for every tensor with valid tensor details. Tensors where required information about the tensor is not found are not added to the list. This includes temporary tensors without a name. Returns: A list of dictionaries containing tensor information. )rrEZ NumTensorsappendr\r4)rZtensor_detailsr7r r r get_tensor_detailszs  zInterpreter.get_tensor_detailscsfddjDS)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. csg|]}|qSr r\rnirr r rosz1Interpreter.get_input_details..)rEZ InputIndicesrr rr r^s zInterpreter.get_input_detailscCs|j||dS)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)rErT)rr]r9r r r set_tensorszInterpreter.set_tensorcCs,|tj|tjd}|j|||dS)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() ``` rLN)r|rOrPrRrErN)r input_indexrstrictr r r resize_tensor_inputszInterpreter.resize_tensor_inputcsfddjDS)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()`. csg|]}|qSr rrrr r rosz2Interpreter.get_output_details..)rEZ OutputIndicesrr rr r_s zInterpreter.get_output_detailscCsH|j}|D]0\}}t|d|d<t|d|d<q|S)aGets 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 dictionary of inputs and outputs. rDrC)rEGetSignatureDefsr0listkeys)rZfull_signature_defs_ signature_defr r r rss  zInterpreter.get_signature_listcCs |jS)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. )rErrr r r rGsz$Interpreter._get_full_signature_listcCsF|dur:t|jdkr,tdt|jntt|j}t||dS)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 this 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. 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 returns dictionary that maps from output names to numpy values of the computed results. Raises: ValueError: If passed signature_key is invalid. NrazwSignatureDef signature_key is None and model has {0} Signatures. None is only allowed when the model has 1 SignatureDef)rrK)r.rtr4r>nextiterrB)rrKr r r get_signature_runners%z Interpreter.get_signature_runnerrcCs|j||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. )rErV)rr]subgraph_indexr r r get_tensorEszInterpreter.get_tensorcsfddS)alReturns function that gives a numpy view of the current tensor buffer. This allows reading and writing to this tensors w/o copies. This more closely mirrors the C++ Interpreter class interface's tensor() member, hence the name. Be careful to not 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 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. csjjSr)rEtensorr rr]r r r r z$Interpreter.tensor..r rr rr rVs0zInterpreter.tensorcCs||jdS)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)r|rErUrr r r invokes zInterpreter.invokecCs |jSr)rEZResetVariableTensorsrr r r reset_all_variablesszInterpreter.reset_all_variablescCs |jS)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. )rErrr r r _native_handleszInterpreter._native_handle)F)N)r)rrrr=r`rdrr;r}rr|rr\rrr^rrr_rsrGrrrrrrr r r r rjbs8) j  7    / 2rjcs"eZdZdZdfdd ZZS)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. Nc s$|pg|_tt|jfi|dS)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. N)rksuperrr)rZcustom_op_registerersr __class__r r rs z!InterpreterWithCustomOps.__init__)N)rrrr=r __classcell__r r rr rs r)N)"r=r#enumosr r~numpyrOpathsplitext__file__endswithjoinZ*tensorflow.lite.python.interpreter_wrapperrrFtensorflow.lite.python.metricsr tensorflow.python.util.tf_exportrrrrr2rrArBuniqueEnumr`rdrirjrr r r r s>     Y /R