
     Ti                        S SK Jr  S SKJrJrJr  S SKJr  S SKJ	r	  S SK
JrJrJrJrJrJrJrJrJrJrJrJrJrJrJr  S SKJrJr   " S S\	5      rg	)
    )annotations)OptionalSequenceTypeVar)
get_schema)Opset1)BOOL	COMPLEX64
COMPLEX128DOUBLEFLOATFLOAT16INT8INT16INT32INT64STRINGUINT8UINT16UINT32UINT64)OpOpsetc                     \ rS rSrS r\" S\\\5      r	SS.SS jjr
\" S\\\5      rSSS	S	S
.             SS jjr\" S\\\5      rSSS.         SS jjr\" S\\\\\\\\\\\\\\\5      rSS	S.       SS jjrSrg	)Opset2(   c                2    [         R                  " U SS5      $ )N    )r   __new__)clss    a/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/onnx_opset/_impl/opset2.pyr    Opset2.__new__)   s    }}S"a((    T_GlobalLpPoolr   )pc               d    [        SSS5      n[        U SU5      nU" U R                  X15      SU06$ )u  [🌐 GlobalLpPool(2)](https://onnx.ai/onnx/operators/onnx__GlobalLpPool.html#globallppool-2 "Online Documentation")


 GlobalLpPool consumes an input tensor X and applies lp pool pooling across
 the values in the same channel. This is equivalent to LpPool with kernel size
 equal to the spatial dimension of input tensor.

Args:
    X: (differentiable) Input data tensor from the previous operator; dimensions
        for image case are (N x C x H x W), where N is the batch size, C is the
        number of channels, and H and W are the height and the width of the
        data. For non image case, the dimensions are in the form of (N x C x D1
        x D2 ... Dn), where N is the batch size.

    p: p value of the Lp norm used to pool over the input data.
GlobalLpPoolr   r   r&   r   r   _prepare_inputs)selfXr&   schemaops        r"   r(   Opset2.GlobalLpPool.   s;    $ NAr2nf-4''28a88r$   T_LpPoolNOTSETN)auto_padr&   padsstridesc          	     l    [        SSS5      n[        U SU5      nU" U R                  Xq5      UUUUUS.6$ )u  [🌐 LpPool(2)](https://onnx.ai/onnx/operators/onnx__LpPool.html#lppool-2 "Online Documentation")


 LpPool consumes an input tensor X and applies Lp pooling across
 the tensor according to kernel sizes, stride sizes, and pad lengths.
 Lp pooling consisting of computing the Lp norm on all values of a subset
 of the input tensor according to the kernel size and downsampling the
 data into the output tensor Y for further processing.

Args:
    X: Input data tensor from the previous operator; dimensions for image case
        are (N x C x H x W), where N is the batch size, C is the number of
        channels, and H and W are the height and the width of the data. For non
        image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn),
        where N is the batch size.

    auto_pad: auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID.
        Where default value is NOTSET, which means explicit padding is used.
        SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial
        size match the input.In case of odd number add the extra padding at the
        end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no
        padding.

    kernel_shape: The size of the kernel along each axis.

    p: p value of the Lp norm used to pool over the input data.

    pads: Padding for the beginning and ending along each spatial axis, it can
        take any value greater than or equal to 0. The value represent the
        number of pixels added to the beginning and end part of the
        corresponding axis. `pads` format should be as follow [x1_begin,
        x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels
        added at the beginning of axis `i` and xi_end, the number of pixels
        added at the end of axis `i`. This attribute cannot be used
        simultaneously with auto_pad attribute. If not present, the padding
        defaults to 0 along start and end of each spatial axis.

    strides: Stride along each spatial axis.
LpPoolr   r   )r2   kernel_shaper&   r3   r4   r)   )	r+   r,   r2   r7   r&   r3   r4   r-   r.   s	            r"   r6   Opset2.LpPoolF   sK    d Ha,h'!!&,%
 	
r$   T_Padconstantg        )modevaluec               f    [        SSS5      n[        U SU5      nU" U R                  XQ5      X#US.6$ )u  [🌐 Pad(2)](https://onnx.ai/onnx/operators/onnx__Pad.html#pad-2 "Online Documentation")


Given `data` tensor, pads, mode, and value.
Example:
  Insert 0 pads to the beginning of the second dimension.
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  pads = [0, 2, 0, 0]
  output = [
      [
          [0.0, 0.0, 1.0, 1.2],
          [0.0, 0.0, 2.3, 3.4],
          [0.0, 0.0, 4.5, 5.7],
      ],
  ]


Args:
    data: Input tensor.

    mode: Three modes: constant(default), reflect, edge

    pads: List of integers indicating the number of padding elements to add or
        remove (if negative) at the beginning and end of each axis. For 2D it is
        the number of pixels. `pads` rank should be double of the input's rank.
        `pads` format should be as follow [x1_begin, x2_begin...x1_end,
        x2_end,...], where xi_begin the number of pixels added at the beginning
        of axis `i` and xi_end, the number of pixels added at the end of axis
        `i`.

    value: One float, indicates the value to be filled.
Padr   r   )r;   r3   r<   r)   )r+   datar;   r3   r<   r-   r.   s          r"   r>   
Opset2.Pad   s<    Z E1b)eV$4''5DSXYYr$   T_Splitr   axissplitc               d    [        SSS5      n[        U SU5      nU" U R                  XA5      X#S.6$ )u  [🌐 Split(2)](https://onnx.ai/onnx/operators/onnx__Split.html#split-2 "Online Documentation")

Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using argument 'split'.
Otherwise, the tensor is split to equal sized parts.


Args:
    input: The tensor to split

    axis: Which axis to split on.

    split: length of each output
Splitr   r   rB   r)   )r+   inputrC   rD   r-   r.   s         r"   rF   Opset2.Split   s8    $ GQ+gv&4''6TOOr$    )r,   r%   r&   intreturnr%   )r,   r0   r2   strr7   Sequence[int]r&   rJ   r3   Optional[Sequence[int]]r4   rN   rK   r0   )
r?   r9   r;   rL   r3   rM   r<   floatrK   r9   )rG   rA   rC   rJ   rD   rN   rK   rA   )__name__
__module____qualname____firstlineno__r    r   r   r   r   r%   r(   r0   r6   r9   r>   r	   r   r
   r   r   r   r   r   r   r   r   r   rA   rF   __static_attributes__rI   r$   r"   r   r   (   sV   ) -vugFN:; 9, z65':H !(,+/;
;
 	;

 $;
 ;
 &;
 );
 
;
z GVUG4E /Z/Z 	/Z
 /Z /Z 
/Zb !G( ./QUPP'*P7NP	P Pr$   r   N)
__future__r   typingr   r   r   	onnx.defsr   "onnxscript.onnx_opset._impl.opset1r   onnxscript.onnx_typesr	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   onnxscript.valuesr   r   r   rI   r$   r"   <module>r[      sD    # . .   5    " (uPV uPr$   