pytorch tensor索引、切片、连接——Indexing, Slicing, Joining

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/LYKXHTP/article/details/81570564

#PyTorch索引,切片,连接,换位
Indexing, Slicing, Joining, Mutating Ops

##torch.cat
torch.cat(inputs, dimension=0) → Tensor
在给定维度上对输入的张量序列进行连接操作。
torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。

###参数：

• inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
• dimension (int, optional) – 沿着此维连接张量序列。

###例子：

x = torch.randn(2, 3)
x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

如果dim=0，表示的就是接下来的操作是对于第一维度进行的，也就是行(使行发生变化）；如果dim=1,那么它表示接下来的操作是对于第二维度进行的，也就是列（使列发生变化）。

##torch.chunk
torch.chunk(tensor, chunks, dim=0)
在给定维度(轴)上将输入张量进行分块儿。

###参数:

• tensor (Tensor) – 待分块的输入张量
• chunks (int) – 分块的个数
• dim (int) – 沿着此维度进行分块

##torch.gather
torch.gather(input, dim, index, out=None) → Tensor
沿给定轴dim，将输入索引张量index指定位置的值进行聚合。
对一个3维张量，输出可以定义为：

out[i][j][k] = tensor[index[i][j][k]][j][k]  # dim=0
out[i][j][k] = tensor[i][index[i][j][k]][k]  # dim=1
out[i][j][k] = tensor[i][j][index[i][j][k]]  # dim=3

###参数:

• input (Tensor) – 源张量
• dim (int) – 索引的轴
• index (LongTensor) – 聚合元素的下标
• out (Tensor, optional) – 目标张量

###例子：

>>> t = torch.Tensor([[1,2],[3,4]])
>>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
 1  1
 4  3
[torch.FloatTensor of size 2x2]
#解释：
input[[1, 2],      
      [3, 4]]  
index[[0, 0],      
      [1, 0]] 
dim = 1表示在第二维度（列）上操作,
输出的每行取原来Tensor的相应行的index所指列的元素。
例如：
输出的第0行第0列元素取原来Tensor的第0行第0列的值1，
输出的第0行第1列元素也是取原来Tensor的第0行第0列的值1，
输出的第1行第0列元素取原来Tensor的第1行第1列的值4，
输出的第1行第1列元素取原来Tensor的第1行第0列的值3。

 
  
  

import torch 
a = torch.Tensor([[1,2,3],[4,5,6]])
index_1 = torch.LongTensor([[0,1],[2,0]])
index_2 = torch.LongTensor([[0,1,1],[0,0,0]])
print(torch.gather(a, dim=1, index=index_1))
print(torch.gather(a, dim=0, index=index_2))

输出如下：        
tensor([[1., 2.],
        [6., 4.]])
解释：
input[[1., 2., 3.],
      [4., 5., 6.]]
index [[0,1],
       [2,0]]  
dim = 1表示在第二维度（列）上操作,  
输出的每行取原来Tensor的相应行的index所指列的元素。 
输出的第0行第0列元素取原来Tensor的第0行第0列的值1，
输出的第0行第1列元素也是取原来Tensor的第0行第1列的值2，
输出的第1行第0列元素取原来Tensor的第1行第2列的值6，
输出的第1行第1列元素取原来Tensor的第1行第0列的值4。

tensor([[1., 5., 6.],
        [1., 2., 3.]])
解释：
input[[1., 2., 3.],
      [4., 5., 6.]]
index [[0,1,1],
       [0,0,0]]
dim = 0表示在第一维度（行）上操作,  
输出的每列取原来Tensor的相应列的index所指行的元素。 
    
输出的第0列第0行元素取原来Tensor的第0列第0行的值1，
输出的第0列第1行元素取原来Tensor的第0列第0行的值1，

输出的第1列第0行元素取原来Tensor的第1列第1行的值5，
输出的第1列第1行元素取原来Tensor的第1列第0行的值2，

输出的第2列第0行元素取原来Tensor的第2列第1行的值6，
输出的第2列第1行元素取原来Tensor的第2列第0行的值3。

##torch.index_select
torch.index_select(input, dim, index, out=None) → Tensor
沿着指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回到一个新的张量， 返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。

注意： 返回的张量不与原始张量共享内存空间。

####参数:

• input (Tensor) – 输入张量
• dim (int) – 索引的轴
• index (LongTensor) – 包含索引下标的一维张量
• out (Tensor, optional) – 目标张量

####例子：

>>> x = torch.randn(3, 4)
>>> x

1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

indices = torch.LongTensor([0, 2])
torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

##torch.masked_select
torch.masked_select(input, mask, out=None) → Tensor
根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量，

张量 mask须跟input张量有相同数量的元素数目，但形状或维度不需要相同。 注意： 返回的张量不与原始张量共享内存空间。

###参数:

• input (Tensor) – 输入张量
• mask (ByteTensor) – 掩码张量，包含了二元索引值
• out (Tensor, optional) – 目标张量

###例子：

>>> x = torch.randn(3, 4)
>>> x

1.2045 2.4084 0.4001 1.1372
0.5596 1.5677 0.6219 -0.7954
1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> mask = x.ge(0.5)
>>> mask

1 1 0 1
1 1 1 0
1 0 0 0
[torch.ByteTensor of size 3x4]

>>> torch.masked_select(x, mask)

1.2045
2.4084
1.1372
0.5596
1.5677
0.6219
1.3635
[torch.FloatTensor of size 7]

##torch.nonzero
torch.nonzero(input, out=None) → LongTensor
返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

###参数:

• input (Tensor) – 源张量
• out (LongTensor, optional) – 包含索引值的结果张量

###例子：

>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))

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

