PyTorch学习笔记(四)

蔚落 2022-08-29 15:54 303阅读 0赞

# PyTorch学习笔记(四) #

## 数学操作Math operations ##

### torch.abs ###

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

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

例子：

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

### torch.add() ###

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

对输入张量`input`逐元素加上标量值value，并返回结果到一个新的张量out，即  o u t = t e n s o r + v a l u e out=tensor+value out=tensor\+value。

参数：

*  input (Tensor) – 输入张量
 *  value (Number) – 添加到输入每个元素的数
 *  out (Tensor, optional) – 结果张量

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

`other`张量的每个元素乘以一个标量值`value`，并加到`input` 张量上。返回结果到输出张量`out`。即， o u t = i n p u t + ( o t h e r ∗ v a l u e ) out=input+(other∗value) out=input\+(other∗value)

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

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

参数:

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

### torch.addcdiv ###

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

用`tensor2`对`tensor1`逐元素相除，然后乘以标量值`value` 并加到tensor。即， o u t = t 1 / t 2 ∗ v a l u e + t out=t1/t2\*value+t out=t1/t2∗value\+t

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

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

参数：

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

例子：

>>> 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 ###

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.  标量

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

用**标量值value**乘以输入`input`的每个元素，并返回一个新的结果张量。  o u t = t e n s o r ∗ v a l u e out=tensor∗value out=tensor∗value

参数：

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

例子：

>>> 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.  张量

*  对应元素相乘

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

例子：

>>> 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() ###

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

将`input`逐元素除以标量值value，并返回结果到输出张量`out`。 即  o u t = t e n s o r / v a l u e out=tensor/value out=tensor/value

### torch.sqrt ###

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

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

参数：

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

例子：

>>> 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 ###

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

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

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

例子：

>>> 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 ###

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

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

*  当幂值为标量时，执行操作：  
     o u t i = x e x p o n e n t out\_i=x^\{exponent\} outi=xexponent
 *  当幂值为张量时，执行操作：  
     o u t i = x e x p o n e n t i out\_i=x^\{exponent\_i\} outi=xexponenti

参数：

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

例子：

>>> 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]

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

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

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

执行操作为:  
 o u t i = b a s e i n p u t i out\_i=base^\{input\_i\} outi=baseinputi

### torch.exp ###

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

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

### torch.log ###

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

计算`input` 的自然对数。

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

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

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

参数：

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

例子：

>>> 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 ###

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

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

### torch.atan ###

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

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

### torch.sin ###

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

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

### torch.cos ###

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

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

### torch.tan ###

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

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

### torch.sinh ###

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

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

### torch.cosh ###

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

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

### torch.tanh ###

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

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

### torch.ceil ###

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

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

参数：

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

>>> 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 ###

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

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

### torch.round ###

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

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

参数：

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

例子：

>>> 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 ###

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

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

参数：

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

例子：

>>> 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 ###

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

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

公式：  
 y i = \{ m i n , i f   x i < m i n x i , i f   m i n < = x i < = m a x m a x , i f   x i > m a x y\_i = \\begin\{cases\}min, if\\ x\_i < min \\\\ x\_i, if \\ min <= x\_i <= max \\\\max, if \\ x\_i > max\\end\{cases\} yi=⎩⎪⎨⎪⎧min,if xi<minxi,if min<=xi<=maxmax,if xi>max  
参数：

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

将输出限制到不小于0.5

torch.clamp(a, min=0.5)

将输出限制到不大于0.5

torch.clamp(a, max=0.5)

例子：

>>> 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 ###

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

计算除法余数。

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

参数：

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

**torch.remainde**r用法相同。

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

例子：

>>> 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 ###

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

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

例子：

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

### torch.lerp ###

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

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

即， o u t i = s t a r t i + w e i g h t ∗ ( e n d i − s t a r t i ) out\_i=start\_i+weight∗(end\_i−start\_i) outi=starti\+weight∗(endi−starti)  
参数：

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

例子：

>>> 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 ###

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

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

参数：

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

例子：

>>> 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]