diff --git a/docs/ops/reduction/ReduceLogicalAnd_1.md b/docs/ops/reduction/ReduceLogicalAnd_1.md index 824d5fdec7fd28..6ff706e1ed23af 100644 --- a/docs/ops/reduction/ReduceLogicalAnd_1.md +++ b/docs/ops/reduction/ReduceLogicalAnd_1.md @@ -18,24 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined *logical and* operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with *logical and* operation along dimensions specified by the 2nd input: - output[i0, i1, ..., iN] = and[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = and[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and *logical and* operation `and[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceLogicalOr_1.md b/docs/ops/reduction/ReduceLogicalOr_1.md index e67a1d0dc3da0c..e2b30dd024443c 100644 --- a/docs/ops/reduction/ReduceLogicalOr_1.md +++ b/docs/ops/reduction/ReduceLogicalOr_1.md @@ -18,14 +18,19 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined *logical or* operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with *logical or* operation along dimensions specified by the 2nd input: @@ -34,8 +39,9 @@ Each element in the output is the result of reduction with *logical or* operatio Where indices i0, ..., iN run through all valid indices for the 1st input and *logical or* operation `or[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceLp_4.md b/docs/ops/reduction/ReduceLp_4.md index 10f5cf3a82ef0e..c0ea0d708dc19d 100644 --- a/docs/ops/reduction/ReduceLp_4.md +++ b/docs/ops/reduction/ReduceLp_4.md @@ -1,4 +1,4 @@ -## ReduceLp +## ReduceLp {#openvino_docs_ops_reduction_ReduceLp_4} **Versioned name**: *ReduceLp-4* diff --git a/docs/ops/reduction/ReduceMax_1.md b/docs/ops/reduction/ReduceMax_1.md index 13379caf9bbe74..e6a512efe8951a 100644 --- a/docs/ops/reduction/ReduceMax_1.md +++ b/docs/ops/reduction/ReduceMax_1.md @@ -18,24 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined maximum operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +** Types ** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with finding a maximum operation along dimensions specified by the 2nd input: - output[i0, i1, ..., iN] = max[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = max[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and finding the maximum value `max[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceMean_1.md b/docs/ops/reduction/ReduceMean_1.md index 3c7b06ed17955d..91ca61a17ad591 100644 --- a/docs/ops/reduction/ReduceMean_1.md +++ b/docs/ops/reduction/ReduceMean_1.md @@ -18,25 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined the arithmetic mean operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with finding the arithmetic mean operation along dimensions specified by the 2nd input: - - output[i0, i1, ..., iN] = mean[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = mean[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and finding the arithmetic mean `mean[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -63,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceMin_1.md b/docs/ops/reduction/ReduceMin_1.md index 4dd3981eb512ab..83eb004bdca4e9 100644 --- a/docs/ops/reduction/ReduceMin_1.md +++ b/docs/ops/reduction/ReduceMin_1.md @@ -18,24 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined minimum operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with finding a minimum operation along dimensions specified by the 2nd input: - output[i0, i1, ..., iN] = min[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = min[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and finding the minimum value `min[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceProd_1.md b/docs/ops/reduction/ReduceProd_1.md index dab222ce8f86ef..fce7cdf9187d52 100644 --- a/docs/ops/reduction/ReduceProd_1.md +++ b/docs/ops/reduction/ReduceProd_1.md @@ -18,24 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined multiplication operation. **Required.** +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required.** +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with multiplication operation along dimensions specified by the 2nd input: - output[i0, i1, ..., iN] = prod[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = prod[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and multiplication `prod[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file diff --git a/docs/ops/reduction/ReduceSum_1.md b/docs/ops/reduction/ReduceSum_1.md index b348ad769ea11e..decab8e292a51e 100644 --- a/docs/ops/reduction/ReduceSum_1.md +++ b/docs/ops/reduction/ReduceSum_1.md @@ -18,24 +18,30 @@ **Inputs** -* **1**: Input tensor x of any data type that has defined addition operation. **Required**. +* **1**: Input tensor x of type *T1*. **Required.** -* **2**: Scalar or 1D tensor with axis indices for the 1st input along which reduction is performed. **Required**. +* **2**: Scalar or 1D tensor of type *T_IND* with axis indices for the 1st input along which reduction is performed. Accepted range is `[-r, r-1]` where where `r` is the rank of input tensor, all values must be unique, repeats are not allowed. **Required.** **Outputs** * **1**: Tensor of the same type as the 1st input tensor and `shape[i] = shapeOf(input1)[i]` for all `i` that is not in the list of axes from the 2nd input. For dimensions from the 2nd input tensor, `shape[i] == 1` if `keep_dims == True`, or `i`-th dimension is removed from the output otherwise. +**Types** + +* *T1*: any supported numeric type. +* *T_IND*: `int64` or `int32`. + **Detailed Description** Each element in the output is the result of reduction with addition operation along dimensions specified by the 2nd input: - output[i0, i1, ..., iN] = sum[j0,..., jN](x[j0, ..., jN]**2)) + output[i0, i1, ..., iN] = sum[j0,..., jN](x[j0, ..., jN])) Where indices i0, ..., iN run through all valid indices for the 1st input and summation `sum[j0, ..., jN]` have `jk = ik` for those dimensions `k` that are not in the set of indices specified by the 2nd input of the operation. Corner cases: - 1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. - 2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. + +1. When the 2nd input is an empty list, then this operation does nothing, it is an identity. +2. When the 2nd input contains all dimensions of the 1st input, this means that a single reduction value is calculated for entire input tensor. **Example** @@ -62,4 +68,75 @@ Corner cases: +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 2 + + + + + 6 + 12 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 10 + 24 + + + +``` + +```xml + + + + + 6 + 12 + 10 + 24 + + + 1 + + + + + 6 + 12 + 24 + + + ``` \ No newline at end of file