逐点行动

译者:ApacheCN

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

计算给定input张量的逐元素绝对值。

参数:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

例:

>>> torch.abs(torch.tensor([-1, -2, 3]))
tensor([ 1,  2,  3])
torch.acos(input, out=None) → Tensor

返回带有input元素的反余弦的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.3348, -0.5889,  0.2005, -0.1584])
>>> torch.acos(a)
tensor([ 1.2294,  2.2004,  1.3690,  1.7298])
torch.add()
torch.add(input, value, out=None)

将标量value添加到输入input的每个元素并返回新的结果张量。

如果input的类型为FloatTensor或DoubleTensor,则value必须是实数,否则应为整数。

Parameters:

  • 输入Tensor) - 输入张量
  • 号码) - 要添加到input的每个元素的数字
关键字参数:

Example:

>>> 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])
torch.add(input, value=1, other, out=None)

张量other的每个元素乘以标量value并添加到张量input的每个元素。返回结果张量。

inputother的形状必须是可播放的

如果other的类型为FloatTensor或DoubleTensor,则value必须是实数,否则应为整数。

Parameters:

  • 输入Tensor) - 第一个输入张量
  • 数字) - other的标量乘数
  • 其他Tensor) - 第二个输入张量
Keyword Arguments:
?

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.9732, -0.3497,  0.6245,  0.4022])
>>> b = torch.randn(4, 1)
>>> b
tensor([[ 0.3743],
 [-1.7724],
 [-0.5811],
 [-0.8017]])
>>> torch.add(a, 10, b)
tensor([[  2.7695,   3.3930,   4.3672,   4.1450],
 [-18.6971, -18.0736, -17.0994, -17.3216],
 [ -6.7845,  -6.1610,  -5.1868,  -5.4090],
 [ -8.9902,  -8.3667,  -7.3925,  -7.6147]])
torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

通过tensor2执行tensor1的逐元素划分,将结果乘以标量value并将其添加到 tensor

tensortensor1tensor2的形状必须是可播放的

对于FloatTensorDoubleTensor类型的输入,value必须是实数,否则是整数。

Parameters:

  • 张量Tensor) - 要加的张量
  • 可选) - 的乘数
  • tensor1Tensor) - 分子张量
  • 张量2张量 ) - 分母张量
  • outTensor 任选) - 输出张量

Example:

>>> t = torch.randn(1, 3)
>>> t1 = torch.randn(3, 1)
>>> t2 = torch.randn(1, 3)
>>> torch.addcdiv(t, 0.1, t1, t2)
tensor([[-0.2312, -3.6496,  0.1312],
 [-1.0428,  3.4292, -0.1030],
 [-0.5369, -0.9829,  0.0430]])
torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

通过tensor2执行tensor1的逐元素乘法,将结果乘以标量value并将其添加到 tensor

The shapes of tensor, tensor1, and tensor2 must be broadcastable.

For inputs of type FloatTensor or DoubleTensor, value must be a real number, otherwise an integer.

Parameters:

  • 张量Tensor) - 要加的张量
  • 可选) - 的乘数
  • tensor1Tensor) - 要倍增的张量
  • tensor2Tensor) - 要倍增的张量
  • outTensor 任选) - 输出张量

Example:

>>> t = torch.randn(1, 3)
>>> t1 = torch.randn(3, 1)
>>> t2 = torch.randn(1, 3)
>>> torch.addcmul(t, 0.1, t1, t2)
tensor([[-0.8635, -0.6391,  1.6174],
 [-0.7617, -0.5879,  1.7388],
 [-0.8353, -0.6249,  1.6511]])
torch.asin(input, out=None) → Tensor

返回具有input元素的反正弦的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.5962,  1.4985, -0.4396,  1.4525])
>>> torch.asin(a)
tensor([-0.6387,     nan, -0.4552,     nan])
torch.atan(input, out=None) → Tensor

返回带有input元素反正切的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.2341,  0.2539, -0.6256, -0.6448])
>>> torch.atan(a)
tensor([ 0.2299,  0.2487, -0.5591, -0.5727])
torch.atan2(input1, input2, out=None) → Tensor

返回带有input1input2元素的反正切的新张量。

input1input2的形状必须是可播放的

Parameters:

  • input1Tensor) - 第一个输入张量
  • input2Tensor) - 第二个输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.9041,  0.0196, -0.3108, -2.4423])
>>> torch.atan2(a, torch.randn(4))
tensor([ 0.9833,  0.0811, -1.9743, -1.4151])
torch.ceil(input, out=None) → Tensor

返回具有input元素的ceil的新张量,该元素是大于或等于每个元素的最小整数。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.6341, -1.4208, -1.0900,  0.5826])
>>> torch.ceil(a)
tensor([-0., -1., -1.,  1.])
torch.clamp(input, min, max, out=None) → Tensor

