《深度学习入门之Pytorch》读书笔记

我不是女神ヾ 2024-05-24 03:54 64阅读 0赞

## 《深度学习入门之Pytorch》读书笔记 ##

##### 如有错误还请不吝指出 #####

### **第三章** ###

#### **3.1 Pytorch基础** ####

3.1.1 张量 Tensor 表示的是多维的矩阵 不同数据类型：

32位浮点型 torch.FloatTensor (默认数据类型)

64位浮点型 torch.DoubleTensor

16位整型 torch.ShortTensor

32位整型 torch.IntTensor

64位整型 torch.LongTensor

3.1.2 Variable(变量)  
这是一个神经网络计算图中特有的概念，Variable提供了自动求导机制。Variable 和 Tensor 本质上没有区别，但是 Variable会被放入一个计算图中，进行前向传播、反向传播和自动求导。  
Variabl 在 **torch.autograd.Variable** 中, 如果 a 是一个张量，使用 **Variable(a)** 可将其变为 Variable.  
Variable 中有三个重要组成性质：**data, grad, grad\_fn**. 通过 data 可以取出 Variable 中的 tensor 数值，grad\_fn 得到这个 Variable 的操作. grad 是 Variable 反向传播的梯度.

from torch.autograd import Variable
    import torch
    
    # create Variable
    x = Variable(torch.Tensor([1]), requires_grad=True)
    w = Variable(torch.Tensor([2]), requires_grad=True)
    b = Variable(torch.Tensor([3]), requires_grad=True)
    
    # Build a computational graph
    y = w * x + b   # y = 2*x + 3
    
    # Compute the gradients
    y.backward()    # same as y.backward(torch.FloatTensor([1]))
    print(x.grad)   # 2
    print(w.grad)   # 1
    print(b.grad)   # 1

构建 Variable 需要传递一个参数 **requires\_grad=True** 这个参数表示是否要对这个变量求导, 默认是 False.  
`y.backward()`就是自动求导, 自动求导不需要明确写明哪个函数对哪个函数求导,直接通过这行代码对所有需要梯度的变量求导.  
下面是对矩阵求导

# 对矩阵求导
    x = torch.randn(3)
    x = Variable(x, requires_grad=True)
    # tensor([ 1.5244, -1.0083, -0.4375])
    
    y = x*2
    # tensor([ 3.0487, -2.0165, -0.8750])
    
    y.backward(torch.FloatTensor([1, 0.1, 0.01]))
    print(x.grad)
    # tensor([ 2.0000,  0.2000,  0.0200])

3.1.3 Dataset(数据集)  
任何机器学习在处理之前都要及逆行数据读取和预处理.  
**torch.utils.data.Dataset** 是代表这一数据的抽象类, 只需定义***\_len\_*** 和 ***\_getitem\_*** 这两个函数就可以继承并重写这个抽象类

from torch.utils.data import Dataset
    import pandas as pd
    
    class myDataset(Dataset):
            def __init__(self, csv_file, txt_file, root_dir, other_file):
                self.csv_data = pd.read_csv(csv_file)
                with open(txt_file, 't') as f:
                    data_list = f.readlines()
                self.txt_data = data_list
                self.root_dir = root_dir
    
            def __len__(self):
                return len(self.csv_data)
    
            def __getitem__(self, idx):
                data = (self.csv_data[idx], self.txt_data[idx])
                return data

通过上面的方式, 可以定义我们需要的数据集, 可以通过迭代的方法获得每一个数据. Pytorch 提供了更简单的方法来实现取 batch, shuffle 或者多线程去读取数据. **torch.utils.data.DataLoader** 来定义一个迭代器.  
`dataiter = DataLoader(myDataset, batch_size=2, shuffle=True, collate_fn=default_collate)`  
其中 shuffle 是打乱或者洗牌的意思. **collate\_fn** 表示如何取样本.  
在 torchvision 包中还有更高级的数据读取类 **ImageFolder**  
`dset = ImageFolder(root='root_path', transform=None, loader=default_loader)`  
`dset.ImageFolder(root="root folder path", [transform, target_transform]) #官方文档`  
root 需要是根目录, 在这个目录下有几个文件夹,每个文件夹表示一个类别. target\_transform 是图片增强. loader 是图片读取的方法, 因为我们要读取的是名字,所以通过 loader 将图片转换成我们需要的图片类型进入神经网络

3.1.4 nn.Module(模组)  
在 Pytorch 中编写神经网络,所有的层结构和损失结构都来自 **torch.nn** , 所有模型构建都是从基类 **nn.Module** 继承的, 下面是模板

from torch.nn import Module
    from torch import nn
    
    class net_name(nn.Module):
        def __init__(self, other_arguments):
            super(net_name, self).__init__()
            self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)
            # other network layer
    
        def forward(self, x):
            x = self.conv1(x)
            return x

