Introduction

PyTorch does not ship with a built-in model.summary() method like Keras, but it gives you enough hooks to inspect model structure clearly. In practice, most PyTorch projects use three layers of inspection: plain print(model), parameter counting, and a third-party summary tool such as torchinfo.

Start With print(model)

Every nn.Module has a readable string representation. This is the quickest sanity check when you want to confirm nested blocks, activation layers, and top-level classifier structure.

1import torch
2import torch.nn as nn
3
4class SimpleCNN(nn.Module):
5    def __init__(self):
6        super().__init__()
7        self.features = nn.Sequential(
8            nn.Conv2d(3, 16, kernel_size=3, padding=1),
9            nn.ReLU(),
10            nn.MaxPool2d(2),
11            nn.Conv2d(16, 32, kernel_size=3, padding=1),
12            nn.ReLU(),
13            nn.MaxPool2d(2),
14        )
15        self.classifier = nn.Sequential(
16            nn.Flatten(),
17            nn.Linear(32 * 8 * 8, 64),
18            nn.ReLU(),
19            nn.Linear(64, 10),
20        )
21
22    def forward(self, x):
23        x = self.features(x)
24        return self.classifier(x)
25
26model = SimpleCNN()
27print(model)

This is built in and costs nothing extra, but it does not tell you output shapes or parameter counts per layer.

Use torchinfo for a Keras-Style Summary

If you want a table with input shapes, output shapes, and parameter counts, torchinfo is the usual choice.

1# pip install torchinfo
2from torchinfo import summary
3
4summary(
5    model,
6    input_size=(32, 3, 32, 32),
7    col_names=("input_size", "output_size", "num_params", "trainable"),
8    depth=3,
9)

This is the closest PyTorch equivalent to Keras-style summaries. It is especially helpful for catching wrong spatial dimensions before a long training run.

Count Parameters Programmatically

Even when you use torchinfo, it is useful to have a lightweight parameter-count utility for experiment logs, test assertions, or CI checks.

1def count_parameters(module: nn.Module) -> tuple[int, int]:
2    total = sum(p.numel() for p in module.parameters())
3    trainable = sum(p.numel() for p in module.parameters() if p.requires_grad)
4    return total, trainable
5
6total, trainable = count_parameters(model)
7print(f"total={total}, trainable={trainable}")

This is a good habit because model size often changes silently during refactors, and logging the counts makes those changes visible.

Inspect Intermediate Shapes With Forward Hooks

Sometimes the model summary table is not enough because the bug lives inside a custom block. In that case, forward hooks let you inspect live shape flow during a real pass.

1hooks = []
2
3def make_hook(name):
4    def hook(module, inputs, output):
5        print(f"{name}: {tuple(inputs[0].shape)} -> {tuple(output.shape)}")
6    return hook
7
8for name, layer in model.named_modules():
9    if isinstance(layer, (nn.Conv2d, nn.Linear)):
10        hooks.append(layer.register_forward_hook(make_hook(name)))
11
12x = torch.randn(2, 3, 32, 32)
13_ = model(x)
14
15for h in hooks:
16    h.remove()

Hooks are excellent for debugging shape mismatches in real inputs, but they should be removed promptly so they do not pollute later runs.

Summaries for Complex Models

For transformer or multi-input models, summary tools need realistic sample input shapes. If the model takes several tensors, pass them in the shape format or input-data format expected by the summary library. If the model uses conditional branches, make sure the chosen sample input actually exercises the path you care about.

Another practical detail is device placement. If the model lives on the GPU, either create the sample input on the same device or run the summary on CPU before moving the model for training.

A Reasonable Default Workflow

A simple workflow that works well in most projects is:

1. print(model) for the structure.
2. count_parameters(model) for total and trainable size.
3. torchinfo.summary(...) when you need layer-by-layer shapes.
4. forward hooks only when debugging a specific issue.

That keeps model inspection lightweight most of the time and deeper only when necessary.

Common Pitfalls

The most common mistake is giving the wrong input_size to torchinfo. If the batch dimension, channel count, or sequence length is wrong, the summary error may look like a model bug when it is really an input bug.

Another issue is forgetting that print(model) shows module composition, not runtime tensor shapes. Many shape mismatches only appear during a forward pass.

Hooks can also become noisy if you register too many of them or forget to remove them after debugging. That makes logs harder to read and can create unnecessary overhead.

Finally, if you freeze layers during fine-tuning, count trainable parameters separately. Total parameters alone does not tell you what the optimizer will actually update.

Summary

• 'print(model) is the fastest built-in way to inspect a PyTorch model.'
• 'torchinfo is the standard option for Keras-style summary tables.'
• Parameter-count utilities are useful for logs, tests, and experiment tracking.
• Forward hooks help debug runtime shapes in custom blocks.
• Always match summary inputs to the real shapes and devices your model expects.