深度学习

最新推荐文章于 2023-05-28 08:06:45 发布

sendoh24

最新推荐文章于 2023-05-28 08:06:45 发布

阅读量655

点赞数

文章标签： pytorch

本文链接：https://blog.csdn.net/weixin_41601540/article/details/114813471

版权

深度学习

Pytorch

1. torch.from_numpy()

把数组转换成张量，且二者共享内存，对张量进行修改比如重新赋值，那么原始数组也会相应发生改变。
返回的张量和ndarray共享同一内存。对张量的修改将反映在ndarray中，反之亦然。返回的张量是不能调整大小的。

示例：

 a = numpy.array([1, 2, 3])
 t = torch.from_numpy(a)

2. nn.MSELoss() 均方损失函数

一般loss 函数都有 size_average 和 reduce 两个布尔类型的参数。因为一般损失函数都是直接计算 batch 的数据，因此返回的 loss 结果都是维度为 (batch_size, ) 的向量。
如果 reduce = False，那么 size_average 参数失效，直接返回向量形式的 loss
如果 reduce = True，那么 loss 返回的是标量

3. loss.backward()

optimizer.zero_grad() 清空过往梯度；
loss.backward() 反向传播，计算当前梯度；
optimizer.step() 根据梯度更新网络参数

4. manual_seed()

使用原因： 需要生成随机数据的实验中，每次实验都需要生成数据。设置随机种子是为了确保每次生成固定的随机数，这就使得每次实验结果显示一致了，有利于实验的比较和改进。
为CPU中设置种子，生成随机数
torch.manual_seed(number)
为特定GPU设置种子，生成随机数
torch.cuda.manual_seed(number)
为所有GPU设置种子，生成随机数
torch.cuda.manual_seed_all()

5. torch.nn.Embedding

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False, _weight=None)
其为一个简单的存储固定大小的词典的嵌入向量的查找表，意思就是说，给一个编号，嵌入层就能返回这个编号对应的嵌入向量，嵌入向量反映了各个编号代表的符号之间的语义关系。注：其表示的为最大不同的词的数量，每次输入的可以小于这个数量
torch.nn.Embedding 模块可以看做一个字典，字典中每个索引对应一个词和词的embedding形式。利用这个模块，可以给词做embedding的初始化操作。
模块中主要参数：
- num_embeddings ：字典中词的个数
- embedding_dim：embedding的维度
- padding_idx（索引指定填充）：如果给定，则遇到padding_idx中的索引，则将其位置填0（0是默认值）。
大小说明：
- input：(∗) , LongTensor 结构
- output：(*,e)：*是input的大小，e是embedding_dim，即每个词的embedding的维度
  注：embeddings中的值是正态分布N(0,1)中随机取值。

示例：

import torch
import torch.nn as nn
x = torch.LongTensor([[1,2,4],[4,3,2]])
embeddings = nn.Embedding(5,5,padding_idx=4) #5个词,每个词也是5维
print(embeddings(x))
print(embeddings(x).size())
 
 
output:
tensor([[[ 0.8839, -1.2889,  0.0697, -0.9998, -0.7471],
         [-0.5681,  0.8486,  0.8176,  0.8349,  0.1719],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000]],  ->index=4 赋值 0
 
        [[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],   ->index=4 赋值 0
         [ 1.4224,  0.2333,  1.9383, -0.7320,  0.9987],
         [-0.5681,  0.8486,  0.8176,  0.8349,  0.1719]]],
       grad_fn=<EmbeddingBackward>)
torch.Size([2, 3, 5])

