Dynamic shape for pad operator

[hdnhan]

🐞Describing the bug

When using torch.nn.functional.pad(x, (1, x.size(-1))) with dynamic pad size, coremltools throws an error at line

coremltools/coremltools/converters/mil/frontend/torch/ops.py

Line 2390 in 0f42442

if pad.val is not None:

Stack Trace

To Reproduce

import torch
import numpy as np
import coremltools as ct

class SimpleModel(torch.nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return torch.nn.functional.pad(x, (1, x.size(-1)))

example_input = torch.rand(3)
traced_model = torch.jit.trace(SimpleModel(), example_input)

for i in range(2, 10):
    x = torch.rand(i)
    output = traced_model(x)
    print(f"{x.shape}: {output.shape}")

input_shape = ct.EnumeratedShapes(shapes=[[1], [2], [3]], default=[2])
model = ct.convert(
    traced_model,
    convert_to="mlprogram",
    inputs=[ct.TensorType(shape=input_shape, name="input", dtype=np.float32)],
    outputs=[ct.TensorType(name="output", dtype=np.float32)],
)

System environment (please complete the following information):

• coremltools version: 8.3.0
• OS (e.g. MacOS version or Linux type): macOS 15.6
• Any other relevant version information (e.g. PyTorch or TensorFlow version): PyTorch 2.6.0

[noobsiecoder]

Hey @hdnhan,

I debugged your code. The issue is that the conversion from torch.pad() to mb.pad() fails when padding values are dynamic (only known at runtime), like x.size(-1).Here's what I found:

CASE 1 - Dynamic padding (FAILS):

# statement: return torch.nn.functional.pad(x, (1, x.size(-1)))
# CASE 1 - Fail
# Model Intermediate Language (MIL) representation:
graph(
    %x : Custom Params(<class 'coremltools.converters.mil.input_types.TensorType'>),
):
  %2 = constant[value=-1]()
  %3 = size[](%x, %2)
  %4 = numtotensor[](%3)
  %5 = int[](%4)
  %6 = constant[value=1]()
  %7 = listconstruct[](%6, %5)
  %8 = constant[value=constant]()
  %9 = constant[]()
  %10 = pad[](%x, %7, %8, %9)
return (%10)

CASE 2 - Static padding (WORKS):

# PyTorch: return torch.nn.functional.pad(x, (1, 0))
# MIL representation:
graph(
    %x : Custom Params(<class 'coremltools.converters.mil.input_types.TensorType'>),
):
  %2 = constant[value=1]()
  %3 = constant[value=0]()
  %4 = listconstruct[](%2, %3)  # Creates [1, 0] - both constants
  %5 = constant[value=constant]()
  %6 = constant[]()
  %7 = pad[](%x, %4, %5, %6)
return (%7)

The root cause is in ops.py, specifically in the _translate_torch_args() function. When padding values are constants (Case 2), they're properly converted to Var objects. However, when padding includes dynamic values (Case 1), the listconstruct operation returns a Python list instead of a Var object.

This causes the error at line 2398:

if pad.val is not None:  # Fails because 'pad' is a list, not a Var

The issue is that _getbindings() in the same file, returns List[Var] for static values but a nested structure for dynamic values, breaking the expected type contract.

[noobsiecoder]

@karimnosseir, I would like to work on fixing this. Are you open to contributions for this issue?

[karimnosseir]

@noobsiecoder sure, please go ahead.
Thanks