Pytorch深度学习之神经网络入门详解

悠悠 2023-09-25 23:26 54阅读 0赞

**目录**

Pytorch 入门

1.将每个图片的label作为txt文件写入另外一个文件夹（txt文件名与图片文件名相同）

2.tensorboard的summary writer

3.torchvision中的transforms

4.DataLoader

5.神经网络-卷积层Conv2d

6.最大池化层

7.非线性激活函数Relu

9.线性层

10.损失函数

11.反向传播和优化器

12.残差网络

13.CIFAR10模型结构

--------------------

## Pytorch 入门 ##

### 1.将每个图片的label作为txt文件写入另外一个文件夹（txt文件名与图片文件名相同） ###

root_dir=r"F:\yolo\img"
    target_dir="car_img"
    print(os.path.join(root_dir,target_dir))
    img_path_list=os.listdir(os.path.join(root_dir,target_dir))
    print(img_path_list)
    out_dir="car_label"
    for i in img_path_list:
        file_name=i.split(".jpg")[0]
        f=open((os.path.join(root_dir,out_dir,file_name)+".txt"),"w")
        f.write("car")
        f.close()

### 2.**tensorboard的summary writer** ###

import numpy as np
    import os
    import cv2 as cv
    from torch.utils.tensorboard import SummaryWriter
    from torchvision import transforms
    writer=SummaryWriter("logs1")
    cv_img=cv.imread(r"F:\yolo\img\street.jpg")
    # for i in range(1,100):
    #     writer.add_scalar("y=2x",2*i,i)
    writer.add_image("test_img",cv_img,1,dataformats='HWC')
    tensor_trans=transforms.ToTensor()
    test_img1=tensor_trans(cv_img)
    writer.add_image("test_img",test_img1,2)
    writer.close()

查看可视化结果

控制台 tensorboard --logdir=logs1命令即可

### 3.**torchvision中的transforms** ###

torchvision.transforms是[pytorch][]中的图像预处理包。一般用Compose把多个步骤整合到一起：

transforms.Compose([
        transforms.CenterCrop(10),
        transforms.ToTensor(),
    ])

下面列举两个常用的 transforms中的函数：

**class torchvision.transforms.Normalize(mean, std)**

给定均值：`(R,G,B)` 方差：`（R，G，B）`，将会把`Tensor`正则化。即：`Normalized_image=(image-mean)/std`。

![48a0f23a3af44210bf6f260bec3fa3bb.png][]

实例代码如下：

import cv2 as cv
    from torch.utils.tensorboard import SummaryWriter
    from torchvision import transforms
    writer=SummaryWriter("logs1")
    cv_img=cv.imread(r"F:\yolo\img\street.jpg")
    tensor_trans=transforms.ToTensor()
    test_img1=tensor_trans(cv_img)
    writer.add_image("test_img",test_img1,1)
    print(test_img1[0][0][0])
    trans_norm=transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
    img_norm=trans_norm(test_img1)
    print(img_norm[0][0][0])
    writer.add_image("test_img",img_norm,2)
    writer.close()

**class torchvision.transforms.ToTensor**

把一个取值范围是`[0,255]`的`PIL.Image`或者`shape`为`(H,W,C)`的`numpy.ndarray`，转换成形状为`[C,H,W]`，取值范围是`[0,1.0]`的`torch.FloadTensor`

方法总结如下图：

![6b67c83d084b40959976fe801b40bc4b.png][]

### **4.**DataLoader ###

数据加载器。组合数据集和采样器，并在数据集上提供单进程或多进程迭代器。

**参数：**

*  **dataset** (*Dataset*) – 加载数据的数据集。
 *  **batch\_size** (*int*, optional) – 每个batch加载多少个样本(默认: 1)。
 *  **shuffle** (*bool*, optional) – 设置为`True`时会在每个epoch重新打乱数据(默认: False).
 *  **sampler** (*Sampler*, optional) – 定义从数据集中提取样本的策略。如果指定，则忽略`shuffle`参数。
 *  **num\_workers** (*int*, optional) – 用多少个子进程加载数据。0表示数据将在主进程中加载(默认: 0)
 *  **collate\_fn** (*callable*, optional) –
 *  **pin\_memory** (*bool*, optional) –
 *  **drop\_last** (*bool*, optional) – 如果数据集大小不能被batch size整除，则设置为True后可删除最后一个不完整的batch。如果设为False并且数据集的大小不能被batch size整除，则最后一个batch将更小。(默认: False)

