Deep Learning学习:Pytorch实现天气识别-CSDN博客

本文链接：https://blog.csdn.net/qq_42967973/article/details/141948340

一，前言(引用)

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/Z9yL_wt7L8aPOr9Lqb1K3w) 中的学习记录博客**
>- **🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)**

二，训练准备

1.训练环境

Framework: Pytorch, matplotlib,numpy
Compiler：Jupyter Lab
Cpu: AMD Ryzen 5600H

2.数据集

4种天气图片jpg，分别存储在['cloudy', 'rain', 'shine', 'sunrise']标签下，图片总数为： 1125

Cloudy数据集示例:

# 指定图像文件夹路径
image_folder = 'E:\Basic Training 365\P3 Wetter Diagnose\weather_photos/cloudy/'

# 获取文件夹中的所有图像文件
image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg", ".png", ".jpeg"))]

# 创建Matplotlib图像
fig, axes = plt.subplots(3, 8, figsize=(16, 6))

# 使用列表推导式加载和显示图像
for ax, img_file in zip(axes.flat, image_files):
    img_path = os.path.join(image_folder, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.axis('off')

# 显示图像
plt.tight_layout()
plt.show()

三，训练过程

初始化:

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets

import os,PIL,pathlib,random

import matplotlib.pyplot as plt
from PIL import Image
import warnings

数据集：

data_dir = 'E:\Basic Training 365\P3 Wetter Diagnose\weather_photos'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]

total_datadir = 'E:/Basic Training 365/P3 Wetter Diagnose/weather_photos'


train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)

(<torch.utils.data.dataset.Subset at 0x1ea49ffc6a0>,
<torch.utils.data.dataset.Subset at 0x1ea49ffe9b0>)
Dataset ImageFolder Number of datapoints: 1125 Root location: E:/Basic Training 365/P3 Wetter Diagnose/weather_photos StandardTransform Transform: Compose( Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=warn) ToTensor() Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) )

训练配置：

torch.utils.data.random_split()方法进行数据集划分。该方法将总体数据total_data按照指定的大小比例（[train_size, test_size]）随机划分为训练集和测试集，并将划分结果分别赋值给train_dataset和test_dataset两个变量。

train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
print(train_size,test_size)

(900, 225)

`torch.utils.data.DataLoader()：`

dataset（必需参数）：这是你的数据集对象，通常是 torch.utils.data.Dataset 的子类，它包含了你的数据样本。
batch_size（可选参数）：指定每个小批次中包含的样本数。默认值为 1。
shuffle（可选参数）：如果设置为 True，则在每个 epoch 开始时对数据进行洗牌，以随机打乱样本的顺序。这对于训练数据的随机性很重要，以避免模型学习到数据的顺序性。默认值为 False。
num_workers（可选参数）：用于数据加载的子进程数量。通常，将其设置为大于 0 的值可以加快数据加载速度，特别是当数据集很大时。默认值为 0，表示在主进程中加载数据。
pin_memory（可选参数）：如果设置为 True，则数据加载到 GPU 时会将数据存储在 CUDA 的锁页内存中，这可以加速数据传输到 GPU。默认值为 False。
drop_last（可选参数）：如果设置为 True，则在最后一个小批次可能包含样本数小于 batch_size 时，丢弃该小批次。这在某些情况下很有用，以确保所有小批次具有相同的大小。默认值为 False。
timeout（可选参数）：如果设置为正整数，它定义了每个子进程在等待数据加载器传递数据时的超时时间（以秒为单位）。这可以用于避免子进程卡住的情况。默认值为 0，表示没有超时限制。
worker_init_fn（可选参数）：一个可选的函数，用于初始化每个子进程的状态。这对于设置每个子进程的随机种子或其他初始化操作很有用。

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True,
                                       num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True,
                                      num_workers=1)

for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

Shape of X [N, C, H, W]: torch.Size([32, 3, 224, 224]) Shape of y: torch.Size([32]) torch.int64

设计CNN训练模型:

torch.nn.Conv2d()函数：

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

第一个参数（in_channels）是输入的channel数量
第二个参数（out_channels）是输出的channel数量
第三个参数（kernel_size）是卷积核大小
第四个参数（stride）是步长，默认为1
第五个参数（padding）是填充大小，默认为0

torch.nn.MaxPool2d()

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

in_channels ( int ) – 输入图像中的通道数

out_channels ( int ) – 卷积产生的通道数

kernel_size ( int or tuple ) – 卷积核的大小

stride ( int or tuple , optional ) -- 卷积的步幅。默认值：1

padding ( int , tuple或str , optional ) – 添加到输入的所有四个边的填充。默认值：0

padding_mode (字符串,可选) – 'zeros', 'reflect', 'replicate'或'circular'. 默认：'zeros'

import torch.nn.functional as F

