Torch常用函数

clamp()

torch.clamp(input, min, max, out=None)

将输入input张量每个元素的范围限制到区间 [min,max]，返回结果到一个新张量。

input (Tensor) – 输入张量

min (Number) – 限制范围下限

max (Number) – 限制范围上限

out (Tensor, optional) – 输出张量

>>> x=torch.randint(-100,1000,(3,4))
>>> print(x)
tensor([[ 40, 968, -56, 841],
        [557, 703, 655, 785],
        [195, 892, -96, 744]])
>>> x = torch.clamp(x, min=0, max=100)
>>> print(x)
tensor([[ 40, 100,   0, 100],
        [100, 100, 100, 100],
        [100, 100,   0, 100]])

Conv1d()

用于文本数据，只对宽度进行卷积，对高度不卷积

Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

• in_channels(int) – 输入信号的通道。在文本分类中，即为词向量的维度

• out_channels(int) – 卷积产生的通道。有多少个out_channels，就需要多少个1维卷积

• kernel_size(int or tuple) - 卷积核的尺寸，卷积核的大小为(k,)，第二个维度是由in_channels来决定的，所以实际上卷积大小为kernel_size*in_channels

• stride(int or tuple, optional) - 卷积步长

• padding (int or tuple, optional)- 输入的每一条边补充0的层数

