TiSSKJr SSKJrJrJrJr SSKJr SSK J r SSK J r SSK JrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJr "SS \ 5r g ) ) annotations)OptionalTupleTypeVarUnion) get_schema) TypeAlias)Opset5)BOOL COMPLEX64 COMPLEX128DOUBLEFLOATFLOAT16INT8INT16INT32INT64STRINGUINT8UINT16UINT32UINT64)OpOpsetc\rSrSr%Sr\"S\\\\ \ \ \ \ \\\5 rS[Sjr\"S\\\\ \ \\5rSSS.S\S jjr\"S \\\5rS SS S S.S]Sjjr\"S\\\\\ \ \ \ \ \\\5 r\\\\\\ \ \ \ \ \\\4 rS\S'S^Sjr\"S\\\5rS_Sjr\"S\\\5rSSS.S`Sjjr \"S\\\\ \ \\5r!SSS.SaSjjr"\"S\\\5r#SSS.SbS jjr$\"S!\\\5r%S"S#.ScS$jjr&\"S%\\\5r'SdS&jr(\"S'\\\5r)SeS(jr*\"S)\\\5r+S"S"SSSS*.SfS+jjr,\"S,\\\5r-S-SS..SgS/jjr.\"S0\\\5r/S S1.ShS2jjr0\"S3\\\5r1S4S#.SiS5jjr2\"S6\\\5r3SjS7jr4\"S8\\\5r5SkS9jr6\"S:\\\5r7SlS;jr8\"S<\\\5r9SmS=jr:\"S>\\\\ \ \\5r;SSS.SnS?jjr<\"S@\\\\ \ \ \ 5r=SoSAjr>\"SB\\\5r?SpSCjr@\"SD\\\5rASqSEjrB\"SF\\\5rCSrSGjrD\"SH\\\5rESISJSK.SsSLjjrF\"SM\\\5rGStSNjrH\"SO\\\5rISuSPjrJ\"SQ\\\\ \ \\5rKSSS.SvSRjjrL\"SS\\\5rMSwSTjrN\"SU\\\5rOSxSVjrP\"SW\\Q\R\\\\ \ \ \ \S\ \\\5rT\ rUS\SX'SySYjrVSZrWg)zOpset6)c2[R"USS5$)N)r__new__)clss a/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/onnx_opset/_impl/opset6.pyr"Opset6.__new__*s}}S"a((T_Absc^[SSS5n[USU5nU"URX!56$)u[🌐 Abs(6)](https://onnx.ai/onnx/operators/onnx__Abs.html#abs-6 "Online Documentation") Absolute takes one input data (Tensor) and produces one output data (Tensor) where the absolute is, y = abs(x), is applied to the tensor elementwise. Args: X: Input tensor Absr!r rr_prepare_inputsselfXschemaops r$r) Opset6.Abs<6E1b) eV $4''233r&T_AddNraxis broadcastcf[SSS5n[USU5nU"URXQU5X4S.6$)u[🌐 Add(6)](https://onnx.ai/onnx/operators/onnx__Add.html#add-6 "Online Documentation") Performs element-wise binary addition (with limited broadcast support). If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor's shape. The starting of the mutually equal shape is specified by the argument "axis", and if it is not set, suffix matching is assumed. 1-dim expansion doesn't work yet. For example, the following tensor shapes are supported (with broadcast=1): shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 Attribute `broadcast=1` needs to be passed to enable broadcasting. Args: A: First operand, should share the type with the second operand. B: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size. axis: If set, defines the broadcast dimensions. See doc for details. broadcast: Pass 1 to enable broadcasting Addr!r r4r*r-ABr5r6r/r0s r$r8 Opset6.AddO;NE1b) eV $4''15DVVr&T_BatchNormalizationg>g?epsilonis_testmomentumspatialc n[SSS5n [USU 5n U "URXX#XE5UUUU S.6$)u[🌐 BatchNormalization(6)](https://onnx.ai/onnx/operators/onnx__BatchNormalization.html#batchnormalization-6 "Online Documentation") Carries out batch normalization as described in the paper https://arxiv.org/abs/1502.03167. Depending on the mode it is being run, there are multiple cases for the number of outputs, which we list below: Output case #1: Y, mean, var, saved_mean, saved_var (training mode) Output case #2: Y (test mode) 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. scale: The scale as a 1-dimensional tensor of size C to be applied to the output. B: The bias as a 1-dimensional tensor of size C to be applied to the output. mean: The running mean (training) or the estimated mean (testing) as a 1-dimensional tensor of size C. var: The running variance (training) or the estimated variance (testing) as a 1-dimensional tensor of size C. epsilon: The epsilon value to use to avoid division by zero, default is 1e-5f. is_test: If set to nonzero, run spatial batch normalization in test mode, default is 0. momentum: Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum), default is 0.9f. spatial: If true, compute the mean and variance across all spatial elements If false, compute the mean and variance across per feature.Default is 1. BatchNormalizationr!r r@r*) r-r.scaler;meanvarrArBrCrDr/r0s r$rFOpset6.BatchNormalization|sN|0!R8 *F 3  ! !&Ut A   r&T1_Castr T2_Castcd[SSS5n[USU5nU"URX15SU06$)ux[🌐 Cast(6)](https://onnx.ai/onnx/operators/onnx__Cast.html#cast-6 "Online Documentation") The operator casts the elements of a given input tensor to a data type specified by the 'to' argument and returns an output tensor of the same size in the converted type. The 'to' argument must be one of the data types specified in the 'DataType' enum field in the TensorProto message. NOTE: Casting to and from strings is not supported yet. Args: input: Input tensor to be cast. to: The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto Castr!r tor*)r-inputrOr/r0s r$rN Opset6.Casts;$FAr* ff %4''6>2>>r&T_Ceilc^[SSS5n[USU5nU"URX!56$)u[🌐 Ceil(6)](https://onnx.ai/onnx/operators/onnx__Ceil.html#ceil-6 "Online Documentation") Ceil takes one input data (Tensor) and produces one output data (Tensor) where the ceil is, y = ceil(x), is applied to the tensor elementwise. Args: X: Input tensor Ceilr!r r*r,s r$rT Opset6.Ceil6FAr* ff %4''233r&T_ClipgGgǩmaxmincd[SSS5n[USU5nU"URXA5X#S.6$)u[🌐 Clip(6)](https://onnx.ai/onnx/operators/onnx__Clip.html#clip-6 "Online Documentation") Clip operator limits the given input within an interval. The interval is specified with arguments 'min' and 'max'. They default to numeric_limits::lowest() and numeric_limits::max() respectively. Args: input: Input tensor whose elements to be clipped max: Maximum value, above which element is replaced by max min: Minimum value, under which element is replaced by min Clipr!r rXr*)r-rPrYrZr/r0s r$r\ Opset6.Clips8.FAr* ff %4''6CIIr&T_Divcf[SSS5n[USU5nU"URXQU5X4S.6$)u[🌐 Div(6)](https://onnx.ai/onnx/operators/onnx__Div.html#div-6 "Online Documentation") Performs element-wise binary division (with limited broadcast support). If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor's shape. The starting of the mutually equal shape is specified by the argument "axis", and if it is not set, suffix matching is assumed. 1-dim expansion doesn't work yet. For example, the following tensor shapes are supported (with broadcast=1): shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 Attribute `broadcast=1` needs to be passed to enable broadcasting. Args: A: First operand, should share the type with the second operand. B: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size. axis: If set, defines the broadcast dimensions. See doc for details. broadcast: Pass 1 to enable broadcasting Divr!r r4r*r9s r$r` Opset6.Div+r=r& T_Dropoutg?rBratiocd[SSS5n[USU5nU"URXA5X#S.6$)u[🌐 Dropout(6)](https://onnx.ai/onnx/operators/onnx__Dropout.html#dropout-6 "Online Documentation") Dropout takes one input data (Tensor) and produces two Tensor outputs, output (Tensor) and mask (Tensor). Depending on whether it is in test mode or not, the output Y will either be a random dropout, or a simple copy of the input. Note that our implementation of Dropout does scaling in the training phase, so during testing nothing needs to be done. Args: data: The input data as Tensor. is_test: (int, default 0) if nonzero, run dropout in test mode where the output is simply Y = X. ratio: (float, default 0.5) the ratio of random dropout Dropoutr!r rcr*)r-datarBrdr/r0s r$rfOpset6.DropoutXs8,Iq"- i (4''5wTTr&T_Elug?)alphacd[SSS5n[USU5nU"URX15SU06$)us[🌐 Elu(6)](https://onnx.ai/onnx/operators/onnx__Elu.html#elu-6 "Online Documentation") Elu takes one input data (Tensor) and produces one output data (Tensor) where the function `f(x) = alpha * (exp(x) - 1.) for x < 0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise. Args: X: (differentiable) Input tensor alpha: Coefficient of ELU. Elur!r rjr*r-r.rjr/r0s r$rl Opset6.Eluts; E1b) eV $4''2@%@@r&T_Expc^[SSS5n[USU5nU"URX!56$)u[🌐 Exp(6)](https://onnx.ai/onnx/operators/onnx__Exp.html#exp-6 "Online Documentation") Calculates the exponential of the given input tensor, element-wise. Args: input: Input tensor Expr!r r*r-rPr/r0s r$rq Opset6.Exp6E1b) eV $4''677r&T_Floorc^[SSS5n[USU5nU"URX!56$)u[🌐 Floor(6)](https://onnx.ai/onnx/operators/onnx__Floor.html#floor-6 "Online Documentation") Floor takes one input data (Tensor) and produces one output data (Tensor) where the floor is, y = floor(x), is applied to the tensor elementwise. Args: X: Input tensor Floorr!r r*r,s r$rw Opset6.Floors6GQ+ gv &4''233r&T_Gemmrjbetar6transAtransBc n[SSS5n [USU 5n U "URXX#5UUUUUS.6$)u[🌐 Gemm(6)](https://onnx.ai/onnx/operators/onnx__Gemm.html#gemm-6 "Online Documentation") General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3 Compute Y = alpha * A * B + beta * C, where input tensor A has dimension (M X K), input tensor B has dimension (K X N), input tensor C and output tensor Y have dimension (M X N). If attribute broadcast is non-zero, input tensor C will be broadcasted to match the dimension requirement. A will be transposed before doing the computation if attribute transA is non-zero, same for B and transB. Args: A: Input tensor A B: Input tensor B C: Input tensor C alpha: Scalar multiplier for the product of input tensors A * B, the default value is 1.0. beta: Scalar multiplier for input tensor C, the default value is 1.0. broadcast: Whether C should be broadcasted transA: Whether A should be transposed transB: Whether B should be transposed Gemmr!r rzr*) r-r:r;Crjr{r6r|r}r/r0s r$r Opset6.GemmsMVFAr* ff %  ! !&Q 2   r& T_HardSigmoidg?rjr{cd[SSS5n[USU5nU"URXA5X#S.6$)u[🌐 HardSigmoid(6)](https://onnx.ai/onnx/operators/onnx__HardSigmoid.html#hardsigmoid-6 "Online Documentation") HardSigmoid takes one input data (Tensor) and produces one output data (Tensor) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)), is applied to the tensor elementwise. Args: X: (differentiable) Input tensor alpha: Value of alpha. beta: Value of beta. HardSigmoidr!r rr*)r-r.rjr{r/r0s r$rOpset6.HardSigmoids8&M1b1 mV ,4''2%KKr&T_InstanceNormalization)rAcf[SSS5n[USU5nU"URXQX#5SU06$)u[🌐 InstanceNormalization(6)](https://onnx.ai/onnx/operators/onnx__InstanceNormalization.html#instancenormalization-6 "Online Documentation") Carries out instance normalization as described in the paper https://arxiv.org/abs/1607.08022. y = scale * (x - mean) / sqrt(variance + epsilon) + B, where mean and variance are computed per instance per channel. Args: input: (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. scale: (differentiable) The input 1-dimensional scale tensor of size C. B: (differentiable) The input 1-dimensional bias tensor of size C. epsilon: The epsilon value to use to avoid division by zero. InstanceNormalizationr!r rAr*)r-rPrGr;rAr/r0s r$rOpset6.InstanceNormalizations@B3Q; -v 64''u@R'RRr& T_LeakyRelug@z?cd[SSS5n[USU5nU"URX15SU06$)u[🌐 LeakyRelu(6)](https://onnx.ai/onnx/operators/onnx__LeakyRelu.html#leakyrelu-6 "Online Documentation") LeakyRelu takes input data (Tensor) and an argument alpha, and produces one output data (Tensor) where the function `f(x) = alpha * x for x < 0`, `f(x) = x for x >= 0`, is applied to the data tensor elementwise. Args: X: (differentiable) Input tensor alpha: Coefficient of leakage. LeakyRelur!r rjr*rms r$rOpset6.LeakyRelu&s;KB/ k6 *4''2@%@@r&T_Logc^[SSS5n[USU5nU"URX!56$)u[🌐 Log(6)](https://onnx.ai/onnx/operators/onnx__Log.html#log-6 "Online Documentation") Calculates the natural log of the given input tensor, element-wise. Args: input: Input tensor Logr!r r*rrs r$r Opset6.Log;rtr&T_Maxcb[SSS5n[USU5nU"UR"U/UQ766$)u[🌐 Max(6)](https://onnx.ai/onnx/operators/onnx__Max.html#max-6 "Online Documentation") Element-wise max of each of the input tensors. All inputs and outputs must have the same shape and data type. Args: data_0: (variadic) List of tensors for Max. Maxr!r r*r-data_0r/r0s r$r Opset6.MaxL;E1b) eV $4''8899r&T_Meancb[SSS5n[USU5nU"UR"U/UQ766$)u[🌐 Mean(6)](https://onnx.ai/onnx/operators/onnx__Mean.html#mean-6 "Online Documentation") Element-wise mean of each of the input tensors. All inputs and outputs must have the same shape and data type. Args: data_0: (variadic) List of tensors for Mean. Meanr!r r*rs r$r Opset6.Mean^s;FAr* ff %4''8899r&T_Mincb[SSS5n[USU5nU"UR"U/UQ766$)u[🌐 Min(6)](https://onnx.ai/onnx/operators/onnx__Min.html#min-6 "Online Documentation") Element-wise min of each of the input tensors. All inputs and outputs must have the same shape and data type. Args: data_0: (variadic) List of tensors for Min Minr!r r*rs r$r Opset6.Minprr&T_Mulcf[SSS5n[USU5nU"URXQU5X4S.6$)u[🌐 Mul(6)](https://onnx.ai/onnx/operators/onnx__Mul.html#mul-6 "Online Documentation") Performs element-wise binary multiplication (with limited broadcast support). If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor's shape. The starting of the mutually equal shape is specified by the argument "axis", and if it is not set, suffix matching is assumed. 1-dim expansion doesn't work yet. For example, the following tensor shapes are supported (with broadcast=1): shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 Attribute `broadcast=1` needs to be passed to enable broadcasting. Args: A: First operand, should share the type with the second operand. B: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size. axis: If set, defines the broadcast dimensions. See doc for details. broadcast: Pass 1 to enable broadcasting Mulr!r r4r*r9s r$r Opset6.Mulr=r&T_Negc^[SSS5n[USU5nU"URX!56$)u[🌐 Neg(6)](https://onnx.ai/onnx/operators/onnx__Neg.html#neg-6 "Online Documentation") Neg takes one input data (Tensor) and produces one output data (Tensor) where each element flipped sign, y = -x, is applied to the tensor elementwise. Args: X: Input tensor Negr!r r*r,s r$r Opset6.Negr2r&T_PReluc`[SSS5n[USU5nU"URX1U56$)u[🌐 PRelu(6)](https://onnx.ai/onnx/operators/onnx__PRelu.html#prelu-6 "Online Documentation") PRelu takes input data (Tensor) and slope tensor as input, and produces one output data (Tensor) where the function `f(x) = slope * x for x < 0`, `f(x) = x for x >= 0`., is applied to the data tensor elementwise. Args: X: Input tensor slope: Slope tensor. If `Slope` is of size 1, the value is sharedacross different channels PRelur!r r*)r-r.sloper/r0s r$r Opset6.PRelus8$GQ+ gv &4''59::r& T_Reciprocalc^[SSS5n[USU5nU"URX!56$)u*[🌐 Reciprocal(6)](https://onnx.ai/onnx/operators/onnx__Reciprocal.html#reciprocal-6 "Online Documentation") Reciprocal takes one input data (Tensor) and produces one output data (Tensor) where the reciprocal is, y = 1/x, is applied to the tensor elementwise. Args: X: Input tensor Reciprocalr!r r*r,s r$rOpset6.Reciprocals6L!R0 lF +4''233r&T_Reluc^[SSS5n[USU5nU"URX!56$)u$[🌐 Relu(6)](https://onnx.ai/onnx/operators/onnx__Relu.html#relu-6 "Online Documentation") Relu takes one input data (Tensor) and produces one output data (Tensor) where the rectified linear function, y = max(0, x), is applied to the tensor elementwise. Args: X: Input tensor Relur!r r*r,s r$r Opset6.RelurVr&T_Selug?g?rjgammacd[SSS5n[USU5nU"URXA5X#S.6$)u[🌐 Selu(6)](https://onnx.ai/onnx/operators/onnx__Selu.html#selu-6 "Online Documentation") Selu takes one input data (Tensor) and produces one output data (Tensor) where the scaled exponential linear unit function, `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`, is applied to the tensor elementwise. Args: X: (differentiable) Input tensor alpha: Coefficient of SELU default to 1.67326319217681884765625 (i.e., float32 approximation of 1.6732632423543772848170429916717). gamma: Coefficient of SELU default to 1.05070102214813232421875 (i.e., float32 approximation of 1.0507009873554804934193349852946). Selur!r rr*)r-r.rjrr/r0s r$r Opset6.Selus84FAr* ff %4''2%MMr& T_Sigmoidc^[SSS5n[USU5nU"URX!56$)u/[🌐 Sigmoid(6)](https://onnx.ai/onnx/operators/onnx__Sigmoid.html#sigmoid-6 "Online Documentation") Sigmoid takes one input data (Tensor) and produces one output data (Tensor) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the tensor elementwise. Args: X: Input tensor Sigmoidr!r r*r,s r$rOpset6.Sigmoid s6Iq"- i (4''233r&T_Sqrtc^[SSS5n[USU5nU"URX!56$)uG[🌐 Sqrt(6)](https://onnx.ai/onnx/operators/onnx__Sqrt.html#sqrt-6 "Online Documentation") Square root takes one input data (Tensor) and produces one output data (Tensor) where the square root is, y = x^0.5, is applied to the tensor elementwise. If x is negative, then it will return NaN. Args: X: Input tensor Sqrtr!r r*r,s r$r Opset6.Sqrt3rVr&T_Subcf[SSS5n[USU5nU"URXQU5X4S.6$)u[🌐 Sub(6)](https://onnx.ai/onnx/operators/onnx__Sub.html#sub-6 "Online Documentation") Performs element-wise binary subtraction (with limited broadcast support). If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor's shape. The starting of the mutually equal shape is specified by the argument "axis", and if it is not set, suffix matching is assumed. 1-dim expansion doesn't work yet. For example, the following tensor shapes are supported (with broadcast=1): shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 Attribute `broadcast=1` needs to be passed to enable broadcasting. Args: A: First operand, should share the type with the second operand. B: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size. axis: If set, defines the broadcast dimensions. See doc for details. broadcast: Pass 1 to enable broadcasting Subr!r r4r*r9s r$r Opset6.SubFr=r&T_Sumcb[SSS5n[USU5nU"UR"U/UQ766$)u[🌐 Sum(6)](https://onnx.ai/onnx/operators/onnx__Sum.html#sum-6 "Online Documentation") Element-wise sum of each of the input tensors. All inputs and outputs must have the same shape and data type. Args: data_0: (variadic) List of tensors for Sum. Sumr!r r*rs r$r Opset6.Sumsrr&T_Tanhc^[SSS5n[USU5nU"URX!56$)u[🌐 Tanh(6)](https://onnx.ai/onnx/operators/onnx__Tanh.html#tanh-6 "Online Documentation") Calculates the hyperbolic tangent of the given input tensor element-wise. Args: input: Input tensor Tanhr!r r*rrs r$r Opset6.Tanhs6FAr* ff %4''677r&T_TileT1_Tilec`[SSS5n[USU5nU"URX1U56$)u[🌐 Tile(6)](https://onnx.ai/onnx/operators/onnx__Tile.html#tile-6 "Online Documentation") Constructs a tensor by tiling a given tensor. This is the same as function `tile` in Numpy, but no broadcast. For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]] Args: input: Input tensor of any shape. repeats: 1D int64 tensor of the same length as input's dimension number, includes numbers of repeated copies along input's dimensions. Tiler!r r*)r-rPrepeatsr/r0s r$r Opset6.Tiles8FAr* ff %4''w?@@r&)r.r'returnr') r:r3r;r3r5 Optional[int]r6intrr3)r.r>rGr>r;r>rHr>rIr>rAfloatrBrrCrrDrrzsTuple[T_BatchNormalization, T_BatchNormalization, T_BatchNormalization, T_BatchNormalization, T_BatchNormalization])rPrKrOrrrL)r.rRrrR)rPrWrYrrZrrrW) r:r^r;r^r5rr6rrr^)rgrbrBrrdrrzTuple[T_Dropout, T_Dropout])r.rirjrrri)rProrro)r.rurru)r:ryr;ryrryrjrr{rr6rr|rr}rrry)r.rrjrr{rrr) rPrrGrr;rrArrr)r.rrjrrr)rPrrr)rrrr)rrrr)rrrr) r:rr;rr5rr6rrr)r.rrr)r.rrrrr)r.rrr)r.rrr)r.rrjrrrrr)r.rrr)r.rrr) r:rr;rr5rr6rrr)rrrr)rPrrr)rPrrrrr)X__name__ __module__ __qualname____firstlineno__r"rrrrrrrrrrrrr'r)r3r8r>rFr rKrrL__annotations__rNrRrTrWr\r^r`rbrfrirlrorqrurwryrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrr__static_attributes__rr&r$rr)sy)        E4" GVUGUE66 RE<@RS)W)W )W+8)WLO)W )WV##965'R/,F F $F  F # F " F F F F F  F P       G          GY ?,Xvug 6F4"Xvug 6F ++ JJ J  J  J6 GVUGUE66 RE<@RS)W)W )W+8)WLO)W )WV VUG65'BL4"Xvug 6F4"Xvug 6F *) N N N  N  N< VUGrsG#22 '5"(QAVQAr&