前言

pytorch 常用函数总结

一、detach方法

• 用来复制变量的
  
  
  detach解析参考连接
  

二、cat方法

• 用来合并变量的
  
  
  cat方法解析
  

三、stack方法

• 用来合并变量的
  
  
  stack方法和cat方法的区别
  

四、camp方法

• 用来将数据归并到指定区间的
  
  
  camp方法参考连接
  

五、full方法

• full 用指定的数据来填充指定大小的数组

import torch
a = torch.full((5,1),6)
print(a)
tensor([[6],
        [6],
        [6],
        [6],
        [6]])
import torch
a = torch.full((5,),6)
print(a)
tensor([6, 6, 6, 6, 6])

六、 expand、 expand_as方法

• 可以延展矩阵，在某一个方向上重复矩阵

import torch
x = torch.tensor([[1], [2], [3]])
print('xsize:',x.size())
print('x:',x)
 
x_expand=x.expand(3,4)
print('x_expand:',x_expand)
 
x_expand=x.expand(-1,4)  # -1 means not changing the size of that dimension
print('x_expand:',x_expand)
 
x_expand_as=x.expand_as(x_expand)
print('x_expand_as:',x_expand_as)
xsize: torch.Size([3, 1])
x: tensor([[1],
        [2],
        [3]])
x_expand: tensor([[1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3]])
x_expand: tensor([[1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3]])
x_expand_as: tensor([[1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3]])

七、torch.chunk（）函数

• torch.cat()函数是把各个tensor连接起来，这里的torch.chunk（）的作用是把一个tensor均匀分割成若干个小tensor
  
  源码定义:torch.chunk(intput,chunks,dim=0)
  
  就是可以把一个矩阵按行或者列分割

第一个参数input是你想要分割的tensor
第二个参数chunks是你想均匀分割的份数，如果该tensor在你要进行分割的维度上的size不能被chunks整除，则最后一份会略小（也可能为空）
第三个参数表示分割维度，dim=0按行分割，dim=1表示按列分割
该函数返回由小tensor组成的list
c=torch.tensor([[1,4,7,9,11],[2,5,8,9,13]])
print(torch.chunk(c,3,1))
#输出结果为：
(tensor([[1, 4],
        [2, 5]]), tensor([[7, 9],
        [8, 9]]), tensor([[11],
        [13]]))

八、torch.split()函数

• 这个函数可以说是torch.chunk（）函数的升级版本，它不仅可以按份数均匀分割，还可以按特定方案进行分割。
  
  源码定义：torch.split(tensor,split_size_or_sections,dim=0)

第一个参数是待分割张量
第二个参数有两种形式。
一种是分割份数，这就和torch.chunk（）一样了。
第二种这是分割方案，这是一个list，待分割张量将会分割为len（list）份，每一份的大小取决于list中的元素
第三个参数为分割维度
section=[1,2,1,2,2]
d=torch.randn(8,4)
print(torch.split(d,section,dim=0))
#输出结果为：
(tensor([[ 0.5388, -0.8537,  0.5539,  0.7793]]), tensor([[ 0.1270,  2.6241, -0.7594,  0.4644],
        [ 0.8160,  0.5553,  0.1234, -1.1157]]), tensor([[-0.4433, -0.3093, -2.0134, -0.4277]]), tensor([[-0.4297,  0.2532,  0.2789, -0.3068],
        [ 1.4208, -0.1202,  0.9256, -1.2127]]), tensor([[ 0.3542, -0.4656,  1.2683,  0.8753],
        [-0.2786, -0.2180,  0.3991,  0.5658]]))

九、topk

• 根据Pytorch中的手册可以看到，topk()方法用于返回输入数据中特定维度上的前k个最大的元素。

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

参数说明：
input -> 输入tensor
k -> 前k个
dim -> 默认为输入tensor的最后一个维度
sorted -> 是否排序
largest -> False表示返回第k个最小值

>>> x = torch.arange(1., 6.)
>>> x
tensor([1.,2.,3.,4.,5.])
>>> torch.topk(x, 3)
tensor([5.,4.,3.]), indices=tensor([4,3,2])

十、numel

• 获取tensor中一共包含多少个元素

import torch
x = torch.randn(3,3)
print("number elements of x is ",x.numel())
y = torch.randn(3,10,5)
print("number elements of y is ",y.numel())
 
输出：
number elements of x is  9
number elements of y is  150

十一、max

• 获取tensor的最大值，按行或者列获取并返回索引

实际上pytorch官方文档中的应该是torch.max(input)方法，而本文要讲的可能严格意义上不是torch中的，而是针对torch中的张量方法，即input.max(axis)[index]。
其中input表示要求取最大值的张量，axis可以为0(表示求取每列的最大值)，也可以为1(每行的最大值)。index为0表示只返回最大值本身，为1表示只返回最大值对应的索引。如下，其中axis可以省去：
a = torch.randn(3,3)
>>
0.2252 -0.0901  0.5663
-0.4694  0.8073  1.3596
 0.1073 -0.7757 -0.8649
 
torch.max(a,1)
>>
(
 0.5663
 1.3596
 0.1073
[torch.FloatTensor of size 3]
, 
 2
 2
 0
[torch.LongTensor of size 3]
)

