o
    hA                    @  sJ  U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlmZm	Z	m
Z
mZmZ d dlmZmZ d dlZd dlm  mZ d dlmZ d dlmZmZmZmZ d dlmZ d dlm Z  ej!rod d	l"m#Z# d d
l$m%Z% edZ&edZ'edZ(e
d Z)		d%d&ddZ*d'ddZ+d(ddZ,d)d"d#Z-d$d% Z.d&d' Z/d*d+d,Z0d+d/d0Z1d+d1d2Z2d,d5d6Z3d-d9d:Z4ddd;d<d.dDdEZ5d/dHdIZ6dJdK Z7d0dLdMZ8d0dNdOZ9d1dPdQZ:d2dRdSZ;d3dWdXZ<d2dYdZZ=d2d[d\Z>d2d]d^Z?d2d_d`Z@d2dadbZAd4dcddZBd5d6dfdgZCd7djdkZDd8dldmZEd9d:drdsZFd9d;dvdwZG	d9d<dzd{ZH	d9d=d}d~ZId>ddZJd?ddZKd@ddZLdAddZMd5dBddZN	d9dBddZOdCddZPdCddZQdBddZRdDdBddZS	dEdBddZTdBddZUdd ZVdBddZWdBddZX			 dFdBddZYdBddZZdBddZ[dBddZ\dBddZ]dBddZ^dGddZ_dd Z`dBddZadBddZbdBddZcdBddZddBddZe	dHdIddÄZfdBddńZgdBddǄZhdBddɄZidJdBdd˄ZjdBdd̈́ZkdKddԄZldLddׄZmdBddلZnddۄ Zodd݄ ZpdBdd߄Zq	d9dMddZr	d9dNddZs	d9dBddZtdd ZudBddZvdBddZwdd Zxd5ddZydd Zz	;d5dOddZ{d%dBddZ|d%dBddZ}dBd dZ~e4dddddBddZdBddZdPddZejjejjejjejjejjejjejjejjejjejjejjejjejjdZdddddddddddddddd ZejejejejejejejejejejejejejejejejgZejejejejejejejejejejejejejejejd!Zed ed ed ed ed ed ed ed ed" ed ed ed ed ed ed ed gZe Zd#ed$< dS (Q      )annotationsN)AnyCallableLiteralNoReturnTypeVar)Concatenate	ParamSpec)_C)
_constants_type_utilserrorsutils)GLOBALS)	jit_utils)Sequence)Number_T_U_P)	viisffsbstnonedesc_ValueDescriptorarg_name
str | None	node_namec              	   C  s  |dkr| S |dkst | s| S |  }| rd S | dkrnt|d}|dkr-t|S |dkr5t|S |dkr=t|S |dkrEt|S |d	krK|S |d
krVdd |D S |dkradd |D S t	
d| d| d| | dkr|d
kr| D ]}| }| dkrt	
d| d| d| q|dd |   D S t	
d| d| |d u s|d u rt	
d|  d| t	
d| d| d|  d| )Nr   r   onnx::Constantvaluer   r   r   r   r   r   c                 S     g | ]}t |qS  )int.0r   r'   r'   n/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/onnx/symbolic_helper.py
<listcomp>L       z_parse_arg.<locals>.<listcomp>r   c                 S  r&   r'   )floatr)   r'   r'   r+   r,   N   r-   z5ONNX symbolic does not understand the Constant node 'z' specified with descriptor ''.prim::ListConstructzFailed 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.c                 S  s   g | ]}t t| d qS r%   )r(   	_node_getnoder)   r'   r'   r+   r,   a   s    zbONNX 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_valuer3   
mustBeNonekindr2   r(   r.   boolstrr   SymbolicValueErrorinputs)r%   r   r!   r#   r3   node_valr   element_noder'   r'   r+   
_parse_arg1   s~   
r>   r3   _C.Nodekeyr9   c                 C  s(   t | tjsJ | |}t| ||S )z@Gets attributes of a node which is polymorphic over return type.)
isinstancer
   NodekindOfgetattr)r3   r@   selr'   r'   r+   r2   v   s   
r2   r%   _C.Valuec                 C     |    dkS )z$Whether a Value is an ONNX constant.r$   r3   r7   r1   r'   r'   r+   _is_onnx_constant}   s   rI   2_C.Value | torch.Tensor | Number | Sequence | None
descriptorc                 C  s"   t | tjrt| rt| |S | S N)rA   r
   ValuerI   r>   )r%   rK   r'   r'   r+   _maybe_get_const   s   
rN   c                 C  s(   t | d}t|tjr|jdkr|S | S )Nr   r'   )rN   rA   torchTensorshape)r%   value_tr'   r'   r+   _maybe_get_scalar   s   
rS   c                 C  s,   t | std| d|  d| t| |S )Nz0ONNX symbolic expected a constant value of the 'z' argument, got 'r4   )_is_constantr   r:   r>   )r%   r   r!   r'   r'   r+   
_get_const   s   
rU   
list_valuereturnlist[_C.Value]c                 C  s4   |   }| dkrtd| d| t| S )Nr0   z;ONNX symbolic expected node type prim::ListConstruct, got 'r/   )r3   r7   r   r:   listr;   )rV   	list_noder'   r'   r+   _unpack_list   s   
r[   tuple_valuetuple[_C.Value, ...]c                 C  s4   |   }t| std|  d| t| S )Nz>ONNX symbolic expected node type 'prim::TupleConstruct', got 'r/   )r3   _is_tuple_constructr   r:   r7   tupler;   )r\   
tuple_noder'   r'   r+   _unpack_tuple   s   ra   c                 C  s`   |   }t| std| d|  dtj | t| }t	|dks.t	|dks.J |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       )
r3   r^   r   r:   r7   r   PYTORCH_GITHUB_ISSUES_URLr_   r;   len)r\   r`   unpackedr'   r'   r+   _unpack_quantized_tensor   s   rg   r   r8   c                 C  s   t | o|   dkS )Nr0   r5   r3   r7   )rV   r'   r'   r+   _is_packed_list   s   ri   arg_descriptorsRCallable[[Callable[_Concatenate[_U, _P], _T]], Callable[_Concatenate[_U, _P], _T]]c                    s   d fdd}|S )a  A 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
    fn"Callable[_Concatenate[_U, _P], _T]rW   c                   s$    _ t d fd	d
}|S )Ngr   args_P.argskwargs	_P.kwargsrW   r   c              	     s
  d}t t |ksJ dt | dt  dj d| zt}t|j dd  }j W n tyF   d gt | }d  Y nw  fddt||D }t |dkseJ d	j d
