day3 索引，切片，连接，换位入门 一起学 PyTorch吧，PyTorch从入门开始 每天都更新 超详细 参数 常用方法 简单案列 共同学习，共同进步 坚持

索引，切片，连接，换位

torch . cat(inputs, dimension =0 ) --> Tensor 在给定维度上对输入的张量序列进行连接操作。torch.cat()可以看做torch.split()和torch.chunk()的反操作。cat()函数可以通过下面例子更好的理解。

参数：

        --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]

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

参数：

        --tensor(Tensor):将分块的输入张量

        --chunks(int):分块的个数

        --dim(int):沿着此维度进行分块

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

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

例子：

>>> 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(Tensor):源张量

        --dim(int):索引的轴

        --index(LongTensor)：聚合元素的下标

        --out(Tensor,optional):目标张量

torch . index_select( input , dim, index, out = None ) -->Tensor，然后返回到一个新的张量，返回的张量与原始张量_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 . nonzero( input , out = None ) --> LongTensor 返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

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

参数：

        --input(Tensro)：源张量

        --out(LongTensor,optional)：包含索引值的结果张量

例子：

>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
0124[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(tensor, split_size, dim =0 ) 将输入张量分割成相等形状的chunks（如果可分）。如果沿指定维的张量形状大小不能被split_size整分,则最后一个分块会小于其他分块。

参数：

        --tensor(Tensor):待分割张量

        --split_size(int):单个分块的形状大小

        --dim(int):沿着此维进行分割

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

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

参数：

        --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)

torch . stack(sequence, dim =0 )，沿着一个新维度对输入张量序列进行连接。序列中所有的张量都应该为相同形状。

参数：

        --seqequence(Sequence):待连接的张量序列。

        --dim(int):插入的维度。必须介于0与待连接的张量序列数之间。

torch . t( input , out = None ) --> Tensor 输入一个矩阵（2维张量），并转置0,1维。可以被视为函数transpose(input,0,1)的简写函数。

参数：

        --input(Tensor):输入张量

        --out(Tensor,optional):结果张量

   例子：

>>> x = torch.randn(2, 3)
>>> x
0.4834 0.6907 1.3417
-0.1300 0.5295 0.2321
[torch.FloatTensor of size 2x3]
>>> torch.t(x)
0.4834 -0.1300
0.6907 0.5295
1.3417 0.2321
[torch.FloatTensor of size 3x2]

torch.transpose ( input, dim0, dim1, out = None ) -->Tensor返回输入矩阵input的转置。交换维度dim0和dim1.输出张量与输入张量共享内存，所以改变其中一个会导致另外一个也被修改。

参数：

        --input(Tensor):输入张量

        --dim0(int):转置的第一维

        --dim1(int):转置的第二维

例子：

>>> x = torch.randn(2, 3)
>>> x
0.5983 -0.0341 2.4918
1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]
>>> torch.transpose(x, 0, 1)
0.5983 1.5981
-0.0341 -0.5265
2.4918 -0.8735
[torch.FloatTensor of size 3x2]

torch . unbind(tensor, dim =0 ) 移除指定维后，返回一个元祖，包含了沿着指定维切片后的各个切片。

参数：

        --tensor(Tensor):输入张量

        --dim(int):删除的维度

例子：

>>> torch.unbind(torch.tensor([[1, 2, 3],
>>> [4, 5, 6],
>>> [7, 8, 9]]))
(tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9]))

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]