逐点行动

译者：ApacheCN

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

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

参数：

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

例：

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

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

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

Parameters:

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

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的每个元素。返回结果张量。

input和other的形状必须是可播放的。

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

Parameters:

• 输入 (Tensor） - 第一个输入张量
• 值(数字） - other的标量乘数
• 其他 (Tensor） - 第二个输入张量

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 。

tensor ，tensor1和tensor2的形状必须是可播放的。

对于FloatTensor或DoubleTensor类型的输入，value必须是实数，否则是整数。

Parameters:

• 张量 (Tensor） - 要加的张量
• 值(数 ， 可选） - 的乘数
• tensor1 (Tensor） - 分子张量
• 张量2 (tensor) - 分母张量
• out (Tensor， 任选） - 输出张量

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） - 要加的张量
• 值(数 ， 可选） - 的乘数
• tensor1 (Tensor） - 要倍增的张量
• tensor2 (Tensor） - 要倍增的张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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

返回带有input1和input2元素的反正切的新张量。

input1和input2的形状必须是可播放的。

Parameters:

• input1 (Tensor） - 第一个输入张量
• input2 (Tensor） - 第二个输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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中的所有元素钳位到[ min ， max ]范围内并返回结果张量：

如果input的类型为FloatTensor或DoubleTensor，则 min 和 max 必须为实数，否则它们应为整数。

Parameters:

• 输入 (Tensor） - 输入张量
• min (Number ) - 要被钳位的范围的下限
• max (Number ) - 要钳位的范围的上限
• out (Tensor， 任选） - 输出张量

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的类型为FloatTensor或DoubleTensor，则value应为实数，否则应为整数。

Parameters:

• 输入 (Tensor） - 输入张量
• 值(数字） - 输出中每个元素的最小值
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• 值(数字） - 输出中每个元素的最大值
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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的类型为FloatTensor或DoubleTensor，value应为实数，否则应为整数

Parameters:

• 输入 (Tensor） - 输入张量
• 值(号码） - 要分配给input的每个元素的数字
• out (Tensor， 任选） - 输出张量

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的每个元素。返回结果张量。 input和other的形状必须是可播放的。

Parameters:

• 输入 (Tensor） - 分子张量
• 其他 (Tensor） - 分母张量
• out (Tensor， 任选） - 输出张量

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上伽玛函数的对数导数。

Example:

>>> a = torch.tensor([1, 0.5])
>>> torch.digamma(a)
tensor([-0.5772, -1.9635])

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

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

Parameters:

• 张量 (tensor) - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

>>> torch.erf(torch.tensor([0, -1., 10.]))
tensor([ 0.0000, -0.8427,  1.0000])

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

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

Parameters:

• 张量 (tensor) - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

>>> torch.erfc(torch.tensor([0, -1., 10.]))
tensor([ 1.0000, 1.8427,  0.0000])

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

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

Parameters:

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

>>> torch.erfinv(torch.tensor([0, 0.5, -1.]))
tensor([ 0.0000,  0.4769,    -inf])

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

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

Parameters:

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

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

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

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

Parameters:

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

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

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

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

Parameters:

• 输入 (Tensor） - 输入张量
• out (Tensor， 任选） - 输出张量

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是张量时，input和divisor的形状必须是可广播。

Parameters:

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

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对两个张量start和end进行线性插值，并返回得到的out张量。

start和end的形状必须是可播放的。

Parameters:

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

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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的每个元素相乘的数字
• out (Tensor， 任选） - 输出张量

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） - 第二个被乘数张量
• out (Tensor， 任选） - 输出张量

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函数的张量
• p (int） - 维数

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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是张量时，input和exponent的形状必须是可广播。

Parameters:

• 输入 (Tensor） - 输入张量
• 指数 (float或 tensor） - 指数值
• out (Tensor， 任选） - 输出张量

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是张量。返回的张量out与input具有相同的形状

适用的操作是：

Parameters:

• base (float） - 电源操作的标量基值
• 输入 (Tensor） - 指数张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 股息
• 除数 (tensor 或 漂浮) - 可能是一个除数数字或与被除数相同形状的张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

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） - 输入张量
• out (Tensor， 任选） - 输出张量

Example:

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