Tensor的数学运算

#Tensor的数学运算

总结的方法包括：

Tensor求和以及按索引求和：torch.sum() torch.Tensor.indexadd()

Tensor元素乘积：torch.prod(input)

对Tensor求均值、方差、极值：

torch.mean() torch.var()

torch.max() torch.min()

最后还有在NLP领域经常用到的：

求Tensor的平方根倒数、线性插值、双曲正切

torch.rsqrt(input) torch.lerp(star,end,weight)

torch.tanh(input, out=None)

元素求和

torch.sum(input) → float

返回输入向量input中所有元素的和。

参数：

• input (Tensor) - 输入张量

例子：

> def tensor_sum():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.sum(a)
>     print(b)
>

0.6491 -0.1617 0.7009
[torch.FloatTensor of size 1x3]

1.1884211152791977

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

返回新的张量，其中包括输入张量input中指定维度dim中每行的和。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入Tensor
• dim (int) - 指定维度
• keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
• out (Tensor,optional) - 结果张量

例子：

> def tensor_sum_2d():
>     a = torch.randn(4, 3)
>     print(a)
>     b = torch.sum(a, 0, True)
>     print(b)
>

-0.8452 -0.2816 0.2672
1.0685 2.4003 -0.6541
-0.1700 -0.4373 -0.2217
-1.2500 1.1798 -0.6842
[torch.FloatTensor of size 4x3]

-1.1968 2.8613 -1.2928
[torch.FloatTensor of size 1x3]

元素乘积

torch.prod(input) → float

返回输入张量input所有元素的乘积。

参数：

• input (Tensor) - 输入张量

例子：

> def tensor_prod():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.prod(a)
>     print(b)
>

-0.3751 0.3082 -0.7879
[torch.FloatTensor of size 1x3]

0.09109678113290456

torch.prod(input, dim, keepdim=False, out=None) → Tensor

返回新的张量，其中包括输入张量input中指定维度dim中每行的乘积。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入Tensor
• dim (int) - 指定维度
• keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
• out (Tensor,optional) - 结果张量

例子：

> def tensor_prod_2d():
>     a = torch.randn(4, 2)
>     print(a)
>     b = torch.prod(a, 1, True)
>     print(b)
>

0.2707 0.4322
-2.0925 0.3860
-1.1050 1.2551
-0.9644 -0.8771
[torch.FloatTensor of size 4x2]

0.1170
-0.8077
-1.3869
0.8459
[torch.FloatTensor of size 4x1]

按索引求和

torch.Tensor.indexadd(dim, index, tensor) → Tensor

按索引参数index中所确定的顺序，将参数张量tensor中的元素与执行本方法的张量的元素逐个相加。参数tensor的尺寸必须严格地与执行方法的张量匹配，否则会发生错误。

参数：

• dim (int) - 索引index所指向的维度
• index (LongTensor) - 包含索引数的张量
• tensor (Tensor) - 含有相加元素的张量

例子：