| t |dkrzd|v szJ d	j d| | g|R i |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'.    c                   s    g | ]\}}}t ||| qS r'   )r>   )r*   argarg_descr!   fn_namer'   r+   r,   	  s    zBparse_args.<locals>.decorator.<locals>.wrapper.<locals>.<listcomp>zSymbolic function z4's '**kwargs' can contain a single key/value entry. _outputsz='s '**kwargs' can only contain '_outputs' key at '**kwargs'. )	re   __name__inspect	signaturerY   
parameterskeys	Exceptionzip)rn   ro   rq   FILE_BUG_MSGsig	arg_names)rj   rl   rv   r+   wrapper   sD   






z.parse_args.<locals>.decorator.<locals>.wrapper)rn   r   ro   rp   rq   rr   rW   r   )_arg_descriptors	functoolswrapsrl   r   rj   rl   r+   	decorator   s   )zparse_args.<locals>.decoratorN)rl   rm   rW   rm   r'   )rj   r   r'   r   r+   
parse_args   s   1r   T)scale
zero_pointquantize_outputarg_q_descriptorsr   float | Noner   
int | Noner   .Callable[[Callable[_P, _T]], Callable[_P, _T]]c                   s    fdd}|S )a  A 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
    c                   s"   t   fdd}|S )Nc                   s  d ur| j dtd}nd }d ur | j dtd}nd }dt|t   }tt||}dd  g }|D ]"\}t|rW| fdd| 	 D  q=|
 | q=t|so| g|R i |S g }	|D ][\} |rt| |\}
}}}|	
|
 |d u r|}|d u r|}qst|r| 	 D ]!} |rt| |\}
}}}|d u r|}|d u r|}||
 q|	
| qs|	
| qs| g|	R i |}|d usJ d|d usJ d	rt| |||S |S )
NConstantrR   )Fc                 S  s   | o	t |o	t|S rL   )r5   r^   )rK   rt   r'   r'   r+   _is_arg_quantizedd     zMquantized_args.<locals>.decorator.<locals>.wrapper.<locals>._is_arg_quantizedc                 3  s    | ]} |V  qd S rL   r'   )r*   	arg_inputr   rK   r'   r+   	<genexpr>l  s
    
zEquantized_args.<locals>.decorator.<locals>.wrapper.<locals>.<genexpr>z-Bug: Scale must be set for quantized operatorz2Bug: Zero point must be set for quantized operator)oprO   tensorre   r_   r   ri   extendr3   r;   appendanydequantize_helperreplaceAllUsesWithquantize_helper)rn   ro   rq   _scale_zero_pointarg_q_descriptors_extendeddescriptor_argsis_quantizedrt   non_quantized_argsdequantized_arg	arg_scalearg_zero_point_r   output)r   rl   r   r   r   r   r+   r   Q  sr   






z2quantized_args.<locals>.decorator.<locals>.wrapperr   r   r   r   r   r   r   r   r+   r   P  s   Tz!quantized_args.<locals>.decoratorr'   )r   r   r   r   r   r'   r   r+   quantized_args!  s   /Xr   xNumber | Nonec                 C  s"   t | tjr| jdkr|  S dS )z,Convert a scalar tensor into a Python value.r'   N)rA   rO   rP   rQ   itemr   r'   r'   r+   _scalar  s   r   c                 C  sJ   t | tjr| S tj|tjj}|tjjkr#|  }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.
    )
rA   r
   rM   r   JitScalarType
from_value	UNDEFINEDscalar_namelowerrD   )selfr   scalar_typetyr'   r'   r+   _if_scalar_type_as  s   r   c                 C  s$   | d u pt | tjr|   S dS NF)rA   r
   rM   r3   r6   r   r'   r'   r+   _is_none  s   $r   c                 C  s   t | tjS rL   )rA   r
   rM   r   r'   r'   r+   r5     s   r5   c                 C  s   t |  p|   dv S )N>   r$   prim::Constantrh   r1   r'   r'   r+   rT     s   rT   c                 C  s   |   tj S rL   )typeisSubtypeOfr
   
TensorTypegetr   r'   r'   r+   
_is_tensor  r   r   jit_type
_C.JitType_C.ListType | Nonec                 C  s   t | tjr| S d S rL   )rA   r
   ListType)r   r'   r'   r+   _as_list_type  s   r   c                 C  s   t |  d uS rL   )r   r   r   r'   r'   r+   _is_list     r   c                 C  s(   t |  }|d u rdS t| tjS r   )r   r   rA   getElementTyper
   r   r   x_typer'   r'   r+   _is_tensor_list  s   r   c                 C  s,   t |  }|du rdS tj| }| 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)r   r   r   r   r   onnx_compatible)r   r   r   r'   r'   r+   _is_scalar_list  s
   r   c                 C  rG   )Nprim::TupleConstructrH   r   r'   r'   r+   r^     r   r^   c                 C  s4   t | sJ tj| tjjtjjtjjtjjhv S rL   )r5   r   r   r   r   	COMPLEX32	COMPLEX64
COMPLEX128r   r'   r'   r+   is_complex_value  s   r   c                 C  s6   t | r
|  d u rd S |  }ttj|}| S rL   )r   r   typingcastr
   r   dimr   r'   r'   r+   _get_tensor_rank  s
   r   allow_nonstaticc                 C  sB   t | r
