【Pytorch】深度学习快速上手心得

前言
一、环境安装
二、一个简单的demo快速入门深度学习
2.1 环境依赖
2.2 数据预处理

前言

本文环境是在win10系统上搭建的。除了环境搭建，其他内容和Linux系统一致。使用的环境是Pytorch

学习资料：李沫《动手学深度学习》（该书所有代码都有Tensorflow、Pytorch、Mxnet 3个版本）
b站视频：动手学深度学习Pytorch版（视频和上面的书是对应的）

在这里插入图片描述

一、环境安装

1.1 安装Anaconda

环境安装是进行深度学习的基础。一般推荐使用Anaconda来进行python工具包管理。
Anaconda官网
更详细安装教程见以下文章：超详细Anaconda安装教程

1.2 Anaconda 常见指令

pip升级

python -m pip install --upgrade pip

conda 换源

常见的镜像源：

https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/

添加源指令

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/

查看并使源生效

conda config --show channels
conda config --set show_channel_urls yes

创建新环境

conda create -n learn python=3.6 // 创建一个名为learn的环境并指定python版本为3.6

切换环境

activate + 环境

查看所有的环境

conda env list

查看当前环境的所有包

conda list // 列出当前环境的所有包

其他指令

deactivate + 环境
conda install/remove/update + 库
tf.test.is_gpu_available()
pip install tensorflow-gpu==2.2.0 安装TensorFlow-gpu版本的
activate // 切换到base环境
conda update -n base -c defaults conda  更新conda命令
conda create -n learn python=3 // 创建一个名为learn的环境并指定python版本为3(的最新
版本)
conda env list // 列出conda管理的所有环境
conda list // 列出当前环境的所有包
conda install requests 安装requests包
conda remove requests 卸载requets包
conda remove -n learn --all // 删除learn环境及下属所有包
conda update requests 更新requests包
conda env export > environment.yaml // 导出当前环境的包信息
conda env create -f environment.yaml // 用配置文件创建新的虚拟环境

1.4 Pytorch环境安装

首先创建一个包含python的环境（如果1.2节已经创建完成，可以跳过这步）

conda create -n learn python=3.6 // 创建一个名为learn的环境并指定python版本为3.6

切换到learn环境

activate learn

安装pytorch环境
Pytorch官网有各种环境安装的指令。
本文安装的是Pytorch 1.5.0，python环境使用的是python 3.6

conda install pytorch==1.5.0 torchvision==0.6.0 cudatoolkit=10.1 -c pytorch

1.3 Jupyter安装

本文代码都是在Jupyter上编写并执行的，具体安装教程如下文。
Jupyter Notebook介绍、安装及使用教程

jupyter 启动
安装完成jupyter后通过以下指令启动。

jupyter notebook

启动成功后，就可以在浏览器中打开了，一般默认的是端口8888。

二、一个简单的demo快速入门深度学习

本章节我们将通过一个数据预测的demo，来对深度学习有一个基础的认识。更详细内容可以通过前言里面的知识来学习。

一般来说，我们在做深度学习时候，可以将代码分为以下几个部分：

1. 环境依赖
2. 数据预处理
3. 数据加载
4. 模型定义
5. 定义损失函数和优化器
6. 训练模型
7. 模型准确度评估
8. 评估结果可视化

下面内容就是按照上面步骤展开。

2.1 环境依赖

首先导入一些基本的numpy和matplotlib绘图依赖

import numpy as np
import os
import torch 
import matplotlib.pyplot as plt
from IPython import display

2.2 数据预处理

良好的数据是深度学习的基础。在数据处理前，我们先定义一个绘图方法，方便后续可视化的调用。

def myplot(x, y, label=None, xlimit=None, size=(9, 3), save_path=None, file_name=None):
    display.set_matplotlib_formats('svg')
    if len(x) != len(y):
        raise ValueError('x和y的长度不一致,无法绘制图像')
    else:
        plt.figure(figsize=size)
        if xlimit and isinstance(xlimit, tuple):
            plt.xlim(xlimit)
        plt.plot(x, y, label=label)
        if label and isinstance(label, str):
            plt.legend(loc="upper left")
        if file_name and save_path:
            if not os.path.isdir(save_path):
                os.mkdir(save_path)
            plt.savefig(os.path.join(save_path,file_name))
        plt.show()

通过sin函数+随机噪声来模拟1000个数据点

T = 1000  # 总共产生1000个点
x= torch.arange(1, T + 1, dtype=torch.float32)
y = torch.sin(0.01 * time) + torch.normal(0, 0.2, (T,))

可视化

myplot(x, y, label='time', size=(6, 3))

在这里插入图片描述

2.3 数据加载

