NXP backend: added support for aten.pad with mode reflect

[novak-vaclav]

Summary

Added support for aten.pad with mode reflect using new Neutron MLIR flow.

Test plan

tests can be manually run using pytest -c /dev/null backends/nxp/tests/

cc @robert-kalmar @JakeStevens @digantdesai @rascani @MartinPavella

[pytorch-bot]

🔗 Helpful Links

🧪 See artifacts and rendered test results at hud.pytorch.org/pr/pytorch/executorch/21515

• 📄 Preview Python docs built from this PR

Note: Links to docs will display an error until the docs builds have been completed.

❌ 1 New Failure, 9 Pending

As of commit 8c50a26 with merge base 4b4df96 ():

NEW FAILURE - The following job has failed:

• pull / unittest-editable / linux / linux-job (gh)
  backends/xnnpack/test/recipes/test_xnnpack_recipes.py::TestXnnpackRecipes::test_all_models_with_recipes

This comment was automatically generated by Dr. CI and updates every 15 minutes.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[linux-foundation-easycla]

• ❌ - login: @novak-vaclav / name: Vaclav Novak. The commit (8c50a26) is not authorized under a signed CLA. Please click here to be authorized. For further assistance with EasyCLA, please visit our EasyCLA portal and chat with our support bot.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[novak-vaclav]

Fixed minor issues I found out about after creating the PR.

[novak-vaclav]

And rebased onto current main to run the tests on Neutron Software 3.2.0

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[novak-vaclav]

Resolved comments from code review, resolved conflicts with main and rebased.

[roman-janik-nxp]

Just move the comment, otherwise GJ!

[novak-vaclav]

Fixed all found issues in code review, rebased onto main and when tests pass, I will merge.

[Copilot]

Pull request overview

Copilot reviewed 9 out of 9 changed files in this pull request and generated 1 comment.

Suppressed comments (3)

backends/nxp/backend/ir/converter/node_converters/ops_converters/pad_converter.py:33

• PadConverter._get_mode() only looks at positional args. If aten.pad is emitted with keyword arguments (common in FX graphs), mode may be present in node.kwargs and this will incorrectly default to "constant", causing reflect padding to be treated as unsupported and decomposed.

    @staticmethod
    def _get_mode(node: Node) -> str:
        return node.args[2] if len(node.args) > 2 else "constant"

backends/nxp/backend/ir/converter/node_converters/ops_converters/pad_converter.py:87

• _convert_paddings_to_tflite() is annotated to return list[int], but it actually returns a list of 2-element pairs (rank x 2). Also, paddings_reversed becomes a list of NumPy row arrays, which then gets concatenated with Python lists; converting to plain list[list[int]] early avoids mixed element types and matches what MirrorPad expects.

    @staticmethod
    def _convert_paddings_to_tflite(
        paddings: Collection[int], input_tensor: tflite_model.Tensor
    ) -> list[int]:
        # Group `padding` by two elements per list.

backends/nxp/neutron_partitioner.py:559

• Docstring has a mismatched bracket in the return-type description (Optional[Callable[[torch.fx.Node], bool]]]:). This makes the rendered/parsed type unclear.

        Returns:
            List[torch._ops.OpOverload]: a list of ops that should not be decomposed.
            Optional[Callable[[torch.fx.Node], bool]]]: an optional filter, called for each node in the
            graph, that lets a node be decomposed even though its op is in the list above. A node is kept
            (not decomposed) only if the filter returns True for it; if it returns False, the node is decomposed.

[novak-vaclav]

Github CI seemed to fail for some unrelated reason, so I rebased onto main and will wait till tests pass.

[Copilot]

Pull request overview

Copilot reviewed 9 out of 9 changed files in this pull request and generated no new comments.

Suppressed comments (4)

backends/nxp/tests/models.py:370

• PadModule (and similarly PadConvModule) annotates value as float | None, but callers/tests may pass an int (and the previous API allowed float | int | None). Consider widening the annotation to float | int | None to match actual usage and avoid type-checker friction.

class PadModule(torch.nn.Module):
    def __init__(
        self,
        paddings: Collection[int],
        mode: str = "constant",
        value: float | None = None,
    ):

backends/nxp/backend/ir/converter/node_converters/ops_converters/pad_converter.py:32

• aten.pad mode can be provided via keyword arguments in FX (node.kwargs.get('mode')), not only positionally. With the current implementation, a node like pad(x, pad, mode='reflect') captured in kwargs could be misclassified as constant, making the converter incorrectly report unsupported and causing decomposition instead of delegation. Update _get_mode to check node.kwargs first (and fall back to positional/default).

    def _get_mode(node: Node) -> str:
        return node.args[2] if len(node.args) > 2 else "constant"

backends/nxp/backend/ir/converter/node_converters/ops_converters/pad_converter.py:78

• Two issues here: (1) the return annotation says list[int], but the function returns a 2D structure (list[list[int]] / array of pairs), which is what MirrorPad expects. (2) this code will raise (or produce invalid padding) when len(paddings) is odd or when len(paddings)/2 > input_tensor.rank (negative complement). It would be safer to validate these conditions in _is_supported_in_IR (return False) or raise a clearer error before hitting NumPy reshape / negative rank math.

    def _convert_paddings_to_tflite(
        paddings: Collection[int], input_tensor: tflite_model.Tensor
    ) -> list[int]:
        # Group `padding` by two elements per list.
        paddings_grouped = np.array(paddings).reshape(-1, 2)

        # In TFLite, `padding` order is reversed.
        paddings_reversed = list(reversed(paddings_grouped))

        # Add complementary zero pairs to `padding` to match input tensor rank.
        zero_pair_compl = [[0, 0]] * (input_tensor.rank - len(paddings_reversed))
        padding_tfl = zero_pair_compl + paddings_reversed

backends/nxp/neutron_partitioner.py:560

• Docstring type markup has a bracket mismatch: Optional[Callable[[torch.fx.Node], bool]]]: has an extra ]. This makes the docstring harder to read and can confuse generated docs; please fix the bracket structure.

    ) -> tuple[list[torch._ops.OpOverload], Callable[[torch.fx.Node], bool] | None]:
        """
        Method to determine which operators SHOULD NOT be decomposed to simpler edge ops.

        Returns:
            List[torch._ops.OpOverload]: a list of ops that should not be decomposed.
            Optional[Callable[[torch.fx.Node], bool]]]: an optional filter, called for each node in the
            graph, that lets a node be decomposed even though its op is in the list above. A node is kept
            (not decomposed) only if the filter returns True for it; if it returns False, the node is decomposed.
        """