自定义Dropout实现错误，如何修正以正确使用Dropout？

我来帮你一步步搞定这个Dropout的错误，先拆解下原代码里的几个核心问题：

• numpy与PyTorch张量混用：用np.random.binomial生成掩码会断开PyTorch的计算图，没法进行反向传播，必须用PyTorch原生的随机函数。
• 变量名不一致：代码里同时出现了dropout_percent和self.p，明显是参数定义和使用没统一。
• 形状逻辑错误：np.ones((len(input),np.array(list(input.shape))))生成的形状完全不对，我们需要的是和输入张量形状完全一致的掩码。
• 缺少训练/测试模式区分：Dropout只应该在训练阶段生效，测试时要禁用，原代码没处理这个逻辑。

正确的自定义Dropout实现 #

首先我们实现一个符合PyTorch规范的Dropout类，支持训练/测试模式切换：

import torch
import torch.nn as nn
import torch.nn.functional as F

class MyDropout(nn.Module):
    def __init__(self, p=0.5):
        super().__init__()
        # p是神经元被丢弃的概率，所以保留概率是1-p
        self.p = p
        # 确保p在合理范围内
        assert 0 <= self.p < 1, "Dropout概率p必须在[0,1)"

    def forward(self, x):
        # 只有训练模式下才应用Dropout
        if self.training:
            # 生成和输入x形状相同的掩码，用torch.bernoulli生成0/1分布
            # 这里用1-self.p作为保留概率，对应每个神经元被保留的概率
            mask = torch.bernoulli(torch.full_like(x, 1 - self.p))
            # 缩放激活值，保证训练和测试时的期望一致（Hinton原论文的缩放技巧）
            return x * mask / (1 - self.p)
        else:
            # 测试模式直接返回输入
            return x

集成到自定义MyLinear层 #

接下来把这个Dropout集成到你的自定义全连接层里，比如在激活函数后加入Dropout：

class MyLinear(nn.Module):
    def __init__(self, in_features, out_features, dropout_p=0.5):
        super().__init__()
        # 定义全连接层的权重和偏置
        self.weight = nn.Parameter(torch.randn(out_features, in_features))
        self.bias = nn.Parameter(torch.randn(out_features))
        # 集成自定义Dropout
        self.dropout = MyDropout(p=dropout_p)

    def forward(self, x):
        # 线性变换：y = xW^T + b
        linear_output = F.linear(x, self.weight, self.bias)
        # 先过激活函数（比如ReLU）
        activated = F.relu(linear_output)
        # 应用Dropout
        dropped = self.dropout(activated)
        return dropped

用于make_moons二分类任务的完整示例 #

最后我们用这个自定义层来完成二分类任务，注意训练时要开启模型的train()模式，测试时用eval()模式：

from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 生成数据集
X, y = make_moons(n_samples=1000, noise=0.1, random_state=42)
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 转成PyTorch张量
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.long)

# 构建模型
class MoonClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = MyLinear(2, 16, dropout_p=0.3)
        self.fc2 = MyLinear(16, 8, dropout_p=0.3)
        self.fc3 = nn.Linear(8, 2)  # 最后一层输出分类结果，不用Dropout

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

model = MoonClassifier()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练循环
model.train()  # 开启训练模式，Dropout生效
epochs = 100
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()
    if (epoch+1) % 10 == 0:
        print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

# 测试模型
model.eval()  # 开启测试模式，Dropout禁用
with torch.no_grad():
    outputs = model(X_test)
    _, preds = torch.max(outputs, 1)
    accuracy = (preds == y_test).float().mean().item()
    print(f"Test Accuracy: {accuracy:.4f}")

关键细节说明 #

1. 训练/测试模式切换：通过model.train()和model.eval()来控制Dropout是否生效，这是PyTorch里标准的做法。
2. 缩放激活值：在训练时用/(1-self.p)缩放保留的神经元输出，这样可以保证训练和测试阶段的输出期望一致，避免测试时输出突然变大。
3. 用torch原生函数：所有随机操作都用PyTorch的torch.bernoulli，确保计算图完整，支持反向传播。

内容的提问来源于stack exchange，提问作者blue-sky