这样建立了一个计算图, 这个结构可以复用多次, 每次调用相当于计算图定义时的相同参数做一次前向传播, 我们不用自己编写反向传播.  
定义完模型, 来定义损失函数, 常见的损失函数都定义在 nn 中. 这样我们就能求得输出和真是目标之间的损失函数.

criterion = nn.CrossEntropyLoss()
    loss = criterion(output, target)

3.1.5 torch.optim(优化)

**1.一阶优化算法:** 使用各个参数的梯度值来更新参数, 最常用的是帝都下降  
 θ=θ−η×δJ(θ)δθ  θ = θ − η × δ J ( θ ) δ θ

**1.二阶优化算法:** 使用二阶导数 ( Hessian方法 ) 来最大化或者最小化代价函数, 主要基于牛顿法. 下面举一个例子  
`optimizer = torch.optim(model.parameters(), lr=0.01, momentum=0.9)`  
这样,我们就得到了学习速率为0.01, 动量是0.9的随机梯度下降, 在优化之前 **要将梯度归零, optimizer.zeros()**, 然后通过 **loss.backward()** 反向传播, 自动求导得到每个参数的梯度, 然后通过 **optimizer.step()** 进行参数的更新.

3.1.6 模型的保存和加载  
在 Pytorch 中使用 **torch.save** 来保存模型的结构和参数,有两种方式  
1. 保存整个模型的结构信息和参数信息, **保存的对象是模型 model**  
2. 保存模型的参数, **保存的对象是模型的状态 model.state\_dict()**  
save 的第一个参数是保存的对象, 第二个是保存的路径

torch.save(model, './model.pth')   # 方式1
    torch.save(model.state_dict(), './model_state.pth') # 方式2

加载模型对应两种保存方式也有两种  
1. 加载完整的模型结构和参数信息, 使用 **load\_model = torch.load(‘model.pth’)** 在网络较大的时候记载时间教程, 存储空间较大  
2. 加载模型参数信息, 需要先导入模型的结构, 然后通过 **model.load\_state\_dict(torch.load(‘model\_state.pth’))** 来导入.

#### **3.2 线性模型** ####

#### **3.3 分类问题** ####

3.3.4 二分类的Logistics回归

P(Y=0|x)=11\+ew×x\+b  P ( Y = 0 | x ) = 1 1 + e w × x + b

P(Y=1|x)=ew×x\+b1\+ew×x\+b  P ( Y = 1 | x ) = e w × x + b 1 + e w × x + b

事件发生的 **几率(odd)**: 事件发生的概率和不发生的概率之比

logP(Y=1|x)1−P(Y=1|x)=w×x\+b  l o g P ( Y = 1 | x ) 1 − P ( Y = 1 | x ) = w × x + b

#### **3.4 简单的多层全连接前向网络** ####

3.4.3 激活函数

1. Sigmoid函数  σ(x)=11\+e−z  σ ( x ) = 1 1 + e − z   
两大缺点: (1) Sigmoid函数会造成梯度消失. 在靠近0和1两端时,函数梯度接近0. 在初始化权重的时候如果权重太大,经过激活函数也会导致大多数神经元变得饱和,没办法更新参数.  
(2).Sigmoid的输出不是以0为均值

3.4.4 神经网络的结构  
一般而言，N层的神经网络并不会把输入层算计去，因此，一个一层的网络是指没有隐藏层、只有输入层和输出层的网络。输出层一般是没有激活函数的。  
一般神经网络的损失函数是非凸的，容量更小的网络更容易陷入局部最小点达不到最优效果，且这些局部最小点的方差特别大。但是对于容量更大的网络，它的局部最小点方差特别小，也就是说，训练多次虽然可能陷入局部最小点，但是他们之间的差异很小，这样训练就不会弯曲依靠随机初始化。

#### **3.7 处理数据和训练模型的技巧** ####

3.7.1 数据预处理

1.中心化  
每个特征维度都减去相应的均值来实现中心化，这样可以使数据变成0均值。

2.标准化  
在数据都变成0均值后，采用标准化的做法是数据不同的特征维度都有相同的规模。有两种常用的方法。一种是除以数据标准差，是数据的分布接近标准高斯分布。二是让每个维度特征的最大值和最小值按比例缩放到-1~1之间。

3.PCA  
在用PCA处理数据前，通常将数据中心化，并计算数据的协方差矩阵。该协方差矩阵是对称半正定的，可以通过矩阵来进行奇异值分解(SVD)， 然后对数据进行去相关性，再将其投影到一个特征空间，选取较大的、主要的向量来降低数据的维度，这种方法叫做PCA，主成分分析

4.白噪声  
与PCA相似，首先将数据投影到一个特征空间，然后每个维度除以特征值来标准化这些数据。直观上就是将一个多元高斯分布转化到了一个0均值、协方差为1的多元高斯分布。  
白噪声的处理增强数据中的噪声，因为其增强了数据中的所有维度。  
在实际处理中，中心化和标准化都特别重要，但是白噪声和PCA在卷积神经网络中几乎不使用，因为网络可以自动学些如何提取这些特征。

