Pytorch基础_1

Pytorch

presentation: 就是Pytorch的一个学习日志，持续记录一些遇到的知识点和问题。

git（https://github.com/Du-Sen-Lin/Pytorch）代码基本参照liaoxingyu老师的，加了很多小白（指我）注释。

顺便博客中也记录了一些expand。

0、Log

000——PyTorch基本操作单元

001——线性回归

002——逻辑回归

003——神经网络

1、Docs

1-1、环境

Pytorch官方网站
前置环境：

Anoconda3;
CUDA；

主要方法：安装Anoconda3 ,使用conda 创建虚拟环境，在虚拟环境中安装所需模块。
有机会会更一篇博客详细介绍从0安装，大概总结：其实就是先CUDA， 再Anoconda; 再创建虚机环境（或者docker里面创建虚拟环境），再安装需要的模块，再使用jupyter notebook写代码。
自己yy的优点：
1、服务器自己的虚拟环境方便管理，互不干扰；
2、docker, 不同项目方便部署、管理。
配置环境：

3090需要cuda11以上。

如果channel有问题，运行下面命令：

conda config --add channels conda-forge

verification:

python
import torch
print(torch.__version__)
print(torch.version.cuda)
torch.cuda.is_available()
x = torch.rand(5, 3)
print(x)

配置其他模块：

conda install scipy matplotlib ipython jupyter pandas sympy nose pillow bokeh tqdm opencv cython h5py rsa

pip install torchsummary

其他见文档all_安装开发环境以及组件介绍.md

jupyter notebook:

jupyter-notebook password

nohup jupyter notebook --port xxxx --ip xxx --allow-root&

2、GPU:

1、PyTorch指定GPU设备：

1. 类似tensorflow指定GPU的方式，使用CUDA_VISIBLE_DEVICES。

1.1 直接终端中设定：

CUDA_VISIBLE_DEVICES=1 python my_script.py

1.2 python代码中设定：

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"

2. 使用函数 set_device

import torch
torch.cuda.set_device(id)

4、torch
torch.cuda.is_available() #CUDA是否可用

2、PyTorch内存泄漏相关

https://zhuanlan.zhihu.com/p/86286137

3、Pytorch cpu||GPU利用相关

https://blog.csdn.net/qq_32998593/article/details/92849585

https://tangshusen.me/Deep-Learning-with-PyTorch-Chinese/#/chapter5/5.3

2、Expand

1、Variable向量

一个Variable里面包含着三个属性:data，grad和creator
creator表示得到这个Variabel的操作，比如乘法或者加法等等，
grad表示方向传播的梯度，
data表示取出这个Variabel里面的数据

https://blog.csdn.net/KGzhang/article/details/77483383

2、 torch.optim中的优化算法

SGD, Adam…

torch.optim是一个实现了多种优化算法的包，大多数通用的方法都已支持，提供了丰富的接口调用，未来更多精炼的优化算法也将整合进来。
为了使用torch.optim，需先构造一个优化器对象Optimizer，用来保存当前的状态，并能够根据计算得到的梯度来更新参数。

优化步骤：

方法1：

所有的优化器Optimizer都实现了step()方法来对所有的参数进行更新。

optimizer.step()

这是大多数优化器都支持的简化版本，使用如下的backward()方法来计算梯度的时候会调用它。

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

方法2：

一些优化算法，如共轭梯度和LBFGS需要重新评估目标函数多次，所以你必须传递一个closure以重新计算模型。 closure必须清除梯度，计算并返回损失。

optimizer.step(closure)

for input, target in dataset:
    def closure():
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        return loss
    optimizer.step(closure)

• SGD算法

• Adam算法

Adam(Adaptive Moment Estimation)本质上是带有动量项的RMSprop，它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。它的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳。其公式如下：