input中的所有元素钳位到[ minmax ]范围内并返回结果张量:

如果input的类型为FloatTensorDoubleTensor,则 minmax 必须为实数,否则它们应为整数。

Parameters:

  • 输入Tensor) - 输入张量
  • minNumber ) - 要被钳位的范围的下限
  • maxNumber ) - 要钳位的范围的上限
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-1.7120,  0.1734, -0.0478, -0.0922])
>>> torch.clamp(a, min=-0.5, max=0.5)
tensor([-0.5000,  0.1734, -0.0478, -0.0922])
torch.clamp(input, *, min, out=None) → Tensor

input中的所有元素钳位为大于或等于 min

如果input的类型为FloatTensorDoubleTensor,则value应为实数,否则应为整数。

Parameters:

  • 输入Tensor) - 输入张量
  • 数字) - 输出中每个元素的最小值
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.0299, -2.3184,  2.1593, -0.8883])
>>> torch.clamp(a, min=0.5)
tensor([ 0.5000,  0.5000,  2.1593,  0.5000])
torch.clamp(input, *, max, out=None) → Tensor

input中的所有元素钳位为小于或等于 max

If input is of type FloatTensor or DoubleTensor, value should be a real number, otherwise it should be an integer.

Parameters:

  • 输入Tensor) - 输入张量
  • 数字) - 输出中每个元素的最大值
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.7753, -0.4702, -0.4599,  1.1899])
>>> torch.clamp(a, max=0.5)
tensor([ 0.5000, -0.4702, -0.4599,  0.5000])
torch.cos(input, out=None) → Tensor

返回具有input元素的余弦的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 1.4309,  1.2706, -0.8562,  0.9796])
>>> torch.cos(a)
tensor([ 0.1395,  0.2957,  0.6553,  0.5574])
torch.cosh(input, out=None) → Tensor

返回具有input元素的双曲余弦值的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.1632,  1.1835, -0.6979, -0.7325])
>>> torch.cosh(a)
tensor([ 1.0133,  1.7860,  1.2536,  1.2805])
torch.div()
torch.div(input, value, out=None) → Tensor

将输入input的每个元素与标量value分开,并返回一个新的结果张量。

如果input的类型为FloatTensorDoubleTensorvalue应为实数,否则应为整数

Parameters:

  • 输入Tensor) - 输入张量
  • 号码) - 要分配给input的每个元素的数字
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(5)
>>> a
tensor([ 0.3810,  1.2774, -0.2972, -0.3719,  0.4637])
>>> torch.div(a, 0.5)
tensor([ 0.7620,  2.5548, -0.5944, -0.7439,  0.9275])
torch.div(input, other, out=None) → Tensor

张量input的每个元素除以张量other的每个元素。返回结果张量。 inputother的形状必须是可播放的

Parameters:

  • 输入Tensor) - 分子张量
  • 其他Tensor) - 分母张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4, 4)
>>> a
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.randn(4)
>>> b
tensor([ 0.8032,  0.2930, -0.8113, -0.2308])
>>> torch.div(a, b)
tensor([[-0.4620, -6.6051,  0.5676,  1.2637],
 [ 0.2260, -3.4507, -1.2086,  6.8988],
 [ 0.1322,  4.9764, -0.9564,  5.3480],
 [-0.2278, -0.1068, -1.4678,  6.3936]])
torch.digamma(input, out=None) → Tensor

计算input上伽玛函数的对数导数。

参数: 输入Tensor) - 计算digamma函数的张量

Example:

>>> a = torch.tensor([1, 0.5])
>>> torch.digamma(a)
tensor([-0.5772, -1.9635])
torch.erf(tensor, out=None) → Tensor

计算每个元素的错误函数。错误函数定义如下:

Parameters:

  • 张量张量 ) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.erf(torch.tensor([0, -1., 10.]))
tensor([ 0.0000, -0.8427,  1.0000])
torch.erfc(input, out=None) → Tensor

计算input的每个元素的互补误差函数。互补误差函数定义如下:

Parameters:

  • 张量张量 ) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.erfc(torch.tensor([0, -1., 10.]))
tensor([ 1.0000, 1.8427,  0.0000])
torch.erfinv(input, out=None) → Tensor

计算input的每个元素的反向误差函数。反向误差函数在 范围内定义为:

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.erfinv(torch.tensor([0, 0.5, -1.]))
tensor([ 0.0000,  0.4769,    -inf])
torch.exp(input, out=None) → Tensor

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

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.exp(torch.tensor([0, math.log(2.)]))
tensor([ 1.,  2.])
torch.expm1(input, out=None) → Tensor

返回一个新的张量,其元素的指数减去input的1。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.expm1(torch.tensor([0, math.log(2.)]))
tensor([ 0.,  1.])
torch.floor(input, out=None) → Tensor