3.7.2 权重初始化

1.全0初始化  
直观但是不应采取的策略就是全0初始化。在神经网络中如果每个权重都被初始化为相同的值，那个每个神经元都会计算出相同的结果，在反向传播时计算出相同的梯度，最后权重都会有相同的更新。

2.随机初始化  
我们希望权重初始化时能够尽量靠近0，但不都是0。一般随机化策略有高斯随机化和均匀随机化，值得注意的是并不是越小的随机化产生的结果越好。

3.稀疏初始化  
将权重全部初始化为0，然后挑选一些参数赋随机值，这种方法在实际中使用较少。

4.初始化偏置  
对于偏置(bias)，通常初始化为0。

5.批标准化(Batch Normalization)  
核心思想是标准化这个过程是可微的,批标准化通常应用在全连接层后面,非线性层前面。批标准化还可以理解为在网络中的每一层前面都会做数据的预处理。

3.7.3 防止过拟合

1.正则化  
L2正则化是正则化中比较常用的手段，其思想是对权重过大的部分进行惩罚，也就是直接在损失函数中加入权重的二范数量级。

1.Dropout  
核心思想是在训练网络的时候依概率P保留每个神经元，也就是每次训练的时候有些神经元会被置为0。

#### **3.8 多层全连接神经网络实现MNIST手写数字分类** ####

3.8.1 简单的三层全连接神经网络

对于这个网络,需要传入四个参数,分别是输入的维度,第一、二、三层神经元的个数

class simpleNet(nn.Module):
        def __init__(self, in_dim, n_hidden_1, n_hidden_2, n_hidden_3):
            super(simpleNet, self).__init__()
    
            self.layer1 = nn.Linear(in_dim, n_hidden_1)
            self.layer2 = nn.Linear(n_hidden_1, n_hidden_2)
            self.layer3 = nn.Linear(n_hidden_2, n_hidden_3)
    
        def forward(self, x):
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            return x

3.8.2 添加激活函数(activation function)

class ActivationNet(nn.Module):
        def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
            super(ActivationNet, self).__init__()
    
            self.layer1 = nn.Sequential(
                nn.Linear(in_dim, n_hidden_1), nn.ReLU(True)
            )
    
            self.layer2 = nn.Sequential(
                nn.Linear(n_hidden_1, n_hidden_2), nn.ReLU(True)
            )
    
            self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
    
        def forward(self, x):
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            return x

**nn.Sequential()** 这个函数是将网络的层组合在一起.

3.8.3 添加批标准化 – 加速收敛

class BatchNet(nn.Module):
        def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
            super(BatchNet, self).__init__()
    
            self.layer1 = nn.Sequential(
                nn.Linear(in_dim, n_hidden_1), nn.BatchNorm1d(n_hidden_1), nn.ReLU(True)
            )
    
            self.layer2 = nn.Sequential(
                nn.Linear(n_hidden_1, n_hidden_2), nn.BatchNorm1d(n_hidden_2), nn.ReLU(True)
            )
    
            self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
    
    
        def forward(self, x):
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            return x

3.8.4 训练网络  
导入一些包

import test             # test是之前定义网络的文件
    import torch
    from torch import nn, optim
    from torch.autograd import Variable
    from torch.utils.data import DataLoader
    from torchvision import datasets, transforms

定义一些超参数

# 超参数 hyperparameters
    batch_size = 4
    learning_rate = 1e-2
    num_epoches = 20

进行数据预处理, 这里用到的函数是 **torchvision.transforms**, 它提供了很多图片预处理的方法。第一个方法是 **transforms.ToTensor()**, 将图片转化成为Tensor, 第二个是 **transforms.Normalize()**, 需要传递两个参数, 第一个参数是**均值**, 第二个参数是**方差**. 第三个**transforms.Compose()** 是将各种预操作组合在一起进行.

dat_tf = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize([0.5], [0.5])]
    )

因为MNIST的图片是灰度图片, 只有一个通道, 如果是彩色图片的话, 换用下面的处理方法.

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

读取数据

train_dataset = datasets.MNIST(root='./data', train=True, transform=data_tf, download=True)
    test_dataset = datasets.MNIST(root='./data', train=False, transform=data_tf, download=True)
    trainloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    testloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

使用 **torch.utlis.data.DataLoader** 建立一个数据迭代器, shuffle=True 表示在每次迭代数据的时候是否将数据打乱.  
下面导入网络, 定义损失函数和优化方法.

model = test.simpleNet(28*28, 300, 100, 10)
    if torch.cuda.is_available():
        model = model.cuda()
    
    cretirion = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

下面就要训练网络了, 训练的流程和之前的一致, 不再赘述.