embedding方法获取的向量只是随机初始化的，并不代表任何含义，并且不会有word2vec等训练出来的效果。但是可以利用这样的方法先赋值然后在学习。
总结一下一般任务中的流程：
- 首先将单词转成字典的形式，由于英语中以空格为词的分割，所以可以直接建立词典索引结构。类似于：dic={‘i’:1,‘like’:2,‘you’:3,‘want’:4,‘an’:5,‘apple’:6}这样的形式。如果是中文的话，首先进行分词操作。
- 然后在以句子为list，为每个句子建立索引结构，list[[sentence1],[sentence2]]。以上面字典的索引来说，最终建立的就是[[1,2,3],[1,4,5,6]]。这样长短不一的句子。
- 接下来要进行padding的操作。由于tensor结构中都是等长的，所以要对上面那样的句子做padding操作后再利用nn.Embedding来进行词的初始化。padding后的可能是这样的结构[[1,2,3,0],[1,4,5,6]]。其中0作为填充。（注意：由于在NMT任务中肯定存在着填充问题，所以在embedding时一定存在着第三个参数，让某些索引为下的值为0，代表无实际意义的填充）
输入为一个编号列表，输出为对应的符号嵌入向量列表。

6. torch.nn.LSTM()

输入的参数列表包括:

input_size 输入数据的特征维数，通常就是embedding_dim(词向量的维度)
hidden_size　LSTM中隐层的维度
num_layers　循环神经网络的层数
bias　用不用偏置，default=True
batch_first 这个要注意，通常我们输入的数据shape(batch_size,seq_length,embedding_dim),而batch_first默认是False,所以我们的输入数据最好送进LSTM之前将batch_size与seq_length这两个维度调换
dropout　默认是0，代表不用dropout bidirectional默认是false，代表不用双向LSTM
输入数据包括input,(h_0,c_0):

input就是shape==(seq_length,batch_size,input_size)的张量
h_0 的shape==(num_layers*num_directions,batch,hidden_size)的张量，它包含了在当前这个batch_size中每个句子的初始隐藏状态，num_layers就是LSTM的层数，如果bidirectional=True,num_directions=2,否则就是１，表示只有一个方向，
c_0和h_0的形状相同，它包含的是在当前这个batch_size中的每个句子的初始细胞状态。h_0,c_0如果不提供，那么默认是０
输出数据包括output,(h_n,c_n):

output的shape==(seq_length,batch_size,num_directions*hidden_size),
它包含的LSTM的最后一层的输出特征(h_t),ｔ是batch_size中每个句子的长度.
h_n.shape==(num_directions * num_layers,batch,hidden_size)
c_n.shape==h_n.shape
h_n包含的是句子的最后一个单词的隐藏状态，c_n包含的是句子的最后一个单词的细胞状态，所以它们都与句子的长度seq_length无关。

output[-1]与h_n是相等的，因为output[-1]包含的正是batch_size个句子中每一个句子的最后一个单词的隐藏状态，注意LSTM中的隐藏状态其实就是输出，cellstate细胞状态才是LSTM中一直隐藏的，记录着信息

7. nn.Linear()

**PyTorch的nn.Linear（）是用于设置网络中的全连接层的，**需要注意的是全连接层的输入与输出都是二维张量，一般形状为[batch_size, size]，不同于卷积层要求输入输出是四维张量。其用法与形参说明如下

8. nn.parameter()

首先可以把这个函数理解为类型转换函数，将一个不可训练的类型Tensor转换成可以训练的类型parameter并将这个parameter绑定到这个module里面(net.parameter()中就有这个绑定的parameter，所以在参数优化的时候可以进行优化的)，所以经过类型转换这个self.v变成了模型的一部分，成为了模型中根据训练可以改动的参数了。使用这个函数的目的也是想让某些变量在学习的过程中不断的修改其值以达到最优化。
示例：transitions = nn.Parameter(torch.randn(12, 12))初始化一个12*12的标准正态分布的随机数的可训练的张量。

9. torch.randn()

标准正态分布 :torch.randn(*sizes, out=None) → Tensor
返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取的一组随机数。张量的形状由参数sizes定义。

10. optim.SGD()

