permute函数：可以同时多次交换tensor的维度
示例：b = a.permute(0,2 ,1) 将a的维度索引1和维度索引2交换位置

1 先看看官方中英文doc：
  torch.Tensor.permute (Python method, in torch.Tensor)
1.1 permute(dims)
将tensor的维度换位。
参数： - __dims__ (int ..*)  - 换位顺序
例：
>>> x = torch.randn(2, 3, 5) 
>>> x.size() 
torch.Size([2, 3, 5]) 
>>> x.permute(2, 0, 1).size() 
torch.Size([5, 2, 3])
1.2 permute(*dims) → Tensor
Permute the dimensions of this tensor.
Parameters： *dims (int...) – The desired ordering of dimensions
Example：
>>> x = torch.randn(2, 3, 5) 
>>> x.size() 
torch.Size([2, 3, 5]) 
>>> x.permute(2, 0, 1).size() 
torch.Size([5, 2, 3])
2 pytorch permute的使用
permute函数功能还是比较简单的，下面主要介绍几个细节点：
2.1 transpose与permute的异同
Tensor.permute(a,b,c,d, ...)：permute函数可以对任意高维矩阵进行转置，但没有 torch.permute() 这个调用方式， 只能 Tensor.permute()：
>>> torch.randn(2,3,4,5).permute(3,2,0,1).shape
torch.Size([5, 4, 2, 3])
torch.transpose(Tensor, a,b)：transpose只能操作2D矩阵的转置，有两种调用方式；
另：连续使用transpose也可实现permute的效果：
>>> torch.randn(2,3,4,5).transpose(3,0).transpose(2,1).transpose(3,2).shape
torch.Size([5, 4, 2, 3])
>>> torch.randn(2,3,4,5).transpose(1,0).transpose(2,1).transpose(3,1).shape
torch.Size([3, 5, 2, 4])
从以上操作中可知，permute相当于可以同时操作于tensor的若干维度，transpose只能同时作用于tensor的两个维度；
2.2 permute函数与contiguous、view函数之关联
contiguous：view只能作用在contiguous的variable上，如果在view之前调用了transpose、permute等，就需要调用contiguous()来返回一个contiguous copy；
一种可能的解释是：有些tensor并不是占用一整块内存，而是由不同的数据块组成，而tensor的view()操作依赖于内存是整块的，这时只需要执行contiguous()这个函数，把tensor变成在内存中连续分布的形式；
判断ternsor是否为contiguous，可以调用torch.Tensor.is_contiguous()函数:
import torch 
x = torch.ones(10, 10) 
x.is_contiguous()                                 # True 
x.transpose(0, 1).is_contiguous()                 # False
x.transpose(0, 1).contiguous().is_contiguous()    # True
另：在pytorch的最新版本0.4版本中，增加了torch.reshape()，与 numpy.reshape() 的功能类似，大致相当于 tensor.contiguous().view()，这样就省去了对tensor做view()变换前，调用contiguous()的麻烦；
3 permute与view函数功能demo
import torch
import numpy as np

a=np.array([[[1,2,3],[4,5,6]]])
unpermuted=torch.tensor(a)
print(unpermuted.size())              #  ——>  torch.Size([1, 2, 3])

permuted=unpermuted.permute(2,0,1)
print(permuted.size())                #  ——>  torch.Size([3, 1, 2])

view_test = unpermuted.view(1,3,2)
print(view_test.size())               #  ——>  torch.Size([1, 3, 2])
利用函数 permute(2,0,1) 可以把 Tensor([[[1,2,3],[4,5,6]]]) 转换成：
tensor([[[ 1,  4]],
        [[ 2,  5]],
        [[ 3,  6]]])     # print(permuted)    
如果使用view(1,3,2) 可以得到：
tensor([[[ 1,  2],
         [ 3,  4],
         [ 5,  6]]])   # print(view_test)
5 参考
https://zhuanlan.zhihu.com/p/64376950
https://pytorch.org/docs/stable/tensors.html?highlight=permute#torch.Tensor.permute
https://pytorch-cn.readthedocs.io/zh/latest/package_references/Tensor/#permutedims

permute函数的作用是对tensor进行转置。

import torch
import torch.nn as nn

x = torch.randn(1, 2, 3, 4)
print(x.size())      
print(x.permute(2, 1, 0, 3).size())


随机生成一个1X2X3X4的四维向量，permute函数的参数表示的是转置后的向量位置。比如原向量中(1, 2, 3, 4)，1的下标是0，2的下标是1，3的下标是2，4的下标是3；在x.permute(2, 1, 0, 3)中，2代表原来下表为2的数字3放在第一位（也就是N），1代表原来下表为1的数字2放在第二位（也就是C），0代表原来下表为0的数字1放在第三位（也就是H），3代表原来下表为3的数字4放在第四位（也就是W）。这样产生的结果如下：
torch.Size([1, 2, 3, 4])   #原来的tensor
torch.Size([3, 2, 1, 4])   #转置后的tensor


**torch.transpose()只能操作二维转置。**这个意思不是torch.transpose()只能作用于二维向量，它的意思是一次只能进行两个维度的转置，如果需要多个维度的转置，那么需要多次调用transpose()。比如上述的tensor[1,2,3,4]转置为tensor[3,4,1,2]，使用transpose需要做如下

x.transpose(0,2).transpose(1,3)


view()函数作用的内存必须是连续的，如果操作数不是连续存储的，必须在操作之前执行contiguous()，把tensor变成在内存中连续分布的形式；
我们来直观看一下tensor转置的实际效果。

import torch
import torch.nn as nn
import numpy as np

y = np.array([[[1, 2, 3], [4, 5, 6]]]) # 1X2X3
y_tensor = torch.tensor(y)
y_tensor_trans = y_tensor.permute(2, 0, 1) # 3X1X2
print(y_tensor.size())
print(y_tensor_trans.size())

print(y_tensor)
print(y_tensor_trans)
print(y_tensor.view(1, 3, 2)) 


torch.Size([1, 2, 3])
torch.Size([3, 1, 2])
tensor([[[1, 2, 3],
         [4, 5, 6]]])
tensor([[[1, 4]],

        [[2, 5]],

        [[3, 6]]])
tensor([[[1, 2],
         [3, 4],
         [5, 6]]])


view()函数是连续操作内存的，他会将1、2、3、4、5、6连续分配，上述是将1X2X3变成1X3X2。如果变成1X2X3，结果如下：

tensor([[[1, 2, 3],
         [4, 5, 6]]])

pytorch transpose与permute函数

pemute可以对高维,2阶或以上矩阵进行重排列，或者说转置，而transpose只能对两个维度进行调换
b = torch.tensor([[[1,4],[2,5]],[[3,7],[4,6]]])
b.shape
Out[36]: torch.Size([2, 2, 2])
b
Out[37]: 
tensor([[[1, 4],
         [2, 5]],
        [[3, 7],
         [4, 6]]])
b.permute(0,2,1)
Out[38]: 
tensor([[[1, 2],
         [4, 5]],
        [[3, 4],
         [7, 6]]])
         
b.transpose(2,1)
Out[40]: 
tensor([[[1, 2],
         [4, 5]],
        [[3, 4],
         [7, 6]]])