【PYTHON随笔2】Pytorch-基于CIFAR10数据集的CNN分类器

# 线性多分类器
import torch
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms

# 梯度下降 + Mini-Batch法进行运算
# batch-size -> 50，五十个为一组并行计算（速度快但性能低）
batch_size = 50
# 卷积核大小
kernel_size = 5

# 数据归一化处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 训练集以及训练集加载器
path = "resources/data/" # 数据集存储路径
train_datasets = datasets.CIFAR10(
    root=path,
    train=True,
    download=True,
    transform=transform
)
train_loader = DataLoader(
    train_datasets,
    shuffle=True,
    batch_size=batch_size
)

# 测试集以及测试集加载器
test_datasets = datasets.CIFAR10(
    root=path,
    train=False,
    download=True,
    transform=transform
)
test_loader = DataLoader(
    test_datasets,
    shuffle=False,
    batch_size=batch_size
)


# 构建训练模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # image [batch-50, channel-3, w-32, h-32]
        # 32*32 - 28*28 -pooling- 14*14
        self.conv1 = torch.nn.Conv2d(3, 10, kernel_size=kernel_size)
        # 14*14 - 10*10 -pooling- 5*5
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=kernel_size)
        # 池化 行列各消减一半
        self.pooling = torch.nn.MaxPool2d(2)
        # 设置全连接层，input 5*5*20 = 500
        self.linear1 = torch.nn.Linear(500, 128)
        self.linear2 = torch.nn.Linear(128, 64)
        self.linear3 = torch.nn.Linear(64, 10)

    def forward(self, x):
        # 这里选择relu激活函数
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = F.relu(self.linear1(x.view(x.size(0), -1)))
        x = F.relu(self.linear2(x))
        x = F.relu(self.linear3(x))
        return x


# new 一个新模型
model = Net()
# 支持GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
# 交叉熵损失以及优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# 训练
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        # data, label
        inputs, target = data
        # 数据发送至GPU
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()

        # forward+backward+update
        # model training
        outputs = model(inputs)
        # get loss
        loss = criterion(outputs, target)
        # backward
        loss.backward()
        # update weight
        optimizer.step()

        # 得到当前损失值加和
        running_loss += loss.item()
        # 每300个打印一次平均损失
        if batch_idx % 300 == 299:
            print("[%d, %5d] loss: %.3f" % (epoch+1, batch_idx+1, running_loss/300))
            running_loss = 0.0


# 测试
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        # 从测试集获取数据
        for data in test_loader:
            # 图像与相应标签
            images, labels = data
            # 数据发送至GPU
            images, labels = images.to(device), labels.to(device)
            # 根据模型进行预测
            outputs = model(images)
            # 获得预测结果，每一行（维度）里值为1的索引
            _, predicted = torch.max(outputs.data, dim=1)
            # 预测总计
            total += labels.size(0)
            # 预测正确的数量
            correct += (predicted == labels).sum().item()
    print("Accuracy on test set：%d%%"%(100*correct/total))


if __name__ == "__main__":
    for epoch in range(20):
        train(epoch)
        test()