PyTorch深度学习实践

中文文档Pytorch
参考视频六二大人《PyTorch深度学习实践》完结合集

1. 概述

1 监督学习

监督学习是指通过让机器学习大量带有标签的样本数据，训练出一个模型，并使该模型可以根据输入得到相应输出的过程。通过已有的一部分输入数据与输出数据之间的对应关系，生成一个函数，将输入映射到合适的输出，例如分类。

2 过拟合

过拟合：在训练集上测试正确度较高，在测试集上测试正确度较低。

3 泛化能力

泛化能力：是指机器学习算法对新鲜样本的适应能力。

4 数据集的划分
将训练集中一部分分离出来用于评估。

5 损失函数
损失函数是针对一个样本的

2. 线性模型

import numpy as np
import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def forward(x):
    return x * w

def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) ** 2

# 穷举法
w_list = []
mse_list = []
for w in np.arange(0.0, 4.1, 0.1):
    print("w=", w)
    l_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        y_pred_val = forward(x_val)
        loss_val = loss(x_val, y_val)
        l_sum += loss_val
        print('\t', x_val, y_val, y_pred_val, loss_val)
    print('MSE=', l_sum / 3)
    w_list.append(w)
    mse_list.append(l_sum / 3)

plt.plot(w_list, mse_list)
plt.ylabel('Loss')
plt.xlabel('w')
plt.show()

3. 梯度下降算法

梯度下降法不一定得到最优的结果，可能是局部最优解。其性能不高，但是时间复杂度低。



随机梯度下降一定程度上可以缓解鞍点问题。其会使用每一个样本更新权重。随机梯度下降性能比较好，但是因为前后计算之间有依赖，所以影响并行化。

Batch批量的梯度下降是指把样本分成一组一组去求梯度，而不是一个一个或者全部。

4. 反向传播

5. 用Pytorch实现线性回归

（1）准备数据集
（2）准备模型
（3）构造损失函数和优化器
（4）训练周期

1、首先，X,Y都Tensor化为矩阵

loss必须是标量才能进行反向传播，所以要对向量求和

2、首先要把我们的模型定义为一个类，我们的模型都要继承自module，因为这个父类里含有好多方法，类里最少要实现如下两个函数：

• __init__ 是它的构造函数，初始化对象时默认调用的函数。
• forword是你在进行前馈的过程中所要执行的计算，backword过程是由model自动实现的。

当我们执行model(X)时会自动调用forword函数

3、 损失和优化如下
4、 训练过程

5、测试过程

6、完整步骤

7、可尝试优化器

6. Logistic回归分类问题

1、通过Sigmoid函数把实数映射到[0,1]之间

其他激活函数

2、损失函数变化（交叉熵损失）


3、模型改变

4、最终模型

7. 处理多维特征的输入

数据集如下所示，一个样本包含多个特征：

进行向量化


Linear Layer 可进行线性的维度变化


1、读取数据集

2、模型变化

3、损失

4、训练

注意：如果用Relu激活函数的话，最好还是得使用Sigmoid函数。

8. 加载数据集

1、概念理解

2、DataLoder主要是拿出一个mini batch一组数据来供我们训练时快速使用。

3、 具体实现

import torch
import numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
 
# prepare dataset
 
 
class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        self.len = xy.shape[0] # shape(多少行，多少列)
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])
 
    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]
 
    def __len__(self):
        return self.len
 
 
dataset = DiabetesDataset('diabetes.csv')
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True, num_workers=0) #num_workers 多线程
 
 
# design model using class
 
 
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()
 
    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x
 
 
model = Model()
 
# construct loss and optimizer
criterion = torch.nn.BCELoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
 
# training cycle forward, backward, update
if __name__ == '__main__':
    for epoch in range(100):
        for i, data in enumerate(train_loader, 0): # train_loader 是先shuffle后mini_batch
            inputs, labels = data
            y_pred = model(inputs)
            loss = criterion(y_pred, labels)
            print(epoch, i, loss.item())
 
            optimizer.zero_grad()
            loss.backward()
 
            optimizer.step()

4、数据集使用示例

9. 多分类问题

1、softmax可以让概率和为一，并且每个概率都是正值。


2、多分类损失问题




3、完整代码

10. 卷积神经网络（基础）

1、卷积层保留图像的空间特征，即原始的空间信息

2、输入的有色图像为三通道的

3、单通道卷积

4、多通道卷积


5、卷积总结

6、代码使用

7、Padding


8、步长


9、池化层无权重，通道数量也不会变


9、简单神经网络



10、迁移到GPU进行计算

• 模型迁移

• input 和 target 都迁移到这个对应的device上 ，要迁移到和模型同样的显卡上。
  
  

11. 卷积神经网络（高级）

1、1x1卷积可以融合相同位置的信息，改变你的通道数量，且可以减少计算量。

2、模型分解




3、如果某一次的测试集使得模型准确率达到了新的高点，把当前网络的参数做一个备份存盘，等都训练完了存盘的那个肯定是泛化性能最好的那个网络。

4、当梯度趋近于0时，权重得不到什么更新，就是梯度消失。