在深度学习中，对数据进行预处理时候，当数据量比较大的时候，一般需要将数据集划分成多个batch。
这时可以通过实现一个torch自带的DataSet类，来完成常见的batch划分以及shuffle操作。
关于【Pytorch】DataLoader和 DataSet快速入门可以查看这篇文章。

定义一个数据集类来对数据进行划分，把数据集划分成训练集和测试集，比例为8：2。

from torch.utils.data import Dataset,DataLoader,TensorDataset
class myDataSet(Dataset):

    def __init__(self, data, history_length, predict_length, train_mode):
        
        self.train_length, self.test_length = 800,200
        # 历史数据步长
        self.history_length = history_length
        
        # 预测长度
        self.predict_length = predict_length
        
        # 训练模式
        self.train_mode = train_mode
        
        self.data = data

    def __getitem__(self, index: int):
        if self.train_mode == 'train':
            index = index
        elif self.train_mode == 'test':
            # test 模式有一个偏移量
            index += self.train_length
        else:
            raise ValueError('train mode {} is not defined '.format(self.train_mode))
        data_x, data_y = myDataSet.slice_data(data=self.data,
                                              history_length=self.history_length,
                                              predict_length=self.predict_length,
                                              index=index,
                                              train_mode=self.train_mode)
        
        data_x= myDataSet.to_tensor(data_x).squeeze()
        data_y = myDataSet.to_tensor(data_y).squeeze() 
        return data_x, data_y

    def __len__(self) -> int:
        if self.train_mode == 'train':
            return self.train_length - self.history_length -self.predict_length
        elif self.train_mode == 'test':
            # 每一个样本都可以测试
            return self.test_length - self.predict_length
        else:
            raise ValueError('train mdoe : {} is not defined'.format(self.train_mode))



    @staticmethod
    def slice_data(data, history_length, predict_length, index, train_mode):  #根据历史长度,下标来划分数据样本

        if train_mode == "train":
            start_index = index  #开始下标就是时间下标本身，这个是闭区间
            end_index = index + history_length  #结束下标,这个是开区间
        elif train_mode == "test":
            start_index = index - history_length  #　开始下标，这个最后面贴图了，可以帮助理解
            end_index = index  # 结束下标
        else:
            raise ValueError(
                "train model {} is not defined".format(train_mode))

        data_x = data[start_index:end_index]  # 在切第二维，不包括end_index
        data_y = data[end_index :end_index + predict_length]  # 把上面的end_index取上

        return data_x, data_y

    @staticmethod
    def to_tensor(data):
        return torch.tensor(data, dtype=torch.float)

测试方法

train_data = myDataSet(data=y,history_length=4,predict_length=2,train_mode="train")
test_data = myDataSet(data=y,history_length=4,predict_length=2,train_mode="test")

在这里插入图片描述
从图中，我们可以看出训练集和测试集都是输入为4，输出为2的形状

接着将数据送入加载器中。进行分batch_size,和随机打乱的操作。方便后续训练。

train_loader = DataLoader(dataset=train_data, shuffle=False,batch_size=64)
test_loader = DataLoader(dataset=test_data, shuffle=False,batch_size=64)

然后我们验证一下输入格式，是我们想要的格式。
在这里插入图片描述

2.4定义模型

import torch.nn as nn

定义一个最简单的多层感知机模型，包含一个输入层，一个输出层，一个隐藏层

class MyNet(nn.Module):  # GCN模型，向空域的第一个图卷积
    def __init__(self, in_c, hid_c, out_c):
        super(MyNet, self).__init__()  # 表示继承父类的所有属性和方法
        self.linear_1 = nn.Linear(in_c, hid_c)  # 定义一个输入层
        self.linear_2 = nn.Linear(hid_c, hid_c)  # 定义一个隐藏层
        self.linear_3 = nn.Linear(hid_c,out_c) # 输出层
        self.act = nn.ReLU()  # 定义激活函数

    def forward(self, data, device):
    
        output_1 = self.linear_1(flow_x)  
        output_1 = self.act(output_1)  

        output_2 = self.linear_2(output_1)
        output_2 = self.act(output_2) 

        output_3 = self.linear_3(output_2) 
        output_3 = self.act(output_3)  
        
        return output_3

实例化模型，并打印模型结构

my_net = MyNet(in_c=4,hid_c=8,out_c=2)

在这里插入图片描述

2.5 定义优化函数和损失函数

import torch.optim as optim

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 定义设备

my_net = my_net.to(device)  # 模型送入设备

# 第三步：定义损失函数和优化器
criterion = nn.MSELoss()  # 均方损失函数

optimizer = optim.Adam(params=my_net.parameters(), lr=0.001)# 没写学习率，表示使用的是默认的，也就是lr=1e-3

# 第四步：训练+测试
# Train model
Epoch = 20 # 训练的次数

2.6 开始训练

在这里插入代码片