数据科学导引上机（6）神经网络

最新推荐文章于 2023-06-23 18:18:56 发布

小琳哥

最新推荐文章于 2023-06-23 18:18:56 发布

阅读量1.8k

点赞数

分类专栏：笔记文章标签： pytorch 神经网络

本文链接：https://blog.csdn.net/weixin_47238158/article/details/121967169

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

这次是简单的神经网络，因为层数比较少

关于环境配置，

Pytorch的安装：安装分为cpu版本和gpu版本，gpu版本的pytorch运行速度更快一些，但gpu版本的安装需要有NVIDIA的显卡，尽量安装cpu版本。cpu版本的安装可以参考网址：在Windows下安装配置CPU版的PyTorch_On the road丶的博客-CSDN博客
tqdm的安装：在base环境下直接pip install tqdm
cv2的安装：python cv2模块怎么安装?-Python学习网

这次处理的是数字识别，用到手写数字集

lenet模型构建

# 导入相关的包
import torch
from torch import nn

# 判断是否安装gpu版本的torch，若没有则使用cpu运算
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("using {} device.".format(device))

# 定义Lenet模型
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        ## 定义网络结构
        self.conv = nn.Sequential(
            #在此处更改网络的结构，使网络在3232的输入大小下，可以输入2828的Mnist数据集。
            
             ## C1卷积层         
            nn.Conv2d(3,6,(5,5),padding=(2,2)),# 输入通道3，输出通道6，卷积矩阵5x5
            # nn.Conv2d(3,6,(5,5)),# 输入通道3，输出通道6，卷积矩阵5x5
            nn.Sigmoid(),
            nn.MaxPool2d(2,2), # 池化2x2
            # NO.2
            nn.Conv2d(6,16,5),#
            nn.Sigmoid(),
            nn.MaxPool2d(2,2)
            )
        self.fc = nn.Sequential(
            nn.Linear(16*5*5,120),# 上面池化层的结果输入，输出
            # nn.Linear(16*4*4,120),# 上面池化层的结果输入，输出
            nn.Sigmoid(),
            nn.Linear(120,84),
            nn.Sigmoid(),
            nn.Linear(84,10)            
            )
    ## 前向传播
    def forward(self, img):
        feature = self.conv(img)
        img = feature.view(img.shape[0],-1) # 把图矩阵拉成向量
        output = self.fc(img) # 得到长度为10 的向量
        return output

# 查看模型
net = LeNet()
print(net)

模型训练

# 导入相关的包
import os
import json
from sklearn.metrics import confusion_matrix    # 生成混淆矩阵函数
import torch
import torch.nn as nn
from torchvision import transforms, datasets
import torch.optim as optim
from tqdm import tqdm

## 1. 定义数据的预处理方式

# Resize：把给定的图片的大小resize以适应网络的输入大小。
# ToTensor：把灰度范围从[0,255]变换到[0,1]之间，并且转换到pytorch能够处理的tensor数据类型。
# Normalize：前面的(0.5, 0.5, 0.5)是R、G、B三个通道上的mean，后面(0.5, 0.5, 0.5)是三个通道的std。执行变换image=(image-mean)/std，将[0,1]的值变到[-1,1]。
# CenterCrop：在图片的中间区域进行裁剪
# RandomCrop：在一个随机的位置进行裁剪
# RandomHorizontalFlip：以0.5的概率水平翻转给定的PIL图像
# ColorJitter：随机改变图像的亮度对比度和饱和度
# Grayscale：将图像转换为灰度图像
# 等等......

## 1. 定义数据的预处理方式
data_transform = {
    # 训练集
    "train": transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
        # transforms.resize(28,28) # 若图像大小不是28*28
                                ]),
    # 测试集
    "val": transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                ])}

## 2. 训练集数据的预处理

# 训练集的地址，最好将训练集放在相对路径下
image_path_train = './data/training/'
train_dataset = datasets.ImageFolder(root=image_path_train, transform=data_transform["train"])

