ScatterElements¶
ScatterElements - 29¶
Version¶
name: ScatterElements (GitHub)
domain:
mainsince_version:
29function:
Falsesupport_level:
SupportType.COMMONshape inference:
True
This version of the operator has been available since version 29.
Summary¶
ScatterElements takes three inputs data, indices, and updates of the same
rank r >= 1. indices and updates must have the same shape; their sizes must
not exceed the sizes of data in dimensions other than axis.
data and updates must have the same element type.
The output has the same shape and element type as data.
For each entry in updates, the target coordinate is the entry’s coordinate
with the coordinate along axis replaced by the corresponding value in indices.
For an axis of size s, index values must be in [-s, s-1].
A negative index i identifies the same element as i + s.
When reduction is “none”, each update replaces its target element. Multiple
updates must not address the same output element.
For other reductions, group all updates that address the same output element.
Also include the original data value exactly once in that group.
Elements not addressed by any update retain their original data values.
“add”, “mul”, “max”, and “min” compute the sum, product, maximum,
and minimum of each group, respectively.
For “mean”, consider an output element addressed by N >= 1 updates.
Let x be its original data value and u_1, …, u_N be those update values.
Its output value is:
output = (x + u_1 + ... + u_N) / (N + 1)
The “mean” reduction supports integer and floating-point tensors, but not boolean, string, or complex tensors. Integer results are rounded toward negative infinity. Floating-point results are converted to the input element type after division.
A floating-point mean is NaN if x, u_1, …, u_N contain a NaN or infinities of both signs. Otherwise, if any of these values is infinite, the mean is that infinity.
Example:
data = [1.0, 2.0, 3.0, 4.0]
indices = [0, 1, 0, 1, 2, 1]
updates = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
axis = 0
reduction = "mean"
output = [5.0 / 3.0, 3.5, 4.0, 4.0]
Attributes¶
axis - INT (default is
0):Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
reduction - STRING (default is
none):Type of reduction to apply: none (default), add, mul, max, min, mean. ‘none’: no reduction applied. ‘add’: reduction using the addition operation. ‘mul’: reduction using the multiplication operation. ‘max’: reduction using the maximum operation. ‘min’: reduction using the minimum operation. ‘mean’: arithmetic mean of all contributions to each output element.
Inputs¶
data (heterogeneous) - T:
Tensor of rank r >= 1.
indices (heterogeneous) - Tind:
Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
updates (heterogeneous) - T:
Tensor of rank r >=1 (same rank and shape as indices)
Outputs¶
output (heterogeneous) - T:
Tensor of rank r >= 1 (same rank as input).
Type Constraints¶
T in (
tensor(bfloat16),tensor(bool),tensor(complex128),tensor(complex64),tensor(double),tensor(float),tensor(float16),tensor(int16),tensor(int32),tensor(int64),tensor(int8),tensor(string),tensor(uint16),tensor(uint32),tensor(uint64),tensor(uint8)):Input and output types can be of any tensor type.
Tind in (
tensor(int32),tensor(int64)):Constrain indices to integer types
Examples¶
_scatter_elements_mean¶
import numpy as np
import onnx
data = np.array([[1, 2, 3, 4]], dtype=np.float32)
indices = np.array([[0, 1, 0, 1, -2, 1]], dtype=np.int64)
updates = np.array([[1, 2, 3, 4, 5, 6]], dtype=np.float32)
node = onnx.helper.make_node(
"ScatterElements",
["data", "indices", "updates"],
["y"],
axis=-1,
reduction="mean",
)
expect(
node,
inputs=[data, indices, updates],
outputs=[np.array([[5 / 3, 3.5, 4, 4]], dtype=np.float32)],
name="test_scatter_elements_mean",
opset_imports=[onnx.helper.make_opsetid("", 29)],
)
_scatter_elements_mean_integer¶
import numpy as np
import onnx
node = onnx.helper.make_node(
"ScatterElements",
["data", "indices", "updates"],
["y"],
reduction="mean",
)
data = np.array([-2, 8, 9], dtype=np.int64)
indices = np.array([0, 0, 1], dtype=np.int64)
updates = np.array([-3, -3, 5], dtype=np.int64)
expect(
node,
inputs=[data, indices, updates],
outputs=[np.array([-3, 6, 9], dtype=np.int64)],
name="test_scatter_elements_mean_integer",
opset_imports=[onnx.helper.make_opsetid("", 29)],
)
_scatter_elements_without_axis¶
import numpy as np
import onnx
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
)
data = np.zeros((3, 3), dtype=np.float32)
indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
y = scatter_elements(data, indices, updates)
# print(y) produces
# [[2.0, 1.1, 0.0],
# [1.0, 0.0, 2.2],
# [0.0, 2.1, 1.2]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_without_axis",
)
_scatter_elements_with_axis¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, 3]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis)
# print(y) produces
# [[1.0, 1.1, 3.0, 2.1, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_axis",
)
_scatter_elements_with_negative_indices¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, -3]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis)
# print(y) produces
# [[1.0, 1.1, 2.1, 4.0, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_negative_indices",
)
_scatter_elements_with_duplicate_indices¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
reduction="add",
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, 1]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis, reduction="add")
# print(y) produces
# [[1.0, 5.2, 3.0, 4.0, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_duplicate_indices",
)
_scatter_elements_with_reduction_mul¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
reduction="mul",
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, 1]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis, reduction="mul")
# print(y) produces
# [[1.0, 4.62, 3.0, 4.0, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_reduction_mul",
)
_scatter_elements_with_reduction_max¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
reduction="max",
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, 1]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis, reduction="max")
# print(y) produces
# [[1.0, 2.1, 3.0, 4.0, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_reduction_max",
)
_scatter_elements_with_reduction_min¶
import numpy as np
import onnx
axis = 1
node = onnx.helper.make_node(
"ScatterElements",
inputs=["data", "indices", "updates"],
outputs=["y"],
axis=axis,
reduction="min",
)
data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
indices = np.array([[1, 1]], dtype=np.int64)
updates = np.array([[1.1, 2.1]], dtype=np.float32)
y = scatter_elements(data, indices, updates, axis, reduction="min")
# print(y) produces
# [[1.0, 1.1, 3.0, 4.0, 5.0]]
expect(
node,
inputs=[data, indices, updates],
outputs=[y],
name="test_scatter_elements_with_reduction_min",
)
ScatterElements - 18¶
Version¶
name: ScatterElements (GitHub)
domain:
mainsince_version:
18function:
Falsesupport_level:
SupportType.COMMONshape inference:
True
This version of the operator has been available since version 18.
Summary¶
ScatterElements takes three inputs data, updates, and indices of the same
rank r >= 1 and an optional attribute axis that identifies an axis of data
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input data, and then updating its value
to values specified by updates at specific index positions specified by
indices. Its output shape is the same as the shape of data.
For each entry in updates, the target index in data is obtained by combining
the corresponding entry in indices with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in indices and the index-value for dimension != axis is obtained from the
index of the entry itself.
reduction allows specification of an optional reduction operation, which is applied to all values in updates
tensor into output at the specified indices.
In cases where reduction is set to “none”, indices should not have duplicate entries: that is, if idx1 != idx2,
then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] = updates[i][j] if axis = 0,
output[i][indices[i][j]] = updates[i][j] if axis = 1,
When reduction is set to some reduction function f, the update corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] = f(output[indices[i][j]][j], updates[i][j]) if axis = 0,
output[i][indices[i][j]] = f(output[i][indices[i][j]], updates[i][j]) if axis = 1,
where the f is +, *, max or min as specified.
This operator is the inverse of GatherElements. It is similar to Torch’s Scatter operation.
(Opset 18 change): Adds max/min to the set of allowed reduction ops.
Example 1:
data = [
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
]
indices = [
[1, 0, 2],
[0, 2, 1],
]
updates = [
[1.0, 1.1, 1.2],
[2.0, 2.1, 2.2],
]
output = [
[2.0, 1.1, 0.0]
[1.0, 0.0, 2.2]
[0.0, 2.1, 1.2]
]
Example 2:
data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
indices = [[1, 3]]
updates = [[1.1, 2.1]]
axis = 1
output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
Attributes¶
axis - INT (default is
0):Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
reduction - STRING (default is
none):Type of reduction to apply: none (default), add, mul, max, min. ‘none’: no reduction applied. ‘add’: reduction using the addition operation. ‘mul’: reduction using the multiplication operation.’max’: reduction using the maximum operation.’min’: reduction using the minimum operation.
Inputs¶
data (heterogeneous) - T:
Tensor of rank r >= 1.
indices (heterogeneous) - Tind:
Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
updates (heterogeneous) - T:
Tensor of rank r >=1 (same rank and shape as indices)
Outputs¶
output (heterogeneous) - T:
Tensor of rank r >= 1 (same rank as input).
Type Constraints¶
T in (
tensor(bfloat16),tensor(bool),tensor(complex128),tensor(complex64),tensor(double),tensor(float),tensor(float16),tensor(int16),tensor(int32),tensor(int64),tensor(int8),tensor(string),tensor(uint16),tensor(uint32),tensor(uint64),tensor(uint8)):Input and output types can be of any tensor type.
Tind in (
tensor(int32),tensor(int64)):Constrain indices to integer types
ScatterElements - 16¶
Version¶
name: ScatterElements (GitHub)
domain:
mainsince_version:
16function:
Falsesupport_level:
SupportType.COMMONshape inference:
True
This version of the operator has been available since version 16.
Summary¶
ScatterElements takes three inputs data, updates, and indices of the same
rank r >= 1 and an optional attribute axis that identifies an axis of data
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input data, and then updating its value
to values specified by updates at specific index positions specified by
indices. Its output shape is the same as the shape of data.
For each entry in updates, the target index in data is obtained by combining
the corresponding entry in indices with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in indices and the index-value for dimension != axis is obtained from the
index of the entry itself.
reduction allows specification of an optional reduction operation, which is applied to all values in updates
tensor into output at the specified indices.
In cases where reduction is set to “none”, indices should not have duplicate entries: that is, if idx1 != idx2,
then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] = updates[i][j] if axis = 0,
output[i][indices[i][j]] = updates[i][j] if axis = 1,
When reduction is set to “add”, the update corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] += updates[i][j] if axis = 0,
output[i][indices[i][j]] += updates[i][j] if axis = 1,
When reduction is set to “mul”, the update corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] *= updates[i][j] if axis = 0,
output[i][indices[i][j]] *= updates[i][j] if axis = 1,
This operator is the inverse of GatherElements. It is similar to Torch’s Scatter operation. Example 1:
data = [
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
]
indices = [
[1, 0, 2],
[0, 2, 1],
]
updates = [
[1.0, 1.1, 1.2],
[2.0, 2.1, 2.2],
]
output = [
[2.0, 1.1, 0.0]
[1.0, 0.0, 2.2]
[0.0, 2.1, 1.2]
]
Example 2:
data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
indices = [[1, 3]]
updates = [[1.1, 2.1]]
axis = 1
output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
Attributes¶
axis - INT (default is
0):Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
reduction - STRING (default is
none):Type of reduction to apply: none (default), add, mul. ‘none’: no reduction applied. ‘add’: reduction using the addition operation. ‘mul’: reduction using the multiplication operation.
Inputs¶
data (heterogeneous) - T:
Tensor of rank r >= 1.
indices (heterogeneous) - Tind:
Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
updates (heterogeneous) - T:
Tensor of rank r >=1 (same rank and shape as indices)
Outputs¶
output (heterogeneous) - T:
Tensor of rank r >= 1 (same rank as input).
Type Constraints¶
T in (
tensor(bfloat16),tensor(bool),tensor(complex128),tensor(complex64),tensor(double),tensor(float),tensor(float16),tensor(int16),tensor(int32),tensor(int64),tensor(int8),tensor(string),tensor(uint16),tensor(uint32),tensor(uint64),tensor(uint8)):Input and output types can be of any tensor type.
Tind in (
tensor(int32),tensor(int64)):Constrain indices to integer types
ScatterElements - 13¶
Version¶
name: ScatterElements (GitHub)
domain:
mainsince_version:
13function:
Falsesupport_level:
SupportType.COMMONshape inference:
True
This version of the operator has been available since version 13.
Summary¶
ScatterElements takes three inputs data, updates, and indices of the same
rank r >= 1 and an optional attribute axis that identifies an axis of data
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input data, and then updating its value
to values specified by updates at specific index positions specified by
indices. Its output shape is the same as the shape of data.
For each entry in updates, the target index in data is obtained by combining
the corresponding entry in indices with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in indices and the index-value for dimension != axis is obtained from the
index of the entry itself.
For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] = updates[i][j] if axis = 0,
output[i][indices[i][j]] = updates[i][j] if axis = 1,
This operator is the inverse of GatherElements. It is similar to Torch’s Scatter operation.
Example 1:
data = [
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
]
indices = [
[1, 0, 2],
[0, 2, 1],
]
updates = [
[1.0, 1.1, 1.2],
[2.0, 2.1, 2.2],
]
output = [
[2.0, 1.1, 0.0]
[1.0, 0.0, 2.2]
[0.0, 2.1, 1.2]
]
Example 2:
data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
indices = [[1, 3]]
updates = [[1.1, 2.1]]
axis = 1
output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
Attributes¶
axis - INT (default is
0):Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
Inputs¶
data (heterogeneous) - T:
Tensor of rank r >= 1.
indices (heterogeneous) - Tind:
Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
updates (heterogeneous) - T:
Tensor of rank r >=1 (same rank and shape as indices)
Outputs¶
output (heterogeneous) - T:
Tensor of rank r >= 1 (same rank as input).
Type Constraints¶
T in (
tensor(bfloat16),tensor(bool),tensor(complex128),tensor(complex64),tensor(double),tensor(float),tensor(float16),tensor(int16),tensor(int32),tensor(int64),tensor(int8),tensor(string),tensor(uint16),tensor(uint32),tensor(uint64),tensor(uint8)):Input and output types can be of any tensor type.
Tind in (
tensor(int32),tensor(int64)):Constrain indices to integer types
ScatterElements - 11¶
Version¶
name: ScatterElements (GitHub)
domain:
mainsince_version:
11function:
Falsesupport_level:
SupportType.COMMONshape inference:
True
This version of the operator has been available since version 11.
Summary¶
ScatterElements takes three inputs data, updates, and indices of the same
rank r >= 1 and an optional attribute axis that identifies an axis of data
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input data, and then updating its value
to values specified by updates at specific index positions specified by
indices. Its output shape is the same as the shape of data.
For each entry in updates, the target index in data is obtained by combining
the corresponding entry in indices with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in indices and the index-value for dimension != axis is obtained from the
index of the entry itself.
For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry is performed as below:
output[indices[i][j]][j] = updates[i][j] if axis = 0,
output[i][indices[i][j]] = updates[i][j] if axis = 1,
This operator is the inverse of GatherElements. It is similar to Torch’s Scatter operation.
Example 1:
data = [
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
]
indices = [
[1, 0, 2],
[0, 2, 1],
]
updates = [
[1.0, 1.1, 1.2],
[2.0, 2.1, 2.2],
]
output = [
[2.0, 1.1, 0.0]
[1.0, 0.0, 2.2]
[0.0, 2.1, 1.2]
]
Example 2:
data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
indices = [[1, 3]]
updates = [[1.1, 2.1]]
axis = 1
output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
Attributes¶
axis - INT (default is
0):Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
Inputs¶
data (heterogeneous) - T:
Tensor of rank r >= 1.
indices (heterogeneous) - Tind:
Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
updates (heterogeneous) - T:
Tensor of rank r >=1 (same rank and shape as indices)
Outputs¶
output (heterogeneous) - T:
Tensor of rank r >= 1 (same rank as input).
Type Constraints¶
T in (
tensor(bool),tensor(complex128),tensor(complex64),tensor(double),tensor(float),tensor(float16),tensor(int16),tensor(int32),tensor(int64),tensor(int8),tensor(string),tensor(uint16),tensor(uint32),tensor(uint64),tensor(uint8)):Input and output types can be of any tensor type.
Tind in (
tensor(int32),tensor(int64)):Constrain indices to integer types