示例：
- optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
- optimizer = optim.Adam([var1, var2], lr = 0.0001)
- model.parameters()是获取model网络的参数，构建好神经网络后，网络的参数都保存在parameters()函数当中。
SGD 详解
class torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)[source]
参数说明：
- params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
- lr (float) – 学习率
- momentum (float, 可选) – 动量因子（默认：0）
- weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认：0）
- dampening (float, 可选) – 动量的抑制因子（默认：0）
- nesterov (bool, 可选) – 使用Nesterov动量（默认：False）
learning rate
学习率较小时，收敛到极值的速度较慢。
学习率较大时，容易在搜索过程中发生震荡。
weight decay
为了有效限制模型中的自由参数数量以避免过度拟合，可以调整成本函数。
一个简单的方法是通过在权重上引入零均值高斯先验值，这相当于将代价函数改变为 $E 〜（ w ） = E （ w ） + λ 2 w 2$ 。
在实践中，这会惩罚较大的权重，并有效地限制模型中的自由度。
正则化参数λ决定了如何将原始成本E与大权重惩罚进行折衷。
learning rate decay
- decay越小，学习率衰减地越慢，当decay = 0时，学习率保持不变。
- decay越大，学习率衰减地越快，当decay = 1时，学习率衰减最快。
momentum
- “冲量”这个概念源自于物理中的力学，表示力对时间的积累效应。
- 当本次梯度下降- dx * lr的方向与上次更新量v的方向相同时，上次的更新量能够对本次的搜索起到一个正向加速的作用。
- 当本次梯度下降- dx * lr的方向与上次更新量v的方向相反时，上次的更新量能够对本次的搜索起到一个减速的作用。

11. optimizer.step()

所有的optimizer都实现了step()方法，这个方法会更新所有的参数。
optimizer.step()

12. with torch.no_grad()

在使用pytorch时，并不是所有的操作都需要进行计算图的生成（计算过程的构建，以便梯度反向传播等操作）。而对于tensor的计算操作，默认是要进行计算图的构建的，在这种情况下，可以使用 with torch.no_grad():，强制之后的内容不进行计算图构建。
数据不需要计算梯度，也不会进行反向传播
torch.no_grad()是新版本pytorch中volatile的替代）

13. torch.tensor()

用于生成张量
torch.tensor(data, dtype=None, device=None, requires_grad=False)
参数
- 其中data可以是：list, tuple, array, scalar等类型。
- torch.tensor()可以从data中的数据部分做拷贝（而不是直接引用），根据原始数据类型生成相应的torch.LongTensor，torch.FloatTensor，torch.DoubleTensor。也可以使用dtype指定数据类型

14. zero_grad()

对模型参数的梯度置0
model.zero_grad()
model.zero_grad()的作用是将所有模型参数的梯度置为0
optimizer.zero_grad()
optimizer.zero_grad()的作用是清除所有优化的torch.Tensor的梯度。
总结
- 当使用optimizer = optim.Optimizer(net.parameters())设置优化器时，此时优化器中的param_groups等于模型中的parameters()，此时，二者是等效的，从二者的源码中也可以看出来。
- 当多个模型使用同一个优化器时，二者是不同的，此时需要根据实际情况选择梯度的清除方式。
- 当一个模型使用多个优化器时，二者是不同的，此时需要根据实际情况选择梯度的清除方式。

15. torch.max()

torch.max(Tensor,dim)
简单来说是返回一个tensor中的最大值。
这个函数的参数中还有一个dim参数，使用方法为re = torch.max(Tensor,dim),返回的re为一个二维向量，其中re[0]为最大值的Tensor，re[1]为最大值对应的index的Tensor。

示例：

si=torch.randn(4,5)
print(si)
>>>tensor([[ 1.1659, -1.5195, 0.0455, 1.7610, -0.2064],
    [-0.3443, 2.0483, 0.6303, 0.9475, 0.4364],
    [-1.5268, -1.0833, 1.6847, 0.0145, -0.2088],
    [-0.8681, 0.1516, -0.7764, 0.8244, -1.2194]])
