1. 加法运算

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

将标量 other 与input输入的每个元素相加并返回一个新的结果张量。

out=input+other

如果 input 是 Fl​​oatTensor 或 DoubleTensor 类型，则 other 必须是实数，否则应该是整数。

参数

• input (Tensor) – the input tensor.

• other (Number) – the number to be added to each element of input

关键字参数

• out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(4)
>>> a
tensor([ 0.0202,
1.0985,
1.3506, -0.6056])
>>> torch.add(a, 20)
tensor([ 20.0202,
21.0985,
21.3506,
19.3944])

2. 减法运算

torch.sub(input, other, *, alpha=1, out=None) → Tensor

从输入中减去按 alpha 缩放的 other。

 支持广播(broadcasting)到相同的shape、类型转换以及整数、浮点数和复数输入。

 参数

•  input (Tensor) – the input tensor.

• other (Tensor or Scalar) – the tensor or scalar to subtract from input

关键字参数

• alpha (Scalar) – the scalar multiplier for other

• out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.tensor((1, 2))
>>> b = torch.tensor((0, 1))
>>> torch.sub(a, b, alpha=2)
tensor([1, 0])

3. 哈达玛积(element wise，对应元素相乘)

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

将输入input的每个元素与标量other元素相乘，并返回一个新的结果张量。

如果输入类型为 FloatTensor 或 DoubleTensor，则other应为实数，否则应为整数

参数

•  input (Tensor) – the input tensor.

• other (Number) – the number to be multiplied to each element of input

关键字参数

• out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(3)
>>> a
tensor([ 0.2015, -0.4255,
2.6087])
>>> torch.mul(a, 100)
tensor([
20.1494,
-42.5491,
260.8663])

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

张量input的每个元素都乘以张量 other 的相应元素。返回运算结果的张量。

Input和other的shape必须是可以自动扩张的（broadcastable）。

参数

•  input (Tensor) – 第一个被乘数张量
  

• other (Tensor) – 第二个被乘数张量

关键字参数

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

举例:

>>> a = torch.randn(4, 1)
>>> a
tensor([[ 1.1207],
[-0.3137],
[ 0.0700],
[ 0.8378]])
>>> b = torch.randn(1, 4)
>>> b
tensor([[ 0.5146,
0.1216, -0.5244,
2.2382]])
>>> torch.mul(a, b)
tensor([[ 0.5767,
0.1363, -0.5877,
2.5083],
[-0.1614, -0.0382,
0.1645, -0.7021],
[ 0.0360,
0.0085, -0.0367,
0.1567],
[ 0.4312,
0.1019, -0.4394,
1.8753]])

4. 除法运算

torch.div(input, other, *, rounding_mode=None, out=None) → Tensor

将输入input的每个元素除以other的对应元素。

支持广播(broadcasting)到相同的shape、类型转换以及整数、浮点数和复数输入。

参数

•  input (Tensor) – 被除数
  

• other (Tensor or Number) – 除数

关键字参数

• rounding_mode (str, optional) – 应用于结果的舍入类型

1. None 默认行为。不执行舍入，如果输入和其他都是整数类型，则将输入转化为默认标量类型。相当于
 
Python 中的真正除法（/ 运算符）和 NumPy 的 np.true_divide
2. “trunc” - 将除法结果向零舍入。相当于 C 风格的整数除法。
3. “floor” - 将除法结果向下舍入。相当于 Python 中的楼层除法（// 运算符）和 NumPy 的 np.floor_divide。

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

举例:

>>> x = torch.tensor([ 0.3810,
1.2774, -0.2972, -0.3719,
0.4637])
>>> torch.div(x, 0.5)
tensor([ 0.7620,
2.5548, -0.5944, -0.7438,
0.9274])
>>> a = torch.tensor([[-0.3711, -1.9353, -0.4605, -0.2917],
...
[ 0.1815, -1.0111,
0.9805, -1.5923],
...
[ 0.1062,
1.4581,
0.7759, -1.2344],
...
[-0.1830, -0.0313,
1.1908, -1.4757]])
>>> b = torch.tensor([ 0.8032,
0.2930, -0.8113, -0.2308])
>>> torch.div(a, b)
tensor([[-0.4620, -6.6051,
0.5676,
1.2639],
[ 0.2260, -3.4509, -1.2086,
6.8990],
[ 0.1322,
4.9764, -0.9564,
5.3484],
[-0.2278, -0.1068, -1.4678,
6.3938]])
>>> torch.div(a, b, rounding_mode='trunc')
tensor([[-0., -6.,
0.,
1.],
[ 0., -3., -1.,
6.],
[ 0.,
4., -0.,
5.],
[-0., -0., -1.,
6.]])
>>> torch.div(a, b, rounding_mode='floor')
tensor([[-1., -7.,
0.,
1.],
[ 0., -4., -2.,
6.],
[ 0.,
4., -1.,
5.],
[-1., -1., -2.,
6.]])

5. 矩阵乘法

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

两个张量的矩阵乘积，行为取决于张量的维度，如下所示：

