Ngo8ddlmZddlZddlmZmZmZddlZddl m Z ddl m Z m Z mZddlmZmZmZddlmZmZddlmZmZmZmZdd lmZmZmZmZm Z m!Z!m"Z"d Z#Gd d e$Z%Gd de$Z&Gdde'Z(GddZ)GddZ*d-dZ+e+Z,GddZ-GddZ.d.dZ/d/d"Z0Gd#d$Z1Gd%d&ej2Z3Gd'd(e3Z4Gd)d*e3Z5Gd+d,e5Z6dS)0) annotationsN)AnyClassVarIterable) TensorProto)get_all_schemas_with_history get_schemaonnx_opset_version) make_nodemake_tensor_type_protonp_dtype_to_tensor_dtype)to_array unpack_int4)AttributeProto GraphProto NodeProto TypeProto)bfloat16 float8e4m3fnfloat8e4m3fnuz float8e5m2float8e5m2fnuzint4uint4cd|vrC|dd\}} t|}n#t$r|dfcYSwxYw||fS|dfS)N_)maxsplit)rsplitint ValueError)nameprefixversvs Q/var/www/html/ai-engine/env/lib/python3.11/site-packages/onnx/reference/op_run.py_split_class_namer'su d{{{{3{33  D AA   :    qy :s0AAceZdZdZdS)RuntimeTypeErrorz/Raised when a type of a variable is unexpected.N__name__ __module__ __qualname____doc__r&r)r)&s9999r0r)ceZdZdZdS)RuntimeContextErrorzfRaised when the context is missing but an context dependent implementation is defined for an operator.Nr*r/r0r&r2r2*sppppr0r2ceZdZdZdS)RuntimeImplementationErrorz8Raised when no implementation was found for an operator.Nr*r/r0r&r4r4.sBBBBr0r4ceZdZdZdS) DefaultNonezjDefault value for parameters when the parameter is not set but the operator has a default behavior for it.Nr*r/r0r&r6r62sttttr0r6c"eZdZdZddZd dZdS) RefAttrNamez}Implements a link between a parameter of a function and an attribute in node. Args: name: name of the input r"strc||_dSN)r")selfr"s r&__init__zRefAttrName.__init__=s  r0returnc0|jjd|jdS)N()) __class__r+r"r<s r&__repr__zRefAttrName.__repr__@s .)::DI::::r0N)r"r9r>r9)r+r,r-r.r=rDr/r0r&r8r86sF ;;;;;;r0r8r>dict[str, type]c ~i}tD]}|j|vrt|j||jjkr3td|jd|jd||jjd|j||jjkr |||j<n |||j<|||jdzt |jz<|S)Nz7This function assumes every operator has a unique name z even accross multiple domains z and .r)rr"domainNotImplementedError since_versionr9)resschemas r&_build_schemasrNDsC.00 D D ;#  }FK 0 777)hfkhh5;]hhKNv{K[Kbhhh#c&+&6&DDD#)FK %C =CFK# F$8 9 9 9:: Jr0ceZdZddZd dZdS) OnnxType type_protorc~t|ts tdt|d||_dS)Nz type_proto z must be of type TypeProto.) isinstancer TypeErrortyperQ)r<rQs r&r=zOnnxType.__init__[sB*i00 YW$z*:*:WWWXX X$r0r>r9cd|jdS)Nz OnnxType(rA)rQrCs r&rDzOnnxType.__repr__`s/4?////r0N)rQrrE)r+r,r-r=rDr/r0r&rPrPZs<%%%% 000000r0rPc2eZdZdZd d Zedd Zd S) SparseTensorzcSimple representation of a sparse tensor. It is based on numpy but does not require scipy. values np.ndarrayindicesshape tuple[int]r>Nonec0||_||_||_dSr;)rYr[r\)r<rYr[r\s r&r=zSparseTensor.__init__is   r0rc|jjSr;)rYdtyperCs r&razSparseTensor.dtypeps {  r0N)rYrZr[rZr\r]r>r^)r>r)r+r,r-r.r=propertyrar/r0r&rXrXdsR!!!X!!!r0rXattrctd|jD}tt|jt|j|S)zHosts a sparse tensor.c3K|]}|VdSr;r/).0ds r& z#to_sparse_tensor..ws"&&!&&&&&&r0)tupledimsrXrrYr[)rcr\s r&to_sparse_tensorrkusF &&SX&&& & &E ,,hs{.C.CU K KKr0tensorrrZcZ|j}|tjkrw|j}t |j}t j|t }t|D] \}}|||< | |S|tj tj tjtjfvrtj t tj t"tjt$tjt&i}|dr|j}n|j}t |j}t j||| }t|D] \}}|||< | |S|tjtjfvr|dr|j}n|j}t |j}tjt0tjt2i}||}|tjk} t jt5|| }t|D] \}}|||< t7||| } | |St;|S)zSimilar to :func:`to_array` but deals with non-numpy types bfloat16, float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, uint4, int4. )raraw_data)rjsigned) data_typerBFLOAT16 int32_datarirjnpemptyrravel enumeratereshape FLOAT8E4M3FNFLOAT8E4M3FNUZ FLOAT8E5M2FLOAT8E5M2FNUZrrrrHasFieldrnUINT4INT4rrlenrastyper) rl elem_typedatar\yirgmraro unpacked_datas r&to_array_extendedr{s^ IK((( fk"" HU( + + + 1 1 3 3dOO  DAqAaDDyy ""   $l  &  "J  &   ??: & & %?DD$Dfk"" HU!I, / / / 5 5 7 7dOO  DAqAaDDyy[& (8999 ??: & & %?DD$Dfk""  t[%6 >) k.. HSYYe , , , 2 2 4 4dOO  DAqAaDD#AE&AAA ##E*** F  r0ceZdZdZddZdS) Graphgrrr>r^c||_dSr;r)r<rs r&r=zGraph.__init__s r0N)rrr>r^)r+r,r- __slots__r=r/r0r&rrs-Ir0rcteZdZUdZdZejdejdejdej dej dej dej d ej d ejd ejd ejd ejdejdejdiZded< dFdGdZdZ dFdHd!Zed"ZdId$ZedJd(ZedKd*ZedKd+ZedLd-Z edLd.Z!dMd0Z"dLd1Z#e$j%d2Z&dNd5Z'ddd6d7Z(e)d8Z*e) dOdPd=Z+e) dQdRdAZ,e)dd>dBdSdEZ-dS)TOpRuna0Ancestor to all operators in this subfolder. Args: onnx_node: `onnx` node run_params: additional parameters such as `verbose`, `opsets` (it can be more than one if the operator has a subgraph), `log` for a logging function schema: operator schema c4tj|jSr;)rsfloat32frcs r&zOpRun.s"*SU*;*;r0c$d|jDS)Nc6g|]}tj|Sr/)rsr)rfrs r& z"OpRun...s +N+N+NaBJqMM+N+N+Nr0)floatsrs r&rzOpRun.s+N+N3:+N+N+Nr0c*t|jSr;)rrrs r&rzOpRun.s%,,r0c$d|jDS)Nc,g|]}t|Sr/)r)rfrs r&rz"OpRun...s+I+I+IE!HH+I+I+Ir0)graphsrs r&rzOpRun.s+I+Icj+I+I+Ir0c*t|jSr;)r rrs r&rzOpRun.sCE r0c$d|jDS)Nc,g|]}t|Sr/)r rfrs r&rz"OpRun...s)C)C)CQ#a&&)C)C)Cr0)intsrs r&rzOpRun.s)C)C#()C)C)Cr0c*t|jSr;)rk sparse_tensorrs r&rzOpRun.s2B3CT2U2Ur0c$d|jDS)Nc,g|]}t|Sr/)rkrfts r&rz"OpRun...s.4 4 4 $% Q  4 4 4 r0)sparse_tensorsrs r&rzOpRun.s#4 4 ),);4 4 4 r0c6|jdS)Nutf-8)sdecoders r&rzOpRun.s35<<+@+@r0c$d|jDS)Nc8g|]}|dS)r)r)rfrs r&rz"OpRun...s$,T,T,T1QXXg->->,T,T,Tr0)stringsrs r&rzOpRun.s,T,T ,T,T,Tr0c*t|jSr;)rrrs r&rzOpRun.s+..s!,W,W,Wa->q-A-A,W,W,Wr0)tensorsrs r&rzOpRun.s,W,W3;,W,W,Wr0c*t|jSr;)rPtprs r&rzOpRun.sx/?/?r0c$d|jDS)Nc,g|]}t|Sr/)rPrs r&rz"OpRun...s0V0V0V!0V0V0Vr0) type_protosrs r&rzOpRun.s0V0Vco0V0V0Vr0zClassVar[dict[Any, Any]]_attribute_conversion_functionsN onnx_noder run_paramsdict[str, Any]rMrc \t|ts tdt|ddD])}||vr#t d|dt |d*d|vrt d||_||_|t|j d r|j j |_ ne|j j tvrt|j j |_ n5|jtvrt|j|_ nd|_ n||_ d |_|dS) Nz$run_params must be a dictionary not rH)opsetsnew_ops Attribute z must be in run_params, only z was found.logz#run_params must contains key 'log'. op_schemaF)rSdictrTrU RuntimeErrorsortedKeyErrorrrhasattrrBr_schemar+_schemasop_type has_subgraph_load_attributes)r<rrrMrcs r&r=zOpRun.__init__sX*d++ XV4 CSCSVVVWW W(  C*$$"777j))777%  " "@AA A"$ >t~{33 $#~7 (H44'(?@ "h..' (9: # !DL! r0c.|jd|g|RdS)Nr)r)r<patternargss r&_logz OpRun._logs'w.......r0rcrref_attAttributeProto | Noner>cb|jtjkr|jdd}d|jvr-t |jd}nd}|jdd}| Jd|||j|jdtd|jddd z |dn t || S|jtj vrtj |j|S|=td |j d |jd |j jd|j jd|d td|j d |jd |j jd|j jd|d|d )z0Converts an attribute value into a python value.rNexisting_functions evaluator_clsz0evaluator_cls must be specified to evaluate att=rrverbose)rrr functionszUnable to convert attribute z type z from node type z , domain  rHz$Unable to convert default value for )rUrGRAPHrgetlistrYrmaxrrAttributeErrorr"rrrI)r<rcrrrrs r&_extract_attribute_valuezOpRun._extract_attribute_values  8~+ + +o)))T::G#t66 1E!F!M!M!O!OPP   O//FFM))G#GG*)) =x0At229a@@1DEE 'T'..:J:J5K5K#   8u< < <8B3GG G ? .1s%BZBZ CCr0>Constantrequiredrz3 is expected based on ONNX specifications for node rH default_valuer)has_linked_attributer attributer" ref_attr_namer8rsetattrappendrUrrrrrritemsrgetattrrrrrpsetattributes_names_)r<added_attributesrcr"rkr%s r&rzOpRun._load_attributess;$)!>+  C8D  ;#C$566,0))55c:: D$ & & &  # #D ) ) )x>///$(!))U-GG))&CH&&*/D < 3DN2,FF /5577 3 31tQ''3q*d33*DDD(,(>DDDq/22 3?/144O0A55 ! 1 ;q @ @%)EE$($A$A!/ST$U$UEa///(//222!$%5!6!6r0graphr list[str]c2t|ts tdt|dt }t }|jD]}||j|jD]}||j|j D]}||j|j D]D}|j D]}|||j D]}||vr||Et|S)zReturns all varibles not registered as inputs and not produced by an node inside the graph. This inputs are part of the context existing in the graph calling this one. zUnexpected type rH) rSrrTrUr initializeraddr"sparse_initializerinputnodeoutputr) rlocalknowninit sparse_initinprors r&implicit_inputszOpRun.implicit_inputsKs4 %,, A?tE{{???@@ @% ! !D IIdi  3 ( (K IIk& ' ' ' ';  C IIch    J ! !D[   ! Z ! !E>>IIaLLL !E{{r0 Iterable[str]c|jjS)zReturns node attribute `input`.)rrrCs r&rz OpRun.inputcs~##r0c|jjS)z Returns node attribute `output`.)rrrCs r&rz OpRun.outputh~$$r0r9c|jjS)z!Returns node attribute `op_type`.)rrrCs r&rz OpRun.op_typems~%%r0c|jjS)z Returns node attribute `domain`.)rrIrCs r&rIz OpRun.domainrrr0boolcdS)zTells the runtime if this node needs the context (all the results produced so far) as it may silently access one of them (operator Scan, If, Loop). The default answer is `False`. Fr/rCs r& need_contextzOpRun.need_contextws ur0cp|jjdzd|jjg}t |jD]H\}}|dvr d|dcxkrdkr+n |ddkr|d |d |d I|d d |S)Nr@z op_type=>descrarzrz =,rAr) rBr+rrr__dict__rrjoin)r<attsrr%s r&__str__z OpRun.__str__s'#-/Vdn>T/V/VW4=..0011 - -DAq)))ad!!!!c!!!!!aesll O1OOqOOO,,, Cyyr0c<td|jjd)aShould be overwritten. Args: *args: operator inputs **kwargs: optional inputs and overriden attributes, an attribute may be overridden if it belongs to a function, in this case, the same instance of OpRun can be called with different values of the same attribute. Returns: outputs z/Method '_run' must be overwritten for operator rH)rJrBr+)r<rkwargss r&_runz OpRun._runs)" Zdn>U Z Z Z   r0rLtuple[Any, ...]ct|ts-td|jjdt |d|st d|jjdtd|Dr,d|D}td|jjd|d td |D}td |Dr,d |D}td|jjd |d |S)z-Checks the output are from the expected type.zMethod '_run' of class z does not return a tuple but 'z'.z does not return any result.c3@K|]}t|tVdSr;)rSrirs r&rhz/OpRun._check_and_fix_outputs..s,11z!U##111111r0c,g|]}t|Sr/rUrs r&rz0OpRun._check_and_fix_outputs..+++!d1gg+++r0z6One of the results returned by method '_run' of class zg is a tuple, this is no ONNX corresponding type (Map, List, Tensor, SparseTensor). All returned types: rHc3jK|].}tj|rtj|n|V/dSr;)rsisscalararray)rfxs r&rhz/OpRun._check_and_fix_outputs..sL  78BKNN 1RXa[[[      r0c3K|]<}t|tjttfpt |d V=dS)todenseN)rSrsndarrayrrrrs r&rhz/OpRun._check_and_fix_outputs..s[  A D$788QGAy.r'r0zr has an unexpected type, this is no ONNX correponding type (Map, List, Tensor, SparseTensor). All returned types: )rSrirTrBr+rUr!any)r<rLdtypess r&_check_and_fix_outputszOpRun._check_and_fix_outputss#u%% p$.*Appcghkclclppp  a$.*Aaaa  11S111 1 1 ++s+++F3I`33'-333    .s%<%<% %d outputsr)rrrUrr!rrrrrSr8r"rrBr+rr NameErrorrr!rTrr2) r<r3rroverridden_attributesrcr%r rLes r&rz OpRun.runs      "QdQQQ \T$ZZ\\\   $ ):)BtT$ZZttt ( ->-JAT$ZZAA'*+<'='=AAA !#  $ K ($. $T ...- K KD#&&a--Kv%666(5355Vg55'+Dzz5552C161J)#. .0GTSSS) - -C+++4%% \\\@W\\\"$,,F3KK   5( 1B "ZTRVZZZZZ$5F<   'F9  $ 1diI)>I&IIdi000>*   ;%<%>;;:@AV:W:W;;!^4;;;    * N #CHHHQ   **3///sH44JA JJc|j}d|vr|tfS|dd\}} t|}n%#t$r|jtfcYSwxYw||fS)Nrr)r+r rr r!)clsr"r$i_verss r& infer_namezOpRun.infer_names| d??+--- -[[a(( d 6YYFF 6 6 6` creates an onnx node returned by method :meth:`make_node `. .. exec_code:: import numpy as np from onnx.reference.ops._op_list import Celu onnx_node = Celu.make_node(alpha=0.5) print(onnx_node) Ncg|]}d|S)r+r/rs r&rz#OpRun.make_node..Gs555GGG555r0cg|]}d|S)rr/rs r&rz#OpRun.make_node..Hs777WWW777r0)r= op_domainr min_input min_outputranger ) r;r>r@r ropsetrIrMnames_in names_outrs r&r zOpRun.make_nodes>))  ~#GUF;;'H  ~#GUF;;)I55U8__55577eI&6&6777 (I@@@@ r0rrr c td fd }|j||fi|}|dd tid }|||}|S) aInstantiates this class based on the given information. Args: n_inputs: number of inputs (default is defined by the operator schema) n_outputs: number of outputs (default is defined by the operator schema) verbose: verbosity **kwargs: node attributes Returns: NodeProto rr9rrr>r^cVdkr!t|t|zdSdS)Nr)printri)rrrs r& log_functionz"OpRun.create..log_functionbs2{{gd +,,,,,{r0Nr)rrrr)rr9rrr>r^)r r ) r;r>r@rr rNrrcls ` r&createz OpRun.createLsz, - - - - - -s}Xy;;F;;-//0   Sz " " r0r@rr list[Any]c|jt|f||d|}|j|}t|dkr|dS|S)aEvaluates this operator. Args: *args: inputs n_outputs: number of outputs (default is defined by the operator schema) verbose: verbosity **kwargs: node attributes Returns: NodeProto rQrr)rPrr)r;r@rrr instrLs r&evalz OpRun.evalpsT(sz#d))Ty'TTVTTdho s88q==q6M r0r;)rrrrrMr)rcrrrr>r)r>r^)rrr>r)r>r rE)r>r)rLr"r>r"NN)r>r?r@r?r rr>r)NNr) r>r?r@r?rr r rr>r) rrRr@r?rr r rr>r).r+r,r-r.rDrFLOATFLOATSrGRAPHSINTINTS SPARSE_TENSORSPARSE_TENSORSSTRINGSTRINGSTENSORTENSORS TYPE_PROTO TYPE_PROTOSr__annotations__r=rr staticmethodrrr rbrrrrIrrabcabstractmethodr!r2r classmethodr=r rPrUr/r0r&rrsEI ;;NN66II22CC$&U&U%( (  @@ T TCC W W!#?#?"$V$V!A#(OS     :///EI! ! ! ! ! FEE\E+7+7+7+7Z\.$$$X$%%%X%&&&X&%%%X%    "@,0S0S0S0S0S0j  [  $ $----[-^ $ $ !!!![!F!% [r0rc$eZdZdZ d d d Zd ZdS) OpRunExpandz.Class any operator to avoid must inherit from.NrrrrimplrcBtdt|dNz5The reference implementation must not use this node (r6rrU)r<rrrks r&r=zOpRunExpand.__init__s* RDJJ R R R   r0cBtdt|drmrnr<inputsr s r&r!zOpRunExpand._runs( RDJJ R R R   r0r;)rrrrrkrr+r,r-r.r=r!r/r0r&rjrjsI88MQ          r0rjc,eZdZdZ d dd Zd Zd ZdS) OpFunctionzRuns a custom function.Nrrrdict[str, Any] | Nonerkrrc| td|jd|jdt|||_fdt jd|D_dS)Nz"impl cannot be None for node type from domain rHc2i|]}|t|Sr/)r)rfr"r<s r& z'OpFunction.__init__..s5    '$%%   r0 attributes_)rrrIrr=impl_rrz)r<rrrkrs` r&r=zOpFunction.__init__s <5Y5F55(/555  tY 333      M:FF   r0c.|j|jg|Ri|Sr;) _run_implr{rps r&r!zOpFunction._runs&t~dj<6<<> t ! !S\\ 1 1J#g,,JJ69$:K6L6LJJ LJJ9=JJJ  W~~r0rV)rrrrurkrrru)r+r,r-r.r=r!r}r/r0r&rtrtsY!! ,0      *===r0rtc$eZdZdZ d d d Zd ZdS) OpFunctionContextDependantzThe function can be instantiated but only at execution time. An instance of OpFunction is created everytime to node is executed. This is needed when the schema of an operator defines a context dependant function. Nrrrruparentrct||||i||_|j|j}t |j||j|_dS)N)rkr)rtr=rrrIr rschema_)r<rrrversions r&r=z#OpFunctionContextDependant.__init__sV D)ZdrRRR - 01!)"3Wi>NOO r0cg}|D]%} t|j}n#t$r}|jtkr tj}n|jt kr tj}n|jtkr tj }nv|jtkr tj }nY|jtkr tj }n<|jtkr tj}n|jt kr tj}n|Yd}~nd}~wwxYw|t'||j'|j|j|}||j|j}|j|jg|Ri|Sr;)r rarrrrxrryrrzrr{rBLOFAT16rr}rr~rr r\r _load_implrrr}r{) r<rqr typesrttyper9rOrTs r&r!zOpFunctionContextDependant._runsn A AA 099   7l**'4EEW..'6EEW **'2EEW..'6EEW(('0EEW%%'-EEW__',EEG! " LL/qw?? @ @ @ @ [ # #DNE : :r$.$/22t~dj<6<<rF)rcrr>rX)rlrr>rZ)7 __future__rrftypingrrrnumpyrsonnxr onnx.defsrr r onnx.helperr r r onnx.numpy_helperrr onnx.onnx_pbrrrr#onnx.reference.custom_element_typesrrrrrrrr'rr)r2rJr4r6r8rNrrPrXrkrrABCrrjrtrr/r0r&rs#""""" **********RRRRRRRRRRSSSSSSSSSS33333333IIIIIIIIIIII:::::|:::qqqqq,qqqCCCCC!4CCCuuuuuuuu ; ; ; ; ; ; ; ;& >  00000000!!!!!!!!"LLLL 2222jQQQQQCGQQQh      %    ,,,,,,,,^,=,=,=,=,=,=,=,=,=,=r0