|  d u rd S |  }ttj|}|r| S | S rL   )r   r   r   r   r
   r   varyingSizessizes)r   r   r   r'   r'   r+   _get_tensor_sizes  s   r   r   r(   c                 C  s   t | }|r
|| S d S rL   )r   )r   r   r   r'   r'   r+   _get_tensor_dim_size  s   r   c                 C  sn   |dkrt | }|d usJ || S |d u r5t| }|d us J t|D ]\}}|d ur4|dkr4|  S q$|S )Nrb   )r   r   	enumerate)r   r   tensor_rankr   indexsizer'   r'   r+   _get_dim_for_cross!  s   r   r   msg_C.Value | NoneNonec                 C  s*   t jtjjkrt|  d| | d S d S )Nz, )r   operator_export_type_C_onnxOperatorExportTypesONNX_onnx_unsupported)r   r   r%   r'   r'   r+   _unimplemented0  s   r   op_namer   c                 C  s4   d|  dt j }t|tjrt||t|)Nz%Unsupported: ONNX export of operator zR. Please feel free to request support or submit a pull request on PyTorch GitHub: )r   rd   rA   r
   rM   r   r:   OnnxExporterError)r   r%   messager'   r'   r+   r   6  s   
r   current_opsetsupported_opsetc                 C  s:   d|  d| d| d}t |tjrt||t|)NUnsupported: ONNX export of 
 in opset . Please try opset version .rA   r
   rM   r   r:   r   )r   r   r   r%   r   r'   r'   r+   _onnx_opset_unsupportedD  s   
r   reasonc              	   C  s@   d|  d| d| d| d	}t |tjrt||t|)Nr   r   z. r   r   r   )r   r   r   r   r%   r   r'   r'   r+    _onnx_opset_unsupported_detailedV  s   
r   namec                   s    fdd}|S )Nc                    s   t d  dtj d)NzONNX export failed on z%, which is not implemented for opset z*. Try exporting with other opset versions.)r   r   r   export_onnx_opset_versionro   rq   r   r'   r+   symbolic_fnj  s
   z)_block_list_in_opset.<locals>.symbolic_fnr'   )r   r  r'   r   r+   _block_list_in_opseti  s   r   _type_utils.JitScalarType | Nonec                  G  s4   | D ]}t j|t jj}|t jjkr|  S qd S rL   )r   r   r   r   )ro   rt   r   r'   r'   r+   _try_get_scalar_typet  s   r  _type_utils.JitScalarTypec                  G  sl   t jj}dd | D }t|dkr|S t|dkr|d S |d  }|D ]
}t|| }q%t j|S )Nc                 S  r&   r'   )r  )r*   rt   r'   r'   r+   r,     r-   z-_type_promote_from_values.<locals>.<listcomp>r   rs   )r   r   r   re   dtyperO   promote_types
from_dtype)ro   undef	jit_types	new_dtyper   r'   r'   r+   _type_promote_from_values~  s   r  rn   jit_utils.GraphContextc                 C  s.   t j|t jj|kr| jd|| dS |S NCastto_i)r   r   r   r   r   	onnx_type)rn   r%   r   r'   r'   r+   _maybe_cast_to_type  s   r  c                 C  s   t |}t|}t|s| jdt|gd}n|d ur1|r1|dkr1t| || jdtdgd}tj	|tjj
}|tjjtjjhvrN| jd|tjjd}| jd|||dS )	Nr   r   r   rs   r  r  Gatheraxis_i)rS   r   r5   r   rO   
LongTensor_reshape_helperr   r   r   r   INT64INTr   TensorProtoDataType)rn   r   r   r   apply_reshapeindex_const	index_dimindex_scalar_typer'   r'   r+   _select_helper  s$   r   c                 C  sD   | j dkrddlm} || ||||S ddlm} || |||||S )N	   r   )_slice)opsettorch.onnx.symbolic_opset9r"  torch.onnx.symbolic_opset10)rn   inputaxesstartsendssteps_slice9_slice10r'   r'   r+   _slice_helper  s
   
r-  c                 C  s.   t j| t jjt jjt jjt jjt jjhv S rL   )r   r   r   r   FLOATDOUBLEHALFBFLOAT16r1   r'   r'   r+   _is_fp  s   r2  c                 C  s   t j| t jjt jjhv S rL   )r   r   r   r   BOOLr1   r'   r'   r+   _is_bool  s
   r4  c                 C  sH   t |tjrJ t |tr| jdtj|tjddS | jdt|dS )a  Creates 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
    r   r  r   )rA   rO   rP   r.   r   r   double)rn   scalarr'   r'   r+   _generate_wrapped_number  s   
r8  c              
   C  s   |d ur	t dd | d|}| d|| jdtj|gtjdd}| jdkr8|s.t dd	 | jd
|||ddS | jd
||||ddS )NSortOut parameter is not supportedShaper  r   r5  r   
   Ascending is not supportedTopK   r  outputs)r  	largest_irA  )r   r   rO   r   int64r#  )rn   r&  r   	decendingoutshape_	dim_size_r'   r'   r+   _sort_helper  s   


rH  Fc              	   C  s   |d ur	t dd t|s| jdtj|gtjdd}n!t| || jdtdgd}t|tj	j
kr=| jd|tjj
d}| jd	krS|sIt dd
 | jd|||ddS | jd|||||ddS )Nr>  r:  r   r5  r   rs   r  r  r<  r=  r?  r@  )r  rB  sorted_irA  )r   r5   r   rO   r   rC  r  r  r   r   r  r   r  r#  )rn   r&  kr   largestsortedrE  r'   r'   r+   _topk_helper  s   


rM  c                 C  s:   | j dkrddlm} || ||S ddlm} || ||S )N   r   )lt)r#  torch.onnx.symbolic_opset8rO  r$  )rn   r&  other_lt8_lt9r'   r'   r+   
_lt_helper  s
   
