二维的情况

先用二维tensor作为例子，方便理解。

permute作用为调换Tensor的维度，参数为调换的维度。例如对于一个二维Tensor来说，调用tensor.permute(1,0)意为将1轴（列轴）与0轴（行轴）调换，相当于进行转置。

In [20]: a              
Out[20]:                
tensor([[0, 1, 2],      
        [3, 4, 5]])     
                        
In [21]: a.permute(1,0) 
Out[21]:                
tensor([[0, 3],         
        [1, 4],         
        [2, 5]])        

如果使用view(3,2)或reshape(3,2)，得到的tensor并不是转置的效果，而是相当于将原tensor的元素按行取出，然后按行放入到新形状的tensor中。

In [22]: a.reshape(3,2) 
Out[22]:                
tensor([[0, 1],         
        [2, 3],         
        [4, 5]])        
                        
In [23]: a.view(3,2)    
Out[23]:                
tensor([[0, 1],         
        [2, 3],         
        [4, 5]])        

高维的情况

一般使用permute的情况都是在更高维的情况下使用，例如对于一个图像batch，其形状为[batch, channel, height, width]，我们可以使用tensor.permute(0,3,2,1)得到形状为[batch, width, height, channel]的tensor.

我们构造一个模拟的batch用于演示。

In [25]: a=torch.arange(2*3*2*1).reshape(2,3,2,1) 
                                                  
In [26]: a                                        
Out[26]:                                          
tensor([[[[ 0],              # 这是第0张“图片”的第0号通道的2个元素                     
          [ 1]],                                  
                                                  
         [[ 2],              # 这是第0张“图片”的第1号通道的2个元素                     
          [ 3]],                                  
                                                  
         [[ 4],              # 这是第0张“图片”的第2号通道的2个元素                     
          [ 5]]],                                 
                                                  
                                                  
        [[[ 6],                                   
          [ 7]],                                  
                                                  
         [[ 8],                                   
          [ 9]],                                  
                                                  
         [[10],                                   
          [11]]]])                                

a的形状为[2,3,2,1]，这个batch有2张“图片”，每张图片有3个通道，每个通道为2x1，例如第0张图片的第0号通道为[[0], [1]].

In [27]: a.permute(0,3,2,1)
Out[27]:
tensor([[[[ 0,  2,  4],
          [ 1,  3,  5]]],


        [[[ 6,  8, 10],
          [ 7,  9, 11]]]])
In [28]: a.permute(0,3,2,1).shape
Out[28]: torch.Size([2, 1, 2, 3])

形状为[2,3,2,1]的batch执行permute(0,3,2,1)交换维度之后，得到的是[2,1,2,3]，即[batch, width, height, channel]

可以理解为，对于一个高维的Tensor执行permute，我们没有改变数据的相对位置，而只是旋转了一下这个(超)立方体。或者也可以说，改变了我们对这个(超)立方体的“观察角度”而已。