返回一个新的张量,其中包含input元素的最低值,这是每个元素小于或等于的最大整数。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.8166,  1.5308, -0.2530, -0.2091])
>>> torch.floor(a)
tensor([-1.,  1., -1., -1.])
torch.fmod(input, divisor, out=None) → Tensor

计算除法的元素余数。

被除数和除数可以包含整数和浮点数。余数与被除数input具有相同的符号。

divisor是张量时,inputdivisor的形状必须是可广播

Parameters:

  • 输入Tensor) - 股息
  • 除数张量 漂浮 ) - 除数,可能是与被除数相同形状的数字或张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.fmod(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
tensor([-1., -0., -1.,  1.,  0.,  1.])
>>> torch.fmod(torch.tensor([1., 2, 3, 4, 5]), 1.5)
tensor([ 1.0000,  0.5000,  0.0000,  1.0000,  0.5000])
torch.frac(input, out=None) → Tensor

计算input中每个元素的小数部分。

Example:

>>> torch.frac(torch.tensor([1, 2.5, -3.2]))
tensor([ 0.0000,  0.5000, -0.2000])
torch.lerp(start, end, weight, out=None)

是否基于标量weight对两个张量startend进行线性插值,并返回得到的out张量。

startend的形状必须是可播放的

Parameters:

  • 启动Tensor) - 张量与起点
  • 结束Tensor) - 带有终点的张量
  • 体重漂浮 ) - 插值公式的权重
  • outTensor 任选) - 输出张量

Example:

>>> start = torch.arange(1., 5.)
>>> end = torch.empty(4).fill_(10)
>>> start
tensor([ 1.,  2.,  3.,  4.])
>>> end
tensor([ 10.,  10.,  10.,  10.])
>>> torch.lerp(start, end, 0.5)
tensor([ 5.5000,  6.0000,  6.5000,  7.0000])
torch.log(input, out=None) → Tensor

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

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(5)
>>> a
tensor([-0.7168, -0.5471, -0.8933, -1.4428, -0.1190])
>>> torch.log(a)
tensor([ nan,  nan,  nan,  nan,  nan])
torch.log10(input, out=None) → Tensor

返回一个新的张量,其对数为input元素的基数10。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.rand(5)
>>> a
tensor([ 0.5224,  0.9354,  0.7257,  0.1301,  0.2251])

>>> torch.log10(a)
tensor([-0.2820, -0.0290, -0.1392, -0.8857, -0.6476])
torch.log1p(input, out=None) → Tensor

返回一个自然对数为(1 + input)的新张量。

注意

对于input的小值,此函数比 torch.log() 更准确

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(5)
>>> a
tensor([-1.0090, -0.9923,  1.0249, -0.5372,  0.2492])
>>> torch.log1p(a)
tensor([    nan, -4.8653,  0.7055, -0.7705,  0.2225])
torch.log2(input, out=None) → Tensor

返回一个新的张量,其对数为input元素的基数2。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.rand(5)
>>> a
tensor([ 0.8419,  0.8003,  0.9971,  0.5287,  0.0490])

>>> torch.log2(a)
tensor([-0.2483, -0.3213, -0.0042, -0.9196, -4.3504])
torch.mul()
torch.mul(input, value, out=None)

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

If input is of type FloatTensor or DoubleTensor, value should be a real number, otherwise it should be an integer

Parameters:

  • 输入Tensor) - 输入张量
  • 号码) - 要与input的每个元素相乘的数字
  • outTensor 任选) - 输出张量

Example:

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

张量input的每个元素乘以张量other的每个元素。返回结果张量。

The shapes of input and other must be broadcastable.

Parameters:

  • 输入Tensor) - 第一个被乘数张量
  • 其他Tensor) - 第二个被乘数张量
  • outTensor 任选) - 输出张量

Example:

>>> 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]])
torch.mvlgamma(input, p) → Tensor

用维度 元素计算多变量log-gamma函数,由下式给出:

其中 是Gamma函数。

如果任何元素小于或等于 ,则抛出错误。

Parameters:

  • 输入Tensor) - 计算多变量log-gamma函数的张量
  • pint) - 维数

Example:

>>> a = torch.empty(2, 3).uniform_(1, 2)
>>> a
tensor([[1.6835, 1.8474, 1.1929],
 [1.0475, 1.7162, 1.4180]])
>>> torch.mvlgamma(a, 2)
tensor([[0.3928, 0.4007, 0.7586],
 [1.0311, 0.3901, 0.5049]])
torch.neg(input, out=None) → Tensor

返回一个新的张量,其元素为input

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(5)
>>> a
tensor([ 0.0090, -0.2262, -0.0682, -0.2866,  0.3940])
>>> torch.neg(a)
tensor([-0.0090,  0.2262,  0.0682,  0.2866, -0.3940])
torch.pow()
torch.pow(input, exponent, out=None) → Tensor

