gwddlmZddlZddlZddlZddlZddlZddlmZmZddl m Z ejrddl Z ddZGddZ ddZGd d ZGd d eZGd dZGddZGddZGddZy)) annotationsN)AnySequence) _pybind_statec|dk(rtjjS|dk(rtjjS|dk(rtjj S|dk(rtjj S|dk(r#tj |jStd|z)NcudacanncpudmlortzUnsupported device type: ) C OrtDevicerr r r get_ort_device device_type Exception)r device_indexs f/var/www/openai/venv/lib/python3.12/site-packages/onnxruntime/capi/onnxruntime_inference_collection.pyget_ort_device_typersf{{!!  {{!!  {{   {{    -99;;3kABBcfeZdZdZd ddZeddZddZdZddZ dZ dd Z d Z dd Z dd Zy) AdapterFormatzK This class is used to create adapter files from python structures NcJ|tj|_y||_yN)r r_adapter)selfadapters r__init__zAdapterFormat.__init__(s ?OO-DM#DMrcRttjj|Sr)rr read_adapter) file_paths rrzAdapterFormat.read_adapter.sQ__99)DEErc:|jj|y)z This function writes a file at the specified location in onnxrunitme adapter format containing Lora parameters. :param file_path: absolute path for the adapter N)rexport_adapter)rr s rr"zAdapterFormat.export_adapter2s $$Y/rc.|jjSr)rformat_versionrs rget_format_versionz AdapterFormat.get_format_version;s}}+++rc&||j_yrradapter_version)rr)s rset_adapter_versionz!AdapterFormat.set_adapter_version>s(7 %rc.|jjSrr(r%s rget_adapter_versionz!AdapterFormat.get_adapter_versionAs}},,,rc&||j_yrr model_version)rr/s rset_model_versionzAdapterFormat.set_model_versionDs&3 #rc.|jjSrr.r%s rget_model_versionzAdapterFormat.get_model_versionGs}}***rc|jDcic]\}}||jc}}|j_ycc}}wr)items _ortvaluer parameters)rparamskvs rset_parameterszAdapterFormat.set_parametersJs2?E||~#N~tq!Aq{{N~#N  #Ns?c|jjjDcic]\}}|t|c}}Scc}}wr)rr6r4OrtValue)rr8r9s rget_parameterszAdapterFormat.get_parametersMs;+/==+C+C+I+I+KL+K41a8A;+KLLLsAr)returnNone)r os.PathLiker>r)r r@)r)int)r/rA)r7dict[str, OrtValue])r>rB)__name__ __module__ __qualname____doc__r staticmethodrr"r&r*r,r0r2r:r=rrrr#sL$ FF0,8-4+OMrrc |ggfStjfd}t|tjjs t d|t|tjjs t dt |t |k7r t dt|Dcgc]}t|tc}s t dt|Dcgc]}t|tc}s t dt||D]\}}|||n|D]}t|tr||t%t|trDt |dk(r6t|dtr#t|d tr||d|d yt d tjtjfScc}wcc}w) a Validates the 'providers' and 'provider_options' arguments and returns a normalized version. :param providers: Optional sequence of providers in order of decreasing precedence. Values can either be provider names or tuples of (provider name, options dict). :param provider_options: Optional sequence of options dicts corresponding to the providers listed in 'providers'. :param available_provider_names: The available provider names. :return: Tuple of (normalized 'providers' sequence, normalized 'provider_options' sequence). 'providers' can contain either names or names and options. When any options are given in 'providers', 'provider_options' should not be used. The normalized result is a tuple of: 1. Sequence of provider names in the same order as 'providers'. 2. Sequence of corresponding provider options dicts with string keys and values. Unspecified provider options yield empty dicts. c2|vr4tjdj|dj|vrtjd|dy|j Dcic]\}}t |t |}}}||<ycc}}w)NzTSpecified provider '{}' is not in available provider names.Available providers: '{}'z, zDuplicate provider 'z' encountered, ignoring.)warningswarnformatjoinr4str)nameoptionskeyvaluenormalized_optionsavailable_provider_namesprovider_name_to_optionss rset_provider_optionsz?check_and_normalize_provider_args..set_provider_optionsqs / / MM,,2F4C[9\,]  + + MM06NO P EL]]_U_zsEc#hE 2_U); &Vs+Bz!'providers' should be a sequence.z('provider_options' should be a sequence.zO'providers' and 'provider_options' should be the same length if both are given.zPOnly string values for 'providers' are supported if 'provider_options' is given.z('provider_options' values must be dicts.rzC'providers' values must be either strings or (string, dict) tuples.) collections OrderedDict isinstanceabcr ValueErrorlenallrOdictziptuplelistkeysvalues) providersprovider_optionsrUrWprovideroptions_for_providerrPrQrVs ` @r!check_and_normalize_provider_argsrkQs62v *668 < i!9!9 :<==#*KOO,D,DEGH H y>S!12 2no oiHi(Jx-iHIop pWghWg?SJ3T:WghiGH H ,<=MD' w />"H(C($Xtv68U+MQ&x{C0x{D1$Xa[(1+> !fgg" (--/ 0$7O7V7V7X2Y YY/Iis .G  G%ceZdZdZdZdZdZdZdZdZ dZ d Z dd Z d Z d ZdZddZddZddZdZdZdZddZdZdddZdZy )Session5 This is the main class used to run a model. c d|_d|_y)NT)_sess_enable_fallbackr%s rrzSession.__init__s $rc|jS)zDReturn the session options. See :class:`onnxruntime.SessionOptions`.) _sess_optionsr%s rget_session_optionszSession.get_session_options!!!rc|jS)zEReturn the inputs metadata as a list of :class:`onnxruntime.NodeArg`.) _inputs_metar%s r get_inputszSession.get_inputss   rc|jS)zFReturn the outputs metadata as a list of :class:`onnxruntime.NodeArg`.) _outputs_metar%s r get_outputszSession.get_outputsrurc|jS)z^Return the inputs (including initializers) metadata as a list of :class:`onnxruntime.NodeArg`.)_overridable_initializersr%s rget_overridable_initializersz$Session.get_overridable_initializerss---rc|jS)z>, KH HJxx $$ 3'0ABC()A)A(B.QR""4#;#;<%%'zz~~lJ LL  s*A,A11DBD DDDc|jt|j|s#|jDcgc]}|j}}|j j |||||Scc}w)a Compute the predictions asynchronously in a separate cxx thread from ort intra-op threadpool. :param output_names: name of the outputs :param input_feed: dictionary ``{ input_name: input_value }`` :param callback: python function that accept array of results, and a status string on error. The callback will be invoked by a cxx thread from ort intra-op threadpool. :param run_options: See :class:`onnxruntime.RunOptions`. :: class MyData: def __init__(self): # ... def save_results(self, results): # ... def callback(results: np.ndarray, user_data: MyData, err: str) -> None: if err: print (err) else: # save results to user_data sess.run_async([output_name], {input_name: x}, callback) )rrdrerzrPrp run_async)rrrcallback user_datarrs rrzSession.run_asyncse2 T*//"3456:6H6HI6HFFKK6HLIzz##L*h S^__JsA-cd}|jt|j|s#|jDcgc]}|j}} ||j |||Scc}w#t j$r}|jrytd|d|jtd|jd|j|j|j||j |||cYd}~Sd}~wwxYw)a Compute the predictions. :param output_names: name of the outputs :param input_dict_ort_values: dictionary ``{ input_name: input_ort_value }`` See ``OrtValue`` class how to create `OrtValue` from numpy array or `SparseTensor` :param run_options: See :class:`onnxruntime.RunOptions`. :return: an array of `OrtValue` :: sess.run([output_name], {input_name: x}) c i}|jD]\}}|j||<|j|||}t|tj s t d|Dcgc] }t|}}|Scc}w)NzFrun_with_ort_values() must return a instance of type 'OrtValueVector'.)r4 _get_c_valuerun_with_ort_valuesr\r OrtValueVector TypeErrorr<) sessrinput_dict_ort_valuesr input_dictnr9result ort_valuess rinvokez+Session.run_with_ort_values..invokeCsJ-3351 ! 0 1 6--j, TFfa&6&67 hii/56v!(1+vJ6 7s*BrrrrN)rrdrerzrPrpr rrqrrrrr)rrrrrrrs rrzSession.run_with_ort_values3s   T"7"<"<">?@6:6H6HI6HFFKK6HLI $**l4I;W WJxx $$ 3'0ABC()A)A(B.QR""4#;#;<%%'djj,8M{[[  s*A'A,,D ?A?D>D DD c6|jjS)z End profiling and return results in a file. The results are stored in a filename if the option :meth:`onnxruntime.SessionOptions.enable_profiling`. )rp end_profilingr%s rrzSession.end_profiling\szz''))rc.|jjS)a Return the nanoseconds of profiling's start time Comparable to time.monotonic_ns() after Python 3.3 On some platforms, this timer may not be as precise as nanoseconds For instance, on Windows and MacOS, the precision will be ~100ns )rpget_profiling_start_time_nsr%s rrz#Session.get_profiling_start_time_nseszz555rct|S)z(Return an onnxruntime.IOBinding object`.) IOBindingr%s r io_bindingzSession.io_bindingns rcP|jj|j|y)z Compute the predictions. :param iobinding: the iobinding object that has graph inputs/outputs bind. :param run_options: See :class:`onnxruntime.RunOptions`. N)rprun_with_iobinding _iobinding)r iobindingrs rrzSession.run_with_iobindingrs %%i&:&:KHrc6|jjSr)rpget_tuning_resultsr%s rrzSession.get_tuning_results{szz,,..rF)error_on_invalidc:|jj||Sr)rpset_tuning_results)rresultsrs rrzSession.set_tuning_results~szz,,W6FGGrcD|jj||||||y)a Compute the predictions similar to other run_*() methods but with minimal C++/Python conversion overhead. :param run_options: See :class:`onnxruntime.RunOptions`. :param feed_names: list of input names. :param feeds: list of input OrtValue. :param fetch_names: list of output names. :param fetches: list of output OrtValue. :param fetch_devices: list of output devices. N)rprun_with_ortvaluevector)rr feed_namesfeeds fetch_namesfetches fetch_devicess rrzSession.run_with_ortvaluevectors" **; E;X_anor)NNr)rCrDrErFrrtrxr{r~rrrrrrrrrrrrrrrrrrHrrrmrms% "!". &9,& %:`<'R*6I/?DH prrmcReZdZdZ d dfd ZddZdZdZxZS) InferenceSessionrnc bt |t|ttj fr"t j ||_d|_n7t|trd|_||_ntdt|d||_ ||_ d|_d|vrt|ddk(|_n'tj"j%ddk(|_|j%d } |j'|||y#t(t*f$r}|jr t-d t-d |d |t-d |j.dt-d|j'|j.d|j1Yd}~y#t2$r}||d}~wwxYw|d}~wwxYw)a :param path_or_bytes: Filename or serialized ONNX or ORT format model in a byte string. :param sess_options: Session options. :param providers: Optional sequence of providers in order of decreasing precedence. Values can either be provider names or tuples of (provider name, options dict). If not provided, then all available providers are used with the default precedence. :param provider_options: Optional sequence of options dicts corresponding to the providers listed in 'providers'. The model type will be inferred unless explicitly set in the SessionOptions. To explicitly set: :: so = onnxruntime.SessionOptions() # so.add_session_config_entry('session.load_model_format', 'ONNX') or so.add_session_config_entry('session.load_model_format', 'ORT') A file extension of '.ort' will be inferred as an ORT format model. All other filenames are assumed to be ONNX format models. 'providers' can contain either names or names and options. When any options are given in 'providers', 'provider_options' should not be used. The list of providers is ordered by precedence. For example `['CUDAExecutionProvider', 'CPUExecutionProvider']` means execute a node using `CUDAExecutionProvider` if capable, otherwise execute using `CPUExecutionProvider`. NzUnable to load from type ''Tread_config_from_modelrYORT_LOAD_CONFIG_FROM_MODEL1disabled_optimizersz(*************** EP Error ***************z EP Error z when using rrz(****************************************)superrr\rOosPathLikefspath _model_path _model_bytesbytesrrrs_sess_options_initialrqrA_read_config_from_modelenvironget_create_inference_sessionr^ RuntimeErrorrrrr) r path_or_bytes sess_optionsrgrhkwargsrefallback_error __class__s rrzInferenceSession.__init__sL  mc2;;%7 8!yy7D  $D   u -#D  -D 8m9L8MQOP P)%1" $ #v -+.v6N/O+PTU+UD (+-::>>:V+W[^+^D (%jj)>?   * *96FH[ \L) $$ 0DEIaS YK@A,T-E-E,FnUVDE2243K3KTR))+ 0(a/0G s72DF. F)"A,F F$FF$$F))F.ctj}d|vr9|r.td|Drtd|Dr ddg|_nz=InferenceSession._create_inference_session..sE%. 77`"8U3^ G^8^`$-+-c3^K|]%}|dk(xst|txr|ddk('yw)rrNrrs rrz=InferenceSession._create_inference_session..sE%. ;;d"8U3b Gb8bd$-rrCPUExecutionProviderMIGraphXExecutionProviderc3^K|]%}|dk(xst|txr|ddk('yw)ROCMExecutionProviderrNrrs rrz=InferenceSession._create_inference_session..sE!!*H33\x/ZHQKCZ4Z\ )rrTF)r get_available_providersanyrrkrsget_default_session_options_register_ep_custom_opsrrrrsetr\initialize_sessionrpsession_options inputs_metarw outputs_metarzoverridable_initializersr} model_metarrrrrr_profiling_start_time_ns)rrgrhravailable_providersrrs rrz*InferenceSession._create_inference_sessions+779 '*= =%. %. -DE[+\(,B+C( (,? ?S!!*! -DE[+\(,B+C((>'?D $'H ')<' # #150B0B$,,HeHeHg $$_iAQSfg   %%ot7G7GtOkOklD%%ot7H7H%QUQmQmnD  &"%% /5"%&9":   +;=PQ !ZZ77 JJ22!ZZ44)-)L)L&::00**224!%!@!@!B(, (N(N%rcd|_d|_d|_d|_d|_d|_d|_d|_d|_|j|_|j||y)z"release underlying session object.N) rsrwrzr}rrrrrprrrs rrzInferenceSession._reset_session%sk" !)-&!%(,% !77 &&y2BCrctt|D]r}|||vr"||dk(rtj|||,t ||t s@||d|vsK||ddk(sWtj|||dty)NrrrY)ranger_r 'register_tensorrt_plugins_as_custom_opsr\rc)rrrgrhris rrz(InferenceSession._register_ep_custom_ops7ss9~&A|22y|Gb7b99/K[\]K^_9Q</aLO'::aLO'BB99/9UVr?r) rCrDrErFrrrr __classcell__)rs@rrrsd;?GK<@ L0L8LE L : L L\AOFD$ \rrcleZdZdZddZdZdZdZdZ ddZ d Z d Z d Z d Z d ZdZdZy)rzW This class provides API to bind input/output to a specified device, e.g. GPU. cZtj|j|_i|_yr)r SessionIOBindingrpr_numpy_obj_references)rsessions rrzIOBinding.__init__Hs ,,W]];%'"rcZ||j|<|jj||y)z bind an input to array on CPU :param name: input name :param arr_on_cpu: input values as a python array on CPU N)rr bind_input)rrP arr_on_cpus rbind_cpu_inputzIOBinding.bind_cpu_inputLs(,6""4( ""44rc |jj|tjt ||tjj ||||y)a :param name: input name :param device_type: e.g. cpu, cuda, cann :param device_id: device id, e.g. 0 :param element_type: input element type. It can be either numpy type (like numpy.float32) or an integer for onnx type (like onnx.TensorProto.BFLOAT16) :param shape: input shape :param buffer_ptr: memory pointer to input data N)rrr rrdefault_memoryrrPr device_id element_typeshape buffer_ptrs rrzIOBinding.bind_inputXsM ""  KK#K; **,     rcP|jj||jy)z\ :param name: input name :param ortvalue: OrtValue instance to bind N)rbind_ortvalue_inputr5rrPortvalues rr zIOBinding.bind_ortvalue_inputms ++D(2D2DErc8|jjyr)rsynchronize_inputsr%s rr$zIOBinding.synchronize_inputsts **,rNc |X|jj|tjt ||tjj |y|| t d|jj|tjt ||tjj ||||y)a :param name: output name :param device_type: e.g. cpu, cuda, cann, cpu by default :param device_id: device id, e.g. 0 :param element_type: output element type. It can be either numpy type (like numpy.float32) or an integer for onnx type (like onnx.TensorProto.BFLOAT16) :param shape: output shape :param buffer_ptr: memory pointer to output data NzQ`element_type` and `shape` are to be provided if pre-allocated memory is provided)r bind_outputr rrrr^rs rr&zIOBinding.bind_outputws0   OO ' ' ' Y?KK..0 #u} !tuu OO ' ' ' Y?KK..0  rcP|jj||jy)z] :param name: output name :param ortvalue: OrtValue instance to bind N)rbind_ortvalue_outputr5r!s rr(zIOBinding.bind_ortvalue_outputs ,,T83E3EFrc8|jjyr)rsynchronize_outputsr%s rr*zIOBinding.synchronize_outputss ++-rc|jj}t|tjs t d|Dcgc] }t |c}Scc}w)z Returns the output OrtValues from the Run() that preceded the call. The data buffer of the obtained OrtValues may not reside on CPU memory z?get_outputs() must return an instance of type 'OrtValueVector'.)rr{r\r rrr<)routputsr"s rr{zIOBinding.get_outputssO //--/'1#3#34]^ ^3:;7x"7;;;sAc6|jjSr)rr{r%s rget_outputs_as_ortvaluevectorz'IOBinding.get_outputs_as_ortvaluevectors**,,rc6|jjS)zCopy output contents to CPU.)rcopy_outputs_to_cpur%s rr0zIOBinding.copy_outputs_to_cpus2244rc8|jjyr)rclear_binding_inputsr%s rr2zIOBinding.clear_binding_inputss ,,.rc8|jjyr)rclear_binding_outputsr%s rr4zIOBinding.clear_binding_outputss --/r)rrm)r rNNN)rCrDrErFrrrr r$r&r(r*r{r.r0r2r4rHrrrrCs\( 5 *F- .`G.<-5/0rrceZdZdZddZdZeddZeddZedddZ edZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZy)r<a A data structure that supports all ONNX data formats (tensors and non-tensors) that allows users to place the data backing these on a device, for example, on a CUDA supported device. This class provides APIs to construct and deal with OrtValues. Ncjt|tjr||_||_yt d)Nz^`Provided ortvalue` needs to be of type `onnxruntime.capi.onnxruntime_pybind11_state.OrtValue`)r\r r<r5 _numpy_objr^)rr" numpy_objs rrzOrtValue.__init__s2 h +%DN(DOp rc|jSr)r5r%s rrzOrtValue._get_c_values ~~rc ttjj|tjt ||tjj ||j dk(r|SdS)a Factory method to construct an OrtValue (which holds a Tensor) from a given Numpy object A copy of the data in the Numpy object is held by the OrtValue only if the device is NOT cpu :param numpy_obj: The Numpy object to construct the OrtValue from :param device_type: e.g. cpu, cuda, cann, cpu by default :param device_id: device id, e.g. 0 r N)r<r ortvalue_from_numpyrrrlower)r8rrs rr;zOrtValue.ortvalue_from_numpyst JJ * * ' Y?KK..0 %**,5I  <@  rcVttjj|||S)a  This method creates an instance of OrtValue on top of the numpy array. No data copy is made and the lifespan of the resulting OrtValue should never exceed the lifespan of bytes object. The API attempts to reinterpret the data type which is expected to be the same size. This is useful when we want to use an ONNX data type that is not supported by numpy. :param data: numpy.ndarray. :param onnx_elemenet_type: a valid onnx TensorProto::DataType enum value )r<r "ortvalue_from_numpy_with_onnx_type)dataonnx_element_types rr>z+OrtValue.ortvalue_from_numpy_with_onnx_types$ EEdL]^`deerc t|trettjj ||tj t ||tj j|Sttjj||tj t ||tj j|S)a Factory method to construct an OrtValue (which holds a Tensor) from given shape and element_type :param shape: List of integers indicating the shape of the OrtValue :param element_type: The data type of the elements. It can be either numpy type (like numpy.float32) or an integer for onnx type (like onnx.TensorProto.BFLOAT16). :param device_type: e.g. cpu, cuda, cann, cpu by default :param device_id: device id, e.g. 0 ) r\rAr<r !ortvalue_from_shape_and_onnx_typerrrortvalue_from_shape_and_type)rrrrs rrCz%OrtValue.ortvalue_from_shape_and_types lC ( << KK+KC 224!   JJ 3 3 ' Y?KK..0   rcnttjj|jS)z The function will construct an OrtValue instance from a valid SparseTensor The new instance of OrtValue will assume the ownership of sparse_tensor )r<r ort_value_from_sparse_tensor _get_c_tensor) sparse_tensors rrEz%OrtValue.ort_value_from_sparse_tensor+s'  ?? @[@[@]^__rcHt|jjS)zR The function will return SparseTensor contained in this OrtValue ) SparseTensorr5as_sparse_tensorr%s rrJzOrtValue.as_sparse_tensor3sDNN;;=>>rc6|jjS)zX Returns the address of the first element in the OrtValue's data buffer )r5data_ptrr%s rrLzOrtValue.data_ptr9s~~&&((rcR|jjjS)zn Returns the name of the device where the OrtValue's data buffer resides e.g. cpu, cuda, cann )r5 device_namer<r%s rrNzOrtValue.device_name?s ~~))+1133rc6|jjS)z? Returns the shape of the data in the OrtValue )r5rr%s rrzOrtValue.shapeEs~~##%%rc6|jjS)zC Returns the data type of the data in the OrtValue )r5 data_typer%s rrQzOrtValue.data_typeK~~''))rc6|jjS)zi Returns the proto type of the data in the OrtValue if the OrtValue is a tensor. )r5rr%s rrzOrtValue.element_typeQs ~~**,,rc6|jjS)zz Returns True if the OrtValue corresponding to an optional type contains data, else returns False )r5 has_valuer%s rrUzOrtValue.has_valueXs ~~''))rc6|jjS)zT Returns True if the OrtValue contains a Tensor, else returns False )r5 is_tensorr%s rrWzOrtValue.is_tensor_rRrc6|jjS)zZ Returns True if the OrtValue contains a SparseTensor, else returns False )r5is_sparse_tensorr%s rrYzOrtValue.is_sparse_tensores~~..00rc6|jjS)z] Returns True if the OrtValue contains a Tensor Sequence, else returns False )r5is_tensor_sequencer%s rr[zOrtValue.is_tensor_sequenceks~~0022rc6|jjS)z Returns a Numpy object from the OrtValue. Valid only for OrtValues holding Tensors. Throws for OrtValues holding non-Tensors. Use accessors to gain a reference to non-Tensor objects such as SparseTensor )r5numpyr%s rr]zOrtValue.numpyqs ~~##%%rc:|jj|y)av Update the OrtValue in place with a new Numpy array. The numpy contents are copied over to the device memory backing the OrtValue. It can be used to update the input valuess for an InferenceSession with CUDA graph enabled or other scenarios where the OrtValue needs to be updated while the memory address can not be changed. N)r5update_inplace)rnp_arrs rr_zOrtValue.update_inplaceys %%f-rr)r r)r@rA)rrOrrA)rCrDrErFrrrGr;r>rCrErJrLrNrrQrrUrWrYr[r]r_rHrrr<r<s   0 f f" " H``? ) 4 & * -** 1 3 &.rr<c8eZdZdZdZdZedZdZdZ y)rzD A data structure that exposes the underlying C++ OrtDevice c\t|tjr||_yt d)& Internal constructor z]`Provided object` needs to be of type `onnxruntime.capi.onnxruntime_pybind11_state.OrtDevice`N)r\r r _ort_devicer^)r c_ort_devices rrzOrtDevice.__init__s* lAKK 0+D o rc|jS)z8 Internal accessor to underlying object )rdr%s r _get_c_devicezOrtDevice._get_c_devicesrcttjt||tjj|Sr)rr rr)ort_device_namers rmakezOrtDevice.makes8 KK#OY? **,   rc6|jjSr)rdrr%s rrzOrtDevice.device_ids))++rc6|jjSr)rdrr%s rrzOrtDevice.device_types++--rN) rCrDrErFrrgrGrjrrrHrrrrs/    ,.rrcreZdZdZdZdZedZedZdZ dZ dZ d Z d Z d Zd Zd ZdZy)rIz A data structure that project the C++ SparseTensor object The class provides API to work with the object. Depending on the format, the class will hold more than one buffer depending on the format c\t|tjr||_yt d)rcz``Provided object` needs to be of type `onnxruntime.capi.onnxruntime_pybind11_state.SparseTensor`N)r\r rI_tensorr^)rrGs rrzSparseTensor.__init__s+ mQ^^ 4(DLr rc|jSr)ror%s rrFzSparseTensor._get_c_tensors ||rc tttjj||||jS)a Factory method to construct a SparseTensor in COO format from given arguments :param dense_shape: 1-D numpy array(int64) or a python list that contains a dense_shape of the sparse tensor must be on cpu memory :param values: a homogeneous, contiguous 1-D numpy array that contains non-zero elements of the tensor of a type. :param coo_indices: contiguous numpy array(int64) that contains COO indices for the tensor. coo_indices may have a 1-D shape when it contains a linear index of non-zero values and its length must be equal to that of the values. It can also be of 2-D shape, in which has it contains pairs of coordinates for each of the nnz values and its length must be exactly twice of the values length. :param ort_device: - describes the backing memory owned by the supplied nummpy arrays. Only CPU memory is suppored for non-numeric data types. For primitive types, the method will map values and coo_indices arrays into native memory and will use them as backing storage. It will increment the reference count for numpy arrays and it will decrement it on GC. The buffers may reside in any storage either CPU or GPU. For strings and objects, it will create a copy of the arrays in CPU memory as ORT does not support those on other devices and their memory can not be mapped. )rIr sparse_coo_from_numpyrg) dense_shaperf coo_indices ort_devices rrrz"SparseTensor.sparse_coo_from_numpys3, NN 0 0fkS]SkSkSm n  rc vttjj|||||jS)a` Factory method to construct a SparseTensor in CSR format from given arguments :param dense_shape: 1-D numpy array(int64) or a python list that contains a dense_shape of the sparse tensor (rows, cols) must be on cpu memory :param values: a contiguous, homogeneous 1-D numpy array that contains non-zero elements of the tensor of a type. :param inner_indices: contiguous 1-D numpy array(int64) that contains CSR inner indices for the tensor. Its length must be equal to that of the values. :param outer_indices: contiguous 1-D numpy array(int64) that contains CSR outer indices for the tensor. Its length must be equal to the number of rows + 1. :param ort_device: - describes the backing memory owned by the supplied nummpy arrays. Only CPU memory is suppored for non-numeric data types. For primitive types, the method will map values and indices arrays into native memory and will use them as backing storage. It will increment the reference count and it will decrement then count when it is GCed. The buffers may reside in any storage either CPU or GPU. For strings and objects, it will create a copy of the arrays in CPU memory as ORT does not support those on other devices and their memory can not be mapped. )rIr sparse_csr_from_numpyrg)rsrf inner_indices outer_indicesrus rrwz"SparseTensor.sparse_csr_from_numpys;, NN 0 0((*    rc6|jjS)z The method returns a numpy array that is backed by the native memory if the data type is numeric. Otherwise, the returned numpy array that contains copies of the strings. )rorfr%s rrfzSparseTensor.valuess ||""$$rc6|jjS)a} The method will return coo representation of the sparse tensor which will enable querying COO indices. If the instance did not contain COO format, it would throw. You can query coo indices as: :: coo_indices = sparse_tensor.as_coo_view().indices() which will return a numpy array that is backed by the native memory. )ro get_coo_datar%s r as_coo_viewzSparseTensor.as_coo_views||((**rc6|jjS)a The method will return CSR(C) representation of the sparse tensor which will enable querying CRS(C) indices. If the instance dit not contain CSR(C) format, it would throw. You can query indices as: :: inner_ndices = sparse_tensor.as_csrc_view().inner() outer_ndices = sparse_tensor.as_csrc_view().outer() returning numpy arrays backed by the native memory. )ro get_csrc_datar%s r as_csrc_viewzSparseTensor.as_csrc_views||))++rc6|jjS)a The method will return coo representation of the sparse tensor which will enable querying BlockSparse indices. If the instance did not contain BlockSparse format, it would throw. You can query coo indices as: :: block_sparse_indices = sparse_tensor.as_blocksparse_view().indices() which will return a numpy array that is backed by the native memory )roget_blocksparse_datar%s ras_blocksparse_viewz SparseTensor.as_blocksparse_view!s||0022rcft|jj|jS)a Returns a copy of this instance on the specified cuda device :param ort_device: with name 'cuda' and valid gpu device id The method will throw if: - this instance contains strings - this instance is already on GPU. Cross GPU copy is not supported - CUDA is not present in this build - if the specified device is not valid )rIroto_cudarg)rrus rrzSparseTensor.to_cuda/s'DLL001I1I1KLMMrc.|jjS)z7 Returns a OrtSparseFormat enumeration )rorMr%s rrMzSparseTensor.format>s||"""rc6|jjS)zZ Returns a numpy array(int64) containing a dense shape of a sparse tensor )rorsr%s rrszSparseTensor.dense_shapeDs||''))rc6|jjS)zH Returns a string data type of the data in the OrtValue )rorQr%s rrQzSparseTensor.data_typeJs||%%''rcR|jjjS)zj Returns the name of the device where the SparseTensor data buffers reside e.g. cpu, cuda )rorNr<r%s rrNzSparseTensor.device_namePs ||'')//11rN)rCrDrErFrrFrGrrrwrfr}rrrrMrsrQrNrHrrrIrIsg   2  >% + , 3 N# * ( 2rrI)rrOr>z C.OrtDevice)rgr rhr rUz Sequence[str]) __future__rrZcollections.abcrtypingrKrronnxruntime.capirr TYPE_CHECKING onnxruntimerrrkrmrrr<rrIrHrrrs #  /  C+M+M\OZ@OZ5OZ,OZdipipXq\wq\hC0C0Lx.x.v$.$.Ni2i2r