深度学习残差模块模型

Question

利用CNN模型编写含三层残差模块模型，添加一行卷积层之后报错

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.nn import functional as F
import matplotlib.pyplot as plt

# 设定下载参数
transform = transforms.Compose([
    transforms.ToTensor(), 
    transforms.Normalize(0.1307, 0.3081)
])
# 下载训练集与测试集
train_Data = datasets.MNIST(
    root = 'D:/Jupyter/dataset/mnist/', 
    train = True, 
    download = True, 
    transform = transform
)
test_Data = datasets.MNIST(
    root = 'D:/Jupyter/dataset/mnist/', 
    train = False, 
    download = True, 
    transform = transform
)

train_loader = DataLoader(train_Data, shuffle=True, batch_size=64)
test_loader  = DataLoader(test_Data, shuffle=False, batch_size=64)

loss_list = []
accuracy_list = []
epoch_list = []

class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock, self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
        
    def forward(self, x):
        y = F.relu(self.conv1(x))
        y = self.conv2(y)
        return F.relu(x + y)

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=5 ,padding=2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=5,padding=2)
        self.conv3 = nn.Conv2d(32, 64, kernel_size=5,padding=2)
        self.mp = nn.MaxPool2d(kernel_size=2)
        self.reblock1 = ResidualBlock(16)
        self.reblock2 = ResidualBlock(32)
        self.reblock3 = ResidualBlock(64)
        self.fc = nn.Linear(64 * 4 * 4,10)
        
    def forward(self, x):
        in_size = x.size(0)
        x = self.mp(F.relu(self.conv1(x)))
        x = self.reblock1(x)
        x = self.mp(F.relu(self.conv2(x)))
        x = self.reblock2(x)
        x = self.mp(F.relu(self.conv3(x)))
        x = self.reblock3(x)
        x = x.view(in_size, -1)
        return self.fc(x)

model = Net()
device = torch.device('cuda')
model.to(device)

criterion = torch.nn.CrossEntropyLoss()


optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
    running_loss = 0
    for batch_index, data in enumerate(train_loader, 0):
        inputs, target = data
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
        if batch_index % 200 == 199:
            print('[%d, %d] loss: %.3f' % (epoch + 1, batch_index + 1, running_loss / 200))
            running_loss = 0.0
    loss_list.append(running_loss)

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicts = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicts == labels).sum().item()
            
    print('Accuracy on test sets: %d%%' % (100 * correct / total))
    print('Total / Correct: [', total, '/', correct, ']')
    accuracy_list.append(correct / total)

for epoch in range(5):
    train(epoch)
    epoch_list.append(epoch)
    test()
plt.plot(epoch_list, accuracy_list)
plt.grid()
plt.show()
plt.plot(epoch_list, loss_list)
plt.grid()
plt.show()

epoch_list

loss_list

报错为mat1 and mat2 shapes cannot be multiplied (64x576 and 1024x10)

Answer 1

检查卷积层输出通道与残差分支是否匹配。

以上回复有部分引自免费微信小程序：皆我百晓生。 如问题尚未解决，还请稍待，如有疑问请回复进一步沟通。