Pytorch实战 | 天气识别

参考：Pytorch实战 | 第P3周：天气识别

数据集:

https://www.aliyundrive.com/s/jHTp9Xy4Dj7
提取码: r2o9
点击链接保存，或者复制本段内容，打开「阿里云盘」APP ，无需下载极速在线查看，视频原画倍速播放。

import os, PIL, random, pathlib
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
from torch.autograd import Variable
import os, PIL, pathlib

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

data_dir = 'data/'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))

classeNames = [str(path).split("\\")[1] for path in data_paths]

transforms = transforms.Compose([transforms.ToTensor(), transforms.Resize([224, 224]),
                                 transforms.Normalize(mean=[0.485, 0.456, 0.407], std=[0.229, 0.224, 0.225])])
data = torchvision.datasets.ImageFolder(data_dir, transform=transforms)
from torch.utils.data import random_split

data_train, data_test = random_split(data, lengths=[int(0.8 * len(data)), len(data) - int(0.8 * len(data))],
                                     generator=torch.Generator().manual_seed(0))

batch_size = 4
data_loader_train = torch.utils.data.DataLoader(dataset=data_train, batch_size=batch_size, shuffle=True)
data_loader_test = torch.utils.data.DataLoader(dataset=data_test, batch_size=batch_size, shuffle=True)

# for X, y in data_loader_test:
#     print("Shape of X [N, C, H, W]: ", X.shape)
#     print("Shape of y: ", y.shape, y.dtype)
#     break
import torch.nn.functional as F


class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5),
            torch.nn.BatchNorm2d(12),
            torch.nn.ReLU(),
            torch.nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5),
            torch.nn.BatchNorm2d(12),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2, 2),
            torch.nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5),
            torch.nn.BatchNorm2d(24),
            torch.nn.ReLU(),
            torch.nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5),
            torch.nn.BatchNorm2d(24),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2, 2)
            )
        self.fc = torch.nn.Linear(50*50*24, len(classeNames))

    def forward(self, x):
        x = self.conv1(x)
        x = x.view(-1, 50 * 50 * 24)
        x = self.fc(x)
        """
        nn.Conv2d()函数：
        第一个参数（in_channels）是输入的channel数量
        第二个参数（out_channels）是输出的channel数量
        第三个参数（kernel_size）是卷积核大小
        第四个参数（stride）是步长，默认为1
        第五个参数（padding）是填充大小，默认为0
        """
    #     self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
    #     self.bn1 = nn.BatchNorm2d(12)
    #     self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
    #     self.bn2 = nn.BatchNorm2d(12)
    #     self.pool = nn.MaxPool2d(2, 2)
    #     self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
    #     self.bn4 = nn.BatchNorm2d(24)
    #     self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
    #     self.bn5 = nn.BatchNorm2d(24)
    #     self.fc1 = nn.Linear(24 * 50 * 50, len(classeNames))
    #
    # def forward(self, x):
    #     x = F.relu(self.bn1(self.conv1(x)))
    #     x = F.relu(self.bn2(self.conv2(x)))
    #     x = self.pool(x)
    #     x = F.relu(self.bn4(self.conv4(x)))
    #     x = F.relu(self.bn5(self.conv5(x)))
    #     x = self.pool(x)
    #     x = x.view(-1, 24 * 50 * 50)
    #     x = self.fc1(x)
        return x


model = Model()
model = model.to(device)
epochs = 20
optimizer = torch.optim.Adam(model.parameters())
cost = torch.nn.CrossEntropyLoss()

for i in range(epochs):
    running_loss = 0.0
    running_correct = 0
    testing_correct = 0
    print("Epoch{}/{}".format(i + 1, epochs))
    print("-" * 20)

    for data in data_loader_train:
        x_train, y_train = data
        x_train, y_train = x_train.to(device), y_train.to(device)
        x_train, y_train = Variable(x_train), Variable(y_train)
        outputs = model(x_train)
        optimizer.zero_grad()
        _, pred = torch.max(outputs.data, 1)
        loss = cost(outputs, y_train)
        loss.backward()
        optimizer.step()
        running_loss += loss
        running_correct += torch.sum(pred == y_train)

    for data in data_loader_test:
        x_test, y_test = data
        x_test, y_test = x_test.to(device), y_test.to(device)
        x_test, y_test = Variable(x_test), Variable(y_test)
        outputs = model(x_test)
        _, pred = torch.max(outputs.data, 1)

        testing_correct += torch.sum(pred.data == y_test.data)
        print("Loss is:{:.4f},Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(
            running_loss / len(data_train),
            100 * running_correct / len(
                data_train),
            100 * testing_correct / len(
                data_test)))

查疑：
Python 的 os.path() 和 pathlib.Path()

pytorch之ImageFolder

PyTorch基础——torch.nn.BatchNorm2d

报错：

一般遇到上面的报错，就是你的模型没算对，好好去算一下，比如说卷出来等于55，你下一层要的却是57