PyTorch索引,切片,连接,换位Indexing, Slicing, Joining, Mutating Ops
#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]