Pointwise Ops

torch.abs

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

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

例子：

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

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.add()

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

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

如果输入input是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

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

>>> a = torch.randn(4)>>> a 0.4050-1.2227 1.8688-0.4185[torch.FloatTensor of size 4]>>> torch.add(a, 20) 20.4050 18.7773 21.8688 19.5815[torch.FloatTensor of size 4]

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

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

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

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

如果other是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

参数:

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

例子：

>>> import torch>>> a = torch.randn(4)>>> a-0.9310 2.0330 0.0852-0.2941[torch.FloatTensor of size 4]>>> b = torch.randn(2, 2)>>> b 1.0663 0.2544-0.1513 0.0749[torch.FloatTensor of size 2x2]>>> torch.add(a, 10, b) 9.7322 4.5770-1.4279 0.4552[torch.FloatTensor of size 4]

torch.addcdiv

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

用tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。

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

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

参数：

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

例子：

>>> t = torch.randn(2, 3)>>> 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) – 张量，对tensor1 ./ tensor 进行相加
• value (Number, optional) – 标量，对 tensor1 . tensor2 进行相乘
• tensor1 (Tensor) – 张量，作为乘子1
• tensor2 (Tensor) –张量，作为乘子2
• out (Tensor, optional) – 输出张量

例子：

>>> t = torch.randn(2, 3)>>> t1 = torch.randn(1, 6)>>> t2 = torch.randn(6, 1)>>> torch.addcmul(t, 0.1, t1, t2) 0.0122 -0.0188 -0.2354 0.7396 -1.5721 1.2878[torch.FloatTensor of size 2x3]

torch.asin

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

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

参数：

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

例子：

>>> a = torch.randn(4)>>> a-0.6366 0.2718 0.4469 1.3122[torch.FloatTensor of size 4]>>> torch.asin(a)-0.6900 0.2752 0.4633 nan[torch.FloatTensor of size 4]

torch.atan

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

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

参数：

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

例子：

>>> a = torch.randn(4)>>> a-0.6366 0.2718 0.4469 1.3122[torch.FloatTensor of size 4]>>> torch.atan(a)-0.5669 0.2653 0.4203 0.9196[torch.FloatTensor of size 4]

torch.atan2

torch.atan2(input1, input2, out=None) → Tensor

返回一个新张量，包含两个输入张量input1和input2的反正切函数

参数：

• input1 (Tensor) – 第一个输入张量
• input2 (Tensor) – 第二个输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)>>> a-0.6366 0.2718 0.4469 1.3122[torch.FloatTensor of size 4]>>> torch.atan2(a, torch.randn(4))-2.4167 2.9755 0.9363 1.6613[torch.FloatTensor of size 4]

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.clamp

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

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

操作定义如下：

| min, if x_i < miny_i = | x_i, if min <= x_i <= max | max, if x_i > max

如果输入是FloatTensor or DoubleTensor类型，则参数min max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min， max取整数、实数皆可。】

参数：

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

例子：

>>> 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.clamp(input, *, min, out=None) → Tensor

将输入input张量每个元素的限制到不小于min ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 min 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min取整数、实数皆可。】

参数：

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

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> torch.clamp(a, min=0.5) 1.3869 0.5000 0.5000 0.5000[torch.FloatTensor of size 4]

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

将输入input张量每个元素的限制到不大于max ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，max取整数、实数皆可。】

参数：

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

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> torch.clamp(a, max=0.5) 0.5000 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]

torch.cos

