PyTorch函数参数传递规范疑问：列表传参与独立传参的差异原因

Great question—this inconsistency is totally confusing when you're just getting started with PyTorch, and it’s not just random contributor preference! There are intentional design choices behind each approach, tied to the specific use cases of each module. Let’s break it down:

1. transforms.Compose: Designed for dynamic, flexible preprocessing pipelines #

The torchvision.transforms module focuses on data preprocessing, where you often need to dynamically adjust your pipeline based on conditions (like whether to apply augmentation, normalization, etc.). Accepting a list as a single parameter makes this workflow much smoother:

# Example: Build a transform list dynamically
transform_steps = [transforms.ToTensor()]
if should_normalize:
    transform_steps.append(transforms.Normalize((0.4915, 0.4823, 0.4468), (0.2470, 0.2435, 0.2616)))
if should_resize:
    transform_steps.append(transforms.Resize((224, 224)))

transform = transforms.Compose(transform_steps)

Additionally, this design has historical roots—early PyTorch versions relied on lists to chain transforms, and keeping this signature maintains backward compatibility for existing codebases. The list format also makes the execution order explicitly clear, which is critical for preprocessing where step order directly affects your data.

2. nn.Sequential: Optimized for clean, static network definitions #

The torch.nn module centers around building neural network architectures, which are often statically defined upfront. Using variable positional arguments (*args) lets you write concise, readable code when defining layers inline:

# Clean, direct layer definition
model = nn.Sequential(
    nn.Linear(1, 4),
    nn.Tanh(),
    nn.Linear(4, 1)
)

That said, nn.Sequential is actually flexible enough to work with lists too—you just need to unpack the list using the * operator:

# Using a list with nn.Sequential
layers = [nn.Linear(1, 4), nn.Tanh(), nn.Linear(4, 1)]
model = nn.Sequential(*layers)

The core difference lies in their constructor signatures:

• transforms.Compose explicitly accepts a single sequence (list/tuple) parameter: def __init__(self, transforms: Sequence[Callable])
• nn.Sequential accepts variable positional arguments (or an ordered dictionary): def __init__(self, *args: Union[Module, OrderedDict[str, Module]])

Key takeaway #

This isn’t about arbitrary style choices—it’s about optimizing for each module’s primary use case. transforms.Compose prioritizes flexibility for dynamic preprocessing, while nn.Sequential prioritizes readability for static network building. Once you understand these goals, the parameter styles make a lot more sense, and you’ll find yourself mixing them naturally based on what you’re building.

内容的提问来源于stack exchange，提问作者Amin.A