import cv2 as cv
    from torch.utils.tensorboard import SummaryWriter
    from torchvision import transforms
    from torch.utils.data import DataLoader
    import torchvision
    train_set=torchvision.datasets.CIFAR10(root="./dataset",train=True,download=True,transform=torchvision.transforms.ToTensor())
    # shuffle 为true设置为打乱顺序
    train_loader=DataLoader(dataset=train_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)
    writer=SummaryWriter("logs1")
    step=0
    for data in train_loader:
        imgs,targets=data
        writer.add_images("imgs",imgs,step)
        step=step+1
        break
    writer.close()

### 5.神经网络-卷积层Conv2d ###

**class torch.nn.Conv2d(in\_channels, out\_channels, kernel\_size, stride=1, padding=0, dilation=1, groups=1, bias=True)**

**Parameters：**

*  in\_channels(`int`) – 输入信号的通道
 *  out\_channels(`int`) – 卷积产生的通道
 *  kerner\_size(`int` or `tuple`) - 卷积核的尺寸
 *  stride(`int` or `tuple`, `optional`) - 卷积步长
 *  padding(`int` or `tuple`, `optional`) - 输入的每一条边补充0的层数
 *  dilation(`int` or `tuple`, `optional`) – 卷积核元素之间的间距
 *  groups(`int`, `optional`) – 从输入通道到输出通道的阻塞连接数
 *  bias(`bool`, `optional`) - 如果`bias=True`，添加偏置

![f4cc2d0e784f475fa28148b610f2889d.png][]

![714f283eb0c24044b25e8dff5f6bb0d1.png][]

import cv2 as cv
    import torch
    from torch.utils.tensorboard import SummaryWriter
    from torchvision import transforms
    from torch.utils.data import DataLoader
    import torchvision
    train_set=torchvision.datasets.CIFAR10(root="./dataset",train=True,download=True,transform=torchvision.transforms.ToTensor())
    # shuffle 为true设置为打乱顺序
    train_loader=DataLoader(dataset=train_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)
    from torch import nn
    
    class test(nn.Module):
        def __init__(self):
            super(test, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 3, stride=1, padding=0)
    
        def forward(self, x):
            x = self.conv1(x)
            return x
    test=test()
    writer=SummaryWriter("logs1")
    step=0
    for data in train_loader:
        imgs,targets=data
        writer.add_images("imgs",imgs,step)
        step=step+1
        output=test(imgs)
        # 由于图片只能以三个通道显示，因此要把6个channel改成3个
        # torch.size([64,6,30,30])->[???,3,30,30]
        # batch_size不知道写多少的时候就写-1,它会自动计算
        output=torch.reshape(output,(-1,3,30,30))
        writer.add_images("imgs", output, step)
        break
    writer.close()

### 6.最大池化层 ###

**参数：class torch.nn.MaxPool2d(kernel\_size, stride=None, padding=0, dilation=1, return\_indices=False, ceil\_mode=False)**

*  kernel\_size(`int` or `tuple`) - max pooling的窗口大小
 *  stride(`int` or `tuple`, `optional`) - max pooling的窗口移动的步长。默认值是`kernel_size`
 *  padding(`int` or `tuple`, `optional`) - 输入的每一条边补充0的层数
 *  dilation(`int` or `tuple`, `optional`) – 一个控制窗口中元素步幅的参数
 *  return\_indices - 如果等于`True`，会返回输出最大值的序号，对于上采样操作会有帮助
 *  ceil\_mode - 如果等于`True`，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

import cv2 as cv
    import torch
    from torch.utils.tensorboard import SummaryWriter
    from torchvision import transforms
    from torch.utils.data import DataLoader
    import torchvision
    from torch.nn import MaxPool2d
    train_set=torchvision.datasets.CIFAR10(root="./dataset",train=True,download=True,transform=torchvision.transforms.ToTensor())
    # shuffle 为true设置为打乱顺序
    train_loader=DataLoader(dataset=train_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)
    from torch import nn
    
    class test(nn.Module):
        def __init__(self):
            super(test, self).__init__()
            self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)
    
        def forward(self, input):
            output = self.maxpool1(input)
            return output
    test=test()
    writer=SummaryWriter("logs1")
    step=0
    for data in train_loader:
        imgs,targets=data
        writer.add_images("imgs1",imgs,step)
        step=step+1
        output=test(imgs)
        writer.add_images("imgs1", output, step)
        break
    writer.close()