十二、索引True,False过滤赋值

• True,False过滤赋值

import torch
section=[True,False]
d=torch.randn(2,)
A = d[section]
d[section]=1
print(d)
print(A)
tensor([ 1.0000, -0.6506])
tensor([0.2636])

十三、 torch.nonzero

• 也就是说torch.nonezero()的作用就是找到tensor中所有不为0的索引。（要注意返回值的size）

import torch
a=torch.randint(-1,2,(10,),dtype=torch.int)
print(a)
print(a.size())
print(torch.nonzero(a))
print(torch.nonzero(a).size())

tensor([ 0, -1,  1,  1, -1,  0,  1, -1, -1, -1], dtype=torch.int32)
torch.Size([10])
tensor([[1],
        [2],
        [3],
        [4],
        [6],
        [7],
        [8],
        [9]])
torch.Size([8, 1])

十四、squeeze

• squeeze的用法主要就是对数据的维度进行压缩或者解压。
  
  先看torch.squeeze() 这个函数主要对数据的维度进行压缩，去掉维数为1的的维度，比如是一行或者一列这种，一个一行三列（1,3）的数去掉第一个维数为一的维度之后就变成（3）行。squeeze(a)就是将a中所有为1的维度删掉。不为1的维度没有影响。a.squeeze(N) 就是去掉a中指定的维数为一的维度。还有一种形式就是b=torch.squeeze(a，N) a中去掉指定的定的维数为一的维度。再看torch.unsqueeze()这个函数主要是对数据维度进行扩充。给指定位置加上维数为一的维度，比如原本有个三行的数据（3），在0的位置加了一维就变成一行三列（1,3）。a.squeeze(N) 就是在a中指定位置N加上一个维数为1的维度。还有一种形式就是b=torch.squeeze(a，N) a就是在a中指定位置N加上一个维数为1的维度

a=torch.randn(1,1,3)
print(a.shape)
b=torch.squeeze(a)
print(b.shape)
c=torch.squeeze(a,0)
print(c.shape)
d=torch.squeeze(a,1)
print(d.shape)
e=torch.squeeze(a,2)#如果去掉第三维，则数不够放了，所以直接保留
print(e.shape)

torch.Size([1, 1, 3])
torch.Size([3])
torch.Size([1, 3])
torch.Size([1, 3])
torch.Size([1, 1, 3])

a=torch.randn(1,3)
print(a.shape)
b=torch.unsqueeze(a,0)
print(b.shape)
c=torch.unsqueeze(a,1)
print(c.shape)
d=torch.unsqueeze(a,2)
print(d.shape)

torch.Size([1, 3])
torch.Size([1, 1, 3])
torch.Size([1, 1, 3])
torch.Size([1, 3, 1])

十五 torch.randperm

• 生成指定范围内容的随机数字

>>> torch.randperm(10)
tensor([4, 9, 7, 3, 8, 1, 0, 2, 5, 6])
>>> 
>>> torch.randperm(10)
tensor([8, 7, 1, 0, 4, 2, 3, 6, 5, 9])
>>> 
>>> torch.randperm(10)
tensor([9, 1, 8, 6, 3, 4, 7, 2, 0, 5])
>>> 
>>> torch.randperm(10)
tensor([2, 1, 6, 3, 4, 8, 0, 5, 9, 7])

十六、随机矩阵

• 产生指定范围内的随机矩阵

 torch.randint（low = 0，high，size，*，generator = None，out = None，dtype = None，layout = torch.strided，device = None，require_grad = False ） →张量



>>> torch.randint(10, (2, 2))
tensor([[0, 2],
        [5, 5]])


>>> torch.randint(3, 10, (2, 2))
tensor([[4, 5],
        [6, 7]])

十七、contiguous()

• 使用contiguous() 如果想要断开这两个变量之间的依赖（x本身是contiguous的），就要使用contiguous()针对x进行变化，感觉上就是我们认为的深拷贝。 当调用contiguous()时，会强制拷贝一份tensor，让它的布局和从头创建的一模一样，但是两个tensor完全没有联系。

十八、view和shape的区别

• 区别
  • 存储
    
    view:返回具有新形状的张量。返回的张量将与原始张量共享基础数据。reshape: torch.reshape可能返回原始张量的副本或视图->不确定的
  • 要求
    
    reshape（）可以在连续和非连续的张量上运行，而view（）只能在连续的张量上运行。

十九、torch.nn.Parameter

• torch.nn.Parameter(torch.FloatTensor(hidden_size)),看了官方教程里面的解释也是云里雾里，于是在栈溢网看到了一篇解释，并做了几个实验才算完全理解了这个函数。首先可以把这个函数理解为类型转换函数，将一个不可训练的类型Tensor转换成可以训练的类型parameter并将这个parameter绑定到这个module里面(net.parameter()中就有这个绑定的parameter，所以在参数优化的时候可以进行优化的)，所以经过类型转换这个self.v变成了模型的一部分，成为了模型中根据训练可以改动的参数了。使用这个函数的目的也是想让某些变量在学习的过程中不断的修改其值以达到最优化。