pytorch torch类

本文介绍一些可能有用的torch类中的方法。

torch.cat(inputs, dimension=0)

对input进行拼接，参数表示在那个维度进行拼接。

x = torch.randn(2, 3)
print(x)
print(torch.cat((x, x, x), 0))

torch.gather(input, dim, index, out=None)

沿给定轴dim，将输入索引张量index指定位置的值进行赋值。
赋值公式为如下：

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

也就是修改输入的dim维的数值排列。
示例：

t = torch.Tensor([[1, 2], [3, 4]])
# gather是对tensor进行重新排序
print(torch.gather(t, 1, torch.LongTensor([[0, 0], [0, 1]])))

torch.masked_select(input, mask, out=None)

根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量。
也就是在原本的input中选择部分数值。

torch.nonzero(input, out=None)

返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

t = torch.Tensor([[0, 2], [3, 2]])
print(torch.nonzero(t))
# tensor([[0, 1],
#         [1, 0],
#         [1, 1]])

torch.squeeze(input, dim=None, out=None)

将输入张量形状中的1 去除并返回。 如果输入是形如(A×1×B×1×C×1×D)，那么输出形状就为： (A×B×C×D)。

• dim (int, optional) – 如果给定，则input只会在给定维度挤压

示例：

x = torch.zeros(2,1,2,1,2)
print(x.size())
# torch.Size([2, 1, 2, 1, 2])
y = torch.squeeze(x)
print(y.size())
# torch.Size([2, 2, 2])
y = torch.squeeze(x, 0)
print(y.size())
# torch.Size([2, 1, 2, 1, 2])
y = torch.squeeze(x, 1)
print(y.size())
# torch.Size([2, 2, 1, 2])

torch.stack(sequence, dim=0)

沿着新的维度对输入张量进行排序。最外面的维度是0.

示例：

a = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
b = a * 10
c = b * 10
print(a)
print(torch.stack([a,b,c],1))
# tensor([[[  1.,   2.,   3.],
#          [ 10.,  20.,  30.],
#          [100., 200., 300.]],
# 
#         [[  4.,   5.,   6.],
#          [ 40.,  50.,  60.],
#          [400., 500., 600.]],
# 
#         [[  7.,   8.,   9.],
#          [ 70.,  80.,  90.],
#          [700., 800., 900.]]])

torch.t(input, out=None)

对二维向量进行转置。

torch.unsqueeze(input, dim, out=None)

返回一个新的张量，对输入的制定位置插入维度 1。如果dim为负，则将会被转化dim+input.dim()+1。

x = torch.Tensor([1, 2, 3, 4])
print(torch.unsqueeze(x, 1))
# tensor([[1.],
#         [2.],
#         [3.],
#         [4.]])

随机抽样

torch.manual_seed(seed)

设定生成随机数的种子。

torch.initial_seed()

返回生成随机数的原始种子值。

torch.normal(means, std, out=None)

返回一个张量，包含从给定参数means,std的离散正态分布中抽取随机数。

• means (Tensor) – 均值
• std (Tensor) – 标准差
• out (Tensor) – 可选的输出张量

数学操作

torch.abs(input, out=None)

计算输入张量的每个元素绝对值。

torch.acos(input, out=None)

返回一个新张量，包含输入张量每个元素的反余弦。

torch.add(input, value, out=None)

对输入张量input逐元素加上标量值value，并返回结果到一个新的张量out，即 out=tensor+value。

torch.add(input, value=1, other, out=None)

other 张量的每个元素乘以一个标量值value，并加到iput 张量上。返回结果到输出张量out。即，out=input+(other∗value)。

torch.ceil(input, out=None)

对输入input张量每个元素向上取整。

torch.floor(input, out=None)

向下取整。

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

将输入input张量每个元素的夹紧到区间 [min,max]，并返回结果到一个新张量。

操作公式

torch.div(input, value, out=None)

将input逐元素除以标量值value，并返回结果到输出张量out。

torch.lerp(start, end, weight, out=None)

对两个张量以start，end做线性插值， 将结果返回到输出张量。

差值公式

torch.log(input, out=None)

计算input 的自然对数。

torch.mul(input, value, out=None)

用标量值value乘以输入input的每个元素，并返回一个新的结果张量。

torch.reciprocal(input, out=None)

