PyTorch学习笔记(四)

数学操作Math operations

torch.abs

1
torch.abs(input, out=None) → Tensor

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

例子：

1
2
>>> torch.abs(torch.FloatTensor([-1, -2, 3]))
FloatTensor([1, 2, 3])

torch.add()

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

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

参数：

  • input (Tensor) – 输入张量
  • value (Number) – 添加到输入每个元素的数
  • out (Tensor, optional) – 结果张量
1
torch.add(input, value=1, other, out=None)

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

两个张量 input and other的尺寸不需要匹配，但元素总数必须一样。

注意 :当两个张量形状不匹配时，输入张量的形状会作为输出张量的尺寸。

参数:

  • input (Tensor) – 第一个输入张量
  • value (Number) – 用于第二个张量的尺寸因子
  • other (Tensor) – 第二个输入张量
  • out (Tensor, optional) – 结果张量

torch.addcdiv

1
torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

用tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。即，$out=t1/t2*value+t$

张量的形状不需要匹配，但元素数量必须一致。

如果输入是FloatTensor or DoubleTensor类型，则value必须为实数，否则须为整数。

参数：

  • tensor (Tensor) – 张量，输出
  • value (Number, optional) – 标量，对 tensor1 ./ tensor2 进行相乘
  • tensor1 (Tensor) – 张量，作为被除数(分子)
  • tensor2 (Tensor) –张量，作为除数(分母)
  • out (Tensor, optional) – 输出张量

例子：

1
2
3
4
5
6
7
8
>>> t = torch.randn(1, 6)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcdiv(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.addcmul

1
torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor。 张量的形状不需要匹配，但元素数量必须一致。

如果输入是FloatTensor or DoubleTensor类型，则value必须为实数，否则须为整数。

参数：

  • tensor (Tensor) – 张量，输出
  • value (Number, optional) – 标量，对 tensor1 . tensor2 进行相乘
  • tensor1 (Tensor) – 张量，作为乘子1
  • tensor2 (Tensor) –张量，作为乘子2
  • out (Tensor, optional) – 输出张量

torch.mul

  1. 标量
1
torch.mul(input, value, out=None)

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

参数：

  • input (Tensor) – 输入张量
  • value (Number) – 乘到每个元素的数
  • out (Tensor, optional) – 输出张量

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> a = torch.randn(3)
>>> a

-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]

>>> torch.mul(a, 100)

-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]
  1. 张量
  • 对应元素相乘
1
torch.mul(input, other, out=None)

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>> a = torch.randn(4,4)
>>> a

-0.7280  0.0598 -1.4327 -0.5825
-0.1427 -0.0690  0.0821 -0.3270
-0.9241  0.5110  0.4070 -1.1188
-0.8308  0.7426 -0.6240 -1.1582
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(2, 8)
>>> b

 0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
-1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
[torch.FloatTensor of size 2x8]

>>> torch.mul(a, b)

-0.0313 -0.0645 -0.8618 -0.6784
 0.0934 -0.0021 -0.0137 -0.3513
 1.1638  0.0149 -0.0346 -0.5068
-1.0304 -0.3460  0.1148 -0.6919
[torch.FloatTensor of size 4x4]

torch.div()

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

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

torch.sqrt

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

返回一个新张量，包含输入input张量每个元素的平方根。

参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.sqrt(a)

 1.1086
 1.1580
    nan
    nan
[torch.FloatTensor of size 4]

torch.neg

1
torch.neg(input, out=None) → Tensor

返回一个新张量，包含输入input 张量按元素取负。 即， $out=−1∗input$
参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> a = torch.randn(5)
>>> a

-0.4430
 1.1690
-0.8836
-0.4565
 0.2968
[torch.FloatTensor of size 5]

>>> torch.neg(a)

 0.4430
-1.1690
 0.8836
 0.4565
-0.2968
[torch.FloatTensor of size 5]

torch.pow

1
torch.pow(input, exponent, out=None)

对输入input的按元素求exponent次幂值，并返回结果张量。 幂值exponent 可以为单一 float 数或者与input相同元素数的张量。

  • 当幂值为标量时，执行操作：
    $out_i=x^{exponent}$
  • 当幂值为张量时，执行操作：
    $out_i=x^{exponent_i}$

参数：

  • input (Tensor) – 输入张量
  • exponent (float or Tensor) – 幂值
  • out (Tensor, optional) – 输出张量

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
>>> a = torch.randn(4)
>>> a

