module onnxrt.ops_cpu.op_scatter_elements

Short summary

module mlprodict.onnxrt.ops_cpu.op_scatter_elements

Runtime operator.

source on GitHub

Classes

class	truncated documentation
ScatterElements	ScatterElements =============== ScatterElements takes three inputs data, updates, and indices of the same rank r …

Functions

function	truncated documentation
scatter_elements

Properties

property	truncated documentation
args_default	Returns the list of arguments as well as the list of parameters with the default values (close to the signature). …
args_default_modified	Returns the list of modified parameters.
args_mandatory	Returns the list of optional arguments.
args_optional	Returns the list of optional arguments.
atts_value	Returns all parameters in a dictionary.

Methods

method	truncated documentation
__init__
_run

Documentation

Runtime operator.

source on GitHub

class mlprodict.onnxrt.ops_cpu.op_scatter_elements.ScatterElements(onnx_node, desc=None, **options)

Bases: OpRun

---

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/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: Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Default value is nameaxisi0typeINT (INT)

• reduction: 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. Default value is namereductionsnonetypeSTRING (STRING)

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 tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128): Input and output types can be of any tensor type.

• Tind tensor(int32), tensor(int64): Constrain indices to integer types

Version

Onnx name: ScatterElements

This version of the operator has been available since version 18.

Runtime implementation: ScatterElements

__init__(onnx_node, desc=None, **options)

_run(data, indices, updates, attributes=None, verbose=0, fLOG=None)

Should be overwritten.

source on GitHub

mlprodict.onnxrt.ops_cpu.op_scatter_elements.scatter_elements(data, indices, updates, axis=0)

::

// for 3-dim and axis=0 // output[indices[i][j][k]][j][k] = updates[i][j][k] // for axis 1 // output[i][indices[i][j][k]][k] = updates[i][j][k] // and so on

source on GitHub