pytorch中一些常用方法的总结_pytorch中有什么方法

主要介绍一些pytorch框架常用的方法，这里torch环境实在torch0.3.1情况，请对号入座。。。

1、首先介绍我们学习pytorch的官方教程地址：http://pytorch.org/docs/master/index.html；还有一个中文文档:点击打开链接，0.4版本的官方文档：点击打开链接

2、我个人也是 pytorch 的初学者，我以一个初学者的身份来简单介绍torch的使用，pytorch是使用GPU和CPU优化的深度张量库，torch中最重要的一个数据类型就是Tensor(张量)，我们计算的时候用Tensor来计算，速度要快一点，如果在训练神经网络进行梯度运算的时候，一般都会用Varaible类型来计算。

常用的Tensor方法：

input:输入可以是Tensor向量，也可以输入单个值。output表示返回的结果，返回可以是向量也可以单个值。

1. torch.lerp(star, end, weight) : 返回结果是out= start+ (end-start) * weight
2. torch.rsqrt(input) : 返回平方根的倒数
3. torch.mean(input) : 返回平均值
4. torch.std(input) : 返回标准偏差
5. torch.prod(input) : 返回所有元素的乘积
6. torch.sum(input) : 返回所有元素的之和
7. torch.var(input) : 返回所有元素的方差
8. torch.tanh(input) ：返回元素双正切的结果
9. torch.equal(torch.Tensor(a), torch.Tensor(b)) ：两个张量进行比较，如果相等返回true，否则返回false
10. torch.ge(input,other,out=none) 、 torch.ge(torch.Tensor(a),torch.Tensor(b))    比较内容：

• ge: input>=other  也就是a>=b, 返回true，否则返回false
• gt: input> other    也就是a>b, 返回true，否则返回false
• lt: input<other 也就是a<b, 返回true，否则返回false

1. torch.max(input)： 返回输入元素的最大值
2. torch.min(input) ： 返回输入元素的最小值
3. element_size() ：返回单个元素的字节

>>>torch.FloatTensor.element_size()
>>>4
>>>torch.ByteTensor.element_size()
>>>1

pytorch 在神经网络常用的方法

1、expand(*size)

返回tensor的一个新视图，单个维度扩大为更大的尺寸。tensor也可以扩大为更高维，新增加的维度将附在前面。 扩大tensor不需要分配新内存，只是仅仅新建一个tensor的视图，其中通过将stride设为0，一维将会扩展位更高维。任何一个一维的在不分配新内存情况下可扩展为任意的数值。

2、index_add_(dim,  index,  tensor) → Tensor

按参数index中的索引数确定的顺序，将参数tensor中的元素加到原来的tensor中。参数tensor的尺寸必须严格地与原tensor匹配，否则会发生错误。参数： - dim(int)-索引index所指向的维度 - index(LongTensor)-需要从tensor中选取的指数 - tensor(Tensor)-含有相加元素的tensor