-0.5274
-0.8232
-2.1128
 1.7558
[torch.FloatTensor of size 4]

>>> torch.pow(a, 2)

 0.2781
 0.6776
 4.4640
 3.0829
[torch.FloatTensor of size 4]

>>> exp = torch.arange(1, 5)
>>> a = torch.arange(1, 5)
>>> a

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

>>> exp

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

>>> torch.pow(a, exp)

   1
   4
  27
 256
[torch.FloatTensor of size 4]

同样底数可以为张量，指数为张量。

1
torch.pow(base, input, out=None)

base 为标量浮点值,input为张量， 返回的输出张量 out 与输入张量相同形状。

执行操作为:
$out_i=base^{input_i}$

torch.exp

1
torch.exp(tensor, out=None) → Tensor

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

torch.log

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

计算input 的自然对数。

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

1
torch.acos(input, out=None) → Tensor

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

参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> a = torch.randn(4)
>>> a

-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.acos(a)
 2.2608
 1.2956
 1.1075
    nan
[torch.FloatTensor of size 4]

torch.asin

1
torch.asin(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的反正弦函数。

torch.atan

1
torch.atan(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的反正切函数。

torch.sin

1
torch.sin(input, out=None) → Tensor

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

torch.cos

1
torch.cos(input, out=None) → Tensor

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

torch.tan

1
torch.tan(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的正切。

torch.sinh

1
torch.sinh(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的双曲正弦。

torch.cosh

1
torch.cosh(input, out=None) → Tensor

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

torch.tanh

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

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

torch.ceil

1
torch.ceil(input, out=None) → Tensor

天井函数，对输入input张量每个元素向上取整, 即取不小于每个元素的最小整数，并返回结果到输出。

参数：

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.ceil(a)

 2
 1
-0
-0
[torch.FloatTensor of size 4]

torch.floor

1
torch.floor(input, out=None) → Tensor

床函数: 返回一个新张量，包含输入input张量每个元素的floor，即不小于元素的最大整数。向下取整。

torch.round

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

返回一个新张量，将输入input张量每个元素舍入到最近的整数(四舍五入)。

参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.round(a)

 1
 1
-1
-0
[torch.FloatTensor of size 4]

torch.trunc

1
torch.trunc(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数，其比x更接近零。简而言之，有符号数的小数部分被舍弃)。

参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.trunc(a)

-0
 1
 0
-0
[torch.FloatTensor of size 4]

torch.clamp

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

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

公式：

参数：

  • input (Tensor) – 输入张量
  • min (Number) – 限制范围下限
  • max (Number) – 限制范围上限
  • out (Tensor, optional) – 输出张量

将输出限制到不小于0.5

1
torch.clamp(a, min=0.5)

将输出限制到不大于0.5

1
torch.clamp(a, max=0.5)

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=-0.5, max=0.5)

 0.5000
 0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]

torch.fmod

1
torch.fmod(input, divisor, out=None) → Tensor

计算除法余数。

除数与被除数可能同时含有整数和浮点数。此时，余数的正负与被除数相同。

参数：

  • input (Tensor) – 被除数
  • divisor (Tensor or float) – 除数，一个数或与被除数相同类型的张量
  • out (Tensor, optional) – 输出张量

torch.remainder用法相同。

1
torch.remainder(input, divisor, out=None) → Tensor

例子：

1
2
3
4
>>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([-1, -0, -1, 1, 0, 1])
>>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

torch.frac

1
torch.frac(tensor, out=None) → Tensor

返回每个元素的分数部分。

例子：

1
2
>>> torch.frac(torch.Tensor([1, 2.5, -3.2])
torch.FloatTensor([0, 0.5, -0.2])

torch.lerp

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

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

即，$out_i=start_i+weight∗(end_i−start_i)$
参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
>>> start = torch.arange(1, 5)
>>> end = torch.Tensor(4).fill_(10)
>>> start

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

>>> end

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

>>> torch.lerp(start, end, 0.5)

 5.5000
 6.0000
 6.5000
 7.0000
[torch.FloatTensor of size 4]

torch.sign

1
torch.sign(input, out=None) → Tensor

符号函数：返回一个新张量，包含输入input张量每个元素的正负。

参数：

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sign(a)

-1
 1
 1
 1
[torch.FloatTensor of size 4]