【吴恩达深度学习】the Happy House（PyTorch）

keras版本链接

导包

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

Dataset类

用于分成不同的mini-batch

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类

由于早期的PyTorch没有提供nn.Faltten 类，所以这里需要手写一个

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)

网络结构

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

        self.net = nn.Sequential(
            nn.ZeroPad2d(3),
            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=7, stride=1),
            nn.BatchNorm2d(num_features=32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2)),
            Flatten(),
            nn.Linear(32768, 1),
            nn.Sigmoid(),
        )

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

binary cross entropy损失函数

class BinartCrossEntropyLoss(nn.Module):
    def __init__(self):
        super(BinartCrossEntropyLoss, self).__init__()

    def forward(self, y_hat, y_label):
        loss = F.binary_cross_entropy(y_hat, y_label)
        return loss

加载数据集和预处理

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])

# Reshape
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 = Net()
optimizer = optim.Adam(model.parameters())
criterion = BinartCrossEntropyLoss()
batch_size = 32
epochs = 100

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.float()

        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).float()

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

    y_hat = y_hat > 0.5
    y = y.byte()
    correct_prediction = y_hat == y
    test_accuracy = torch.sum(correct_prediction).float() / y.shape[0]
    print("Test Accuracy = ", test_accuracy.item())