使用exponent获取input中每个元素的功效,并返回带有结果的张量。

exponent可以是单个float编号,也可以是Tensor,其元素数与input相同。

exponent是标量值时,应用的操作是:

exponent是张量时,应用的操作是:

exponent是张量时,inputexponent的形状必须是可广播

Parameters:

  • 输入Tensor) - 输入张量
  • 指数float 张量) - 指数值
  • outTensor 任选) - 输出张量

Example:

>>> 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(base, input, out=None) → Tensor

base是标量float值,input是张量。返回的张量outinput具有相同的形状

适用的操作是:

Parameters:

  • basefloat) - 电源操作的标量基值
  • 输入Tensor) - 指数张量
  • outTensor 任选) - 输出张量

Example:

>>> exp = torch.arange(1., 5.)
>>> base = 2
>>> torch.pow(base, exp)
tensor([  2.,   4.,   8.,  16.])
torch.reciprocal(input, out=None) → Tensor

返回具有input元素倒数的新张量

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.4595, -2.1219, -1.4314,  0.7298])
>>> torch.reciprocal(a)
tensor([-2.1763, -0.4713, -0.6986,  1.3702])
torch.remainder(input, divisor, out=None) → Tensor

Computes the element-wise remainder of division.

除数和被除数可以包含整数和浮点数。其余部分与除数具有相同的符号。

When divisor is a tensor, the shapes of input and divisor must be broadcastable.

Parameters:

  • 输入Tensor) - 股息
  • 除数张量 漂浮 ) - 可能是一个除数数字或与被除数相同形状的张量
  • outTensor 任选) - 输出张量

Example:

>>> torch.remainder(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
tensor([ 1.,  0.,  1.,  1.,  0.,  1.])
>>> torch.remainder(torch.tensor([1., 2, 3, 4, 5]), 1.5)
tensor([ 1.0000,  0.5000,  0.0000,  1.0000,  0.5000])

也可以看看

torch.fmod() ,它计算与C库函数fmod()等效的除法的元素余数。

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

返回一个新的张量,input的每个元素四舍五入到最接近的整数。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.9920,  0.6077,  0.9734, -1.0362])
>>> torch.round(a)
tensor([ 1.,  1.,  1., -1.])
torch.rsqrt(input, out=None) → Tensor

返回一个新的张量,其具有input的每个元素的平方根的倒数。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.0370,  0.2970,  1.5420, -0.9105])
>>> torch.rsqrt(a)
tensor([    nan,  1.8351,  0.8053,     nan])
torch.sigmoid(input, out=None) → Tensor

返回带有input元素的sigmoid的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.9213,  1.0887, -0.8858, -1.7683])
>>> torch.sigmoid(a)
tensor([ 0.7153,  0.7481,  0.2920,  0.1458])
torch.sign(input, out=None) → Tensor

返回带有input元素符号的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.tensor([0.7, -1.2, 0., 2.3])
>>> a
tensor([ 0.7000, -1.2000,  0.0000,  2.3000])
>>> torch.sign(a)
tensor([ 1., -1.,  0.,  1.])
torch.sin(input, out=None) → Tensor

返回带有input元素正弦的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-0.5461,  0.1347, -2.7266, -0.2746])
>>> torch.sin(a)
tensor([-0.5194,  0.1343, -0.4032, -0.2711])
torch.sinh(input, out=None) → Tensor

返回具有input元素的双曲正弦的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.5380, -0.8632, -0.1265,  0.9399])
>>> torch.sinh(a)
tensor([ 0.5644, -0.9744, -0.1268,  1.0845])
torch.sqrt(input, out=None) → Tensor

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

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

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

返回具有input元素正切的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([-1.2027, -1.7687,  0.4412, -1.3856])
>>> torch.tan(a)
tensor([-2.5930,  4.9859,  0.4722, -5.3366])
torch.tanh(input, out=None) → Tensor

返回具有input元素的双曲正切的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 0.8986, -0.7279,  1.1745,  0.2611])
>>> torch.tanh(a)
tensor([ 0.7156, -0.6218,  0.8257,  0.2553])
torch.trunc(input, out=None) → Tensor

返回具有input元素的截断整数值的新张量。

Parameters:

  • 输入Tensor) - 输入张量
  • outTensor 任选) - 输出张量

Example:

>>> a = torch.randn(4)
>>> a
tensor([ 3.4742,  0.5466, -0.8008, -0.9079])
>>> torch.trunc(a)
tensor([ 3.,  0., -0., -0.])


Copyright © ibooker.org.cn 2019 all right reserved,由 ApacheCN 团队提供支持该文件修订时间: 2019-09-17 10:06:06

results matching ""

    No results matching ""

    results matching ""

      No results matching ""