TiRSSKJr SSKJrJrJrJrJr SSKJ r SSK J r SSK J r SSKJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJ r "SS \ 5r!g ) ) annotations)OptionalSequenceTupleTypeVarUnion) get_schema) TypeAlias)Opset6)BOOL COMPLEX64 COMPLEX128DOUBLEFLOATFLOAT16INT8INT16INT32INT64STRINGUINT8UINT16UINT32UINT64)OpOpsetc\rSrSr%Sr\"S\\\5r SZSjr \"S\\\\ \ \ \5rS[Sjr\rS\S'\rS\S 'S\S jr\"S \\\5rS]S jr\"S \\\5rS^Sjr\"S\\\5rSSSSS.S_Sjjr\"S\\\5rSSSS.S`Sjjr\"S\\\5rSaSjr\"S\\\\ \ \ \5r SbSjr!\"S\\\5r"S S!.ScS"jjr#\"S#\\ \ 5r$\r%S\S$'SdS%jr&\"S&\\\5r'\ r(S\S''SeSSSSS(SSS).SfS*jjjr)\"S+\\\5r*S,S,SSS-.SgS.jjr+\"S/\\\5r,\r-S\S0'ShS1jr.\"S2\\\5r/\ r0S\S3'SiSSSSS(SSS4.SjS5jjjr1\"S6\\\5r2\r3S\S7'SkS8jr4\"S9\\\\ \ \ \5r5SlS:jr6\"S;\\\5r7\8\ \ 4r9S\S<'S=SSS>.SmS?jjr:\r;S\S@'\rSoSDjr?\"SE\\\5r@SpSFjrA\"SG\\\5rB\ rCS\SH'SeSSSISS(SSJ.SqSKjjjrD\"SL\\\5rESrSMjrF\"SN\\\\ \ \ \5rGSsSOjrH\"SP\\\5rIStSQjrJ\"SR\\K\L\\\\M\ \ \N\O\P\ \\Q5rRSSST.SuSUjjrS\rTS\SV'\rUS\SW'SvSXjrVSYrWg)wOpset7)c2[R"USS5$)N)r__new__)clss a/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/onnx_opset/_impl/opset7.pyr#Opset7.__new__*s}}S"a((T_Acosc^[SSS5n[USU5nU"URX!56$)u[🌐 Acos(7)](https://onnx.ai/onnx/operators/onnx__Acos.html#acos-7 "Online Documentation") Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Acosr"r!r r_prepare_inputsselfinputschemaops r%r* Opset7.Acos/6FAr* ff %4''677r'T_Addc`[SSS5n[USU5nU"URX1U56$)u[🌐 Add(7)](https://onnx.ai/onnx/operators/onnx__Add.html#add-7 "Online Documentation") Performs element-wise binary addition (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First operand. B: Second operand. Addr"r!r+r.ABr0r1s r%r6 Opset7.Add@8E1b) eV $4''1566r'r T_AndT1_Andc`[SSS5n[USU5nU"URX1U56$)u^[🌐 And(7)](https://onnx.ai/onnx/operators/onnx__And.html#and-7 "Online Documentation") Returns the tensor resulted from performing the `and` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: (non-differentiable) First input operand for the logical operator. B: (non-differentiable) Second input operand for the logical operator. Andr"r!r+r7s r%r? Opset7.AndW8 E1b) eV $4''1566r'T_Asinc^[SSS5n[USU5nU"URX!56$)u[🌐 Asin(7)](https://onnx.ai/onnx/operators/onnx__Asin.html#asin-7 "Online Documentation") Calculates the arcsine (inverse of sine) of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Asinr"r!r+r-s r%rD Opset7.Asinmr3r'T_Atanc^[SSS5n[USU5nU"URX!56$)u[🌐 Atan(7)](https://onnx.ai/onnx/operators/onnx__Atan.html#atan-7 "Online Documentation") Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Atanr"r!r+r-s r%rH Opset7.Atan~r3r' T_AveragePoolNOTSETrN)auto_padcount_include_padpadsstridesc l[SSS5n[USU5nU"URXq5UUUUUS.6$)u [🌐 AveragePool(7)](https://onnx.ai/onnx/operators/onnx__AveragePool.html#averagepool-7 "Online Documentation") AveragePool consumes an input tensor X and applies average pooling across the tensor according to kernel sizes, stride sizes, and pad lengths. average pooling consisting of computing the average 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. The output spatial shape will be following: ``` output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1) * pad_shape[i] is sum of pads along axis i ``` `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following: ``` VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i]) SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i]) ``` And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`: ``` pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i] ``` The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero). 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. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...]. 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. count_include_pad: Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad. kernel_shape: The size of the kernel along each axis. 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. AveragePoolr"r!)rLrM kernel_shaperNrOr+) r.XrLrMrRrNrOr0r1s r%rQOpset7.AveragePoolsKNM1b1 mV ,  ! !& ,/%   r'T_BatchNormalizationg>g?epsilonmomentumspatialc l[SSS5n [USU 5n U "URXX#XE5UUUS.6$)uo [🌐 BatchNormalization(7)](https://onnx.ai/onnx/operators/onnx__BatchNormalization.html#batchnormalization-7 "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) This operator has **optional** inputs/outputs. See `ONNX `_ for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. 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: If spatial is true, the dimension of scale is (C). If spatial is false, the dimensions of scale are (C x D1 x ... x Dn) B: If spatial is true, the dimension of bias is (C). If spatial is false, the dimensions of bias are (C x D1 x ... x Dn) mean: If spatial is true, the dimension of the running mean (training) or the estimated mean (testing) is (C). If spatial is false, the dimensions of the running mean (training) or the estimated mean (testing) are (C x D1 x ... x Dn). var: If spatial is true, the dimension of the running variance(training) or the estimated variance (testing) is (C). If spatial is false, the dimensions of the running variance(training) or the estimated variance (testing) are (C x D1 x ... x Dn). epsilon: The epsilon value to use to avoid division by zero. momentum: Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum). spatial: If true, compute the mean and variance across per activation. If false, compute the mean and variance across per feature over each mini-batch. BatchNormalizationr"r!rWr+) r.rSscaler9meanvarrXrYrZr0r1s r%r\Opset7.BatchNormalizationsK~0!R8 *F 3  ! !&Ut A   r'T_Cosc^[SSS5n[USU5nU"URX!56$)u[🌐 Cos(7)](https://onnx.ai/onnx/operators/onnx__Cos.html#cos-7 "Online Documentation") Calculates the cosine of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Cosr"r!r+r-s r%rc Opset7.Cos-6E1b) eV $4''677r'T_Divc`[SSS5n[USU5nU"URX1U56$)u[🌐 Div(7)](https://onnx.ai/onnx/operators/onnx__Div.html#div-7 "Online Documentation") Performs element-wise binary division (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First operand. B: Second operand. Divr"r!r+r7s r%rh Opset7.Div>r;r' T_Dropoutg?)ratiocd[SSS5n[USU5nU"URX15SU06$)u[🌐 Dropout(7)](https://onnx.ai/onnx/operators/onnx__Dropout.html#dropout-7 "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. This operator has **optional** inputs/outputs. See `ONNX `_ for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. Args: data: The input data as Tensor. ratio: The ratio of random dropout Dropoutr"r!rkr+)r.datarkr0r1s r%rmOpset7.DropoutSs;$Iq"- i (4''5CUCCr'T_EqualT1_Equalc`[SSS5n[USU5nU"URX1U56$)u<[🌐 Equal(7)](https://onnx.ai/onnx/operators/onnx__Equal.html#equal-7 "Online Documentation") Returns the tensor resulted from performing the `equal` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First input operand for the logical operator. B: Second input operand for the logical operator. Equalr"r!r+r7s r%rs Opset7.Equalms8 GQ+ gv &4''1566r'T_GRUT1_GRUforwardactivation_alphaactivation_beta activationsclip direction hidden_sizelinear_before_resetc v[SSS5n[USU5nU"URXX#XEU5UUU U U U U S.6$)u[🌐 GRU(7)](https://onnx.ai/onnx/operators/onnx__GRU.html#gru-7 "Online Documentation") Computes an one-layer GRU. This operator is usually supported via some custom implementation such as CuDNN. Notations: `X` - input tensor `z` - update gate `r` - reset gate `h` - hidden gate `t` - time step (t-1 means previous time step) `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates `Wb[zrh]` - W bias vectors for update, reset, and hidden gates `Rb[zrh]` - R bias vectors for update, reset, and hidden gates `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates `H` - Hidden state `num_directions` - 2 if direction == bidirectional else 1 Activation functions: Relu(x) - max(0, x) Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x}) Sigmoid(x) - 1/(1 + e^{-x}) (NOTE: Below are optional) Affine(x) - alpha*x + beta LeakyRelu(x) - x if x >= 0 else alpha * x ThresholdedRelu(x) - x if x >= alpha else 0 ScaledTanh(x) - alpha*Tanh(beta*x) HardSigmoid(x) - min(max(alpha*x + beta, 0), 1) Elu(x) - x if x >= 0 else alpha*(e^x - 1) Softsign(x) - x/(1 + |x|) Softplus(x) - log(1 + e^x) Equations (Default: f=Sigmoid, g=Tanh): - zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz) - rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr) - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0 - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0 - Ht = (1 - zt) (.) ht + zt (.) Ht-1 This operator has **optional** inputs/outputs. See `ONNX `_ for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. Args: X: The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`. W: The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`. R: The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`. B: (optional) The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0 sequence_lens: (optional) Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`. initial_h: (optional) Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`. activation_alpha: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01. activation_beta: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators. activations: A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified. clip: Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified. direction: Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional. hidden_size: Number of neurons in the hidden layer linear_before_reset: When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate. GRUr"r!rxr+)r.rSWRr9 sequence_lens initial_hryrzr{r|r}r~rr0r1s r%r Opset7.GRUsWlE1b) eV $  ! !&Q1Y O-+## 3  r'T_Gemmg?alphabetatransAtransBcl[SSS5n[USU5n U "URXX#5UUUUS.6$)u[[🌐 Gemm(7)](https://onnx.ai/onnx/operators/onnx__Gemm.html#gemm-7 "Online Documentation") General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3 A' = transpose(A) if transA else A B' = transpose(B) if transB else B Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M), input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N), and output tensor Y has shape (M, N). A will be transposed before doing the computation if attribute transA is non-zero, same for B and transB. This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check `Broadcasting in ONNX `_. Args: A: Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero. B: Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero. C: Input tensor C. The shape of C should be unidirectional broadcastable to (M, N). alpha: Scalar multiplier for the product of input tensors A * B. beta: Scalar multiplier for input tensor C. transA: Whether A should be transposed transB: Whether B should be transposed Gemmr"r!rr+) r.r8r9Crrrrr0r1s r%r Opset7.Gemm*sJZFAr* ff %  ! !&Q 2   r' T_Greater T1_Greaterc`[SSS5n[USU5nU"URX1U56$)uD[🌐 Greater(7)](https://onnx.ai/onnx/operators/onnx__Greater.html#greater-7 "Online Documentation") Returns the tensor resulted from performing the `greater` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First input operand for the logical operator. B: Second input operand for the logical operator. Greaterr"r!r+r7s r%rOpset7.Greateres8 Iq"- i (4''1566r'T_LSTMT1_LSTMryrzr{r|r}r~ input_forgetc  x[SSS5n[USU5nU"URUXX4XVXx5 U U U U U UUS.6$)u[🌐 LSTM(7)](https://onnx.ai/onnx/operators/onnx__LSTM.html#lstm-7 "Online Documentation") Computes an one-layer LSTM. This operator is usually supported via some custom implementation such as CuDNN. Notations: `X` - input tensor `i` - input gate `o` - output gate `f` - forget gate `c` - cell gate `t` - time step (t-1 means previous time step) `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates `P[iof]` - P peephole weight vector for input, output, and forget gates `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates `PB[iof]` - P peephole weight vector for backward input, output, and forget gates `H` - Hidden state `num_directions` - 2 if direction == bidirectional else 1 Activation functions: Relu(x) - max(0, x) Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x}) Sigmoid(x) - 1/(1 + e^{-x}) (NOTE: Below are optional) Affine(x) - alpha*x + beta LeakyRelu(x) - x if x >= 0 else alpha * x ThresholdedRelu(x) - x if x >= alpha else 0 ScaledTanh(x) - alpha*Tanh(beta*x) HardSigmoid(x) - min(max(alpha*x + beta, 0), 1) Elu(x) - x if x >= 0 else alpha*(e^x - 1) Softsign(x) - x/(1 + |x|) Softplus(x) - log(1 + e^x) Equations (Default: f=Sigmoid, g=Tanh, h=Tanh): - it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi) - ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf) - ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc) - Ct = ft (.) Ct-1 + it (.) ct - ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo) - Ht = ot (.) h(Ct) This operator has **optional** inputs/outputs. See `ONNX `_ for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. Args: X: The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`. W: The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`. R: The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`. B: (optional) The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0. sequence_lens: (optional) Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`. initial_h: (optional) Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`. initial_c: (optional) Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`. P: (optional) The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0. activation_alpha: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01. activation_beta: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators. activations: A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified. clip: Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified. direction: Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional. hidden_size: Number of neurons in the hidden layer input_forget: Couple the input and forget gates if 1. LSTMr"r!rr+)r.rSrrr9rr initial_cPryrzr{r|r}r~rr0r1s r%r Opset7.LSTM}sZNFAr* ff %  ! !&!mPY ]-+##%  r'T_LessT1_Lessc`[SSS5n[USU5nU"URX1U56$)u8[🌐 Less(7)](https://onnx.ai/onnx/operators/onnx__Less.html#less-7 "Online Documentation") Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First input operand for the logical operator. B: Second input operand for the logical operator. Lessr"r!r+r7s r%r Opset7.Less5s8 FAr* ff %4''1566r'T_Mulc`[SSS5n[USU5nU"URX1U56$)u[🌐 Mul(7)](https://onnx.ai/onnx/operators/onnx__Mul.html#mul-7 "Online Documentation") Performs element-wise binary multiplication (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First operand. B: Second operand. Mulr"r!r+r7s r%r Opset7.MulKr;r'T1_MultinomialT2_Multinomialdtype sample_sizeseedch[SSS5n[USU5nU"URXQ5UUUS.6$)u [🌐 Multinomial(7)](https://onnx.ai/onnx/operators/onnx__Multinomial.html#multinomial-7 "Online Documentation") Generate a tensor of samples from a multinomial distribution according to the probabilities of each of the possible outcomes. Args: input: Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch. dtype: (Optional) The data type for the elements of the output tensor, if not specified, we will use int32. sample_size: Number of times to sample. seed: (Optional) Seed to the random generator, if not specified we will auto generate one. Multinomialr"r!rr+)r.r/rrrr0r1s r%rOpset7.MultinomialbsD<M1b1 mV ,  ! !& 0#   r'T_OrT1_Orc`[SSS5n[USU5nU"URX1U56$)uZ[🌐 Or(7)](https://onnx.ai/onnx/operators/onnx__Or.html#or-7 "Online Documentation") Returns the tensor resulted from performing the `or` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: (non-differentiable) First input operand for the logical operator. B: (non-differentiable) Second input operand for the logical operator. Orr"r!r+r7s r%r Opset7.Ors8 D!R( dF #4''1566r'T_PReluc`[SSS5n[USU5nU"URX1U56$)u[🌐 PRelu(7)](https://onnx.ai/onnx/operators/onnx__PRelu.html#prelu-7 "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. This operator supports **unidirectional broadcasting** (tensor slope should be unidirectional broadcastable to input tensor X); for more details please check `Broadcasting in ONNX `_. Args: X: Input tensor slope: Slope tensor. The shape of slope can be smaller than first input X; if so, its shape must be unidirectional broadcastable to X PRelur"r!r+)r.rSsloper0r1s r%r Opset7.PRelus8 GQ+ gv &4''59::r'T_Powc`[SSS5n[USU5nU"URX1U56$)u5[🌐 Pow(7)](https://onnx.ai/onnx/operators/onnx__Pow.html#pow-7 "Online Documentation") Pow takes input data (Tensor) and exponent Tensor, and produces one output data (Tensor) where the function `f(x) = x^exponent`, is applied to the data tensor elementwise. This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: X: First operand, base of the exponent. Y: Second operand, power of the exponent. Powr"r!r+)r.rSYr0r1s r%r Opset7.Powr;r'T_RNNT1_RNN)Tanhrryrzr{r|r}r~c t[SSS5n [USU 5nU"URXX#XEU5UUU U U U S.6$)up[🌐 RNN(7)](https://onnx.ai/onnx/operators/onnx__RNN.html#rnn-7 "Online Documentation") Computes an one-layer simple RNN. This operator is usually supported via some custom implementation such as CuDNN. Notations: `X` - input tensor `i` - input gate `t` - time step (t-1 means previous time step) `Wi` - W parameter weight matrix for input gate `Ri` - R recurrence weight matrix for input gate `Wbi` - W parameter bias vector for input gate `Rbi` - R parameter bias vector for input gate `WBi` - W parameter weight matrix for backward input gate `RBi` - R recurrence weight matrix for backward input gate `WBbi` - WR bias vectors for backward input gate `RBbi` - RR bias vectors for backward input gate `H` - Hidden state `num_directions` - 2 if direction == bidirectional else 1 Activation functions: Relu(x) - max(0, x) Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x}) Sigmoid(x) - 1/(1 + e^{-x}) (NOTE: Below are optional) Affine(x) - alpha*x + beta LeakyRelu(x) - x if x >= 0 else alpha * x ThresholdedRelu(x) - x if x >= alpha else 0 ScaledTanh(x) - alpha*Tanh(beta*x) HardSigmoid(x) - min(max(alpha*x + beta, 0), 1) Elu(x) - x if x >= 0 else alpha*(e^x - 1) Softsign(x) - x/(1 + |x|) Softplus(x) - log(1 + e^x) Equations (Default: f=Tanh): - Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) This operator has **optional** inputs/outputs. See `ONNX `_ for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. Args: X: The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`. W: The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`. R: The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`. B: (optional) The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0. sequence_lens: (optional) Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`. initial_h: (optional) Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`. activation_alpha: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01. activation_beta: Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators. activations: One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified. clip: Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified. direction: Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional. hidden_size: Number of neurons in the hidden layer RNNr"r!rr+)r.rSrrr9rrryrzr{r|r}r~r0r1s r%r Opset7.RNNsTHE1b) eV $  ! !&Q1Y O-+##  r'T_Sinc^[SSS5n[USU5nU"URX!56$)u[🌐 Sin(7)](https://onnx.ai/onnx/operators/onnx__Sin.html#sin-7 "Online Documentation") Calculates the sine of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Sinr"r!r+r-s r%r Opset7.Sinbrer'T_Subc`[SSS5n[USU5nU"URX1U56$)u[🌐 Sub(7)](https://onnx.ai/onnx/operators/onnx__Sub.html#sub-7 "Online Documentation") Performs element-wise binary subtraction (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: First operand. B: Second operand. Subr"r!r+r7s r%r Opset7.Subsr;r'T_Tanc^[SSS5n[USU5nU"URX!56$)u[🌐 Tan(7)](https://onnx.ai/onnx/operators/onnx__Tan.html#tan-7 "Online Documentation") Calculates the tangent of the given input tensor, element-wise. Args: input: (differentiable) Input tensor Tanr"r!r+r-s r%r Opset7.Tanrer' T_Upsamplenearest)modecd[SSS5n[USU5nU"URXA5X#S.6$)u0[🌐 Upsample(7)](https://onnx.ai/onnx/operators/onnx__Upsample.html#upsample-7 "Online Documentation") Upsample the input tensor. Each dimension value of the output tensor is: output_dimension = floor(input_dimension * scale). Args: X: N-D tensor mode: Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc) scales: The scale array along each dimension. It takes value greater than or equal to 1. The number of elements of 'scales' should be the same as the rank of input 'X'. Upsampler"r!)rscalesr+)r.rSrrr0r1s r%rOpset7.Upsamples8,J2. j& )4''2MMr'T_XorT1_Xorc`[SSS5n[USU5nU"URX1U56$)u^[🌐 Xor(7)](https://onnx.ai/onnx/operators/onnx__Xor.html#xor-7 "Online Documentation") Returns the tensor resulted from performing the `xor` logical operation elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support). This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX `_. Args: A: (non-differentiable) First input operand for the logical operator. B: (non-differentiable) Second input operand for the logical operator. Xorr"r!r+r7s r%r Opset7.XorrAr')r/r(returnr()r8r4r9r4rr4)r8r<r9r<rr=)r/rBrrB)r/rFrrF)rSrJrLstrrMintrRz Sequence[int]rNOptional[Sequence[int]]rOrrrJ)rSrUr]rUr9rUr^rUr_rUrXfloatrYrrZrrzsTuple[T_BatchNormalization, T_BatchNormalization, T_BatchNormalization, T_BatchNormalization, T_BatchNormalization])r/rarra)r8rfr9rfrrf)rnrjrkrrzTuple[T_Dropout, T_Dropout])r8rpr9rprrq)NNN)rSrurrurrur9Optional[T_GRU]rzOptional[T1_GRU]rrryOptional[Sequence[float]]rzrr{Optional[Sequence[str]]r|Optional[float]r}rr~ Optional[int]rrrzTuple[T_GRU, T_GRU])r8rr9rrrrrrrrrrrrr)r8rr9rrr)NNNNN) rSrrrrrr9Optional[T_LSTM]rzOptional[T1_LSTM]rrrrrrryrrzrr{rr|rr}rr~rrrrzTuple[T_LSTM, T_LSTM, T_LSTM])r8rr9rrr)r8rr9rrr) r/rrrrrrrrr)r8rr9rrr)rSrrrrr)rSrrrrr)rSrrrrrr9Optional[T_RNN]rzOptional[T1_RNN]rrryrrzrr{z Sequence[str]r|rr}rr~rrzTuple[T_RNN, T_RNN])r/rrr)r8rr9rrr)r/rrr)rSrrrrzSequence[float]rr)r8rr9rrr)X__name__ __module__ __qualname____firstlineno__r#rrrrr(r*rrrrr4r6r r<__annotations__r=r?rBrDrFrHrJrQrUr\rarcrfrhrjrmrprqrsrurvrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrr__static_attributes__rr'r%rr)s)Xvug 6F 8 GVUGUE66 RE7&E9FI7(Xvug 6F 8Xvug 6F 8OVUGDM !!"(,+/P P  P  P $ P &P )P  P d##965'R/,F F $F  F # F " F F F F  F P GVUG 4E 8 GVUGUE66 RE7& VUGrsE#<< '5"(q7Vq7r'