rT  c                 C  s6   t jdkrdnd}td| d tt j d  d S )Nr<  z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.)r   r   warningswarnr9   )interpolate_modeonnx_opr'   r'   r+   _interpolate_warning  s   rY  c                 C  s   t |dkr|S t|d r/| jdkr'| jdtj|tjdd}| d||S | jd||dS | jdk r:td|| d||d S )	Nr      r   r5  r   	Unsqueezeaxes_iz<Opset version must be >= 13 for Unsqueeze with dynamic axes.)	re   rT   r#  r   rO   r   longr   r:   )rn   r&  r]  r'  r'   r'   r+   _unsqueeze_helper+  s   

r_  c                 C  s   t |d r'| jdkr| jdtj|tjdd}| d||S | jd||dS | jdk r2td||d }t|}|d us@J |d	krJtd
||dkr\t	| |dg}| d||S | d||S )Nr   rZ  r   r5  r   Squeezer\  z:Opset version must be >= 13 for Squeeze with dynamic axes.rs   zCFor Squeeze axses as input, the axes rank must be one in ONNX spec.)
rT   r#  r   rO   r   r^  r   r:   r   r_  )rn   r&  r]  r'  axes_t	axes_rankr'   r'   r+   _squeeze_helper<  s(   

rc  rs   c                 C  sr   t |d}| jdkr0|r't|s| jdtj|tjdd}| jd||||dS | jd|||dS | jd|||dS )	Nr   rZ  r   r5  r   	ReduceSum)
keepdims_inoop_with_empty_axes_ir]  re  )rN   r#  r5   r   rO   r   r^  )rn   r&  r]  re  rf  r'   r'   r+   _reducesum_helperU  s*   

rh  c                   s   t dtrOd}| jdtj|tjdd}| jdtjjd}t	| | dd	gt
jg|gd
}| jd|tjjd}| d||}| jd||d	d}	|	S  fddtd	 D }
| jdtj|
tjdd}	|	S )Nr   r?  r   r5  r   r  r  r;  r   r'  r)  r(  DivConcatr  c                   sD   g | ]}|d k r
dnt  |   t    |    qS )r?        ?)r.   r   r   r*   r   r   r&  output_sizer'   r+   r,     s    z/_interpolate_size_to_scales.<locals>.<listcomp>)rN   r5   r   rO   onesfloat32r   r  r.  r-  sysmaxsizeranger   )rn   r&  ro  r   offsetoffsetsdividenddivisor
scale_dimsscalesscales_constantr'   rn  r+   _interpolate_size_to_scalest  s&   
r|  c                 C  sv   t |d ddkot|d  }|sd S | jdtjdtjdd}| jdtt |d dd}| jd||dd	}|S )
Nr   r   r   r   r?  r5  r   rk  r  )rN   r   r   rO   rp  rq  r   )rn   rz  available_scalesrv  scales_listr'   r'   r+   $_interpolate_get_scales_if_available  s   r  c                 C  s@   |dkrd }|dd  }n
|d }|dd  }t | |}||fS )Nnearestr   rs   )r  )rn   modero   align_cornersrz  r'   r'   r+   _get_interpolate_attributes  s   
r  c                   s   | j dtjdtjdd}t }t  tjs!|d ur*|dkr*| j d| ddS t	|  dg | j d t
jjd	  fd
dt|d D }| j d|g|R ddi  S )Nr   r?  r5  r   r   rk  r  r  r  c                      g | ]} qS r'   r'   rm  scale_factorr'   r+   r,         z+_interpolate_get_scales.<locals>.<listcomp>r  )r   rO   rp  rq  r   rA   r   r
   r   r_  r   r  r.  rt  )rn   r  r   rv  scale_factor_rankrz  r'   r  r+   _interpolate_get_scales  s   
r  c                   s  t |d}d|v rd}d|v rd}t| t |d}t|tr&|r&tddS |  s1tddS |  }t|sEt| ||}||fS t st	 sxt  d d	k}|rxt
|  d	g  fd
dt|d D  | jdg R dd	i t| | |}||fS tddS )Nr   linearcubicr   interpolatezalign_corners == Truemissing input shaper   r   c                   r  r'   r'   rm  r   r'   r+   r,     r  z4_interpolate_get_scales_and_mode.<locals>.<listcomp>r?  rk  r  z.Both size and scales are None in __interpolate)rN   rY  rA   r8   r   r   r   r   r  ri   r_  rt  r   r|  )rn   r&  r   r  r  r  r   	is_scalarr'   r  r+    _interpolate_get_scales_and_mode  s6   



r  r&  torch._C.Valuekeepdimc                   s    fdd}t |rGt | jdtdgd}||ddd}|rE d	|} d	|}	 jd
|	tjdgtjdd}
 d||
}|S t|d}||||dS )Nc                   s0    j dkr j| ||ddS  j| ||dS )N   F)r  re  select_last_index_ir  re  )r#  r   )r&  r  re  rn   r   r'   r+   
op_wrapper  s   
z)_argmin_argmax_helper.<locals>.op_wrapperr   r   r   r   Fr  r;  ConstantOfShapers   r5  Reshaper   )r   r  r   rO   r   rC  r>   )rn   r&  r   r  r   r  	flattenedr   input_shapeinput_shape_shape	new_shaper'   r  r+   _argmin_argmax_helper  s$   
r  c                   s   t ddd fdd}|S )NTFc                   s6  t |  |\}}t|} dkrdn|rdnd}|d u rw| d|}t| |dgdgdgd}| jd	|tjjd
}| jd||dd}| jdkrOt| }	t| }
n| jdt	j
g t	jdd}	| jdt	j
g t	jdd}
| jd||	|
||d dd	S | jdkrt| }	n| jdt	j
g t	jdd}	| jd||	||d ddS )Nr  
asymmetricr  
half_pixelr;  r   r?  ri  r  r  rk  r  rZ  r   r5  r   Resize      floor coordinate_transformation_mode_scubic_coeff_a_fmode_snearest_mode_s)r  rS   r   r-  r   r  r  r#  "_optional_input_placeholder_tensorrO   r   rq  )rn   r&  ro  ro   rz  r  coordinate_transformation_mode
input_sizeinput_size_beg	empty_roiempty_scalesrW  r'   r+   r    sh   