print(torch.max(si))
>>>tensor(2.0483)
print(torch.max(si,0)[1])
>>> tensor([0, 0, 0, 0, 2])
print(torch.max(si,0)[0])
>>> tensor([1.1659, 2.0483, 1.6847, 1.7610, 0.4364])

注意：Tensor的维度从0开始算起。在torch.max()中指定了dim之后，比如对于一个3x4x5的Tensor，指定dim为0后，得到的结果是维度为0的“每一行”对应位置求最大的那个值，此时输出的Tensor的维度是4x5.
对于简单的二维Tensor，如上面例子的这个4x5的Tensor。指定dim为0，则给出的结果是4行做比较之后的最大值；如果指定dim为1，则给出的结果是5列做比较之后的最大值，且此处做比较时是按照位置分别做比较，得到一个新的Tensor。

16. tensor.view()

把tensor 进行reshape的操作

示例：

>>> si=torch.randn(4,5)
>>> print(si)
tensor([[ 1.1659, -1.5195, 0.0455, 1.7610, -0.2064],
    [-0.3443, 2.0483, 0.6303, 0.9475, 0.4364],
    [-1.5268, -1.0833, 1.6847, 0.0145, -0.2088],
    [-0.8681, 0.1516, -0.7764, 0.8244, -1.2194]])
 
>>> print(torch.max(si))
tensor(2.0483)

其中参数-1表示剩下的值的个数一起构成一个维度。如上例中，第一个参数1将第一个维度的大小设定成1，后一个-1就是说第二个维度的大小=元素总数目/第一个维度的大小，此例中为345*7/1=420.

17. torch.full()

功能: torch.full()返回一个大小为fill_value的张量的张量。
用法: torch.full(size, fill_value, out=None)
参数：
- size：定义输出张量形状的整数序列
  -fill_value：用于填充输出张量的数字。
- out (Tensor, optional)：输出张量
返回类型：张量

示例：

a = torch.full([3, 4], 3) 
print("a = ", a) 
>>> a =  tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])

18. expand函数

tensor.expend()函数
其将单个维度扩大成更大维度，返回一个新的tensor
expand()函数括号里面为变形后的size大小，而且原来的tensor和tensor.expand()是不共享内存的。

示例：

>>> import torch
>>> a=torch.tensor([[2],[3],[4]])
>>> print(a.size())
torch.Size([3, 1])
>>> a.expand(3,2)
tensor([[2, 2],
        [3, 3],
        [4, 4]])
>>> a
tensor([[2],
        [3],
        [4]])

19. loss.backward

loss.backward()这个函数很简单，就是计算与图中叶子结点有关的当前张量的梯度
反向传播，计算当前梯度；

20. optimizer.step()

optimizer.step()通常用在每个mini-batch之中，而scheduler.step()通常用在epoch里面,但是不绝对，可以根据具体的需求来做。只有用了optimizer.step()，模型才会更新，而scheduler.step()是对lr进行调整。
所有的optimizer都实现了step()方法，这个方法会更新所有的参数。
optimizer.step()

30. squeeze 与unsqueeze

torch.squeeze(input, dim=None, out=None)
- 当不给定dim时，将输入张量形状中的1 去除并返回。
- 当给定dim时，那么挤压操作只在给定维度上。即若tensor.size(dim) = 1，则去掉该维度
- 参数：
  
  input (Tensor) – 输入张量
  dim (int, optional) – 如果给定，则input只会在给定维度挤压，维度的索引（从0开始）
  out (Tensor, optional) – 输出张量
- 注：其中的dim为维度为维度位置，可以从0开始，也可以从负数开始。
torch.unsqueeze(input, dim, out=None)
- 返回一个新的张量，对输入的指定位置插入维度 1
- 注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
- 如果dim为负，则将会被转化dim+input.dim()+1dim+input.dim()+1
- 参数:
  
  tensor (Tensor) – 输入张量
  dim (int) – 插入维度的索引（从0开始）
  out (Tensor, optional) – 结果张量