torch函数记录

•  torch.multinomial函数

torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

作用是对input的每一行做n_samples次取值，输出的张量是每一次取值时input张量对应行的下标。

输入是一个input张量，一个取样数量，和一个布尔值replacement。

input张量可以看成一个权重张量，每一个元素代表其在该行中的权重。如果有元素为0，那么在其他不为0的元素

被取干净之前，这个元素是不会被取到的。

n_samples是每一行的取值次数，该值不能大于每一样的元素数，否则会报错。

replacement指的是取样时是否是有放回的取样，True是有放回，False无放回。

看官方给的例子：
>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
>>> torch.multinomial(weights, 4)
 
 1
 2
 0
 0
[torch.LongTensor of size 4]
 
>>> torch.multinomial(weights, 4, replacement=True)
 
 1
 2
 1
 2
[torch.LongTensor of size 4]
输入是[0,10,3,0]，也就是说第0个元素和第3个元素权重都是0，在其他元素被取完之前是不会被取到的。

所以第一个multinomial取4次，可以试试重复运行这条命令，发现只会有2种结果：[1 2 0 0]以及[2 1 0 0]，以[1 2 0 0]这种情况居多。这其实很好理解，第1个元素权重比第2个元素权重要大，所以先取第1个元素的概率就会大。在第1和2个元素取完之后，剩下了2个没有权重的元素，它们才会被取到。但实际上权重为0的元素被取到时也不会显示正确的下标，关于0的下标问题我还没有想到很合理的解释，先行略过。

而第二个multinomial取4次，发现就只会出现1和2这两个元素了。这是因为replacement为真，所以有放回，就永远也不会取到权重为0的元素了。

再试试输入二维张量，则返回的也会成为一个二维张量，行数为输入的行数，列数为n_samples，即每一行都取了n_samples次，取法和一维张量相同。

• torch.topk函数

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

沿给定dim维度返回输入张量input中 k 个最大值。
如果不指定dim，则默认为input的最后一维。
如果为largest为 False ，则返回最小的 k 个值。

返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。
如果设定布尔值sorted 为True，将会确保返回的 k 个值被排序。

参数:
input (Tensor) – 输入张量
k (int) – “top-k”中的k
dim (int, optional) – 排序的维
largest (bool, optional) – 布尔值，控制返回最大或最小值
sorted (bool, optional) – 布尔值，控制返回值是否排序
out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffer

• torch.masked_fill函数

mask必须是一个 ByteTensor 而且shape的最大维度必须和 a一样 并且元素只能是 0或者1 ，
是将 mask中为1的 元素所在的索引，在a中相同的的索引处替换为 value

import torch
a=torch.tensor([[[5,5,5,5], [6,6,6,6], [7,7,7,7]], [[1,1,1,1],[2,2,2,2],[3,3,3,3]]])
print(a)
print(a.size())
print("#############################################3")
mask = torch.ByteTensor([[[1],[1],[0]],[[0],[1],[1]]])
print(mask.size())
b = a.masked_fill(mask, value=torch.tensor(-1e9))
print(b)
print(b.size())

#输出
tensor([[[5, 5, 5, 5],
         [6, 6, 6, 6],
         [7, 7, 7, 7]],

        [[1, 1, 1, 1],
         [2, 2, 2, 2],
         [3, 3, 3, 3]]])
torch.Size([2, 3, 4])
#############################################3
torch.Size([2, 3, 1])
tensor([[[-1000000000, -1000000000, -1000000000, -1000000000],
         [-1000000000, -1000000000, -1000000000, -1000000000],
         [          7,           7,           7,           7]],

        [[          1,           1,           1,           1],
         [-1000000000, -1000000000, -1000000000, -1000000000],
         [-1000000000, -1000000000, -1000000000, -1000000000]]])
torch.Size([2, 3, 4])

• torch.gather

import torch

tensor_0 = torch.arange(3, 12).view(3, 3)

print(tensor_0)
tensor([[ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])


index = torch.tensor([[2, 1, 0]])
tensor_1 = tensor_0.gather(0, index)

print(tensor_1)
tensor([[9, 7, 5]])

•  torch.max

  torch.max(input) → Tensor 返回输入tensor中所有元素的最大值
  a = torch.randn(1, 3)
  >>0.4729 -0.2266 -0.2085
  torch.max(a) #也可以写成a.max()
  >>0.4729
  
  torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)按维度dim 返回最大值，并且返回索引。
  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
  , 
   2
   2
   0
  )