Pytorch学习之torch----索引、切片、连接、变异操作

1. torch.cat(seq, dim=0, out=None)

说明： 在给定维度上对输入的张量序列seq进行连接操作
参数：

• seq(Tensor的序列) – 可以是相同类型的Tensor的任何Python序列
• dim(int, 可选) – 张量连接的维度，按dim维度连接张量
• out(Tensor,可选) – 输出参数

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.2132,  0.5984,  0.7383],
        [ 1.0272, -0.7861, -0.1590]])
>>> torch.cat((x, x), 0)
tensor([[ 0.2132,  0.5984,  0.7383],
        [ 1.0272, -0.7861, -0.1590],
        [ 0.2132,  0.5984,  0.7383],
        [ 1.0272, -0.7861, -0.1590]])
>>> torch.cat((x, x), 1)
tensor([[ 0.2132,  0.5984,  0.7383,  0.2132,  0.5984,  0.7383],
        [ 1.0272, -0.7861, -0.1590,  1.0272, -0.7861, -0.1590]])

2. torch.chunk(tensor, chunks, dim)

说明： 在给定的维度上讲张量进行分块。
参数：

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

>>> x = torch.randn(3, 3)
>>> x
tensor([[ 1.0103,  2.3358, -1.9236],
        [-0.3890,  0.6594,  0.6664],
        [ 0.5240, -1.4193,  0.1681]])
>>> torch.chunk(x, 3, dim=0)
(tensor([[ 1.0103,  2.3358, -1.9236]]), tensor([[-0.3890,  0.6594,  0.6664]]), tensor([[ 0.5240, -1.4193,  0.1681]]))
>>> torch.chunk(x, 3, dim=1)
(tensor([[ 1.0103],
        [-0.3890],
        [ 0.5240]]), tensor([[ 2.3358],
        [ 0.6594],
        [-1.4193]]), tensor([[-1.9236],
        [ 0.6664],
        [ 0.1681]]))
>>> torch.chunk(x, 2, dim=1)
(tensor([[ 1.0103,  2.3358],
        [-0.3890,  0.6594],
        [ 0.5240, -1.4193]]), tensor([[-1.9236],
        [ 0.6664],
        [ 0.1681]]))

3. torch.gather(input, dim, index, out=None)

说明： 沿着给定维度，将输入索引张量index指定的位置的值重新聚合为一个新的张量。如果dim=1，那就是横向，index的索引代表列。dim=0那就是纵向，index索引代表的就是行值。
参数：

• input(Tensor) – 源张量
• dim(int) – 索引的维度
• index(LongTensor) – 聚合元素的下表
• out(Tensor,可选) – 目标张量

下面的例子中，维度为1.那么取横行的元素。所以在第一行的下标为[0, 0],因此，聚合后的元素都取1，第二行的下表为[1, 0],因此聚合后的元素去[4, 3]。

>>> t = torch.Tensor([[1, 2], [3, 4]])
>>> t
tensor([[1., 2.],
        [3., 4.]])
>>> index = torch.LongTensor([[0, 0], [1, 0]])
>>> index
tensor([[0, 0],
        [1, 0]])
>>> torch.gather(t, 1, index)
tensor([[1., 1.],
        [4., 3.]])

4. torch.index_select(input, dim, index, out=None)

说明：沿着指定维度对输入进行切片，取index中指定的相应项，返回一个新的张量，返回的张量与原始的张量有相同的维度。返回张量不与原始张量共享内存中的空间。
参数：

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

>>> x = torch.randn(3, 4)
>>> x
tensor([[-1.0190, -0.7541,  2.1090, -0.9576],
        [-1.4745,  0.1462, -2.2930, -0.9130],
        [ 0.7339, -2.0842, -0.9208, -0.5618]])
>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)
tensor([[-1.0190, -0.7541,  2.1090, -0.9576],
        [ 0.7339, -2.0842, -0.9208, -0.5618]])
>>> torch.index_select(x, 1, indices)
tensor([[-1.0190,  2.1090],
        [-1.4745, -2.2930],
        [ 0.7339, -0.9208]])

5. torch.masked_select(input, mask, out=None)

说明： 根据掩码张量mask中的二元值，取输入张量中指定项，将取值返回到一个新的1维张量。张量mask必须跟input张量有相同数量的元素数目，但形状或维度不需要相同。并且返回的张量不与原始张量共享内存空间。
参数：

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

>>> mask = torch.ByteTensor(x > 0)
>>> mask
tensor([[0, 0, 1, 1],
        [0, 0, 0, 1],
        [1, 1, 1, 1]], dtype=torch.uint8)
>>> torch.masked_select(x, mask)
tensor([0.1965, 0.4689, 0.2898, 0.4847, 2.8944, 0.7096, 0.0900])

6. torch.nonzero(input, out=None)

说明： 返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。如果输入input有n维，则输出的索引张量output的形状为z x n，这里z是输入张量input中所有非零元素的个数。
参数：

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

>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
tensor([[0],
        [1],
        [2],
        [4]])