class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn, self).__init__()
        
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(12) #Batch Normalization
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn2 = nn.BatchNorm2d(12) #正则化，稳定输出减少偏移
        self.pool1 = 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.pool2 = nn.MaxPool2d(2,2)
        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.pool1(x)                        
        x = F.relu(self.bn4(self.conv4(x)))     
        x = F.relu(self.bn5(self.conv5(x)))  
        x = self.pool2(x)                        
        x = x.view(-1, 24*50*50)
        x = self.fc1(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

model = Network_bn().to(device)

得到模型结构：

Network_bn(
  (conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=60000, out_features=4, bias=True)
)

符合设计大小：

3, 224, 224（输入数据）
-> 12, 220, 220（经过卷积层1）
-> 12, 216, 216（经过卷积层2）-> 12, 108, 108（经过池化层1）
-> 24, 104, 104（经过卷积层3）

-> 24, 100, 100（经过池化层4）-> 24, 50, 50（经过池化层2）
-> 60000

创建损失函数：

loss_fn    = nn.CrossEntropyLoss() 
learn_rate = 1e-4 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)

训练循环设计：

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

测试函数设计：

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

训练过程：

epochs     = 20
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

Epoch: 1, Train_acc:64.1%, Train_loss:0.990, Test_acc:76.9%，Test_loss:0.871
Epoch: 2, Train_acc:80.6%, Train_loss:0.644, Test_acc:78.2%，Test_loss:0.557
Epoch: 3, Train_acc:84.6%, Train_loss:0.527, Test_acc:88.4%，Test_loss:0.381
Epoch: 4, Train_acc:87.3%, Train_loss:0.445, Test_acc:88.0%，Test_loss:0.357
Epoch: 5, Train_acc:89.2%, Train_loss:0.409, Test_acc:88.0%，Test_loss:0.368
Epoch: 6, Train_acc:90.2%, Train_loss:0.343, Test_acc:89.3%，Test_loss:0.298
Epoch: 7, Train_acc:90.3%, Train_loss:0.328, Test_acc:90.2%，Test_loss:0.276
Epoch: 8, Train_acc:91.8%, Train_loss:0.318, Test_acc:87.6%，Test_loss:0.440
Epoch: 9, Train_acc:92.0%, Train_loss:0.277, Test_acc:90.2%，Test_loss:0.259
Epoch:10, Train_acc:91.8%, Train_loss:0.270, Test_acc:87.1%，Test_loss:0.289
Epoch:11, Train_acc:91.2%, Train_loss:0.290, Test_acc:85.3%，Test_loss:0.329
Epoch:12, Train_acc:92.8%, Train_loss:0.261, Test_acc:92.0%，Test_loss:0.241
Epoch:13, Train_acc:94.1%, Train_loss:0.233, Test_acc:92.0%，Test_loss:0.260
Epoch:14, Train_acc:92.6%, Train_loss:0.249, Test_acc:92.0%，Test_loss:0.230
Epoch:15, Train_acc:92.8%, Train_loss:0.232, Test_acc:91.1%，Test_loss:0.245
Epoch:16, Train_acc:95.0%, Train_loss:0.198, Test_acc:91.6%，Test_loss:0.224
Epoch:17, Train_acc:95.2%, Train_loss:0.196, Test_acc:91.1%，Test_loss:0.227
Epoch:18, Train_acc:94.6%, Train_loss:0.227, Test_acc:87.1%，Test_loss:0.318
Epoch:19, Train_acc:93.9%, Train_loss:0.206, Test_acc:92.9%，Test_loss:0.229
Epoch:20, Train_acc:94.7%, Train_loss:0.208, Test_acc:92.4%，Test_loss:0.224
Done

输出测试结果：

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

四、总结

在本次学习中，我们实现了一个基于PyTorch框架的天气图像分类模型。通过完整的深度学习项目实践，深入了解了从数据准备、模型设计到训练和评估的全流程。以下是具体的学习收获：

训练准备与数据集处理：
- 使用PyTorch框架及其相关库（如torchvision、matplotlib）来进行图像分类任务。
- 数据集由四类天气图片组成，分别为cloudy、rain、shine和sunrise，共有1125张图片。通过ImageFolder方法组织这些图片，并对图片进行预处理（如调整尺寸、归一化处理），为模型的训练提供了清晰而规范的数据输入格式。
模型设计与实现：
- 构建了一个卷积神经网络（CNN）模型Network_bn，使用了多层卷积和池化操作来提取图像的特征。每个卷积层之后都进行了批量归一化（Batch Normalization），以稳定模型的训练过程。
- 模型结构包括了多层卷积层、池化层和一个全连接层，分别负责特征提取和最终的分类决策。通过设计网络的前向传播过程，学习了如何将原始输入转换为输出标签。
模型训练与评估：
- 使用了交叉熵损失函数（CrossEntropyLoss）和随机梯度下降优化器（SGD），通过20个周期的训练逐步优化模型参数。数据集被分为训练集和测试集，分别占80%和20%。
- 通过设计训练和测试函数，分别计算模型在训练和测试过程中的损失和准确度。绘制了训练和测试的准确率及损失曲线，展示了模型性能的变化趋势。
- 最终结果显示，模型在训练集上的准确率达到94.7%，在测试集上的准确率为92.4%，表明模型具有较好的泛化能力和较高的分类准确率。