Deep Learning Academy · 课时

继承 nn.Module：init 与 forward

标准的 PyTorch 模型骨架

继承 nn.Module：__init__ 与 forward 是 CoddyKit 上的免费 Deep Learning Academy 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Deep Learning Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Deep Learning Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Models Are Just Classes

In PyTorch, every model is a Python class. You build yours by subclassing nn.Module, the base that powers all networks.

Two Methods Run the Show

A model needs only two methods to work: __init__ sets up the layers, and forward describes how data flows through them.

Always Call super().init

The very first line inside __init__ must call super().__init__(). This wires your model into PyTorch and lets it track everything. 🔌

class Net(nn.Module):
    def __init__(self):
        super().__init__()

Define Layers in init

Inside __init__ you create your layers and store them as attributes. Saving them on self lets PyTorch register them automatically.

self.fc1 = nn.Linear(4, 8)
self.fc2 = nn.Linear(8, 2)

forward Is the Recipe

The forward method takes an input tensor and returns an output. It spells out the exact order your layers process the data.

def forward(self, x):
    x = self.fc1(x)
    return self.fc2(x)

Never Call forward Directly

You call the model like a function, not model.forward(x). Using model(x) runs hooks and bookkeeping that forward alone skips.

out = model(x)   # preferred
# not: out = model.forward(x)

Layers Become Parameters

Because layers live on self, their weights are collected as the model's parameters. The optimizer later updates exactly these.

Instantiate Then Use

Create the model once, then feed it tensors many times. Each call flows through the same learned weights.

model = Net()
prediction = model(sample_input)

Shapes Must Line Up

Each layer's output size must match the next layer's input size. Plan these dimensions as data travels through forward.

Why This Pattern Wins

Subclassing keeps setup and flow cleanly apart. The same simple skeleton scales from a tiny net to a giant one.

Flexible by Design

Inside forward you can branch, reshape, or reuse layers freely. This freedom is why custom nn.Module classes are so powerful. 💪

Quick Check

Think about which method defines how data moves through the network.

Recap

You build a model by subclassing nn.Module, defining layers in __init__ and the data flow in forward. Then just call model(x). 🎯

常见问题解答