• dilation(int or tuple, `optional``) – 卷积核元素之间的间距

• groups(int, optional) – 从输入通道到输出通道的阻塞连接数

• bias(bool, optional) - 如果bias=True，添加偏置

expand()

其将单个维度扩大成更大维度，展某一维度后自身不会发生变化

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

tril()

pytorch中tril函数主要用于返回一个矩阵主对角线以下的下三角矩阵，其它元素全部为0。当输入是一个多维张量时，返回的是同等维度的张量并且最后两个维度的下三角矩阵的。

>>> torch.tril(torch.rand(4,4))
tensor([[0.3389, 0.0000, 0.0000, 0.0000],
        [0.1175, 0.3249, 0.0000, 0.0000],
        [0.4675, 0.0904, 0.6020, 0.0000],
        [0.6040, 0.2779, 0.7150, 0.2499]])

Parameter()

torch.nn.parameter.Parameter(data=None, requires_grad=True)

• nn.Parameter会自动被认为是module的可训练参数，即加入到parameter()这个迭代器中去；而module中非nn.Parameter()的普通tensor是不在parameter中的。

• nn.Parameter的对象的requires_grad属性的默认值是True，即是可被训练的，这与torth.Tensor对象的默认值相反。

Identity()

它实际上是一个恒等映射，不对输入进行任何变换或操作，只是简单地将输入返回作为输出。

它实际上在某些情况下是很有用的，其存在意义包括以下几点：

• 连接路径或跳跃连接（Skip Connections）： 在一些网络架构中，特别是残差网络（Residual Networks）或者一些需要跨层连接的架构（比如 DenseNet），nn.Identity() 可以用于实现跳跃连接。通过跳跃连接，神经网络可以直接从一个层传递信息到后续层，这有助于解决梯度消失或梯度爆炸等问题，同时也有助于提高模型的性能和训练速度。

• 模型组合和特殊结构设计： 在设计复杂的神经网络结构时，nn.Identity() 可以用于在模型中创建一些特殊的连接或分支结构。通过使用恒等映射，可以更轻松地实现某些复杂模型的组合，或者通过条件语句动态地选择是否应用某些层。

• 代码一致性和灵活性： 在编写神经网络代码时，有时需要保持一致性，可能会需要一个占位符层来代表某些特定的操作。nn.Identity() 可以填补这个需求，即使不对输入进行任何更改，也能保持代码的一致性和清晰度。

• 简化模型和调试： 在一些情况下，为了简化模型或者调试网络结构，可以使用 nn.Identity() 层。它允许将某些部分固定为恒等映射，方便单独地测试网络的不同部分。

flatten()

flatten(dim)是对多维数据的降维函数,只保留dim之 前的维度,后面维度的数据全都挤在dim这一维。

>>>torch.rand((1,2,3,4)).flatten(2).shape
torch.Size([1, 2, 12])

repeat()

可以对张量进行重复扩充

>>>torch.rand((6)).repeat(2).shape
torch.Size([12])
>>>torch.rand((6,6)).repeat(2,2).shape
torch.Size([12, 12])
>>>torch.rand((6,6,6)).repeat(2,2,2).shape
torch.Size([12, 12, 12])

contiguous()

下面这些操作不进行数据拷贝和数据的改变，变的是元数据：

• narrow()

• view()

• expand()

• transpose()

这些操作改变数据后，会导致操作前的数据改变。

元数据后的数据is_contiguous() 返回为False

>>>x = torch.randn(3, 2)
>>>y = torch.transpose(x, 0, 1)
>>>y[0] = 0
x- tensor([[ 0,  0.8559],
           [ 0,  1.4375],
           [ 0,  1.0690]])
y- tensor([[      0,       0,       0],
           [ 0.8559,  1.4375,  1.0690]])

>>>x = torch.randn(3, 2)
>>>y = torch.transpose(x, 0, 1).contiguous()
>>>y[0] = 0
x- tensor([[ 0.9730,  0.8559],
           [ 1.6064,  1.4375],
           [-1.0905,  1.0690]])
y- tensor([[      0,       0,       0],
           [ 0.8559,  1.4375,  1.0690]])

narrow()

• dim：0表示对行操作，1表示对列操作

• start：开始位置

• length：取值个数

view() 与 reshape()

• view只适合对满足连续性条件（contiguous）的tensor进行操作

• reshape同时还可以对不满足连续性条件的tensor进行操作

expand()

其将单个维度扩大成更大维度

>>>data=torch.rand(4)
>>>data.expand(2,4)
tensor([[0.8853, 0.1025, 0.9653, 0.9350],
        [0.8853, 0.1025, 0.9653, 0.9350]])

squeeze()和unsqueeze()

squeeze()：将维度为1的挤压移除（3,1,1,2）→（3,2）

unsqueeze(1)：扩容一个维度为1的维度（3,2）→（3,1,2）

>>> a=torch.rand((3,2))
>>> a.unsqueeze(0).shape
torch.Size([1, 3, 2])
>>> a.unsqueeze(1).shape
torch.Size([3, 1, 2])
>>> a.squeeze().shape
torch.Size([3, 2])

transpose()

交换维度 （3,2）→（2,3）

>>>data=torch.rand(3,2)
tensor([[0.3341, 0.8254],
        [0.9084, 0.5621],
        [0.7031, 0.8052]])
>>>data.transpose(0,1)
tensor([[0.3341, 0.9084, 0.7031],
        [0.8254, 0.5621, 0.8052]])

permute()

交换维度 （1,3,2）→（1,2,3）

>>>data=torch.rand(1,3,2)
tensor([[[0.9002, 0.9547],
         [0.9944, 0.9828],
         [0.6325, 0.5995]]])
>>>data.permute(0,2,1)
tensor([[[0.9002, 0.9944, 0.6325],
         [0.9547, 0.9828, 0.5995]]])

size()和shape

• shape是一个Tensor类中的属性

• size()是Tensor从上面的类中继承来的一个方法

masked_fill()

• mask是一个pytorch张量（Tensor），元素是布尔值，

• value是要填充的值，填充规则是mask中取值为True位置用value填充。

>>>t = torch.randn(3,2)
>>>m = torch.randint(0,2,(3,2))
tensor([[1, 1],
        [0, 1],
        [0, 0]])
>>>t.masked_fill(m == 0, -100)
tensor([[   1.5305,   -0.8436],
        [-100.0000,   -1.3557],
        [-100.0000, -100.0000]])

new_zeros()

复制原来tensor的所有类型，比如数据类型和数据所在设备等等。

device="cuda" 
a=torch.rand(2,3,4).double() 
a=a.to(device) 
b=a.new_zeros((2,3,1)) 
b

tensor([[[0.],
         [0.],
         [0.]],

        [[0.],
         [0.],
         [0.]]], device='cuda:0', dtype=torch.float64)