torch.cos(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.cos(a) 0.8041 0.9633 0.9018 0.2557[torch.FloatTensor of size 4]

torch.cosh

torch.cosh(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.cosh(a) 1.2095 1.0372 1.1015 1.9917[torch.FloatTensor of size 4]

torch.div()

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

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

如果输入是FloatTensor or DoubleTensor类型，则参数 value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• value (Number) – 除数
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(5)>>> a-0.6147-1.1237-0.1604-0.6853 0.1063[torch.FloatTensor of size 5]>>> torch.div(a, 0.5)-1.2294-2.2474-0.3208-1.3706 0.2126[torch.FloatTensor of size 5]

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

两张量input和other逐元素相除，并将结果返回到输出。即， ( out_i= input_i / other_i )

两张量形状不须匹配，但元素数须一致。

注意：当形状不匹配时，input的形状作为输出张量的形状。

参数：

• input (Tensor) – 张量(分子)
• other (Tensor) – 张量(分母)
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4,4)>>> a-0.1810 0.4017 0.2863 -0.1013 0.6183 2.0696 0.9012 -1.5933 0.5679 0.4743 -0.0117 -0.1266-0.1213 0.9629 0.2682 1.5968[torch.FloatTensor of size 4x4]>>> b = torch.randn(8, 2)>>> b 0.8774 0.7650 0.8866 1.4805-0.6490 1.1172 1.4259 -0.8146 1.4633 -0.1228 0.4643 -0.6029 0.3492 1.5270 1.6103 -0.6291[torch.FloatTensor of size 8x2]>>> torch.div(a, b)-0.2062 0.5251 0.3229 -0.0684-0.9528 1.8525 0.6320 1.9559 0.3881 -3.8625 -0.0253 0.2099-0.3473 0.6306 0.1666 -2.5381[torch.FloatTensor of size 4x4]

torch.exp

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

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

参数：

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

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

torch.floor

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

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

参数：

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

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> torch.floor(a) 1 0-1-1[torch.FloatTensor of size 4]

torch.fmod

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

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

参数：

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

例子：

>>> 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.remainder(), 计算逐元素余数， 相当于python 中的 % 操作符。

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做线性插值， 将结果返回到输出张量。

即，( out_i=start_i+weight∗(end_i−start_i) )

参数：

• 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.log

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

计算input 的自然对数

参数：

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

例子：

>>> a = torch.randn(5)>>> a-0.4183 0.3722-0.3091 0.4149 0.5857[torch.FloatTensor of size 5]>>> torch.log(a) nan-0.9883 nan-0.8797-0.5349[torch.FloatTensor of size 5]

torch.log1p

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

计算 ( input +1 )的自然对数 ( y_i=log(x_i+1) )

注意：对值比较小的输入，此函数比torch.log()更准确。

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

参数：

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

例子：

>>> a = torch.randn(5)>>> a-0.4183 0.3722-0.3091 0.4149 0.5857[torch.FloatTensor of size 5]>>> torch.log1p(a)-0.5418 0.3164-0.3697 0.3471 0.4611[torch.FloatTensor of size 5]

torch.mul

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

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

如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，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]

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

两个张量input,other按元素进行相乘，并返回到输出张量。即计算( out_i=input_i ∗ other_i )

两计算张量形状不须匹配，但总元素数须一致。 注意：当形状不匹配时，input的形状作为输入张量的形状。

参数：

• input (Tensor) – 第一个相乘张量
• other (Tensor) – 第二个相乘张量
• out (Tensor, optional) – 结果张量

例子：

>>> 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.neg

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

返回一个新张量，包含输入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相同元素数的张量。

当幂值为标量时，执行操作：

$$ out_i=x^{exponent} $$

当幂值为张量时，执行操作：

$$ out_i=x^{exponent_i} $$

参数：

• 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 与输入张量相同形状。

执行操作为:

$$ out_i=base^{input_i} $$

参数：

• base (float) – 标量值，指数的底
• input ( Tensor) – 幂值
• out (Tensor, optional) – 输出张量

例子：

>>> exp = torch.arange(1, 5)>>> base = 2>>> torch.pow(base, exp) 2 4 8 16[torch.FloatTensor of size 4]

torch.reciprocal

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

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

参数：

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

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> torch.reciprocal(a) 0.7210 2.5565-1.1583-1.8289[torch.FloatTensor of size 4]

torch.remainder

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

返回一个新张量，包含输入input张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。

参数：

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

例子：

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

参考: 函数torch.fmod() 同样可以计算除法余数，相当于 C 的 库函数fmod()

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.rsqrt

torch.rsqrt(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.rsqrt(a) 0.9020 0.8636 nan nan[torch.FloatTensor of size 4]

torch.sigmoid

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

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

参数：

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

例子：

>>> a = torch.randn(4)>>> a-0.4972 1.3512 0.1056-0.2650[torch.FloatTensor of size 4]>>> torch.sigmoid(a) 0.3782 0.7943 0.5264 0.4341[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]

torch.sin

torch.sin(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.sin(a)-0.5944 0.2684 0.4322 0.9667[torch.FloatTensor of size 4]

torch.sinh

torch.sinh(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.sinh(a)-0.6804 0.2751 0.4619 1.7225[torch.FloatTensor of size 4]

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.tan

torch.tan(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.tan(a)-0.7392 0.2786 0.4792 3.7801[torch.FloatTensor of size 4]

torch.tanh

torch.tanh(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.tanh(a)-0.5625 0.2653 0.4193 0.8648[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]