>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0]]))
tensor([[0, 0],
        [1, 1]])

7. torch.split(tensor, split_size, dim=0)

说明： 将输入张量分割成相等形状的chunks(如果可分)。如果沿指定维的张量形状大小不能被整分，则最后一块会小于其他分块。
参数：

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

>>> x = torch.randn(3, 4)
>>> x
tensor([[ 0.1135,  0.5779, -0.9737, -0.0718],
        [ 0.4136,  1.1577,  0.5689, -0.1970],
        [ 1.4281,  0.3540,  1.4346, -0.1444]])
>>> torch.split(x, 2, 1)
(tensor([[0.1135, 0.5779],
        [0.4136, 1.1577],
        [1.4281, 0.3540]]), tensor([[-0.9737, -0.0718],
        [ 0.5689, -0.1970],
        [ 1.4346, -0.1444]]))
>>> torch.split(x, 2, 0)
(tensor([[ 0.1135,  0.5779, -0.9737, -0.0718],
        [ 0.4136,  1.1577,  0.5689, -0.1970]]), tensor([[ 1.4281,  0.3540,  1.4346, -0.1444]]))

8. torch.squeeze(input, dim=None, out=None)

说明：将输入张量形状中的1去除并返回。如果输入是形如(Ax1xBx1xCx1xD)，那么输入的形状就为：(AxBxCxD)。当给定维度时，那么挤压操作只在给定维度上。例如，输入形状为：(Ax1xB),squeeze(input,0)将会保持张量不变，只有用squeeze(input,1)，形状会变成(AxB)。注意返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
参数：

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

>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])

9. torch.stack(sequence, dim=0)

说明： 沿着一个新维度对输入张量序列进行连接。序列中所有的张量都应该为相同形状。
** 参数：**

• sequence(序列) – 待连接的张量序列
• dim(int) – 插入的维度，必须介于0与待连接的张量序列数之间

>>> a
tensor([[1., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]])
>>> b = torch.Tensor([[10, 20, 40],
...                   [30, 50, 60],
...                   [70, 80, 90]])
>>> b
tensor([[10., 20., 40.],
        [30., 50., 60.],
        [70., 80., 90.]])
>>> c = torch.Tensor([[100, 200, 300],
...                   [400, 500, 600],
...                   [700, 800, 900]])
>>> c
tensor([[100., 200., 300.],
        [400., 500., 600.],
        [700., 800., 900.]])
>>> torch.stack((a, b, c), dim=2)
tensor([[[  1.,  10., 100.],
         [  2.,  20., 200.],
         [  3.,  40., 300.]],

        [[  4.,  30., 400.],
         [  5.,  50., 500.],
         [  6.,  60., 600.]],

        [[  7.,  70., 700.],
         [  8.,  80., 800.],
         [  9.,  90., 900.]]])

10. torch.t(input, out=None)

说明：输入一个矩阵(2为张量)，并转置0,1维。可以被视为函数transpose(input, 0, 1)的简写函数。
参数：

• input(Tensor) – 输入张量
• out(Tensor, 可选) – 结果张量

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.9204,  0.7971, -1.8631],
        [-0.8583, -2.3379, -0.4079]])
>>> torch.t(x)
tensor([[ 0.9204, -0.8583],
        [ 0.7971, -2.3379],
        [-1.8631, -0.4079]])

11. torch.transpose(input, dim0, dim1, out=None)

说明： 返回输入矩阵input的转置。交换维度dim0和dim1.输出张量与输入张量共享内存，所以改变其中一个会导致另外一个也被修改。
参数：

• input(Tensor) – 输入张量
• dim0(int) – 转置的第一维
• dim1(int) – 转置的第二维

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.5434, -1.3860,  0.0252],
        [ 0.4734,  0.2466,  0.3052]])
>>> torch.transpose(x, 0, 1)
tensor([[ 0.5434,  0.4734],
        [-1.3860,  0.2466],
        [ 0.0252,  0.3052]])

12. torch.unbind(tensor, dim=0):

说明： 移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片。
参数：

• tensor(Tensor) – 输入张量
• dim(int) – 删除的维度

>>> x = torch.randn(3, 3)
>>> x
tensor([[ 0.4775,  0.0161, -0.9403],
        [ 1.6109,  2.1144,  1.1833],
        [-0.2656,  0.7772,  0.5989]])
>>> torch.unbind(x, dim=1)
(tensor([ 0.4775,  1.6109, -0.2656]), tensor([0.0161, 2.1144, 0.7772]), tensor([-0.9403,  1.1833,  0.5989]))

13. torch.unsqueeze(input, dim, out=None)

说明：返回一个新的张量，对输入的指定位置插入维度1.注意返回张量与输入张量共享内存，如果dim为负，则将会被转换为dim + input.dim() + 1.
参数：

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

>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[1., 2., 3., 4.]])
>>> torch.unsqueeze(x, 1)
tensor([[1.],
        [2.],
        [3.],
        [4.]])