• 如果两个张量都是一维的，则返回点积（对应元素相乘再累加，从而得到一个标量）这种形况需要两个一维矩阵的size是一致的。
• 如果两个参数都是二维的，则返回矩阵-矩阵乘积。
• 如果第一个参数是一维的，而第二个参数是二维的，则为了矩阵乘法的目的，在其维度前面加上 1。在矩阵乘法之后，前置维度被删除。
• 如果第一个参数是二维的，第二个参数是一维的，则返回矩阵向量乘积。
• 如果两个参数都至少是一维的并且至少一个参数是 N 维的（其中 N > 2），则返回批处理(batched)矩阵乘法。如果第一个参数是一维的，为了批量(batched)矩阵乘法的目的，在它的维度前面加上 1 并在之后删除。如果第二个参数是一维的，则为了批处理(batched)矩阵乘法的目的，将 1 附加到其维度并在之后删除。非矩阵（即批量）维度被广播（因此必须是可广播的）。例如，如果输入是一个 张量，其他是一个 张量，输出将是张量。请注意，广播逻辑在确定输入是否可广播时仅查看批次维度，而不是矩阵维度。例如，如果输入是一个 (j×1×n×m)(j times 1 times n times m)(j×1×n×m) 张量，其他是一个 (k×m×p)( k times m times p)(k×m×p) 张量，即使最后两个维度（即矩阵维度）不同，这些输入对于广播也是有效的。 out 将是一个 (j×k×n×p)(j times k times n times p)(j×k×n×p) 张量。

此运算符支持 TensorFloat32。

参数

• input (Tensor) – 第一个被乘数张量

• other (Tensor) – 第二个被乘数张量

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> # vector x vector
>>> tensor1 = torch.randn(3)
>>> tensor2 = torch.randn(3)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([])
>>> # matrix x vector
>>> tensor1 = torch.randn(3, 4)
>>> tensor2 = torch.randn(4)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([3])
>>> # batched matrix x broadcasted vector
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(4)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3])
>>> # batched matrix x batched matrix
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(10, 4, 5)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3, 5])
>>> # batched matrix x broadcasted matrix
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(4, 5)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3, 5])

6. 幂运算

torch.pow(input, exponent, *, out=None) → Tensor

用指数exponent计算输入input中每​​个元素的幂，并返回一个带有计算结果的张量。指数可以是单个浮点数或具有与输入相同数量的元素的张量。

• 当指数是标量值时，应用的操作是：

• 当指数是张量时，应用的操作是：

 当指数是张量时，输入和指数的形状必须是可自动扩展（broadcastable）的。

参数

• input (Tensor) – input 张量.

• exponent (float or tensor) – 指数值

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(4)
>>> a
tensor([ 0.4331,
1.2475,
0.6834, -0.2791])
>>> torch.pow(a, 2)
tensor([ 0.1875,
1.5561,
0.4670,
0.0779])
>>> exp = torch.arange(1., 5.)
>>> a = torch.arange(1., 5.)
>>> a
tensor([ 1.,
2.,
3.,
4.])
>>> exp
tensor([ 1.,
2.,
3.,
4.])
>>> torch.pow(a, exp)
tensor([
1.,
4.,
27.,
256.])

torch.pow(self, exponent, *, out=None) → Tensor

self 是标量浮点值，指数exponent是张量。返回的张量与指数exponent形状相同

应用的操作是：

参数

• self (float) – self 是幂运算的标量基值

• exponent (Tensor) – 指数 exponent 张量

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> exp = torch.arange(1., 5.)
>>> exp
tensor([1., 2., 3., 4.])
>>> base = 2
>>> torch.pow(base, exp)
tensor([
2.,
4.,
8.,
16.])

7. 开方运算

torch.sqrt(input, *, out=None) → Tensor

返回具有输入input元素平方根的新张量。

参数

• input (Tensor) – input 张量.

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(4)
>>> a
tensor([-2.0755,
1.0226,
0.0831,
0.4806])
>>> torch.sqrt(a)
tensor([
nan,
1.0112,
0.2883,
0.6933])

torch.rsqrt(input, *, out=None) → Tensor

返回一个新的张量，它是输入的每个元素的平方根的倒数。

参数

• input (Tensor) – input 张量.

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(4)
>>> a
tensor([-0.0370,
0.2970,
1.5420, -0.9105])
>>> torch.rsqrt(a)
tensor([
nan,
1.8351,
0.8053,
nan])

8.指数与对数运算

torch.exp(input, *, out=None) → Tensor

返回具有输入张量 input 元素的指数的新张量。

参数

• input (Tensor) – input 张量.

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> torch.exp(torch.tensor([0, math.log(2.)]))
tensor([ 1.,
2.])

torch.log(input, *, out=None) → Tensor

返回具有输入元素的自然对数的新张量。

参数

• input (Tensor) – input 张量.

关键字参数

out (Tensor, optional) – the output tensor.

举例:

import torch
a = torch.exp(torch.ones(2, 2))
# 得到2*2的全是e的Tensor
print(a)
print(torch.log(a))
# 取自然对数

输出结果：

tensor([[2.7183, 2.7183],
[2.7183, 2.7183]])
tensor([[1., 1.],
[1., 1.]])

9.近似值运算

torch.round(input, *, out=None) → Tensor

返回一个新的张量，其中输入的每个元素都四舍五入为最接近的整数。

参数

• input (Tensor) – input 张量.

关键字参数

out (Tensor, optional) – the output tensor.

举例:

>>> a = torch.randn(4)
>>> a
tensor([ 0.9920,
0.6077,
0.9734, -1.0362])
>>> torch.round(a)
tensor([ 1.,
1.,
1., -1.])

最后

以上就是缓慢黄蜂为你收集整理的Pytorch 数学计算torch.pow(input, exponent, *, out=None) → Tensor的全部内容，希望文章能够帮你解决Pytorch 数学计算torch.pow(input, exponent, *, out=None) → Tensor所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。