其中，前两个公式分别是对梯度的一阶矩估计和二阶矩估计，可以看作是对期望E|gt|，E|gt^2|的估计;
公式3，4是对一阶二阶矩估计的校正，这样可以近似为对期望的无偏估计。可以看出，直接对梯度的矩估计对内存没有额外的要求，而且可以根据梯度进行动态调整。最后一项前面部分是对学习率n形成的一个动态约束，而且有明确的范围。

torch.optim.Adam(
    params,
    lr=0.001,
    betas=(0.9, 0.999),
    eps=1e-08,
    weight_decay=0,
    amsgrad=False,
)
params(iterable)：可用于迭代优化的参数或者定义参数组的dicts。
lr (float, optional) ：学习率(默认: 1e-3)
betas (Tuple[float, float], optional)：用于计算梯度的平均和平方的系数(默认: (0.9, 0.999))
eps (float, optional)：为了提高数值稳定性而添加到分母的一个项(默认: 1e-8)
weight_decay (float, optional)：权重衰减(如L2惩罚)(默认: 0)

step(closure=None)函数：执行单一的优化步骤
closure (callable, optional)：用于重新评估模型并返回损失的一个闭包 

源码：

import math
from .optimizer import Optimizer

class Adam(Optimizer):
    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8，weight_decay=0):
        defaults = dict(lr=lr, betas=betas, eps=eps,weight_decay=weight_decay)
        super(Adam, self).__init__(params, defaults)

    def step(self, closure=None):
        loss = None
        if closure is not None:
            loss = closure()

        for group in self.param_groups:
            for p in group['params']:
                if p.grad is None:
                    continue
                grad = p.grad.data
                state = self.state[p]

                # State initialization
                if len(state) == 0:
                    state['step'] = 0
                    # Exponential moving average of gradient values
                    state['exp_avg'] = grad.new().resize_as_(grad).zero_()
                    # Exponential moving average of squared gradient values
                    state['exp_avg_sq'] = grad.new().resize_as_(grad).zero_()

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                beta1, beta2 = group['betas']

                state['step'] += 1

                if group['weight_decay'] != 0:
                    grad = grad.add(group['weight_decay'], p.data)

                # Decay the first and second moment running average coefficient
                exp_avg.mul_(beta1).add_(1 - beta1, grad)
                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)

                denom = exp_avg_sq.sqrt().add_(group['eps'])

                bias_correction1 = 1 - beta1 ** state['step']
                bias_correction2 = 1 - beta2 ** state['step']
                step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1

                p.data.addcdiv_(-step_size, exp_avg, denom)

        return loss

Adam的特点有：
1、结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点;
2、对内存需求较小;
3、为不同的参数计算不同的自适应学习率;
4、也适用于大多非凸优化-适用于大数据集和高维空间。

3、in-place操作

4、torch.no_grad()

这条语句的作用是：在测试时不进行梯度的计算，这样可以在测试时有效减小显存的占用，以免发生显存溢出（OOM）。

这条语句通常加在网络预测的那条代码上

with torch.no_grad： 
disables tracking of gradients in autograd.
model.eval()： 
changes the forward() behaviour of the module it is called upon. eg, it disables dropout and has batch norm use the entire population statistics

在使用pytorch时，并不是所有的操作都需要进行计算图的生成（计算过程的构建，以便梯度反向传播等操作）。使用 with torch.no_grad():，强制之后的内容不进行计算图构建。

5、model.train()

model.train() 让model变成训练模式，此时 dropout和batch normalization的操作在训练起到防止网络过拟合的问题。

6、model.eval()

model.eval()，pytorch会自动把BN和DropOut固定住，而用训练好的值。不然的话，一旦test的batch_size过小，很容易就会被BN层导致所生成图片颜色失真极大

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有batch normalization层所带来的的性质。

7、nn.CrossEntropyLoss()

交叉熵损失函数：交叉熵主要是用来判定实际的输出与期望的输出的接近程度

Pytorch中CrossEntropyLoss()函数的主要是将softmax-log-NLLLoss合并到一块得到的结果。