U ʹji@s UddlmZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZmZddlZddlmmZddlmZddlmZmZmZmZddlmZddlmZmZddl m!Z!d d d d d dddddddddgZ"e dZ#ej$dddddddZ%ej$dddd d!Z&ej$d"d#d$d%Z'ej$d&dd'd(d)Z(ej$d*d+Z)ej$d,d-Z*ej$d"d.d/d0d1Z+ej$d"d2d3d4d5Z,ej$d"d2d3d6d7Z-ej$d8d9d/d:d;Z.ej$dd<d=dZ/ej$ddd>d?d9d@dAd9dBdCdZ0ej$d8dDdEdFdGZ1ej$dHdIZ2ej$d8d9dEdJdKZ3ej$d8d9dEdLdMZ4ej$d8d9dNdOdPZ5ej$d"d9dEdQdRZ6dSdTdUdVdWZ7ej$d"d9dEdXdYZ8ej$d"d9dEdZd[Z9ej$d"d9dEd\d]Z:ej$d"d9dEd^d_Z;ej$d"d9dEd`dZej$dd"d9dedfdgZ?ej$d"dhdAdidjdkZ@ej$d"dAdldmdnZAej$ddddodpdqdrdsZBej$dddodtdudvdwZCej$dddhdhdodtdxdydzZDej$dddhdhddodtd{d|d}ZEej$dd~ddZFej$ddaddZGej$dddddZHej$dddddZIej$d9daddZJej$d9daddZKej$ddddZLej$dddddZMej$d ddddZNej$ddddZOej$ddZPej$ddddZQej$ddddZRej$d ddddZSej$ddddZTej$ddddZUej$ddddZVej$ddddZWej$ddddZXej$dddd9ddddZYej$ddZZej$ddddZ[ej$ddddZ\ej$ddddZ]ej$ddddZ^ej$ddddZ_ej$d dddddZ`ej$ddddZaej$ddddZbej$ddddÄZcej$d ddddńZdej$ddddDŽZeej$dddd˜dd̈́Zfej$dhddpdΜdd Zgej$ddddфZhej$ddӄZiej$ddՄZjej$ddddׄZkej$d dd"dddڜdd Zlej$ddd"d"d"dod"dܜddZmej$dddddZnej$dd ZoepddddhdddZqepdddddZrepdddd9dddZsejtjuejtjvejtjwejtjxejtjyejtjzejtj{ejtj|ejtj}ejtj~ejtjejtjejtjd ZddddddddddddddddZejejejejejejejejejejejejejejejejgZejejejejejejejejejejejejejejejdZededededededededededededededededgZeZded<dS() annotationsN) AnyCallableListLiteralNoReturnOptionalSequenceSetTupleUnion)_C) _constants _deprecation _type_utilserrors)GLOBALS) _beartype jit_utils)Numberargs_have_same_dtypecast_pytorch_to_onnxcheck_training_modedequantize_helperis_caffe2_aten_fallbackis_complex_value parse_argspytorch_name_to_typequantize_helperquantized_argsrequantize_bias_helperscalar_name_to_pytorchscalar_type_to_onnxscalar_type_to_pytorch_type) viisffsbstnone_ValueDescriptorz Optional[str])descarg_name node_namec Cs|dkr |S|dkst|s |S|}|r4dS|dkrt|d}|dkrZt|S|dkrjt|S|dkrzt|S|dkrt|S|d kr|S|d krd d |DS|d krdd |DSt d|d|d|n|dkr`|d krL| D]6}|}|dkrt d|d|d|qdd | DSt d|d||dkst|dkrt d|d|t d|d|d|d|dS)Nr,r$onnx::Constantvaluer%r'r)r*r+r&cSsg|] }t|qS)int.0r$r3r3Y/var/www/html/bwave/python/venv/lib/python3.8/site-packages/torch/onnx/symbolic_helper.py ]sz_parse_arg..r(cSsg|] }t|qSr3)floatr5r3r3r7r8_sz5ONNX symbolic does not understand the Constant node 'z' specified with descriptor ''.prim::ListConstructzFailed to export a node 'z' (in list node z_) because it is not constant. Please try to make things (e.g. kernel sizes) static if possible.cSsg|]}tt|dqSr2)r4 _node_getnoder5r3r3r7r8rszbONNX symbolic does not know how to unpack the ListConstruct node that is not a list of integers: ''z*Expected node type 'onnx::Constant', got 'z2Expected node type 'onnx::Constant' for argument 'z ' of node 'z', got ') _is_valuer> mustBeNonekindr=r4r9boolstrrSymbolicValueErrorinputs)r2r.r/r0r>Znode_valr$Z element_noder3r3r7 _parse_argAsd     rGz_C.NoderD)r>keycCs(t|tjst||}t|||S)z@Gets attributes of a node which is polymorphic over return type.) isinstancer NodeAssertionErrorZkindOfgetattr)r>rHselr3r3r7r=s r=z_C.Valuer<cCs|dkS)z$Whether a Value is an ONNX constant.r1r>rBr<r3r3r7_is_onnx_constantsrOz9Optional[Union[_C.Value, torch.Tensor, Number, Sequence]]r2 descriptorcCs"t|tjrt|rt||S|SN)rIr ValuerOrGrPr3r3r7_maybe_get_consts rTcCs(t|d}t|tjr$|jdkr$|S|S)Nr+r3)rTrItorchTensorshape)r2value_tr3r3r7_maybe_get_scalars rYcCs,t|s"td|d|d|t||S)Nz0ONNX symbolic expected a constant value of the 'z' argument, got 'r?) _is_constantrrErG)r2r.r/r3r3r7 _get_consts r[zList[_C.Value]) list_valuereturncCs4|}|dkr(td|d|t|S)Nr;z;ONNX symbolic expected node type prim::ListConstruct, got 'r:)r>rBrrElistrF)r\Z list_noder3r3r7 _unpack_lists  r_zTuple[_C.Value, ...]) tuple_valuer]cCs4|}t|s(td|d|t|S)Nz>ONNX symbolic expected node type 'prim::TupleConstruct', got 'r:)r>_is_tuple_constructrrErBtuplerF)r` tuple_noder3r3r7 _unpack_tuplesrdcCs`|}t|s4td|d|dtj|t|}t |dks\t |dks\t |S)zUnpacks a quantized tensor into a tuple of tensor and scale/zero_point. Args: tuple_value: A tuple of tensor, scale, zero_point, and optionally axis. Returns: A tuple of tensor, scale, zero_point, and optionally axis. z&ONNX symbolic expected the output of `zQ` to be a quantized tensor. Is this likely due to missing support for quantized `z`. Please create an issue on ) r>rarrErBrPYTORCH_GITHUB_ISSUES_URLrbrFlenrK)r`rcunpackedr3r3r7_unpack_quantized_tensors rjrrCcCst|o|dkS)Nr;r@r>rB)r\r3r3r7_is_packed_listsrlarg_descriptorscsfdd}|S)aA decorator which converts args from torch._C.Value to built-in types. For example: ``` @parse_args('v', 'i', 'fs') foo(g, a, b, c): assert isinstance(a, torch._C.Value) assert isinstance(b, int) assert isinstance(c, list) assert isinstance(c[0], float) ``` Args: arg_descriptors: list of str, where each element is a string that specifies the type to convert to. Valid descriptors: "v": no conversion, keep torch._C.Value. "i": int "is": list of int "f": float "fs": list of float "b": bool "s": str "t": torch.Tensor "none": the variable is unused cs"_tfdd}|S)Nc sd}tt|ks>tdt|dtdjd|z*t}t|jdd}jWn&tk rdgt|}dYnXfddt ||D}t|dkstd jd |t|dkrd |kstd jd ||f||S) NzIf you believe this is not due to custom symbolic implementation within your code or an external library, please file an issue at https://github.com/pytorch/pytorch/issues/new?template=bug-report.yml to report this bug.z,A mismatch between the number of arguments (z) and their descriptors (z") was found at symbolic function 'z'. cs g|]\}}}t|||qSr3)rG)r6argZarg_descr/fn_namer3r7r8!szBparse_args..decorator..wrapper..zSymbolic function z4's '**kwargs' can contain a single key/value entry. _outputsz='s '**kwargs' can only contain '_outputs' key at '**kwargs'. ) rhrK__name__inspect signaturer^ parameterskeys Exceptionzip)gargskwargsZ FILE_BUG_MSGsig arg_names)rnfnrqr7wrapper s.$       z.parse_args..decorator..wrapper)Z_arg_descriptors functoolswrapsrrrmrr7 decorators)zparse_args..decoratorr3)rnrr3rmr7rs /T)scale zero_pointquantize_outputzOptional[float]z Optional[int])arg_q_descriptorsrrrcsfdd}|S)aA decorator which extends support for quantized version of the base operator. Quantization is detected by examining the arguments that are annotated by `arg_q_descriptors`. If quantization is detected, the base operator symbolic function will be wrapped with argument de-quantization and output quantization. Otherwise, only the base symbolic function will be invoked. For example: ``` @quantized_args(True, False) def foo(g, x, y): return x + y ``` is equivalent to ``` def q_foo(g, x, y): if is_quantized_tensor(x): x = dequantize(x) out = foo(g, x, y) return quantize(out) else: return foo(g, x, y) ``` Args: arg_q_descriptors: A sequence of bool, where each element represents if the argument is QTensor for quantized version of this operator. It defaults to False for unspecified (variable length) arguments. scale: Quantized output scale. If None, derive from the first quantized input scale. zero_point: Quantized output zero point. If None, derive from the first quantized input zero point. quantize_output: If True, quantize the output of the base operator. Default is True cs"tfdd}|S)Ncsdk r|jdtd}nd}dk r@|jdtd}nd}dt|t}tt||}dd}t}|D]D\} } t| r|  D]} | || | qq|| || | q|t |sڈ|f||Sg} |D]\} } || | r0t || \} }}}| | |dkr |}|dkr|}qt| r|  D]J} || | rFt || \} }}}|dkrv|}|dkr|}| | qF| | q| | q|f| |}|dk std|dk stdrt||||S|S)NConstantrX)FcSs|ot|ot|SrR)r@ra)rQrpr3r3r7_is_arg_quantized}szMquantized_args..decorator..wrapper.._is_arg_quantizedz-Bug: Scale must be set for quantized operatorz2Bug: Zero point must be set for quantized operator)oprUtensorrhrbrzr^rlr>rFappendanyrZreplaceAllUsesWithrKr)r{r|r}Z_scaleZ _zero_pointZarg_q_descriptors_extendedZdescriptor_argsrZ is_quantizedrQrpZ arg_inputZnon_quantized_argsZdequantized_argZ arg_scaleZarg_zero_point_output)rrrrrr3r7rjsp             z2quantized_args..decorator..wrapper)rrrrrrrrr7risRz!quantized_args..decoratorr3)rrrrrr3rr7r9s0VzOptional[Number])xr]cCs"t|tjr|jdkr|SdS)z,Convert a scalar tensor into a Python value.r3N)rIrUrVrWitemrr3r3r7_scalarsrcCsJt|tjr|Stj|tjj}|tjjkrF|}t ||S|S)z Convert self into the same type of tensor, as necessary. We only support implicit casting for scalars, so we never actually need to insert an ONNX cast operator here; just fix up the scalar. ) rIr rSr JitScalarType from_value UNDEFINEDZ scalar_namelowerrL)selfr scalar_typetyr3r3r7_if_scalar_type_ass    rcCs$|dkp"t|tjr |SdSNF)rIr rSr>rArr3r3r7_is_nonesrcCs t|tjSrR)rIr rSrr3r3r7r@sr@)r2r]cCst| p|dkS)N>r1prim::Constantrkr<r3r3r7rZsrZcCs|tjSrR)typeZ isSubtypeOfr TensorTypegetrr3r3r7 _is_tensorsrz _C.JitTypezOptional[_C.ListType])jit_typer]cCst|tjr|SdSrR)rIr ListType)rr3r3r7 _as_list_types rcCst|dk SrR)rrrr3r3r7_is_listsrcCs(t|}|dkrdSt|tjSr)rrrIZgetElementTyper rrx_typer3r3r7_is_tensor_lists rcCs,t|}|dkrdStj|}|S)zChecks if x is a scalar list, for example: List[float], List[int]. Besides checking the type is ListType, we also check if the data type is a valid ONNX data type. NF)rrrrrZonnx_compatible)rrrr3r3r7_is_scalar_list s   rcCs|dkS)Nprim::TupleConstructrNrr3r3r7rasracCs4t|s ttj|tjjtjjtjjtjjhkSrR) r@rKrrrrZ COMPLEX32 COMPLEX64 COMPLEX128rr3r3r7rs )r]cCstjtjjkotjSrR)roperator_export_type_C_onnxOperatorExportTypesZONNX_ATEN_FALLBACK_CAFFE2_ATEN_FALLBACKr3r3r3r7r(scCs6t|r|dkrdS|}ttj|}|SrR)rrtypingcastr rdimrr3r3r7_get_tensor_rank0s r)rallow_nonstaticcCsBt|r|dkrdS|}ttj|}|r:|S|SrR)rrrrr rZ varyingSizessizes)rrrr3r3r7_get_tensor_sizes9srr4)rrr]cCst|}|r||SdSrR)r)rrrr3r3r7_get_tensor_dim_sizeHsr)rrcCsn|dkr$t|}|dk st||S|dkrjt|}|dk s@tt|D] \}}|dk rH|dkrH|SqH|S)Nre)rrKr enumerate)rrZ tensor_rankrindexsizer3r3r7_get_dim_for_crossNs   rzOptional[_C.Value]None)rmsgr2r]cCsFtjr td|d|dn"tjtjjkrBt|d||dS)NONNX export failed on z because z not supportedz, ) rrwarningswarnrrrZONNX_onnx_unsupported)rrr2r3r3r7_unimplemented^srr)op_namer2r]cCs8d|dtj}t|tjr*t||t|dS)Nz%Unsupported: ONNX export of operator zR. Please feel free to request support or submit a pull request on PyTorch GitHub: )rrgrIr rSrrEOnnxExporterError)rr2messager3r3r7rgs r)r current_opsetsupported_opsetr2r]cCs>d|d|d|d}t|tjr0t||t|dS)NUnsupported: ONNX export of in opset . Please try opset version .rIr rSrrEr)rrrr2rr3r3r7_onnx_opset_unsupportedvs r)rrrreasonr2r]c CsDd|d|d|d|d }t|tjr6t||t|dS)Nrrz. rrr)rrrrr2rr3r3r7 _onnx_opset_unsupported_detaileds  rnamecsfdd}|S)NcstddtjddS)Nrz%, which is not implemented for opset z*. Try exporting with other opset versions.)rrrexport_onnx_opset_version)r|r}rr3r7 symbolic_fnsz)_block_list_in_opset..symbolic_fnr3)rrr3rr7_block_list_in_opsets rz#Optional[_type_utils.JitScalarType]cGs4|D]*}tj|tjj}|tjjkr|SqdSrR)rrrr)r|rprr3r3r7_try_get_scalar_types  rzjit_utils.GraphContext)r{cCst|}t|}t|s0|jdt|gd}n2|dk rb|rb|dkrbt|||jdtdgd}tj |tjj }|tjj tjj hkr|jd|t jj d}|jd|||dS) NrrrroCastZto_iGatheraxis_i)rYrr@rrU LongTensor_reshape_helperrrrrINT64INTrTensorProtoDataType)r{rrrZ apply_reshapeZ index_constZ index_dimZindex_scalar_typer3r3r7_select_helpers* rcCsH|jdkr&ddlm}||||||Sddlm}|||||||SdS)N r)_slice)opsettorch.onnx.symbolic_opset9rZtorch.onnx.symbolic_opset10)r{inputaxesstartsendsZstepsZ_slice9Z_slice10r3r3r7 _slice_helpers   rcCs.tj|tjjtjjtjjtjjtjjhkSrR)rrrrFLOATDOUBLEZHALFBFLOAT16r<r3r3r7_is_fpsrcCstj|tjjtjjhkSrR)rrrrBOOLr<r3r3r7_is_bools rcCsHt|tjrtt|tr4|jdtj|tjddS|jdt|dS)aCreates a wrapped number based on https://github.com/pytorch/pytorch/issues/9515. A Tensor is a considered a "wrapped number" if it is auto-wrapped from a C++ or Python number type. Integer types are wrapped as 0-dim int64 tensors and floating-point types are wrapped as 0-dim double tensors. The input to this function is constant value. If the data type is a floating point type, it is converted to a 0-dim double tensor, else it is converted to a 0-dim tensor of its original type rdtyper)rIrUrVrKr9rrdouble)r{scalarr3r3r7_generate_wrapped_numbers  rc Cs|dk rtdd|d|}|d||jdtj|gtjdd}|jdkrp|s\tdd |jd |||d d S|jd ||||d d SdS)NZSortOut parameter is not supportedShaperrrr Ascending is not supportedTopKroutputs)r largest_ir)rrrUrint64r)r{rrZ decendingoutZshape_Z dim_size_r3r3r7 _sort_helpers(    rFc Cs|dk rtddt|s8|jdtj|gtjdd}nBt|||jdtdgd}t|tj j krz|jd|t j j d}|j d kr|stdd |jd|||d d S|jd|||||d d SdS)Nrrrrrrorrrrrr)rrZsorted_ir)rr@rrUrrrrrrrrrr)r{rkrlargestsortedrr3r3r7 _topk_helpers(   r cCs>|jdkr"ddlm}||||Sddlm}||||SdS)Nr)lt)rZtorch.onnx.symbolic_opset8rr)r{rotherZ_lt8Z_lt9r3r3r7 _lt_helper0s     rcCs6tjdkrdnd}td|dttjddS)Nrz onnx:Resizez onnx:Upsamplez(You are trying to export the model with z for ONNX opset version a. This operator might cause results to not match the expected results by PyTorch. ONNX's Upsample/Resize operator did not match Pytorch's Interpolation until opset 11. Attributes to determine how to transform the input were added in onnx:Resize in opset 11 to support Pytorch's behavior (like coordinate_transformation_mode and nearest_mode). We recommend using opset 11 and above for models using this operator.)rrrrrD)interpolate_modeZonnx_opr3r3r7_interpolate_warning<srcCsvt|drN|jdkr>|jdtj|tjdd}|d||S|jd||dS|jdkrdtd||d||dS) Nr rrrZ Unsqueezeaxes_iz= 13 for Unsqueeze with dynamic axes.)rZrrrUrlongrrE)r{rrrr3r3r7_unsqueeze_helperNs   rcCst|drN|jdkr>|jdtj|tjdd}|d||S|jd||dS|jdkrdtd||d}t|}|dk st |d krtd |n$|dkrt ||dg}|d||S|d||S) NrrrrrZSqueezerz:Opset version must be >= 13 for Squeeze with dynamic axes.rozCFor Squeeze axses as input, the axes rank must be one in ONNX spec.) rZrrrUrrrrErrKr)r{rrrZaxes_tZ axes_rankr3r3r7_squeeze_helper]s,    rrocCsvt|d}|jdkr`|rNt|s:|jdtj|tjdd}|jd||||dS|jd|||dS|jd|||dSdS) Nr%rrrrZ ReduceSum) keepdims_inoop_with_empty_axes_i)rr)rTrr@rrUrr)r{rrrrr3r3r7_reducesum_helperws,  rc stdtrd}|jdtj|tjdd}|jdtjjd}t ||dd gt j g|gd }|jd|tjjd}|d ||}|jd ||d d } n6fddt d D} |jdtj | tjdd} | S)Nr&rrrrrrrrrrrDivConcatrcsDg|]<}|dkrdn*t| t| qS)r?)r9rrr6r%rr output_sizer3r7r8s z/_interpolate_size_to_scales..)rTr@rrUonesfloat32rrrrsysmaxsizeranger) r{rr"roffsetoffsetsZdividendZdivisorZ scale_dimsscalesZscales_constantr3r!r7_interpolate_size_to_scaless.  r+cCsvt|dddkot|d }|s(dS|jdtjdtjdd}|jdtt|ddd}|jd||dd }|S) Nrr(rrrrrrr)rTrrrUr#r$r)r{r*Zavailable_scalesr)Z scales_listr3r3r7$_interpolate_get_scales_if_availablesr,cCs@|dkrd}|dd}n|d}|dd}t||}||fS)Nnearestrro)r,)r{moder| align_cornersr*r3r3r7_get_interpolate_attributess  r0cs|jdtjdtjdd}t}ttjsB|dk rT|dkrT|jd|ddSt |dg|jdt j j d fd d t |dD}|jd|f|d diS) Nrrrrrrrrrcsg|]}qSr3r3r  scale_factorr3r7r8sz+_interpolate_get_scales..r)rrUr#r$rrIrr rrrrrr')r{r2rr)Zscale_factor_rankr*r3r1r7_interpolate_get_scaless"r3cst|d}d|krd}d|kr"d}t|t|d}t|trL|rLtddS|sbtddS|}t|st|||}n|tst stdd k}|rt |d gfd d t |d D|j ddd it |||}n tddS||fS)Nr*linearcubicr)Z interpolatezalign_corners == Truemissing input shaper+rcsg|]}qSr3r3r rr3r7r8sz4_interpolate_get_scales_and_mode..rrrz.Both size and scales are None in __interpolate)r)rTrrIrCrrrrr3rlrr'rr+)r{rrr2r.r/r is_scalarr3r7r7 _interpolate_get_scales_and_modes6      r9ztorch._C.Value)r{rrkeepdimrc sfdd}t|rt|jdtdgd}||ddd}|rd |}d |} jd | tjd gtjd d} d || }|St|d}||||dS)Ncs0jdkrj|||ddSj|||dS)N F)rrZselect_last_index_irr)rr)rrrr{rr3r7 op_wrapper s z)_argmin_argmax_helper..op_wrapperrrrrFr<rConstantOfShaperorReshaper%)rrrrUrrrG) r{rrr:rr>Z flattenedrZ input_shapeZinput_shape_shapeZ new_shaper3r=r7_argmin_argmax_helpers(    rAcstdddfdd}|S)NTFc s<t||\}}t|}dkr$dn |r,dnd}|dkr|d|}t||dgdgdgd}|jd |tjjd }|jd ||dd }|jd krt|} t|} n4|jdt j gt j dd} |jdt j gt j dd} |jd|| | ||ddd S|jd krt|} n|jdt j gt j dd} |jd|| ||dddSdS)Nr- asymmetricr/ half_pixelrrrrrrrrrrrrResizefloorZ coordinate_transformation_mode_sZcubic_coeff_a_fZmode_sZnearest_mode_s) r0rYrrrrrr"_optional_input_placeholder_tensorrUrr$) r{rr"r|r*r/coordinate_transformation_mode input_sizeZinput_size_beg empty_roi empty_scalesrr3r7r.sz     z(_interpolate_helper..symbolic_fn)r)rrrrr3rMr7_interpolate_helper,s >rNc s8t|d}d|krd}d|kr"d}t|d}t|ts:dn|}|dkrJdn |rRdnd }ts|d |}t||d gd gd gd }z t otdd k} Wn,tk rt } | st dYnX| r.t |} | dkrt ddSt |d gfddt| d D|jd#dd i|jdtjjd|jd|d d|jdkrrt|} t|} n4|jdtjgtjdd} |jdtjgtjdd} |jd|| | |d|dd St |} | dkrt d!d"S|jdkrt|} n|jdtjgtjdd} t||| } |jd|| | |d|dd SdS)$Nr*r4r5r)Fr-rBr/rCrrrrr+zkCannot verify if the output_size is a scalar while exporting interpolate. Assuming that it is not a scalar.z'interpolate (with a scalar output_size)z?missing input shape (try giving an array of output_size values)csg|]}qSr3r3r r7r3r7r8sz(__interpolate_helper..rrrrrrrrrrDrErFrGzinterpolate (with scales)r6)r)rTrIrCrrrrlrAttributeErrorrrrrrr'rrrrrHrUrr$r3)r{rrr2r.r/Zrecompute_scale_factorrIrJr8rankrKrLr*r3r7r7__interpolate_helperps               rQcCsJ|jdkrddlm}n$|jdkr0ddlm}n ddlm}|||||S)N r)unbindr;)rrrStorch.onnx.symbolic_opset11torch.onnx.symbolic_opset13)r{rrrsrSr3r3r7_unbind_helpers    rVcCs4|jdkrddlm}n ddlm}||||||S)Nrrscatter)rrrXrT)r{rrrsrcrXr3r3r7_scatter_helpers  rZcCsp|jdkr&|jd|dg|||d}n8ddlm}|jdtdg|d}||||||d }|dkrj|S|gS) Nr;ZSplitro)Zsplit_irrr)splitrr)rs)rrrUr[rUr)r{rrepsrZ split_outr[repeatsr3r3r7_repeat_interleave_split_helpers   r^c Cs,ddlm}m}t|s,|jdt|d}t|}t|d}t |dkrj|d||jdt dgd}||||d}|rtj t |tj d} || |d<|jd| d} n^|d |||dd|jdt t |d|jd |jdt dgd|dd } ||| dd} |d || } ||| ||dS) Nr)flatten unsqueezerrr+r@rorZOneHotrrZTile) rr_r`rrrUrrZrTrrr#r) r{rr]rr_r`Z const_repeatsr\Z unsqueezedZonehotZrepeats_per_dimZtiledr3r3r7-_repeat_interleave_single_value_repeat_helpers:      raz\Tuple[_type_utils.JitScalarType, Optional[_C.Value], Optional[_C.Value], Optional[_C.Value]])r{r]cCsdd}|dks t|rJt|rJ||||gr8tjj}qbtjt}nt|t sXt t|}|rz|j d|| dnd}|r|j d|| dnd}|r|j d|| dnd}||||fS)NcSs>|D]4}tj|tjj}|tjjkr|tjjkrdSqdS)NFT)rrrrr)Zscalarsrrr3r3r7_is_all_integral)s  z-_arange_cast_helper.._is_all_integralrr) r@rrrrZ from_dtyperUZget_default_dtyperIr4rKr onnx_type)r{endstartsteprrbrr3r3r7_arange_cast_helper s   rgcGs2|jdkrddlm}n ddlm}||f|S)Nrr)arange)rrrhrT)r{r|rhr3r3r7_arange_helperKs  ricCs8|d|}ddlm}||||jdtdgd|S)Nrr)selectrr)rrrjrUr)r{rrZ full_shaperjr3r3r7 _size_helperTs  rkc sddlm}|jdkr$ddlm}n ddlm}|dkrJtddS|}t|dt ||fdd t |D}||| d |dt ||dg| d |}||||d} || fS) Nr)expandrrWZ index_fillzinput rank not accessibler%csg|]}|kr|qSr3r3r Z dim_valuer3r7r8psz._index_fill_reshape_helper..r) rrlrrXrTrrrrGrr'r) r{rrrrlrXZself_dimZunsqueezed_indexZexpanded_index_shapeZexpanded_indexr3rmr7_index_fill_reshape_helper\s,        rncCslt|d}t|s&|jdt|d}|jdkrV|dkrHtdtjd||d||S|jd|||d SdS) Nr&rrrrozReshape with allowzero=1r@)Z allowzero_i) rTr@rrUrrrrr)r{rrWZ allowzeror3r3r7r~s  rc Csrddlm}t|d}t|d}|dks0t|rr|dkrDtd|tjdg|tj | d} |j d| d}|dkst|r|dkrtd|tjd g|tj | d} |j d| d}|dkst|s|dkst|rf|dk r|dk st t|||j dtj||d gtjdd} |j d | dd dgd } ||| |j dtjddgtjdddd\}}||||fS)Nr) _var_meanroz@Unsupported: ONNX export of batch_norm for unknown channel size.rrrrgrZ Transposer)Zperm_iF)rrprrrrErUrrrrrrrKrr) r{rweightbiasZ running_meanZ running_varrpZ batch_sizeZ channel_sizeZ weight_valueZ bias_valueZ reshape_inZtrans_inr3r3r7_batchnorm_helpersf   rszCallable[[Any], Sequence[int]]zUnion[int, Sequence[int]]zTuple[int, ...])tuple_fnpaddingr]cCs*|r|dkrt|dt||S)Nrdivisor_override)r>rBrrb)rtruZ kernel_sizeZstridervrr3r3r7_avgpool_helpers  rw) op_train_moderr]c CsntjtjjkrdS|r tjj}ntjj}|tjkr6dSdt|}t dtjd|d|d|d dS)zMWarns the user if the model's training mode and the export mode do not agree.Nztrain=zONNX export mode is set to z, but operator 'z ' is set to z. Exporting with r) rZ training_moderZ TrainingModeZPRESERVEZTRAININGZEVALrCrr)rxrZ op_mode_enumZ op_mode_textr3r3r7rs  c Cs|d|}t||dgdg|gd}||jdtjdgtjddg}||dkrt||dg|dg|gd}||jdtjdgtjdd|g}|jd |d di} dd lm} | ||| S) Nrr)rrrrrrrrorr)_reshape_from_tensor)r)rrrUrrrry) r{rZ start_dimZend_dimrrJZslice1ZslicesZslice3Z final_shaperyr3r3r7_flatten_helpers$    rzcCs,|dkr dSt|r(|dkr(dSdS)NFr1Trk)Zsplit_size_or_sizesrsr3r3r7_is_split_staticsr{cCs|d}|tj|S)Nr)rZsetTyper Z OptionalTypeZofTensor)r{nr3r3r7rHs rHcsJt}|dk r:tfddt|Dr:|j|ddS|j|ddS)Nc3s|]}t|dkVqdS)rN)rr rr3r7 sz*_handle_reduce_dim_none..ro)rr)rrr'r)r{rrrPr3r}r7_handle_reduce_dim_nones rz%Optional[_C_onnx.TensorProtoDataType]z7Tuple[_C.Value, _C.Value, _C.Value, Optional[_C.Value]])r{qtensorqdtyper]c Cst|}|dd\}}}t|dkr.|dnd}t|dd}tj|} |dkrl| dk rd| }ntjj }|j d||d} |j d|tjj d}|j d||d}|dk rt j dkrtd t j dd ||j d | |||d |||fS) aAppends to graph `g` ONNX nodes that dequantizes `qtensor` into `tensor`. Args: g: Graph, the ONNX IR graph that is under construction. qtensor: torch._C.Value, either a tuple of (quantized_tensor, scale, zero_point) for per tensor quantization, or (quantized_tensor, scale, zero_point, axis) for per channel quantization, representing the quantized tensor. qdtype: torch.onnx.TensorProtoDataType default None, if not None, represents the data type of quantized tensor. It must be either torch.onnx.TensorProtoDataType.UINT8 or torch.onnx.TensorProtoDataType.INT8. Nrerfr%axisrrrZDequantizeLinear Attribute axis is not supported.r)rjrhr[rrrrcrrUINT8rrrrr) r{rrZunpacked_qtensorsrrrrrZ input_qdtyper2r3r3r7r#s2    )r{rrrrr]c Cs|dk r,t|s,tjdkr,tdtjdd||dk s8ttj|tjjtjj krf|j d|t j j d}|dk srttj|tjjtjj tjjhkr|j d|t j j d}|j d|||t|ddd }|||g}|dk rt|s|||j d |S) aiAppends to graph `g` ONNX nodes that quantizes `tensor` based on `scale`, `zero_point` and `axis`. Args: g: Graph, the ONNX IR graph that is under construction. tensor: torch._C.Value, representing the tensor to be quantized. scale: torch._C.Value, quantized scale. zero_point: torch._C.Value, quantized zero point. axis: Optional[torch._C.Value] default None, if None, represents per tensor quantization. Otherwise, represents per channel quantization, along given axis. Returns: A TupleConstruct storing information of the quantized tensor. NrZQuantizeLinearrrrr%rrr)r)rrrrrKrrrrrrrrrINT8r[r)r{rrrrrr|r3r3r7rTsP     c Cs|d||}|d|}|jd|tjdgtjdd}|jd|d||tjjd }g} |d k rtt|st| ||jd |||f| S) adIn PyTorch, bias is float and is quantized to int32 implicitly inside the quantized ATen op kernel. In ONNX we need to make the quantization explicit because operators expect all of their inputs to be quantized. Since int32 is not a supported output type by ONNX operator `QuantizeLinear`, quantization is exported using regular operators. ZMulrr?rrrrrrNr) rrUrr4rrINT32rr) r{rrZ input_scaleZ weight_scalerZ bias_scaleZbias_scale_shapeZbias_zero_pointZq_biasZ axis_argsr3r3r7r s    cs2|sttj|dtfdd|D}|S)Nrc3s|]}tj|kVqdSrR)rrr)r6elemZ base_dtyper3r7r~sz'args_have_same_dtype..)rKrrrall)r|Zhas_same_dtyper3rr7rs  z1.13z2.0z>remove its usage and avoid setting internal variables directlyZ opset_versioncCs |t_dSrR)rrrr3r3r7_set_opset_versionsrcCs |t_dSrR)rr)rr3r3r7_set_operator_export_typesronnx_shape_inferencecCs |t_dSrR)rrrr3r3r7_set_onnx_shape_inferencesr) ByteCharDoubleFloatHalfIntLongShortBool ComplexFloat ComplexDoubleBFloat16 UndefinedrrrrrrrrrrrQInt8QUInt8QInt32r)Zuint8_tZint8_trr9halfr4Zint64_tZint16_trC complex64 complex128qint8quint8qint32bfloat16)rrrrrrrrrrrrrrrrzSet[int]_quantized_ops)NN)T)N)N)N)N)T)N)TN)TFN)Nror)NNN)r)N)N)N) __future__rrrur%rrrrrrrrr r r r rUZtorch._C._onnxr Z_onnxrZ torch.onnxrrrrZtorch.onnx._globalsrZtorch.onnx._internalrrZ torch.typesr__all__r-ZbeartyperGr=rOrTrYr[r_rdrjrlrrrrrr@rZrrrrrrarrrrrrrrrrrrrrrrrrr rrrrrr+r,r0r3r9rArNrQrVrZr^rargrirkrnrrsrwrrzr{rHrrrr r deprecatedrrrrrrrrZFLOAT16rrZINT16rrrrrrr!Zuint8Zint8shortr4rrr9rZ complex32rrrCrrrrr#rr"setr__annotations__r3r3r3r7sZ 0     E     N          #& Cc   **!9    0=