MCdropout pytorch实现

MCdropout是一种基于蒙特卡罗方法的dropout技术，可以用于在神经网络中进行不确定性估计。它通过在测试时对网络进行多次前向传播，并对每个前向传播结果进行平均，从而得到网络输出的概率分布。

下面是MCdropout在PyTorch中的实现：

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

class Net(nn.Module):
    def __init__(self, dropout_prob):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)
        self.dropout_prob = dropout_prob

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, p=self.dropout_prob, training=True)
        x = F.relu(self.fc2(x))
        x = F.dropout(x, p=self.dropout_prob, training=True)
        x = self.fc3(x)
        return x

    def mc_predict(self, x, n_samples):
        # Perform n_samples forward passes with dropout
        y_preds = []
        for i in range(n_samples):
            y_pred = F.softmax(self.forward(x), dim=1)
            y_preds.append(y_pred)
        # Average the predictions
        y_preds = torch.stack(y_preds)
        y_preds = torch.mean(y_preds, dim=0)
        return y_preds

在模型的初始化中，我们需要传入一个dropout_prob参数，用于指定dropout的丢弃概率。在forward方法中，我们使用F.dropout函数实现dropout操作，同时我们添加了一个mc_predict方法来进行MCdropout的预测。这个方法会对输入数据进行n_samples次前向传播，并对每次前向传播的结果进行平均，得到最终的预测结果。

以下是使用MCdropout进行手写数字识别的例子：

import torchvision
from torchvision import transforms

# Load MNIST dataset
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,), (0.3081,))])
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# Create dataloaders
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)

# Create model
model = Net(dropout_prob=0.5)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Train the model
n_epochs = 10
for epoch in range(n_epochs):
    for i, (x, y) in enumerate(trainloader):
        optimizer.zero_grad()
        y_pred = model(x)
        loss = criterion(y_pred, y)
        loss.backward()
        optimizer.step()
        if i % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                  .format(epoch+1, n_epochs, i+1, len(trainloader), loss.item()))

# Evaluate the model using MCdropout
model.eval()
n_samples = 100
correct = 0
total = 0
with torch.no_grad():
    for x, y in testloader:
        y_pred = model.mc_predict(x, n_samples)
        _, predicted = torch.max(y_pred.data, 1)
        total += y.size(0)
        correct += (predicted == y).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

在训练时，我们使用普通的dropout进行正则化。在测试时，我们使用MCdropout进行预测，并计算模型在测试集上的准确率。