### 7.非线性激活函数Relu ###

Relu函数的作用是将将小于0的数据变成为0，实例代码如下：

from torch.nn import ReLU
    input=torch.tensor([[1,-0.5],
                        [-1,3]])
    class test(nn.Module):
        def __init__(self):
            super(test, self).__init__()
            #inplace-选择是否进行覆盖运算
            self.relu1=ReLU(inplace=False)
        def forward(self,input):
            output=self.relu1(input)
            return output
    
    test=test()
    output=test(input)
    print(output)

### 9.线性层 ###

**Linear layers**

对输入数据做线性变换：y=Ax+b

**参数：**

*  **in\_features** \- 每个输入样本的大小
 *  **out\_features** \- 每个输出样本的大小
 *  **bias** \- 若设置为False，这层不会学习偏置。默认值：True

**形状：**

*  **输入:** (N,in\_features)(N,in\_features)
 *  **输出：** (N,out\_features)(N,out\_features)

**变量：**

*  **weight** \-形状为(out\_features x in\_features)的模块中可学习的权值
 *  **bias** \-形状为(out\_features)的模块中可学习的偏置

如下图：

![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81Mjc2NzgzOQ==,size\_16,color\_FFFFFF,t\_70][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81Mjc2NzgzOQ_size_16_color_FFFFFF_t_70]

代码实例如下:

import torch
    import torchvision
    from torch import nn
    from torch.nn import Linear
    from torch.utils.data import DataLoader
     
    dataset=torchvision.datasets.CIFAR10("dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                        download=True)
    dataloader=DataLoader(dataset,batch_size=64,drop_last=True)
     
    class test(nn.Module):
        def __init__(self):
            super(test, self).__init__()
            self.linear1=Linear(3072,10)
        def forward(self,input):
            output=self.linear1(input)
            return output
    test1=test()
    for data in dataloader:
        imgs,t=data
        print(imgs.shape)
        #将图片线性化
        output=torch.flatten(imgs)
        print(output.shape)
        output=test1(output)
        print(output.shape)
     
    output：
    #torch.Size([64, 3, 32, 32])
    #torch.Size([64, 1, 1, 3072])
    #torch.Size([64, 1, 1, 10])

### 10.损失函数 ###

损失函数这里列举几个：

**class torch.nn.L1Loss(size\_average=True)[\[source\]][source]**

创建一个衡量输入`x`(`模型预测输出`)和目标`y`之间差的绝对值的平均值的标准。

![56c806bb8254453bb4017bd52fe094f1.png][]

*  `x` 和 `y` 可以是任意形状，每个包含`n`个元素。
 *  对`n`个元素对应的差值的绝对值求和，得出来的结果除以`n`。
 *  如果在创建`L1Loss`实例的时候在构造函数中传入`size_average=False`，那么求出来的绝对值的和将不会除以`n`

代码如下实例

import torch
    from torch.nn import L1Loss
    
    input=torch.tensor([1,2,3],dtype=torch.float32)
    output=torch.tensor([1,2,5],dtype=torch.float32)
    loss=L1Loss()
    result=loss(input,output)
    print(result)

运行结果如下图，如果不需要求平均可以这样设置

loss=L1Loss(reduction="sum")

![610c0ecb800c44518cfda484be1bffde.png][]

**class torch.nn.MSELoss(size\_average=True)[\[source\]][source 1]**

创建一个衡量输入`x`(`模型预测输出`)和目标`y`之间均方误差标准。

![5187ec816a7741ba888415b47c1f3d0d.png][]

*  `x` 和 `y` 可以是任意形状，每个包含`n`个元素。
 *  对`n`个元素对应的差值的绝对值求和，得出来的结果除以`n`。
 *  如果在创建`MSELoss`实例的时候在构造函数中传入`size_average=False`，那么求出来的平方和将不会除以`n`

**class torch.nn.CrossEntropyLoss(weight=None, size\_average=True)**

![9c79c2cac78340249d468cd671b8388d.png][]

当训练一个多类分类器的时候，这个方法是十分有用的。exp是以e为底的指数函数，在一个猫狗二分类问题中，一个图片经过神经网络模型输出为x\[0.5,0.7\]，其中这张图片的target为0，0代表为猫，1代表为狗，损失函数的计算为-x\[0(target)\]+ln(exp(x\[0\])+exp(x\[1\])。

代码如下

import torch
    from torch.nn import CrossEntropyLoss
    
    x=torch.tensor([0.1,0.2,0.3])
    y=torch.tensor([1])
    x=torch.reshape(x,(1,3))
    loss=CrossEntropyLoss()
    result=loss(x,y)
    print(result)

### 11.反向传播和优化器 ###

反向传播 loss.backward()

优化器一般是使用梯度下降的方法进行优化：在梯度法中，函数的取值从当前位置沿着梯度方向前进一定距离，然后在新的地方重新求梯度，再沿着新梯度方向前进，如此反复，不断地沿梯度方向前进。像这样，通过不断地沿梯度方向前进，逐渐减小函数值的过程就是梯度法（gradient method）。梯度法是解决机器学习中最优化问题的常用方法，特别是在神经网络的学习中经常被使用。根据目的是寻找最小值还是最大值，梯度法的叫法有所不同。严格地讲，寻找最小值的梯度法称为梯度下降法（gradient descent method），寻找最大值的梯度法称为梯度上升法（gradient ascent method）。但是通过反转损失函数的符号，求最小值的问题和求最大值的问题会变成相同的问题，因此“下降”还是“上升”的差异本质上并不重要。一般来说，神经网络（深度学习）中，梯度法主要是指梯度下降法。

反向传播和优化器代码实例如下：

test1=test()
    #lossFunction模型
    loss=nn.CrossEntropyLoss()
    #优化器模型
    optim=torch.optim.SGD(test1.parameters(),0.01)
    #进行20次优化
    for epcho in range (20):
        running_loss=0.0
        for data in dataloader:
            imgs,t=data
            output=test1(imgs)
            loss=loss(output,t)
            #将每个梯度清为0（初始化）
            optim.zero_grad()
            #反向传播，得到每个可调节参数对应的梯度（grad不再是none）
            loss.backward()
            #对每个参数进行改变，weight-data被改变
            optim.step()
            #计算每轮优化中每个变量的loss和
            running_loss=running_loss+result_loss
        print(running_loss)
     
    output：
    #总loss在逐渐变小
    # tensor(18712.0938, grad_fn= < AddBackward0 >)
    # tensor(16126.7949, grad_fn= < AddBackward0 >)
    # tensor(15382.0703, grad_fn= < AddBackward0 >)

### 12.**残差网络** ###

传统的神经网络，由于网络层数增加，会导致梯度越来越小，这样会导致后面无法有效的训练模型，这样的问题成为梯度消弭。为了解决这样的问题，引入残差神经网络（Residual Networks），残差神经网络的核心是”跳跃”+“残差块”。通过引入RN网络，可以有效缓解梯度消失的问题，可以训练更深的网络。

下图是一个基本残差块。它的操作是把某层输入跳跃连接到下一层乃至更深层的激活层之前，同本层输出一起经过激活函数输出。

![24353e89d9c84a17babbbf4ebe90630b.png][]

定义残差模型，根据最基本的残差块，残差中间需要经过卷积->激活->卷积这样的操作，为了保证输入输出大小一致，故中间两个卷积层的输入输出大小都和模型最初输入大小保持一致。

class ResidualBlock(nn.Module):
        def __init__(self, channels):
            super(ResidualBlock, self).__init__()
            self.channels = channels
            self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
            self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
    
        def forward(self, x):
            y = F.relu(self.conv1(x))
            y = self.conv2(y)
            return F.relu(x + y)

### 13.CIFAR10模型结构 ###

下面是利用CIFAR10模型结构进行图像分类数据的训练和预测。

![c702f32874c54bb998261fa356c9a38f.png][]

import torch
    import torchvision
    from torch import nn
    from torch.utils.data import DataLoader
    from torch.utils.tensorboard import SummaryWriter
    #import自己写的models
    from p27_1model import *
     
    train_data=torchvision.datasets.CIFAR10("../datasets",train=True,transform=torchvision.transforms.ToTensor(),
                                            download=True)
    test_data=torchvision.datasets.CIFAR10("../datasets",train=False,transform=torchvision.transforms.ToTensor(),
                                            download=True)
    #查看数据集长度
    train_size=len(train_data)
    test_size=len(test_data)
    print("size of train,test is:{},{}".format(train_size,test_size))
    #利用dataloader加载
    train_dataloader=DataLoader(train_data,64)
    test_dataloader=DataLoader(test_data,64)
    #创建网络模型
    test1=test()
    #损失函数
    loss_f=nn.CrossEntropyLoss()
    #优化器
    #1e-2=0.01
    learning_rate=1e-2
    opt=torch.optim.SGD(test1.parameters(),lr=learning_rate,)
    #设置训练网络的参数
    #记录训练次数
    train_step=0
    #测试次数
    test_step=0
    #训练轮数
    epoch=10
    #添加tensoeboard
    writer=SummaryWriter("train_log")
     
     
    for i in range(epoch):
        print("第{}轮训练开始".format(i+1))
        #训练步骤开始
        #有时不必要：test1.train()
        for data in train_dataloader:
            imgs,t=data
            output=test1(imgs)
            loss=loss_f(output,t)
            #优化器优化模型
            opt.zero_grad()
            loss.backward()
            opt.step()
            train_step=train_step+1
            #loss.item更加规范（.item不会打印数据类型，例如tensor(5))
            if train_step%100==0:
                print("训练次数{}，loss值为{}".format(train_step,loss.item()))
                writer.add_scalar("train_loss",loss.item(),train_step)
        loss_total=0
        #测试步骤开始
        #有时不必要：test1.eval()
        total_correct=0
        with torch.no_grad():
            for data in test_dataloader:
                imgs,t=data
                output=test1(imgs)
                loss=loss_f(output,t)
                loss_total=loss_total+loss.item()
                test_step=test_step+1
                #argmax参数：1为横向比较，2为纵向比较，output为64,10的矩阵
                #output.argmax(1)==t是为了得到[Ture,False,True....]这种形式
                #.sum:T为1，F为0
                corect=(output.argmax(1)==t).sum()
                total_correct=total_correct+corect
                accuracy=total_correct/test_size
        print("测试集总loss{}".format(loss_total))
        writer.add_scalar("test_loss",loss_total,test_step)
        writer.add_scalar("accuracy",accuracy,test_step)
     
        torch.save(test1,"test1{}.pth".format(i))
        print("模型已保存")

[pytorch]: https://so.csdn.net/so/search?q=pytorch&spm=1001.2101.3001.7020
[48a0f23a3af44210bf6f260bec3fa3bb.png]: https://img-blog.csdnimg.cn/48a0f23a3af44210bf6f260bec3fa3bb.png
[6b67c83d084b40959976fe801b40bc4b.png]: https://img-blog.csdnimg.cn/6b67c83d084b40959976fe801b40bc4b.png
[f4cc2d0e784f475fa28148b610f2889d.png]: https://img-blog.csdnimg.cn/f4cc2d0e784f475fa28148b610f2889d.png
[714f283eb0c24044b25e8dff5f6bb0d1.png]: https://img-blog.csdnimg.cn/714f283eb0c24044b25e8dff5f6bb0d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81Mjc2NzgzOQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210707141823575.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81Mjc2NzgzOQ==,size_16,color_FFFFFF,t_70
[source]: http://pytorch.org/docs/_modules/torch/nn/modules/loss.html#L1Loss
[56c806bb8254453bb4017bd52fe094f1.png]: https://img-blog.csdnimg.cn/56c806bb8254453bb4017bd52fe094f1.png
[610c0ecb800c44518cfda484be1bffde.png]: https://img-blog.csdnimg.cn/610c0ecb800c44518cfda484be1bffde.png
[source 1]: http://pytorch.org/docs/_modules/torch/nn/modules/loss.html#MSELoss
[5187ec816a7741ba888415b47c1f3d0d.png]: https://img-blog.csdnimg.cn/5187ec816a7741ba888415b47c1f3d0d.png
[9c79c2cac78340249d468cd671b8388d.png]: https://img-blog.csdnimg.cn/9c79c2cac78340249d468cd671b8388d.png
[24353e89d9c84a17babbbf4ebe90630b.png]: https://img-blog.csdnimg.cn/24353e89d9c84a17babbbf4ebe90630b.png
[c702f32874c54bb998261fa356c9a38f.png]: https://img-blog.csdnimg.cn/c702f32874c54bb998261fa356c9a38f.png