返回一个新张量，包含输入input张量每个元素的倒数，即 1.0/x。

torch.remainder(input, divisor, out=None)

返回一个新张量，包含输入input张量每个元素的除法余数。

torch.round(input, out=None)

四舍五入。

torch.rsqrt(input, out=None)

计算每个元素的平方根倒数。

torch.sigmoid(input, out=None)

输入input张量每个元素的sigmoid值。

累计操作

torch.cumprod(input, dim, out=None)

返回输入沿指定维度的累积积。例如，如果输入是一个N 元向量，则结果也是一个N 元向量，第i 个输出元素值为yi=x1∗x2∗x3∗...∗xi。

torch.cumsum(input, dim, out=None)

返回输入沿指定维度的累积和。第i 个输出元素值为 yi=x1+x2+x3+...+xi。

torch.mean(input)

返回输入张量所有元素的均值。

torch.prod(input, dim, out=None)

返回输入张量给定维度上每行的积。
示例：

a = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
print(torch.prod(a,0))
# tensor([  6., 120., 504.])

torch.std(input) → float

返回输入张量input 所有元素的标准差。

torch.sum(input, dim, out=None) → Tensor

返回输入张量给定维度上每行的和。 输出形状与输入相同，除了给定维度上为1。

torch.var(input) → float

返回输入张量所有元素的方差。

比较操作

torch.eq(input, other, out=None) → Tensor

对input张量和第二个参数进行比较。如果相同则在对应位置返回1.第二个参数可以是张量或数。
示例：

print(torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])))
# tensor([[1, 0],
#         [0, 1]], dtype=torch.uint8)
print(torch.eq(torch.Tensor([[1, 2], [3, 4]]), 1))
# tensor([[1, 0],
#         [0, 0]], dtype=torch.uint8)

torch.equal(tensor1, tensor2) → bool

如果两个张量有相同的形状和元素值，则返回True ，否则 False。
即比较张量形状也比较元素值。

torch.ge(input, other, out=None) → Tensor

逐元素比较input和other的大小，即是否 input>=other。

torch.gt(input, other, out=None) → Tensor

逐元素比较input和other的大小 ， 即是否input>other。

torch.le(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否input<=other 。

torch.lt(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否 input

torch.max()

返回输入张量所有元素的最大值。

torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。

torch.min(input) → float

返回输入张量所有元素的最小值。

torch.min(input, other, out=None) → Tensor

input中逐元素与other相应位置的元素对比，返回最小值到输出张量。即，outi=min(tensori,otheri)。

torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

对输入张量input沿着指定维按升序排序。如果不给定dim，则默认为输入的最后一维。如果指定参数descending为True，则按降序排序。
返回元组 (sorted_tensor, sorted_indices) ， sorted_indices 为原始输入中的下标。

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿给定dim维度返回输入张量input中 k 个最大值。 如果不指定dim，则默认为input的最后一维。 如果为largest为 False ，则返回最小的 k 个值。
返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。 如果设定布尔值sorted 为True，将会确保返回的 k 个值被排序。

其他操作

torch.cross(input, other, dim=-1, out=None) → Tensor

返回沿着维度dim上，两个张量input和other的向量积（叉积）。 input和other 必须有相同的形状，且指定的dim维上size必须为3。

矩阵运算

torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作。

torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor

对矩阵mat1和mat2进行矩阵乘操作。
out=(beta∗M)+(alpha∗mat1@mat2)

torch.bmm(batch1, batch2, out=None) → Tensor

对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作。batch1和 batch2都为包含相同数量矩阵的3维张量。 如果batch1是形为b×n×m的张量，batch1是形为b×m×p的张量，则out和mat的形状都是n×p，即 res=(beta∗M)+(alpha∗sum(batch1i@batch2i,i=0,b))

torch.dot(tensor1, tensor2) → float

计算两个张量的点乘(内乘),两个张量都为1-D 向量.

torch.mm(mat1, mat2, out=None) → Tensor

对矩阵mat1和mat2进行相乘。 如果mat1 是一个n×m 张量，mat2 是一个 m×p 张量，将会输出一个 n×p 张量out。

torch.mv(mat, vec, out=None) → Tensor

对矩阵mat和向量vec进行相乘。 如果mat 是一个n×m张量，vec 是一个m元 1维张量，将会输出一个n 元 1维张量。