【深度学习】Pytorch学习笔记（五）

pytorch实现卷积神经网络（执行效率相对于keras慢太多）

import torch
import warnings
import torchvision
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader

warnings.filterwarnings("ignore")
BATCH_SIZE = 32

train_data = MNIST(
    root='./mnist',
    train=True,
    transform=torchvision.transforms.ToTensor(),
    download=True
)
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
test_data = MNIST(
    root='./mnist',
    train=False,
    transform=torchvision.transforms.ToTensor(),
    download=True
)
x_test = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000] / 255.0
y_test = test_data.test_labels[:2000]

class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(  # out:(32, 28, 28)
                in_channels=1,
                out_channels=32,
                kernel_size=5,
                stride=1,
                padding=2
            ),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(stride=2, kernel_size=2),  # out:(32, 14, 1
        )
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(  # out:(64, 14, 14)
                in_channels=32,
                out_channels=64,
                kernel_size=5,
                stride=1,
                padding=2
            ),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(stride=2, kernel_size=2),  # out:(64, 7, 7)
        )
        self.hidden_one = torch.nn.Linear(64 * 7 * 7, 120)
        self.hidden_two = torch.nn.Linear(120, 84)
        self.outlayer = torch.nn.Linear(84, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)
        x = self.hidden_one(x)
        x = self.hidden_two(x)
        output = self.outlayer(x)
        return output

model = Model()

optimizer = torch.optim.Adam(model.parameters(), lr=1e-1)   # 定义优化器
loss_func = torch.nn.CrossEntropyLoss()  # 定义损失函数为交叉熵

print("Training-------------------")
for epoch in range(100):
    for step, (x, y) in enumerate(train_loader):
        output_train = model(x)
        loss = loss_func(output_train, y)   # 计算交叉熵

        optimizer.zero_grad()   # 梯度清零
        loss.backward()         # 实现后向传播，计算各参数梯度
        optimizer.step()        # 更新各参数的值
    if epoch % 10 == 0:
        output_test = model(x_test)
        y_pre = output_test.argmax(dim=1)
        accuracy = sum(y_pre == y_test) / y_test.size(0)
        print("Epoch: ", epoch, "------>train loss: %.4f" % loss.detach().numpy(), "------->test accuracy: %.4f" % accuracy.numpy())

这里有padding公式，pytorch是在tensor的四周全填0，而padding的数值代表填几层pytorch的padding的理解和操作
求解padding的值实际就是解个一元一次方程。