z(_interpolate_helper.<locals>.symbolic_fn)r   )r   r   rW  r  r'   r  r+   _interpolate_helper  s   
>r  c                   s,  t |d}d|v rd}d|v rd}t |d}t|tsdn|}|dkr%dn|r)dnd	}t s| d
|}t| |dgdgdgd}zt  oOt  d dk}	W n tyf   t  }	|	sdt	
d Y nw |	rt|}
|
d u rvtddS t|  dg  fddt|
d D  | jdg R ddi | jd tjjd | jd| dd | jdkrt| }t| }n| jdtjg tjdd}| jdtjg tjdd}| jd||| |d|dd 	S t|}
|
d u rtd!d"S | jdkrt| }n| jdtjg tjdd}t| ||
}| jd||||d|dd S )#Nr   r  r  r   Fr  r  r  r  r;  r   r?  ri  r   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)c                   r  r'   r'   rm  r  r'   r+   r,   y  r  z(__interpolate_helper.<locals>.<listcomp>rk  r  r  r  r  rZ  r   r5  r   r  r  r  r  zinterpolate (with scales)r  )rN   rA   r8   r   r   r-  ri   r   AttributeErrorrU  rV  r   r   r_  rt  r   r  r  r#  r  rO   r   rq  r  )rn   r&  r   r  r  r  recompute_scale_factorr  r  r  rankr  r  rz  r'   r  r+   __interpolate_helperF  s   
	







r  c                 C  sJ   | j dk rddlm} n| j dkrddlm} nddlm} || |||S )N   r   )unbindr  )r#  r$  r  torch.onnx.symbolic_opset11torch.onnx.symbolic_opset13)rn   r   r   rx   r  r'   r'   r+   _unbind_helper  s   

r  c                 C  s4   | j dkrddlm} nddlm} || ||||S )Nr<  r   scatter)r#  r$  r  r  )rn   r   r   r   srcr  r'   r'   r+   _scatter_helper  s   
r  c                 C  sp   | j dkr| jd|dg| ||d}nddlm} | jdtdg| d}|| ||||d	}|dkr5|S |gS )
Nr  Splitrs   )split_ir  rA  r   )splitr   r   )rx   )r#  r   r  r  rO   r   )rn   r   repsr   	split_outr  repeatsr'   r'   r+   _repeat_interleave_split_helper  s   
r  c                 C  s,  ddl m}m} t|s| jdt|d}t|}t|d}t	|dkr5| d|| jdt
dgd}|| ||d }|rWtjt	|tjd}	||	|d < | jd|	d}
n/| d	|| |d d| jdt
t	|d| jd
| jdt
dgd|dd}	|| |	dd}
| d||
}|| |||d S )Nr   )flatten	unsqueezer   r   r   r  rs   r5  OneHotrk  r  Tile)r$  r  r  r   r   rO   r  rT   rN   r   r   rp  rC  )rn   r   r  r   r  r  const_repeatsr  
unsqueezedonehotrepeats_per_dimtiledr'   r'   r+   -_repeat_interleave_single_value_repeat_helper  s2   
 
r  Stuple[_type_utils.JitScalarType, _C.Value | None, _C.Value | None, _C.Value | None]c                 C  s   dd }|d u st |r%t|r%||||grtjj}ntjt }nt|t	s,J t|}|r=| j
d|| dnd }|rK| j
d|| dnd }|rY| j
d|| dnd }||||fS )Nc                 S  s>   | D ]}t j|t jj}|t jjkr|t jjkr dS qdS )NFT)r   r   r   r   r  )scalarsr7  r   r'   r'   r+   _is_all_integral  s   z-_arange_cast_helper.<locals>._is_all_integralr  r  )r5   r   r   r   r  r  rO   get_default_dtyperA   r(   r   r  )rn   endstartstepr  r  r   r'   r'   r+   _arange_cast_helper  s   

r  c                 G  s4   | j dkrddlm} nddlm} || g|R  S )Nr<  r   )arange)r#  r$  r  r  )rn   ro   r  r'   r'   r+   _arange_helper  s   
r  c                 C  s8   |  d|}ddlm} || || j dtdgd|S )Nr;  r   )selectr   r   )r   r$  r  rO   r   )rn   r   r   
full_shaper  r'   r'   r+   _size_helper#  s    r  c           
   	     s   ddl m} | jdkrddl m} nddlm} |  d u r%tddS |  }t|d  dk r8 |7  t	| | fdd	t
|D }|| | d
|dt	| |dg| d
|}|| ||d }	||	fS )Nr   )expandr<  r  
index_fillzinput rank not accessibler   c                   s   g | ]}| kr|qS r'   r'   rm  	dim_valuer'   r+   r,   ?  s    z._index_fill_reshape_helper.<locals>.<listcomp>r;  )r$  r  r#  r  r  r   r   r   r>   r_  rt  r   )
rn   r   r   r   r  r  self_dimunsqueezed_indexexpanded_index_shapeexpanded_indexr'   r  r+   _index_fill_reshape_helper*  s$   


$r  c                 C  sh   t |d}t|s| jdt|d}| jdkr+|dkr$tdtjd| | d||S | jd|||d	S )
Nr   r   r   rZ  rs   zReshape with allowzero=1   r  )allowzero_i)	rN   r5   r   rO   r  r#  r   r   r   )rn   r&  rQ   	allowzeror'   r'   r+   r  M  s   