>>> x = torch.Tensor([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
>>> t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> index = torch.LongTensor([0, 2, 1]) #这里是把第2行和第3行进行对调
>>> x.index_add_(0, index, t)
>>> x
  2 3 4
  8 9 10
[torch.FloatTensor of size 3x3]

3、index_copy_(dim, index, tensor) → Tensor

按参数index中的索引数确定的顺序，将参数tensor中的元素复制到原来的tensor中。参数tensor的尺寸必须严格地与原tensor匹配，否则会发生错误。解释一下：index = torch.LongTensor([0,2,1]),这里是把第2行和第3行进行对调，所以得到上述结果。

4、norrow (demension , start, length)---> te

返回一个本tensor经过缩小后的tensor。维度dim缩小范围是start到start+length。原tensor与返回的tensor共享相同的底层内存。

>>>x = torch.Tensor([[1,2,3], [4,5,6], [7,8,9]])
>>>x.narrow(0,0,2)
1 2 3
4 5 6
[torch.FloatTensor of size 2x3]

>>>x.narrow(1,1,2)
2 3 5
6 8 9
[torch.FloatTensor of size 3x2]

 

4、permute(dims)，常用的维度转换方法

 

将tensor的维度换位      参数：dim(int)---换位顺序

>>>x = torch.randn(2,3,4)
>>>x.size()
torch.size([2,3,5])
>>>x.permute(2,0,1).size()
torch.size([5,2,3])

5、 repeat(*sizes)

沿着指定的维度重复tensor。不同与expand()，本函数复制的是tensor中的数据。

参数：*size(torch.size ot int...)-沿着每一维重复的次数

>>>x = torch.Tensor([1,2,3])
>>>x.repeat(4,2)
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
[torch.FloatTensor of size 4x6]

6、resize_(*size)

>>>x.repeat(4,2)
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
[torch.FloatTensor of size 4x6]

>>>x.repeat(4,2,1).size()
torch.Size([4,2,3])

7、resize_(*size)

将tensor的大小调整为指定的大小。如果元素个数比当前的内存大小大，就将底层存储大小调整为与新元素数目一致的大小。

如果元素个数比当前内存小，则底层存储不会被改变。原来tensor中被保存下来的元素将保持不变，但新内存将不会被初始化。

参数：sizes(torch.Size or int....)需要调整的大小

>>>x = torch.Tensor([[1,2], [3,4], [5,6]])
>>>x.resize_(2,2) #这两个2，分别表示两行两列，如果换成（1，3），则打印的结果是一个一行三列的向量
>>>x
12
34
[torch.FloatTensor of size 2x2]

8、storage_offset()---->int

以存储元素的个数的形式返回tensor在地城内存中的偏移量。

>>>x = torch.Tensor([1,2,3,4,5])
>>>x.storage_offset()
0
>>>x[3:].storage_offset()
3

9、unfold(dim, size, step)---->Tensor

返回一个Tensor，其中含有在dim维tianchong度上所有大小为size的分片。两个分片之间的步长为step。如果_sizedim_是dim维度的原始大小，则返回tensor

中的维度dim大小是_(sizesdim-size)/step+1_维度大小的附加维度将附加在返回的tensor中。

参数：_dim(int)--需要展开的维度--size(int)每一个分片需要展开的大小--step(int)-相邻分片之间的步长

10、torch.gather(input, dim, index)

说明一下： dim=1，表示按行索引，dim = 0,按列索引。举例说明一下

import torch
input = torch.LongTensor([[1,2],[3,4]])
print(input)
index = torch.LongTensor([[0,0],[1,0]])
res = torch.gather(input, 1, index)
print(res)

结果是：

 1  2
 3  4
[torch.LongTensor of size 2x2]
 1  1
 4  3
[torch.LongTensor of size 2x2]

按列索引：

 

import torch
input = torch.LongTensor([[1,2],[3,4]])
index = torch.LongTensor([[0,0],[1,0]])
res = torch.gather(input, 0, index)
print(res)

结果是：

 1  2
 3  4
[torch.LongTensor of size 2x2]
 1  2
 3  2
[torch.LongTensor of size 2x2]

另一个例子

index0 = torch.LongTensor([[0], [1]])
print(index0)
res = torch.gather(input, 1, index0)
print(res)

结果是：

 0
 1
[torch.LongTensor of size 2x1]
 1
 4
[torch.LongTensor of size 2x1]

11、torch.masked_select(input, mask)

说明一下这个方法的使用，input、mask这两个参数维度必须一致，我试过不同维度，但是都没有成功，姑且这么认为吧。mask必须是ByteTensor类型。

masked =torch.ByteTensor([[0,1,0,0],[0,0,0,1],[0,0,1,0]])
input = torch.LongTensor([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
res = torch.masked_select(input,masked)
print(res)

结果是：

 2
 8
 11
[torch.LongTensor of size 3]

12、target.masked_scatter_(mask, source)

说明：source是表示用来替换（改变）的值，而mask只有0,1；0表示不替换目标值（或者叫不改变）；1是表示要替换目标值。target是需要被替换（改变）的值 。特别说明一下，mask、source的维度一致，而且必须和target的行的维度一致。

source = torch.LongTensor([[5],[7]])
mask = torch.ByteTensor([[1],[0]])
target = torch.LongTensor([[1,2],[3,4]])
res = target.masked_scatter_(mask,source)
print(res)

结果是：

 5  7
 3  4
[torch.LongTensor of size 2x2]

source = torch.LongTensor([[5],[7]])
mask = torch.ByteTensor([[0],[0]]) ###改变索引值
target = torch.LongTensor([[1,2],[3,4]])
res = target.masked_scatter_(mask,source)
print(res)
 
 1  2
 3  4
[torch.LongTensor of size 2x2]

source = torch.LongTensor([[5],[7]])
mask = torch.ByteTensor([[0],[1]])  #####改变索引值
target = torch.LongTensor([[1,2],[3,4]])
res = target.masked_scatter_(mask,source)
print(res)
 
1  2
5  7
[torch.LongTensor of size 2x2]

 

上述的每个方法都参考过文章前面的两个链接，如果你想深入了解，转向链接。