> def tensor_index_add():
>     x = torch.Tensor([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
>     print(x)
>     t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>     index = torch.LongTensor([0, 2, 1])
>     x.index_add_(0, index, t)
>     print(x)
>

Output:

1 1 1
1 1 1
1 1 1
[torch.FloatTensor of size 3x3]

2 3 4
8 9 10
5 6 7
[torch.FloatTensor of size 3x3]

平均数

torch.mean(input)

返回输入张量input中每个元素的平均值。

参数：

• input (Tensor) – 输入张量

例子：

> def tensor_mean():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.mean(a)
>     print(b)
>

0.9257 -0.1373 1.5762
[torch.FloatTensor of size 1x3]

0.788198247551918

torch.mean(input, dim, keepdim=False, out=None)

返回新的张量，其中包含输入张量input指定维度dim中每行的平均值。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入张量
• dim (int) - 指定进行均值计算的维度
• keepdim (bool, optional) - 输出张量是否保持与输入张量有相同数量的维度
• out (Tensor) - 结果张量

例子：

> def tensor_mean_2d():
>     a = torch.randn(3, 5)
>     print(a)
>     b = torch.mean(a, 0, True)
>     print(b)
>

0.3839 -1.2157 0.0210 1.1199 0.0319
-1.3452 -1.0125 -1.2500 1.0597 -0.9030
0.1642 0.9110 0.8520 0.0481 -0.5234
[torch.FloatTensor of size 3x5]

-0.2657 -0.4391 -0.1257 0.7425 -0.4648
[torch.FloatTensor of size 1x5]

方差

torch.var(input, unbiased=True) → float

返回输入向量input中所有元素的方差。

参数：

• input (Tensor) - 输入张量
• unbiased (bool) - 是否使用基于修正贝塞尔函数的无偏估计

例子：

> def tensor_var():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.var(a)
>     print(b)
>

-0.7808 0.1883 0.7654
[torch.FloatTensor of size 1x3]

0.6105006681458913

torch.var(input, dim, keepdim=False, unbiased=True, out=None) → Tensor

返回新的张量，其中包括输入张量input中指定维度dim中每行的方差。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入Tensor
• dim (int) - 指定维度
• keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
• unbiased (bool) - 是否使用基于修正贝塞尔函数的无偏估计
• out (Tensor,optional) - 结果张量

例子：

> def tensor_var_2d():
>     a = torch.randn(3, 5)
>     print(a)
>     b = torch.var(a, 0, True)
>     print(b)
>

-0.2789 -1.6603 1.1928 0.9614 1.2953
0.9082 0.4015 1.1001 -0.9432 0.9254
-1.0593 -0.2636 -0.9274 0.0006 1.3933
[torch.FloatTensor of size 3x5]

0.9815 1.1074 1.4358 0.9069 0.0609
[torch.FloatTensor of size 1x5]

最大值

torch.max(input) → float

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

参数：

• input (Tensor) - 输入张量

例子：

> def tensor_max():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.max(a)
>     print(b)
>

0.8944 0.8395 -0.8867
[torch.FloatTensor of size 1x3]

0.8944145441055298

torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

返回新的张量，其中包括输入张量input中指定维度dim中每行的最大值，同时返回每个最大值的位置索引。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入Tensor
• dim (int) - 指定维度
• keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
• out (tuple,optional) - 结果张量

例子：

> def tensor_max_2d():
>     a = torch.randn(3, 5)
>     print(a)
>     b = torch.max(a, 0, True)
>     print(b)
>

0.5306 -0.8915 2.7820 0.1723 -0.5061
2.0535 0.2018 -3.1085 -0.7618 0.5924
0.9906 -0.3212 0.1849 1.7002 0.8102
[torch.FloatTensor of size 3x5]

(
2.0535 0.2018 2.7820 1.7002 0.8102
[torch.FloatTensor of size 1x5]
,
1 1 0 2 2
[torch.LongTensor of size 1x5]
)

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

逐个元素比较张量input与张量other，将比较出的最大值保存到输出张量中。
两个张量尺寸不需要完全相同，但需要支持自动扩展法则。

参数：

• input (Tensor) - 输入Tensor
• other (Tensor) - 另一个输入的Tensor
• out (Tensor,optional) - 结果张量

例子：

> def tensor_max_2tensor():
>     a = torch.randn(4)
>     print(a)
>     b = torch.randn(1)
>     print(b)
>     print(torch.max(a, b))
>

0.5369
-1.5926
-1.3574
-1.6009
[torch.FloatTensor of size 4]

-0.1394
[torch.FloatTensor of size 1]

0.5369
-0.1394
-0.1394
-0.1394
[torch.FloatTensor of size 4]

最小值

torch.min(input) → float

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

参数：

• input (Tensor) - 输入张量

例子：

> def tensor_min():
>     a = torch.randn(1, 3)
>     print(a)
>     b = torch.min(a)
>     print(b)
>

-0.8926 0.2079 -0.6790
[torch.FloatTensor of size 1x3]

-0.8925955295562744

torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

返回新的张量，其中包括输入张量input中指定维度dim中每行的最小值，同时返回每个最小值的位置索引。

若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。

参数：

• input (Tensor) - 输入Tensor
• dim (int) - 指定维度
• keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
• out (tuple,optional) - 结果张量

例子：

> def tensor_min_2d():
>     a = torch.randn(3, 5)
>     print(a)
>     b = torch.min(a, 0, True)
>     print(b)
>

-0.8179 1.1834 -0.2989 0.6051 -0.1072
-1.1543 0.0666 -0.7919 0.2359 1.1995
-0.8094 0.5873 0.5116 -0.6181 0.9788
[torch.FloatTensor of size 3x5]

(
-1.1543 0.0666 -0.7919 -0.6181 -0.1072
[torch.FloatTensor of size 1x5]
,
1 1 1 2 0
[torch.LongTensor of size 1x5]
)

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

逐个元素比较张量input与张量other，将比较出的最小值保存到输出张量中。
两个张量尺寸不需要完全相同，但需要支持自动扩展法则。

参数：

• input (Tensor) - 输入Tensor
• other (Tensor) - 另一个输入的Tensor
• out (Tensor,optional) - 结果张量

例子：

> def tensor_min_2tensor():
>     a = torch.randn(1,4)
>     print(a)
>     b = torch.randn(1)
>     print(b)
>     print(torch.min(a, b))
>

0.3494 0.2155 -0.0723 0.8322
[torch.FloatTensor of size 1x4]

0.2635
[torch.FloatTensor of size 1]

0.2635 0.2155 -0.0723 0.2635
[torch.FloatTensor of size 1x4]

平方根倒数

torch.rsqrt(input) → Tensor

返回新的张量，其中包含input张量每个元素平方根的倒数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

> def tensor_rsqrt():
>     a = torch.randn(1, 4)
>     print(a)
>     b = torch.rsqrt(a)
>     print(b)
>

0.1615 0.3116 -0.3093 -1.5020
[torch.FloatTensor of size 1x4]

2.4884 1.7915 nan nan
[torch.FloatTensor of size 1x4]

线性插值

torch.lerp(start,end,weight) → Tensor

基于weight对输入的两个张量start与end逐个元素计算线性插值，结果返回至输出张量。

返回结果是： $outs_i=start_i+weight*(end_i-start_i)$

参数：

• start (Tensor) – 起始点张量
• end (Tensor) – 终止点张量
• weight (float) – 插入公式的 weight
• out (Tensor, optional) – 结果张量

例子：

> def tensor_lerp():
>     start = torch.arange(1, 5)
>     print(start)
>     end = torch.Tensor(4).fill_(10)
>     print(end)
>     outs = torch.lerp(start, end, 0.4)
>     print(outs)
>

1
2
3
4
[torch.FloatTensor of size 4]

10
10
10
10
[torch.FloatTensor of size 4]

4.6000
5.2000
5.8000
6.4000
[torch.FloatTensor of size 4]

双曲正切

torch.tanh(input, out=None) → Tensor

返回新的张量，其中包括输入张量input中每个元素的双曲正切。

参数：

• input (Tensor) - 输入张量
• out (Tensor,optional) - 结果张量

例子：

> def tensor_tanh():
>     a = torch.randn(1, 5)
>     print(a)
>     outs = torch.tanh(a)
>     print(outs)
>

-0.4298 0.0992 0.1322 1.4975 0.8817
[torch.FloatTensor of size 1x5]

-0.4051 0.0989 0.1314 0.9047 0.7073
[torch.FloatTensor of size 1x5]