pytorch函数，unsqueeze，squeeze，transpose，contiguous，gt，

一、unsqueeze()函数：在张量里增加一个维度

1. 首先初始化一个a

可以看出a的维度为（2，3）

2. 在第二维增加一个维度，使其维度变为（2，1，3）

可以看出a的维度已经变为（2，1，3）了，同样如果需要在倒数第二个维度上增加一个维度，那么使用b.unsqueeze(-2)

二、squeeze()函数介绍：去掉张量里某一个维度，只有维度为1时才会去掉

1. 首先得到一个维度为（1，2，3）的tensor（张量）

由图中可以看出c的维度为（1，2，3）

2.下面使用squeeze()函数将第一维去掉

可见，维度已经变为（2，3）

3.另外

可以看出维度并没有变化，仍然为（1，2，3），这是因为只有维度为1时才会去掉。

三、torch.transpose(Tensor,dim0,dim1)是pytorch中的ndarray矩阵进行转置的操作

注意：transpose()一次只能在两个维度间进行转置（也可以理解为维度转换）

例如：

import torch as t
 
x=t.Tensor(2,3,4,5) #这是一个4维的矩阵（只用空间位置，没有数据）
print(x.size())
#先转置0维和1维，之后在第2，3维间转置，之后在第1，3间转置
y=x.transpose(0,1).transpose(3,2).transpose(1,3)
print(y.size())
 
#输出：
 
torch.Size([2, 3, 4, 5])
torch.Size([3, 4, 5, 2])
 
Process finished with exit code 0

四、contiguous() 

使用contiguous() 

如果想要断开这两个变量之间的依赖（x本身是contiguous的），就要使用contiguous()针对x进行变化，感觉上就是我们认为的深拷贝。

当调用contiguous()时，会强制拷贝一份tensor，让它的布局和从头创建的一模一样，但是两个tensor完全没有联系。

x = torch.randn(3, 2)
y = torch.transpose(x, 0, 1).contiguous()
print("修改前：")
print("x-", x)
print("y-", y)
 
print("\n修改后：")
y[0, 0] = 11
print("x-", x)
print("y-", y)

运行结果：

修改前：
x- tensor([[ 0.9730,  0.8559],
           [ 1.6064,  1.4375],
           [-1.0905,  1.0690]])
y- tensor([[ 0.9730,  1.6064, -1.0905],
           [ 0.8559,  1.4375,  1.0690]])
 
修改后：
x- tensor([[ 0.9730,  0.8559],
           [ 1.6064,  1.4375],
           [-1.0905,  1.0690]])
y- tensor([[11.0000,  1.6064, -1.0905],
           [ 0.8559,  1.4375,  1.0690]])

  可以看到，当对y使用了.contiguous()后，改变y的值时，x没有任何影响！

[参考](Pytorch中contiguous()函数理解-CSDN博客)

五、torch.gt()

torch.gt(a,b)函数比较a中元素大于（这里是严格大于）b中对应元素，大于则为1，不大于则为0，这里a为Tensor，b可以为与a的size相同的Tensor或常数。

>>> import torch
>>> a=torch.randn(2,4)
>>> a
tensor([[-0.5466,  0.9203, -1.3220, -0.7948],
        [ 2.0300,  1.3090, -0.5527, -0.1326]])
>>> b=torch.randn(2,4)
>>> b
tensor([[-0.0160, -0.3129, -1.0287,  0.5962],
        [ 0.3191,  0.7988,  1.4888, -0.3341]])
>>> torch.gt(a,b)            #得到a中比b中元素大的位置
tensor([[0, 1, 0, 0],
        [1, 1, 0, 1]], dtype=torch.uint8)
>>> torch.gt(b,a)           #b中比a中大
tensor([[1, 0, 1, 1],
        [0, 0, 1, 0]], dtype=torch.uint8)
>>> torch.gt(a,1)
tensor([[0, 0, 0, 0],
        [1, 1, 0, 0]], dtype=torch.uint8)
>>> c=torch.Tensor([[1,2,3],[4,5,6]])
>>> d=torch.Tensor([[1,1,3],[5,5,5]])
>>> torch.gt(c,d)                   #必须是严格大于才为1
tensor([[0, 1, 0],
        [0, 0, 1]], dtype=torch.uint8)

x=torch.tensor([[1, 2], [3, 4]])
y=torch.tensor([[1, 1], [4, 4]])
torch.gt(x,y)

#输出
tensor([[False, True], [False, False]])