train_num = len(train_dataset)   # 训练集的大小
num_list = train_dataset.class_to_idx   # 通过这个获取分类名称对应索引

# 将分类名称对应索引写入json文件
cla_dict = dict((val, key) for key, val in num_list.items())
json_str = json.dumps(cla_dict, indent=4)
with open('class_indices.json', 'w') as json_file:
    json_file.write(json_str)

print(train_num)
print(num_list)

## 设置batch_size的值，一般为2的幂次方

# batch_size:即一次训练所抓取的数据样本数量；batch_size的大小影响训练速度和模型优化。
# 设置batch_size最大的好处在于使得cpu或gpu满载运行，提高了训练的速度，并且使得梯度下降的方向更加准确。
batch_size = 64

## 加载一个batch_size的数据

# 取Num_workers为机器内核数和batch_size的最小值。
# Num_workers：https://blog.csdn.net/peacefairy/article/details/108015095
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
print('Using {} dataloader workers every process'.format(nw))

train_loader = torch.utils.data.DataLoader(train_dataset,
                                            batch_size=batch_size,
                                            shuffle=True, # 打乱
                                            num_workers=nw)

## 3. 测试集数据的预处理

# 测试集的地址，与训练集放在同一文件夹下
image_path_test = './data/testing/'
validate_dataset = datasets.ImageFolder(root=image_path_test, transform=data_transform["val"])
val_num = len(validate_dataset)
validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                              batch_size=batch_size,
                                              shuffle=False,
                                              num_workers=nw)

# 分别输出训练集和测试集的数据的个数
print("using {} images for training, {} images for testing.".format(train_num, val_num))

## 4. 加载模型

net = LeNet()
net.to(device) # 如果有gpu，则将模型转换到到gpu上，后面数据也同样要转换到gpu上

## 5. 定义损失函数

# 交叉熵损失函数
loss_function = nn.CrossEntropyLoss()

## 6. 定义优化方法
# 所有方法运行一遍
optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, dampening=0, weight_decay=0, nesterov=True)
# optimizer = optim.Adagrad(net.parameters(), lr=0.01, lr_decay=0, weight_decay=0, initial_accumulator_value=0)
# optimizer = optim.RMSprop(net.parameters(), lr=0.001)
# optimizer = optim.Adam(net.parameters(), lr=0.001)# lr学习率

## 7. 初始化参数，开始训练

epochs = 5 # 期望运行次数
best_acc = 0.0 # 存准确率
LOSS_Iter = []     # 记录每一步迭代的损失值
save_path = 'LeNet_number.pth'    # 保存权重的地址
train_steps = len(train_loader)

# 开始训练
for epoch in range(epochs):
    # 初始化所有数据的预测标签pre_y, 所有数据的真实标签ture_y，为了生成混淆矩阵。
    pre_y = []
    ture_y = []
    # 训练
    net.train() # 开始训练标志
    running_loss = 0.0
    train_bar = tqdm(train_loader)  # tqdm添加进度提示信息
    for step, data in enumerate(train_bar): # 取出一个batch的数据
        images, labels = data
        optimizer.zero_grad() # 先把梯度置零
        # 前向传播
        outputs = net(images.to(device)) # 变换设备GPU时，同时记得变换数据 
        # 计算损失
        loss = loss_function(outputs, labels.to(device))
        # 后向传播 /求梯度
        loss.backward()
        # 优化
        optimizer.step()

        # 输出进度
        running_loss += loss.item()  # 将一个batch_size的损失值累加起来
        train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1, epochs, loss)
    
    # 测试
    net.eval()
    acc = 0.0  # accumulate accurate number / epoch
    with torch.no_grad():    # with torch.no_grad()中的数据不需要计算梯度，也不会进行反向传播
        val_bar = tqdm(validate_loader)
        for val_data in val_bar:
            val_images, val_labels = val_data
            # 前向传播
            outputs = net(val_images.to(device))
            # 寻找最大的概率值，并求出其对应的标签
            predict_y = torch.max(outputs, dim=1)[1]
            # 混淆矩阵的参数
            pre_y += predict_y.numpy().tolist()
            ture_y += val_labels.numpy().tolist()

            acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
            
    # 一个epoch结束后，计算测试集的准确率     
    val_accurate = acc / val_num
    # 求出混淆矩阵
    cm = confusion_matrix(ture_y, pre_y)
    # 一个epoch结束后，计算平均损失
    train_loss = running_loss / train_steps
    print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' % (epoch + 1, train_loss, val_accurate))
    # 保存每一个epoch的损失，可以绘制损失变化的曲线图
    LOSS_Iter.append(train_loss)
    # 输出每个epoch的混淆矩阵
    print(cm)
    # 保存有最好的测试集准确率的模型
    if val_accurate > best_acc:
        best_acc = val_accurate
        torch.save(net.state_dict(), save_path)

