For these, it should be okay to not cast to np.array in the converter (instead leave them as ints or floats), since to_numpy should dictate this casting behavior for ints and floats. Specifically, one small difference is that I think np.array(1.0) has shape () (0D), but to_numpy generally adds a dimension, to make it 1D.

See above comment

See above comment

Since line 189 is shape = weight.shape and lines 191 and 192 call weight.reshape and bias.reshape, I think weight and bias shouldn't be scalars.

I see - in that case, it might be preferable to use to_numpy(0.0), for instance, to get back a default-formatted numpy array for the float default. Additionally, I noticed the code below has some issues:

gamma = to_numpy(weight.reshape(*shape))
##### Above is invalid, since the reshape should apply to the numpy output. It should instead be:
gamma = to_numpy(weight).reshape(shape)

The same as the above applies for beta.

Additionally, lines 194 - 196 should be using get_axes_for_reduce_op, as here:

I see - in that case, it might be preferable to use to_numpy(0.0), for instance, to get back a default-formatted numpy array for the float default. Additionally, I noticed the code below has some issues:

gamma = to_numpy(weight.reshape(*shape))
##### Above is invalid, since the reshape should apply to the numpy output. It should instead be:
gamma = to_numpy(weight).reshape(shape)

The same as the above applies for beta.

Additionally, lines 194 - 196 should be using get_axes_for_reduce_op, as here:

TRTTensor would not be a valid input here, for the scale layer

Do you mean the type of weight and bias in all the three functions should be Optional[Union[torch.Tensor, np.ndarray]]? I see its native function:

func: layer_norm(Tensor input, SymInt[] normalized_shape, Tensor? weight=None, Tensor? bias=None, float eps=1e-05, bool cudnn_enable=True) -> Tensor

Yes, I think it should be Optional[Union[torch.Tensor, np.ndarray]], because if either of those is a TRTTensor, the computation below would not work (to_numpy can't be called on a TRTTensor)

The torch.Tensor cast can be removed, because to_numpy will return an np.ndarray, so this typing would be incorrect.

Is it possible to avoid invoking the plugin here, and instead use the full implementation, adapting from here: https://github.com/NVIDIA-AI-IOT/torch2trt/blob/36656b614f3fbc067ac673932e2200d7afdae712/torch2trt/converters/group_norm.py#L7-L73? The plugin is not preferable for use in new converters unless it cannot be otherwise supported.

Alternatively, the TRT layer-based implementation can be the backup for the plugin, etc.

The returned values here should be correct intermediate tensors from during the computation unless we explicitly remove support for nodes which need the other two values

Based on the schema of native_layer_norm, it looks like it requires 3 outputs much like native_group_norm. As a comment on both of those - if you want to support it with essentially the same converter as the regular layer norm, you can do the following:

Add this validator

def validator(layer_norm: Node) -> bool:
    # Validate only one user, which is a getitem node that accesses the first element in the list
    return (len(layer_norm.users) == 1 and
            list(node.users)[0].target == operator.getitem and
            list(node.users)[0].args[1] == 0))

Add this converter

@dynamo_tensorrt_converter(torch.ops.aten.native_layer_norm.default, capability_validator=validator)
def converter(...):
    return (regular_layer_norm, )

It is important that the above converter returns a tuple, because it will be accessed by getitem, but as you have validated, it will only access the first element. This should also work for group norm.