【吴恩达深度学习】Residual Networks（PyTorch）

keras版本链接

导包

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from resnets_utils import *

Dataset类

class MyDataset(Dataset):
    def __init__(self, x, y):
        super(MyDataset, self).__init__()
        assert x.shape[0] == y.shape[0]
        self.x = x
        self.y = y

    def __len__(self):
        return self.x.shape[0]

    def __getitem__(self, item):
        return self.x[item], self.y[item]

Flatten类

class Flatten(nn.Module):
    def __init__(self, start_dim=1, end_dim=-1):
        super(Flatten, self).__init__()
        self.start_dim = start_dim
        self.end_dim = end_dim

    def forward(self, input):
        return input.flatten(self.start_dim, self.end_dim)

The identity block

class IdentityBlock(nn.Module):
    def __init__(self, channels, f):
        super(IdentityBlock, self).__init__()
        channel1, channel2, channel3, channel4 = channels
        self.conv = nn.Sequential(
            # nn.Conv2d(in_channels=channel1, out_channels=channel2, kernel_size=1, stride=1, padding='valid'),
            nn.Conv2d(in_channels=channel1, out_channels=channel2, kernel_size=1, stride=1, padding=0),
            nn.BatchNorm2d(num_features=channel2),
            nn.ReLU(),

            # nn.Conv2d(in_channels=channel2, out_channels=channel3, kernel_size=f, stride=1, padding='same'),
            nn.Conv2d(in_channels=channel2, out_channels=channel3, kernel_size=f, stride=1, padding=(f - 1) // 2),
            nn.BatchNorm2d(num_features=channel3),
            nn.ReLU(),

            # nn.Conv2d(in_channels=channel3, out_channels=channel4, kernel_size=1, stride=1, padding='valid'),
            nn.Conv2d(in_channels=channel3, out_channels=channel4, kernel_size=1, stride=1, padding=0),
            nn.BatchNorm2d(num_features=channel4),
        )

    def forward(self, input):
        x_shortcut = input
        x = self.conv(input)
        x = x_shortcut + x
        x = F.relu(x)
        return x

The convolutional block

class ConvolutionalBlock(nn.Module):
    def __init__(self, channels, f, s):
        super(ConvolutionalBlock, self).__init__()
        channel1, channel2, channel3, channel4 = channels
        self.conv1 = nn.Sequential(
            # nn.Conv2d(in_channels=channel1, out_channels=channel2, kernel_size=1, stride=s, padding='valid'),
            nn.Conv2d(in_channels=channel1, out_channels=channel2, kernel_size=1, stride=s, padding=0),
            nn.BatchNorm2d(num_features=channel2),
            nn.ReLU(),

            # nn.Conv2d(in_channels=channel2, out_channels=channel3, kernel_size=f, stride=1, padding='same'),
            nn.Conv2d(in_channels=channel2, out_channels=channel3, kernel_size=f, stride=1, padding=(f - 1) // 2),
            nn.BatchNorm2d(num_features=channel3),
            nn.ReLU(),

            # nn.Conv2d(in_channels=channel3, out_channels=channel4, kernel_size=1, stride=1, padding='valid'),
            nn.Conv2d(in_channels=channel3, out_channels=channel4, kernel_size=1, stride=1, padding=0),
            nn.BatchNorm2d(num_features=channel4)
        )

        self.conv2 = nn.Sequential(
            # nn.Conv2d(in_channels=channel1, out_channels=channel4, kernel_size=1, stride=s, padding='valid'),
            nn.Conv2d(in_channels=channel1, out_channels=channel4, kernel_size=1, stride=s, padding=0),
            nn.BatchNorm2d(num_features=channel4)
        )

    def forward(self, input):
        x = self.conv1(input)
        x_shortcut = self.conv2(input)
        x = x + x_shortcut
        x = F.relu(x)
        return x

ResNet50

class ResNet50(nn.Module):
    def __init__(self, classes=6):
        super(ResNet50, self).__init__()
        self.net = nn.Sequential(
            nn.ZeroPad2d(padding=(3, 3, 3, 3)),
            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=0),
            nn.BatchNorm2d(num_features=64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2),

            ConvolutionalBlock(channels=[64, 64, 64, 256], f=3, s=1),
            IdentityBlock(channels=[256, 64, 64, 256], f=3),
            IdentityBlock(channels=[256, 64, 64, 256], f=3),

            ConvolutionalBlock(channels=[256, 128, 128, 512], f=3, s=2),
            IdentityBlock(channels=[512, 128, 128, 512], f=3),
            IdentityBlock(channels=[512, 128, 128, 512], f=3),
            IdentityBlock(channels=[512, 128, 128, 512], f=3),

            ConvolutionalBlock(channels=[512, 256, 256, 1024], f=3, s=2),
            IdentityBlock(channels=[1024, 256, 256, 1024], f=3),
            IdentityBlock(channels=[1024, 256, 256, 1024], f=3),
            IdentityBlock(channels=[1024, 256, 256, 1024], f=3),
            IdentityBlock(channels=[1024, 256, 256, 1024], f=3),
            IdentityBlock(channels=[1024, 256, 256, 1024], f=3),

            ConvolutionalBlock(channels=[1024, 512, 512, 2048], f=3, s=2),
            IdentityBlock(channels=[2048, 512, 512, 2048], f=3),
            IdentityBlock(channels=[2048, 512, 512, 2048], f=3),

            nn.AvgPool2d(kernel_size=2),
            Flatten(),
            nn.Linear(2048, classes),
        )

    def forward(self, input):
        x = self.net(input)
        return x

加载数据集和预处理

X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

# Normalize image vectors
X_train = X_train_orig / 255.
X_test = X_test_orig / 255.
X_train = np.transpose(X_train, [0, 3, 1, 2])
X_test = np.transpose(X_test, [0, 3, 1, 2])

Y_train = Y_train_orig.T
Y_test = Y_test_orig.T

print("number of training examples = " + str(X_train.shape[0]))
print("number of test examples = " + str(X_test.shape[0]))
print("X_train shape: " + str(X_train.shape))
print("Y_train shape: " + str(Y_train.shape))
print("X_test shape: " + str(X_test.shape))
print("Y_test shape: " + str(Y_test.shape))

构建网络、优化器、损失函数

model = ResNet50()
optimizer = optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()
epochs = 2
batch_size = 32
train_dataset = MyDataset(X_train, Y_train)
train_data = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

训练

model.train()
for epoch in range(epochs):
    for i, (x, y) in enumerate(train_data):
        x = x.float()
        y = y.long().squeeze()

        optimizer.zero_grad()
        y_hat = model(x)
        loss = criterion(y_hat, y)
        loss.backward()
        optimizer.step()

测试

model.eval()
with torch.no_grad():
    x = torch.tensor(X_test).float()
    y = torch.tensor(Y_test).long().squeeze()

    y_hat = model(x)
    loss = criterion(y_hat, y)
    print("Loss = ", loss.item())

    y_hat = torch.argmax(y_hat, dim=-1)
    correct_prediction = y_hat == y
    test_accuracy = torch.sum(correct_prediction).float() / y.shape[0]
    print("Test Accuracy = ", test_accuracy.item())