Pointwise Ops
逐点行动
译者：ApacheCN
torch.abs(input, out=None) → Tensor
计算给定input张量的逐元素绝对值。
参数：
例：
>>> torch.abs(torch.tensor([-1, -2, 3]))
tensor([ 1, 2, 3])
torch.acos(input, out=None) → Tensor
返回带有input元素的反余弦的新张量。
Parameters:
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:
| 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 。
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
Example:
>>> torch.erf(torch.tensor([0, -1., 10.]))
tensor([ 0.0000, -0.8427, 1.0000])
torch.erfc(input, out=None) → Tensor
计算input的每个元素的互补误差函数。互补误差函数定义如下：
Parameters:
Example:
>>> torch.erfc(torch.tensor([0, -1., 10.]))
tensor([ 1.0000, 1.8427, 0.0000])
torch.erfinv(input, out=None) → Tensor
计算input的每个元素的反向误差函数。反向误差函数在 
范围内定义为：
Parameters:
Example:
>>> torch.erfinv(torch.tensor([0, 0.5, -1.]))
tensor([ 0.0000, 0.4769, -inf])
torch.exp(input, out=None) → Tensor
返回具有输入张量input元素的指数的新张量。
Parameters:
Example:
>>> torch.exp(torch.tensor([0, math.log(2.)]))
tensor([ 1., 2.])
torch.expm1(input, out=None) → Tensor
返回一个新的张量，其元素的指数减去input的1。
Parameters:
Example:
>>> torch.expm1(torch.tensor([0, math.log(2.)]))
tensor([ 0., 1.])
torch.floor(input, out=None) → Tensor
返回一个新的张量，其中包含input元素的最低值，这是每个元素小于或等于的最大整数。
Parameters:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
Example:
>>> a = torch.randn(4)
>>> a
tensor([ 3.4742, 0.5466, -0.8008, -0.9079])
>>> torch.trunc(a)
tensor([ 3., 0., -0., -0.])