print('Finished Training')
print(LOSS_Iter)

模型预测

import os
import json
import torch
import cv2
from torchvision import transforms
import matplotlib.pyplot as plt

## 1.预测数据的预处理

data_transform_yuce = transforms.Compose([transforms.ToTensor(),
                                          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) # 标准化
# 预测数据地址
img_path = "yuce.png"
img = cv2.imread(img_path)
plt.imshow(img)
img = data_transform_yuce(img)
img = torch.unsqueeze(img, dim=0)  # 扩展维度,返回一个新的张量，对输入的既定位置插入维度1

## 2. 加载类别json文件

json_path = 'class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
print(class_indict)

## 3. 加载模型

net = LeNet()
net.to(device)

## 4. 加载权重

weights_path = "LeNet_number.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
net.load_state_dict(torch.load(weights_path, map_location=device))

## 5. 开始预测

net.eval()
with torch.no_grad():
    # 预测类别
    output = torch.squeeze(net(img.to(device))).cpu()
    predict = torch.softmax(output, dim=0) # 一个非线性转换函数，通常用在网络输出的最后一层，输出的是概率分布
    # 对于二维输入来说，dim = -1表示行，dim = -2 表示列
    predict_cla = torch.argmax(predict).numpy()
# 输出结果
print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy())
print(print_res)

根据训练模型时的第6点，对所有优化方法运行一遍，记录结果：

1、optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, dampening=0, weight_decay=0, nesterov=True)

最终损失：train_loss: 0.082 最终准确率：val_accuracy: 0.979
每个epoch的损失：[2.3081201327635026, 2.270713436705217, 0.7664757501333952, 0.12912240321201873, 0.0820480018287206] 测试时准确率为：prob: 0.97

2、optimizer = optim.Adagrad(net.parameters(), lr=0.01, lr_decay=0, weight_decay=0, initial_accumulator_value=0)

最终损失：train_loss: 0.135 最终准确率：val_accuracy: 0.964
每个epoch的损失：[0.7487788433109773, 0.24527604862062663, 0.18069904045795582, 0.1521519784853339, 0.13491002251225304] 测试时准确率为：prob: 0.964

3、optimizer = optim.RMSprop(net.parameters(), lr=0.001)

最终损失：train_loss: 0.058 最终准确率：val_accuracy: 0.984
每个epoch的损失：[0.6667835087036845, 0.13589878989927678, 0.08895638625997343, 0.06969588328533169, 0.05826678191860721]
测试时准确率为：prob: 0.99

4、optimizer = optim.Adam(net.parameters(), lr=0.001)

最终损失：train_loss: 0.060 最终准确率：val_accuracy: 0.984 每个epoch的损失：[0.8521189910413296, 0.13498563570445027, 0.0914289139068203, 0.07249301789241082, 0.06016580363003803]
测试时准确率为：prob: 0.973

可见3和4两个优化方法的训练损失最小，但是测试效果3最好