Add onnx importer functions: ScatterND, EyeLike, Mod2, BitShift, and Unique

[TomonobuTsujikawa]

This PR adds onnx importer functions.

ScatterND

Convert ONNX output = ScatterND(data, indices, updates, reduction) to the following nnabla representation:

if len(indices_shape) == 1:
    indices_shape = [1] + indices_shape
    reshaped_indices = F.reshape(indices, indices_shape, inplace=False)
    updates_shape = [1] + updates_shape
    reshaped_updates = F.reshape(updates, updates_shape, inplace=False)

transpose_shape = np.roll(np.arange(len(indices_shape)), 1)
transpose_indices = F.transpose(reshaped_indices, transpose_shape)

duplicated_data = F.identity(data)

add = False
if reduction == ‘add’:
    add = True
y = F.scatter_nd(reshaped_updates, transpose_indices, out = duplicated_data, add = add)

• Reshape
  • The rank of ONNX indices is 1 or higher, but nnabla doesn't support indices with a rank of 1.
• Transpose
  • The shape of nnabla indices is [M, Y_0, ..., Y_K-1], but the shape of ONNX indices is [Y_0, ..., Y_K-1, M]
• Identity
  • Duplicating the data Variable by nnabla Identity, because nnabla ScatterND parameter out is written in-place.

Limitation

• reduction == 'mul' is not supported in the current implementation.

EyeLike

Convert ONNX output = EyeLike(input, dtype, k) to the following nnabla representation:

output = F.eye_like(input, k)

The interface of nnabla EyeLike function is compatible with ONNX EyeLike except dtype attribute. For details, see ONNX Operators documentation: https://github.com/onnx/onnx/blob/main/docs/Operators.md#eyelike

In ONNX importer, attribute dtype of ONNX EyeLike is ignored, and the output dtype is determined by nnabla context. This implementation does not generate information loss due to the type conversion because EyeLike outputs only 0 or 1.

Mod2

Convert ONNX C = Mod(A, B, fmod) to the following nnabla representation:

C = F.mod2(A, B, bool(fmod))

The interface of nnabla Mod2 function is compatible with ONNX Mod. For details, see ONNX Operators documentation: https://github.com/onnx/onnx/blob/main/docs/Operators.md#mod

NOTICE:

• nnabla Mod2 function does not support long double as dtype.
• The output dtype is determined by the dtype of the first input.
• The type of input and output variables are not statically determined, so Mod2::in_types() and Mod2::out_types() raise an error.

BitShift

Convert ONNX Z = BitShift(X, Y, direction) to the following nnabla representation:

Z = F.bit_shift(X, Y, direction)

The interface of nnabla BitShift function is compatible with ONNX BitShift. For details, see ONNX Operators documentation: https://github.com/onnx/onnx/blob/main/docs/Operators.md#bitshift

NOTICE:

• The type of the output is determined by the dtype of the first input.
• The types of the input/output variables are not statically determined, so BitShift::in_types() and BitShift::out_types() raise an error.

Unique

Convert ONNX Y, indices, inverse_indices, counts = Unique(X, axis, sorted) to the following nnabla representation:

flatten = False
if axis is None:
    flatten = True
    axis = 0

# Set True or False to with_(indices|inverse|counts) according to the existence of optional outputs
with_indices = # True or False
with_inverse = # True or False
with_counts = # True or False

# Unique
Y, indices, inverse_indices, counts = F.unique(x, flatten, axis, sorted, with_index, with_inverse, with_counts)

The interface of Unique function is basically compatible with ONNX Unique. For details, see ONNX Operators documentation: https://github.com/onnx/onnx/blob/main/docs/Operators.md#unique

nnabla Unique has flatten as additional parameter because nnabla layer function cannot have optional parameters. The difference between ONNX Unique and nnabla Unique is as follows:

• ONNX
  • If attribute axis is specified, unique is computed along the axis.
  • If attribute axis is not specified, unique is computed along all the axis (the input is flattened).
• nnabla
  • If flatten is False, unique is computed along the axis specified with attribute axis.
  • If flatten is True, unique is computed along all the axis (attribute axis is ignored).