r  c              	   C  sn  ddl m} t|d}t|d}|d u st|r9|d u r"td|tjdg| tj	
| d}	| jd|	d}|d u sAt|rb|d u rKtd|tjd	g| tj	
| d}
| jd|
d}|d u srt|sr|d u srt|r|d urz|d us|J t| || jdtj||d
gtjdd}| jd|g dd}|| || jdtjddgtjdddd\}}||||fS )Nr   )	_var_meanrs   z@Unsupported: ONNX export of batch_norm for unknown channel size.rl  r5  r   r   g        r   	Transpose)r   r?  rs   )perm_iF)r$  r  r   r   r   r:   rO   r   r   r   r   r  r   r  rC  )rn   r&  weightbiasrunning_meanrunning_varr  
batch_sizechannel_sizeweight_value
bias_value
reshape_intrans_inr'   r'   r+   _batchnorm_helper[  sb   

r  tuple_fnCallable[[Any], Sequence[int]]paddingint | Sequence[int]tuple[int, ...]c                 C  s*   |r|   dkrt|d t| |S )Nr   divisor_override)r3   r7   r   r_   )r  r  kernel_sizestrider  r   r'   r'   r+   _avgpool_helper  s   
r  op_train_modec                 C  sn   t jtjjkr	dS | rtjj}ntjj}|t jkrdS dt|  }t	dt j d| d| d| d	 dS )zMWarns the user if the model's training mode and the export mode do not agree.Nztrain=zONNX export mode is set to z, but operator 'z' is set to z. Exporting with r   )
r   training_moder   TrainingModePRESERVETRAININGEVALr8   rU  rV  )r  r   op_mode_enumop_mode_textr'   r'   r+   check_training_mode  s   

r  c                 C  s   |  d|}t| |dgdg|gd}|| j dtjdgtjddg}||d k rGt| |dg|d g|gd}|| j dtjdgtjdd|g}| j d	g|R d
di}	ddlm}
 |
| ||	S )Nr;  r   )r'  r(  r)  r   r   r5  r   rs   rk  r  )_reshape_from_tensor)r   r-  rO   r   r^  r$  r  )rn   r&  	start_dimend_dimr   r  slice1slicesslice3final_shaper  r'   r'   r+   _flatten_helper  s    r  c                 C  s,   |d u rdS t | r|   dkrdS dS )NFr$   Trh   )split_size_or_sizesrx   r'   r'   r+   _is_split_static  s   r  c                 C  s   |  d}|tj  |S )Nr   )r   setTyper
   OptionalTypeofTensor)rn   nr'   r'   r+   r    s   
r  c                   sJ   t  }|d urt fddt|D r| j| ddS | j| ddS )Nc                 3  s    | ]
}t  |d kV  qdS )r   N)r   rm  r   r'   r+   r     s    
z*_handle_reduce_dim_none.<locals>.<genexpr>rs   re  r   )r   r   rt  r   )rn   r   r   r  r'   r  r+   _handle_reduce_dim_none  s   r  qtensorqdtype"_C_onnx.TensorProtoDataType | None4tuple[_C.Value, _C.Value, _C.Value, _C.Value | None]c                 C  s   t |}|dd \}}}t|dkr|d nd}t|dd}tj|}	|du r6|	dur2|	 }ntjj	}| j
d||d}
| j
d|tjjd}| j
d||d}|durbtjdk rbtd	tjdd
| | j
d	|
|||d|||fS )a  Appends 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.
    Nrb   rc   r   axisr  r  rZ  DequantizeLinear Attribute axis is not supported.r  )rg   re   rU   r   r   r   r  r   r  UINT8r   r.  r   r   r   )rn   r  r  unpacked_qtensorsr   r   r   r  r  input_qdtyper%   r'   r'   r+   r     s2   
	r   r   r  c              	   C  s   |durt |stjdk rtdtjdd| |dusJ tj|tjjtjjkr3| j	d|t
jjd}|dus9J tj|tjjtjjtjjhvrT| j	d|t
jjd}| j	d|||t|ddd	}|||g}|durtt |st|| | j	d
g|R  S )ai  Appends 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.
    NrZ  QuantizeLinearr  r  r  r   r  r  r   )r   r   r   r   r   r   r   r   r.  r   r   r  r   INT8rU   r   )rn   r   r   r   r  r   ro   r'   r'   r+   r     sH   



r   c           
      C  s   |  d||}|  d|}| j d|tjdgtjdd}| j d|  d||tjjd	}g }	|d
ur:t|s:|	| | j d|||g|	R  S )ad  In 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.
    Mulr;  r  r   r5  r   r  rj  r  Nr   )	r   rO   r   r(   r   r  INT32r   r   )
rn   r  input_scaleweight_scaler  
bias_scalebias_scale_shapebias_zero_pointq_bias	axis_argsr'   r'   r+   requantize_bias_helperW  s   
r.  c                   s2   | sJ t j| d  t fdd| D }|S )Nr   c                 3  s     | ]}t j| kV  qd S rL   )r   r   r   )r*   elem
base_dtyper'   r+   r   p  s    
z'args_have_same_dtype.<locals>.<genexpr>)r   r   r   all)ro   has_same_dtyper'   r0  r+   args_have_same_dtypem  s   r4  c              
   O  s  | dd}| dtjj}t|}tj|d }t|d  o)|du p)tj|k }|ro|D ]#}	|		 rQtj|	}
|
|krQt
d| d|  d|
  |	q.t|D ]\}}	|		 rnt|	sn| jd|	| d	||< qV| j|g|R i |}|r| jd|| d	}|S )
a  Some PyTorch operators (e.g., Clip/Min/ReLU/Pad) are super set of ONNX in terms of data types.
    This function maximizes the exportability of PyTorch-ONNX by allowing ONNX-unsupported PyTorch
    operator data type. For example, `Cast<int>(Clip<float>(Cast<float>(INPUT)))` can be used to mimic
    `Clip<int>(INPUT)` (opset version < 12).

    Args:
        g (torch._C.Graph): graph to write the ONNX representation into.
        op_name (str): operator name in ONNX.
        *args (tuple): operands to the operator.
        **kwargs (dict): attributes to the operator along with "opset_before" (optional, None by default)
            indicating the smallest opset version to trigger such casting behavior and "target_float_t"
            (optional, torch.onnx.JitScalarType.FLOAT by default) indicating the data type of internal operator.

    Returns:
        Optional[torch._C.Value, Tuple[torch._C.Value, ...]]: output(s) of the operator.
    opset_beforeNtarget_float_tr   z