>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
… [0.0, 0.4, 0.0, 0.0],
… [0.0, 0.0, 1.2, 0.0],
… [0.0, 0.0, 0.0,-0.4]]))

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

##torch.split
torch.split(tensor, split_size, dim=0)
将输入张量分割成相等形状的chunks（如果可分）。 如果沿指定维的张量形状大小不能被split_size 整分， 则最后一个分块会小于其它分块。

###参数:

• tensor (Tensor) – 待分割张量
• split_size (int) – 单个分块的形状大小
• dim (int) – 沿着此维进行分割

##torch.squeeze
torch.squeeze(input, dim=None, out=None)
将输入张量形状中的1 去除并返回。 如果输入是形如(A×1×B×1×C×1×D)，那么输出形状就为： (A×B×C×D)
当给定dim时，那么挤压操作只在给定维度上。例如，输入形状为: (A×1×B), squeeze(input, 0) 将会保持张量不变，只有用 squeeze(input, 1)，形状会变成 (A×B)。

注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

###参数:

• input (Tensor) – 输入张量
• dim (int, optional) – 如果给定，则input只会在给定维度挤压
• out (Tensor, optional) – 输出张量

###例子：

>>> x = torch.zeros(2,1,2,1,2)
>>> x.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x)
>>> y.size()
(2L, 2L, 2L)
>>> y = torch.squeeze(x, 0)
>>> y.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 1)
>>> y.size()
(2L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 3)
>>> y.size()
(2L, 1L, 2L, 2L)

 
  
  

##torch.unsqueeze
torch.unsqueeze(input, dim, out=None)
返回一个新的张量，对输入的指定位置插入维度 1

注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。如果dim为负，则将会被转化dim+input.dim()+1

###参数:

• tensor (Tensor) – 输入张量
• dim (int) – 插入维度的索引
• out (Tensor, optional) – 结果张量

###例子：

>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]

参考：https://blog.csdn.net/LYKXHTP/article/details/81570564

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/LYKXHTP/article/details/81570564

#PyTorch索引,切片,连接,换位
Indexing, Slicing, Joining, Mutating Ops

##torch.cat
torch.cat(inputs, dimension=0) → Tensor
在给定维度上对输入的张量序列进行连接操作。
torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。

###参数：

• inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
• dimension (int, optional) – 沿着此维连接张量序列。

###例子：