Inputs of z must have same dtype.Got z and r  r  )popr   r   r.  rY   r   r2  r   r   isCompleteTensorr   r:   r   r   r   r  )rn   r   ro   rq   r5  r6  r;   dtype_0require_castr&  input_scalar_typer   r   r'   r'   r+   _op_with_optional_float_castv  sB   
r<  c                 C  sJ   t j|t jj}|t jjkr#t|s#|t jjkr#| jd|tjjd}|S r  )	r   r   r   r   r2  r  r   r   r  )rn   r   r   r'   r'   r+   _maybe_cast_reduce_op_input  s   r=  c                    s    fdd}|S )z_Returns a decorator that calls the decorated (higher-order) function with the given parameters.c                   s   |  i S rL   r'   r   r   r'   r+   _apply  s   z_apply_params.<locals>._applyr'   )ro   rq   r>  r'   r   r+   _apply_params  s   r?  c                   s   d fdd	}|S )Nc                   s   t | |}|d u s|dkrt| |S t|dd}| jdk r: r"dnd}t||d} r.|n|g}| j|||dS t|rA|}n rQ| jdtj|tjd	d
}n| jdtj|gtjd	d
}| j|||dS )Nr'   r   r     r   r   rg  r   r5  r   r  )	r=  r  rU   r#  r   r5   rO   r   r^  )rn   r   r   r  r   dim_listr'  allow_multi_dim_supportonnx_op_namer'   r+   symbolic  s&   

z,_reduce_op_symbolic_helper.<locals>.symbolicNNr'   )rD  rC  rE  r'   rB  r+   _reduce_op_symbolic_helper  s   rG  c                   s   t   fdd}|S )Nc                   sb    | g|R  }|D ]}|j }t|t|kr!|| g|R    S q
td j dt| dS )Nzaten::zwith z
 arguments)r   re   r   ry   )rn   ro   	overloadsoverloadrj   r   r'   r+   r     s   z'_overload_by_arg_count.<locals>.wrapperr   r   r'   r   r+   _overload_by_arg_count  s   rJ  rX  rC  c                   s$   t |  dt fdd}|S )N)rC  c                   sX   t dtddfdd} rdnd}t dtd|ddfdd	}||fS )
NTr   r   c                   s   d }|   dkr t|dd}t| }| jd||d}n|   dkr.t d|S | |}|d urKtj| }||krK| jd||d}|S Nr$   r   r  r  r  r   	r3   r7   rU   r   r   r  r   r   r   )rn   r   r  
dtype_onnxresultresult_dtype_onnxr   rE  r'   r+   reduce_nodim  s"   
z?_reduce_with_dtype_helper.<locals>.reduce.<locals>.reduce_nodimr   r   c                   s   d }|   dkr t|dd}t| }| jd||d}n|   dkr.t d|S | |||}|d urMtj| }||krM| jd||d}|S rK  rL  )rn   r   r   r  r  rM  rN  rO  rP  r'   r+   
reduce_dim  s"   z=_reduce_with_dtype_helper.<locals>.reduce.<locals>.reduce_dim)r   r   )rn   ro   rq   rQ  dim_descrR  rC  r   rE  r'   r+   reduce  s   z)_reduce_with_dtype_helper.<locals>.reduce)rG  rJ  )rX  r   rC  rU  r'   rT  r+   _reduce_with_dtype_helper  s   +rV  c                 C     |d u r|d u r| j d|ddS |d u rt| d||ddS t|dd}t|dd	}| jd
k r9| j d||g|d}n| j dtj|gtjdd}| j d|||d}| j d|||d}||fS )N	ReduceMaxr   r  Maxr  r5  r   r  r   r@  rg  r   r5  r   ArgMaxr  r   r<  rU   r#  rO   r   r^  )rn   r   dim_or_yr  r   maxr'  indicesr'   r'   r+   _max_helper$     
r`  c                 C  rW  )N	ReduceMinr   r  Minr  rZ  r   r  r   r@  rg  r   r5  r   ArgMinr  r\  )rn   r   r]  r  r   minr'  r_  r'   r'   r+   _min_helper8  ra  rf  c                 C  s   |  d|}| j d|ddS )Nr;  
ReduceProdr   r  )r   )rn   r   rQ   r'   r'   r+   _numel_helperL  s   rh  r   r   r   c              	   C  s  | j dk r|d u r| jd|dd}|}t| |}n1| jd|||d}| jd||dd}| d|}| jd|| jd	t|d
dd}| jd|dd}| d||}	| d|	|	}
|d u r^dn|}| jd|
||d}|d u rod}|dkr| jd|tjjd}| jd	tj|tjdd
}| d||}| d|| d||}||fS d }|d u r| jd|dd}|}t| |}n>| jd	tj|tj	dd
}| jd|||d}| jd||dd}| d|}| jd|| jd	t|d
dd}| jd|dd}| d||}	| d|	|	}
|d u r
dn|}|d u r| jd|
|d}n	| jd|
||d}|d u r*d}|dkrY| jd|tjjd}| jd	tj|tjdd
}| d||}| d|| d||}||fS )Nr@  
ReduceMeanr   r  rg  rs   r;  r  r   r   r  rg  Subr%  r  r  r5  rj  )
r#  r   rh  rO   r   r   r  r.  r.   r^  )rn   r&  r   
correctionr  meant_meannum_elementsredudced_dimssub_vsqr_subkeepdim_meanvaronemulr'  r'   r'   r+   _var_mean_helperQ  sz   





rv  c
              
   C  s  |r	t jr	tdS |	d ur|	dkrtd| jdtdd}
| jd|
tjj	d}
| jdtdgd}t
| t| || jdtdddg}|sY||g}| jd	g|R d
di}t| |dgdgtjgdgd}t| |dgdgtjgdgd}t| || jdtdd}tj| d||
dd\}\}}|j}t|}t| |jd||dd}|jd||dd}t
||dg}t
||dg}|d||||}|jd||dd}t|s|d||||}t
||dg}|d||}|dkrt||dgdd}nV|dkr)|jdk r|jd|dgdd}n@|jdtjdgtjdd}|jd||dd}n(|jdk r:|jd|dgdd}n|jdtjdgtjdd}|jd||dd}|jd|
tjj	d}t|| t|| |  d d d fS )Nz7embedding_bag with scale_grad_by_freq for training moder   zembedding_bag with padding_idxr   rs   r   r  r  rk  r  )r'  r(  r)  r*  Loop)n_blocksr  r  Slicer%  rg  r@  ri  r5  r  rX  )r   export_trainingr   RuntimeErrorr   rO   r   r   r  r3  r_  r  r-  rr  rs  r   add_op_with_blocksblockr   _add_input_to_blockr   rh  r#  r^  _add_output_to_blockr3   r   )rn   embedding_matrixr_  rv  scale_grad_by_freqr  sparseper_sample_weightsinclude_last_offsetpadding_idxloop_conditionzeroindices_lenoffsets_startsoffsets_endsloop_lenlooploop_contextr   
loop_blockblock_input_iterindices_startindices_endindices_row
embeddingsper_sample_weights_rowr'  cond_outr'   r'   r+   _embedding_bag_helper  s   









r  r   ordr.   Sequence[int] | Noner  c           
      C  s,  d }t |rt| |dg}d}n| jdkr"| jdtj|tjdd}|tjkr\| jdk r;| jd| d|||d	}nA|d u rM| jd| d||d
}n/| jd| d|||d
}n |tj kr| jdk rv| jd| d|||d	}n|d u r| jd| d||d
}n| jd| d|||d
}n|dkr| jdk rt	dddd|S |d u rt| || jdtjdgtj
dd}d}| d| d|| jdtdgd}| jd|tj| d}t| |||d	S |dkr| jdk rtd| |||d}n|d u rtd| ||d}nptd| |||d}ne|dkrG| jdk r-td| |||d}nO|d u r<td| ||d}n@td| |||d}n5| jdtj|tjdd}	t| | d| d||	||d	}| d|| d| jdtjdtjdd|	}t |st|dd}| jd|t| d}|S )Nr   Fr@  r   r5  r   rX  Absrg  r  rb  r   r  linalg_vector_normr!  zord=0 not supportedNotEqualr  r  rs   ReduceL1)r   r  )r  r?  ReduceL2Powrj  r   r  )r   r  r#  r   rO   r   r^  mathinfr   rC  r  r   r   r   r  rh  rG  rq  rU   )
rn   r   r  r   r  r  r'  rN  cond_opord_opr'   r'   r+   _linalg_vector_norm_helper  s   














r  )ByteCharDoubleFloatHalfIntLongShortBoolComplexFloatComplexDoubleBFloat16	Undefinedr  r  r  r  r  r  r  r  r  r  r  QInt8QUInt8QInt32r  )uint8_tint8_tr6  r.   halfr(   int64_tint16_tr8   	complex64
complex128qint8quint8qint32bfloat16)r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  zset[int]_quantized_opsrF  )r   r    r!   r"   r#   r"   )r3   r?   r@   r9   )r%   rF   )r%   rJ   rK   r    )rV   rF   rW   rX   )r\   rF   rW   r]   )rV   r   rW   r8   )rj   r    rW   rk   )
r   r8   r   r   r   r   r   r8   rW   r   )r   r   rW   r   )r   r   rW   r8   )r%   r   rW   r8   )r   rF   rW   r8   )r   r   rW   r   )r   rF   rW   r   )T)r   rF   r   r8   )r   rF   r   r(   rW   r   )r   rF   r   r   rL   )r   r9   r   r9   r%   r   rW   r   )r   r9   r%   r   rW   r   )
r   r9   r   r(   r   r(   r%   r   rW   r   )r   r9   r   r(   r   r(   r   r9   r%   r   rW   r   )r   r9   )rW   r  )rW   r  )rn   r  r   r  )rn   r  )rW   r8   )TN)TFN)Nrs   r   )
rn   r  r&  r  r   r  r  r8   r   r9   )NNN)rn   r  rW   r  )r   )r  r  r  r  rW   r  )r  r(   r   r9   rW   r   )rn   r  r  rF   r  r  rW   r  )rn   r  r   rF   r   rF   r   rF   r  r   rW   rF   )rX  r9   r   r9   rC  r8   )rn   r  r   r  r  r.   r   r  r  r8   r  r  )
__future__r   r   rz   r  rr  r   rU  r   r   r   r   r   _TypeVartyping_extensionsr   _Concatenater	   
_ParamSpecrO   torch._C._onnxr
   _onnxr   
torch.onnxr   r   r   r   torch.onnx._globalsr   torch.onnx._internalr   TYPE_CHECKINGcollections.abcr   torch.typesr   r   r   r   r    r>   r2   rI   rN   rS   rU   r[   ra   rg   ri   r   r   r   r   r   r5   rT   r   r   r   r   r   r^   r   r   r   r   r   r   r   r   r   r  r  r  r  r   r-  r2  r4  r8  rH  rM  rT  rY  r_  rc  rh  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r   r.  r4  r<  r=  r?  rG  rJ  rV  r`  rf  rh  rv  r  r  r  r   r$  r/  r.  FLOAT16r&  r  INT16r3  r   r   r1  r   cast_pytorch_to_onnxscalar_name_to_pytorchuint8int8shortr(   rC  r  r.   r6  	complex32r  r  r8   r  r  r  r  scalar_type_to_pytorch_typepytorch_name_to_typescalar_type_to_onnxsetr  __annotations__r'   r'   r'   r+   <module>   s  E

T 
#&Cc
	+*#95>	5	!6Hjq