Reduction Ops

torch.cumprod

torch.cumprod(input, dim, out=None) → Tensor

返回输入沿指定维度的累积积。例如，如果输入是一个N 元向量，则结果也是一个N 元向量，第i 个输出元素值为( yi=x1∗x2∗x3∗...∗xi )

参数：

• input (Tensor) – 输入张量
• dim (int) – 累积积操作的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(10)>>> a 1.1148 1.8423 1.4143-0.4403 1.2859-1.2514-0.4748 1.1735-1.6332-0.4272[torch.FloatTensor of size 10]>>> torch.cumprod(a, dim=0) 1.1148 2.0537 2.9045-1.2788-1.6444 2.0578-0.9770-1.1466 1.8726-0.8000[torch.FloatTensor of size 10]>>> a[5] = 0.0>>> torch.cumprod(a, dim=0) 1.1148 2.0537 2.9045-1.2788-1.6444-0.0000 0.0000 0.0000-0.0000 0.0000[torch.FloatTensor of size 10]

torch.cumsum

torch.cumsum(input, dim, out=None) → Tensor

返回输入沿指定维度的累积和。例如，如果输入是一个N元向量，则结果也是一个N元向量，第i 个输出元素值为 ( yi=x1+x2+x3+...+xi)

参数：

• input (Tensor) – 输入张量
• dim (int) – 累积和操作的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(10)>>> a-0.6039-0.2214-0.3705-0.0169 1.3415-0.1230 0.9719 0.6081-0.1286 1.0947[torch.FloatTensor of size 10]>>> torch.cumsum(a, dim=0)-0.6039-0.8253-1.1958-1.2127 0.1288 0.0058 0.9777 1.5858 1.4572 2.5519[torch.FloatTensor of size 10]

torch.dist

torch.dist(input, other, p=2, out=None) → Tensor

返回 (input - other) 的 p范数 。

参数：

• input (Tensor) – 输入张量
• other (Tensor) – 右侧输入张量
• p (float, optional) – 所计算的范数
• out (Tensor, optional) – 结果张量

例子：

>>> x = torch.randn(4)>>> x 0.2505-0.4571-0.3733 0.7807[torch.FloatTensor of size 4]>>> y = torch.randn(4)>>> y 0.7782-0.5185 1.4106-2.4063[torch.FloatTensor of size 4]>>> torch.dist(x, y, 3.5)3.302832063224223>>> torch.dist(x, y, 3)3.3677282206393286>>> torch.dist(x, y, 0)inf>>> torch.dist(x, y, 1)5.560028076171875

torch.mean

torch.mean(input) → float

返回输入张量所有元素的均值。

参数： input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a-0.2946 -0.9143 2.1809[torch.FloatTensor of size 1x3]>>> torch.mean(a)0.32398951053619385

torch.mean(input, dim, out=None) → Tensor

返回输入张量给定维度dim上每行的均值。

输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• dim (int) – the dimension to reduce
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4, 4)>>> a-1.2738 -0.3058 0.1230 -1.9615 0.8771 -0.5430 -0.9233 0.9879 1.4107 0.0317 -0.6823 0.2255-1.3854 0.4953 -0.2160 0.2435[torch.FloatTensor of size 4x4]>>> torch.mean(a, 1)-0.8545 0.0997 0.2464-0.2157[torch.FloatTensor of size 4x1]

torch.median

torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的LongTensor。

dim值默认为输入张量的最后一维。 输出形状与输入相同，除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

参数：

• input (Tensor) – 输入张量
• dim (int) – 缩减的维度
• values (Tensor, optional) – 结果张量
• indices (Tensor, optional) – 返回的索引结果张量

>>> a -0.6891 -0.6662 0.2697 0.7412 0.5254 -0.7402 0.5528 -0.2399[torch.FloatTensor of size 4x2]>>> a = torch.randn(4, 5)>>> a 0.4056 -0.3372 1.0973 -2.4884 0.4334 2.1336 0.3841 0.1404 -0.1821 -0.7646-0.2403 1.3975 -2.0068 0.1298 0.0212-1.5371 -0.7257 -0.4871 -0.2359 -1.1724[torch.FloatTensor of size 4x5]>>> torch.median(a, 1)( 0.4056 0.1404 0.0212-0.7257[torch.FloatTensor of size 4x1], 0 2 4 1[torch.LongTensor of size 4x1])

torch.mode

torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回给定维dim上，每行的众数值。 同时返回一个LongTensor，包含众数职的索引。dim值默认为输入张量的最后一维。

输出形状与输入相同，除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

参数：

• input (Tensor) – 输入张量
• dim (int) – 缩减的维度
• values (Tensor, optional) – 结果张量
• indices (Tensor, optional) – 返回的索引张量

例子：

>>> a -0.6891 -0.6662 0.2697 0.7412 0.5254 -0.7402 0.5528 -0.2399[torch.FloatTensor of size 4x2]>>> a = torch.randn(4, 5)>>> a 0.4056 -0.3372 1.0973 -2.4884 0.4334 2.1336 0.3841 0.1404 -0.1821 -0.7646-0.2403 1.3975 -2.0068 0.1298 0.0212-1.5371 -0.7257 -0.4871 -0.2359 -1.1724[torch.FloatTensor of size 4x5]>>> torch.mode(a, 1)(-2.4884-0.7646-2.0068-1.5371[torch.FloatTensor of size 4x1], 3 4 2 0[torch.LongTensor of size 4x1])

torch.norm

torch.norm(input, p=2) → float

返回输入张量input 的p 范数。

参数：

• input (Tensor) – 输入张量
• p (float,optional) – 范数计算中的幂指数值

例子：

>>> a = torch.randn(1, 3)>>> a-0.4376 -0.5328 0.9547[torch.FloatTensor of size 1x3]>>> torch.norm(a, 3)1.0338925067372466

torch.norm(input, p, dim, out=None) → Tensor

返回输入张量给定维dim 上每行的p 范数。 输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• p (float) – 范数计算中的幂指数值
• dim (int) – 缩减的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4, 2)>>> a-0.6891 -0.6662 0.2697 0.7412 0.5254 -0.7402 0.5528 -0.2399[torch.FloatTensor of size 4x2]>>> torch.norm(a, 2, 1) 0.9585 0.7888 0.9077 0.6026[torch.FloatTensor of size 4x1]>>> torch.norm(a, 0, 1) 2 2 2 2[torch.FloatTensor of size 4x1]

torch.prod

torch.prod(input) → float

返回输入张量input 所有元素的积。

参数：input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a 0.6170 0.3546 0.0253[torch.FloatTensor of size 1x3]>>> torch.prod(a)0.005537458061418483

torch.prod(input, dim, out=None) → Tensor

返回输入张量给定维度上每行的积。 输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• dim (int) – 缩减的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4, 2)>>> a 0.1598 -0.6884-0.1831 -0.4412-0.9925 -0.6244-0.2416 -0.8080[torch.FloatTensor of size 4x2]>>> torch.prod(a, 1)-0.1100 0.0808 0.6197 0.1952[torch.FloatTensor of size 4x1]

torch.std

torch.std(input) → float

返回输入张量input 所有元素的标准差。

参数：- input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a-1.3063 1.4182 -0.3061[torch.FloatTensor of size 1x3]>>> torch.std(a)1.3782334731508061

torch.std(input, dim, out=None) → Tensor

返回输入张量给定维度上每行的标准差。 输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• dim (int) – 缩减的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4, 4)>>> a 0.1889 -2.4856 0.0043 1.8169-0.7701 -0.4682 -2.2410 0.4098 0.1919 -1.1856 -1.0361 0.9085 0.0173 1.0662 0.2143 -0.5576[torch.FloatTensor of size 4x4]>>> torch.std(a, dim=1) 1.7756 1.1025 1.0045 0.6725[torch.FloatTensor of size 4x1]

torch.sum

torch.sum(input) → float

返回输入张量input 所有元素的和。

输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a 0.6170 0.3546 0.0253[torch.FloatTensor of size 1x3]>>> torch.sum(a)0.9969287421554327

torch.sum(input, dim, out=None) → Tensor

返回输入张量给定维度上每行的和。 输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• dim (int) – 缩减的维度
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4, 4)>>> a-0.4640 0.0609 0.1122 0.4784-1.3063 1.6443 0.4714 -0.7396-1.3561 -0.1959 1.0609 -1.9855 2.6833 0.5746 -0.5709 -0.4430[torch.FloatTensor of size 4x4]>>> torch.sum(a, 1) 0.1874 0.0698-2.4767 2.2440[torch.FloatTensor of size 4x1]

torch.var

torch.var(input) → float

返回输入张量所有元素的方差

输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a-1.3063 1.4182 -0.3061[torch.FloatTensor of size 1x3]>>> torch.var(a)1.899527506513334

torch.var(input, dim, out=None) → Tensor

返回输入张量给定维度上每行的方差。 输出形状与输入相同，除了给定维度上为1.

参数：

• input (Tensor) – 输入张量
• dim (int) – the dimension to reduce
• out (Tensor, optional) – 结果张量 例子： ```python

a = torch.randn(4, 4) a

-1.2738 -0.3058 0.1230 -1.9615 0.8771 -0.5430 -0.9233 0.9879 1.4107 0.0317 -0.6823 0.2255 -1.3854 0.4953 -0.2160 0.2435 [torch.FloatTensor of size 4x4]

torch.var(a, 1)

0.8859 0.9509 0.7548 0.6949 [torch.FloatTensor of size 4x1]

比较操作 Comparison Ops### torch.eq```python torch.eq(input, other, out=None) → Tensor

比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。

参数：

• input (Tensor) – 待比较张量
• other (Tensor or float) – 比较张量或数
• out (Tensor, optional) – 输出张量，须为 ByteTensor类型 or 与input同类型

返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(相等为1，不等为0 )

返回类型： Tensor

例子：

>>> torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))1 00 1[torch.ByteTensor of size 2x2]

torch.equal

torch.equal(tensor1, tensor2) → bool

如果两个张量有相同的形状和元素值，则返回True ，否则 False。

例子：

>>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))True

torch.ge

torch.ge(input, other, out=None) → Tensor

逐元素比较input和other，即是否 ( input >= other )。

如果两个张量有相同的形状和元素值，则返回True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

• input (Tensor) – 待对比的张量
• other (Tensor or float) – 对比的张量或float值
• out (Tensor, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor

例子：

>>> torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 1 1 0 1[torch.ByteTensor of size 2x2]

torch.gt

torch.gt(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否( input > other ) 如果两个张量有相同的形状和元素值，则返回True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

• input (Tensor) – 要对比的张量
• other (Tensor or float) – 要对比的张量或float值
• out (Tensor, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor

例子：

>>> torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 0 1 0 0[torch.ByteTensor of size 2x2]

torch.kthvalue

torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

取输入张量input指定维上第k 个最小值。如果不指定dim，则默认为input的最后一维。

返回一个元组 (values,indices)，其中indices是原始输入张量input中沿dim维的第 k 个最小值下标。

参数:

• input (Tensor) – 要对比的张量
• k (int) – 第 k 个最小值
• dim (int, optional) – 沿着此维进行排序
• out (tuple, optional) – 输出元组 (Tensor, LongTensor) 可选地给定作为 输出 buffers

例子：

>>> x = torch.arange(1, 6)>>> x 1 2 3 4 5[torch.FloatTensor of size 5]>>> torch.kthvalue(x, 4)( 4[torch.FloatTensor of size 1], 3[torch.LongTensor of size 1])

torch.le

torch.le(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否( input <= other ) 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

• input (Tensor) – 要对比的张量
• other (Tensor or float ) – 对比的张量或float值
• out (Tensor, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor

例子：

>>> torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 1 0 1 1[torch.ByteTensor of size 2x2]

torch.lt

torch.lt(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否 ( input < other )

第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

• input (Tensor) – 要对比的张量
• other (Tensor or float ) – 对比的张量或float值
• out (Tensor, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

input： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 tensor >= other )。 返回类型： Tensor

例子：

>>> torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 0 0 1 0[torch.ByteTensor of size 2x2]

torch.max

torch.max()

返回输入张量所有元素的最大值。

参数:

• input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a 0.4729 -0.2266 -0.2085[torch.FloatTensor of size 1x3]>>> torch.max(a)0.4729

torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。

输出形状中，将dim维设定为1，其它与输入形状保持一致。

参数:

• input (Tensor) – 输入张量
• dim (int) – 指定的维度
• max (Tensor, optional) – 结果张量，包含给定维度上的最大值
• max_indices (LongTensor, optional) – 结果张量，包含给定维度上每个最大值的位置索引

例子：

>> a = torch.randn(4, 4)>> a0.0692 0.3142 1.2513 -0.54280.9288 0.8552 -0.2073 0.64091.0695 -0.0101 -2.4507 -1.22300.7426 -0.7666 0.4862 -0.6628torch.FloatTensor of size 4x4]>>> torch.max(a, 1)( 1.2513 0.9288 1.0695 0.7426[torch.FloatTensor of size 4x1], 2 0 0 0[torch.LongTensor of size 4x1])

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

返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。 即，( out_i=max(input_i,other_i) )

输出形状中，将dim维设定为1，其它与输入形状保持一致。

参数:

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

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> b = torch.randn(4)>>> b 1.0067-0.8010 0.6258 0.3627[torch.FloatTensor of size 4]>>> torch.max(a, b) 1.3869 0.3912 0.6258 0.3627[torch.FloatTensor of size 4]

torch.min

torch.min(input) → float

返回输入张量所有元素的最小值。

参数: input (Tensor) – 输入张量

例子：

>>> a = torch.randn(1, 3)>>> a 0.4729 -0.2266 -0.2085[torch.FloatTensor of size 1x3]>>> torch.min(a)-0.22663167119026184

torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引。

输出形状中，将dim维设定为1，其它与输入形状保持一致。

参数:

• input (Tensor) – 输入张量
• dim (int) – 指定的维度
• min (Tensor, optional) – 结果张量，包含给定维度上的最小值
• min_indices (LongTensor, optional) – 结果张量，包含给定维度上每个最小值的位置索引

例子：

>> a = torch.randn(4, 4)>> a0.0692 0.3142 1.2513 -0.54280.9288 0.8552 -0.2073 0.64091.0695 -0.0101 -2.4507 -1.22300.7426 -0.7666 0.4862 -0.6628torch.FloatTensor of size 4x4]>> torch.min(a, 1)0.54280.20732.45070.7666torch.FloatTensor of size 4x1]3221torch.LongTensor of size 4x1]

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

input中逐元素与other相应位置的元素对比，返回最小值到输出张量。即，( out_i = min(tensor_i, other_i))

两张量形状不需匹配，但元素数须相同。

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

参数:

• input (Tensor) – 输入张量
• other (Tensor) – 第二个输入张量
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4)>>> a 1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]>>> b = torch.randn(4)>>> b 1.0067-0.8010 0.6258 0.3627[torch.FloatTensor of size 4]>>> torch.min(a, b) 1.0067-0.8010-0.8634-0.5468[torch.FloatTensor of size 4]

torch.ne

torch.ne(input, other, out=None) → Tensor

逐元素比较input和other ， 即是否 ( input != other )。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

• input (Tensor) – 待对比的张量
• other (Tensor or float) – 对比的张量或float值
• out (Tensor, optional) – 输出张量。必须为ByteTensor或者与input相同类型。

返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果 (如果 tensor != other 为True ，返回1)。

返回类型： Tensor

例子：

>>> torch.ne(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 0 1 1 0[torch.ByteTensor of size 2x2]

torch.sort

torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

对输入张量input沿着指定维按升序排序。如果不给定dim，则默认为输入的最后一维。如果指定参数descending为True，则按降序排序

返回元组 (sorted_tensor, sorted_indices) ， sorted_indices 为原始输入中的下标。

参数:

• input (Tensor) – 要对比的张量
• dim (int, optional) – 沿着此维排序
• descending (bool, optional) – 布尔值，控制升降排序
• out (tuple, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

例子：

>>> x = torch.randn(3, 4)>>> sorted, indices = torch.sort(x)>>> sorted-1.6747 0.0610 0.1190 1.4137-1.4782 0.7159 1.0341 1.3678-0.3324 -0.0782 0.3518 0.4763[torch.FloatTensor of size 3x4]>>> indices 0 1 3 2 2 1 0 3 3 1 0 2[torch.LongTensor of size 3x4]>>> sorted, indices = torch.sort(x, 0)>>> sorted-1.6747 -0.0782 -1.4782 -0.3324 0.3518 0.0610 0.4763 0.1190 1.0341 0.7159 1.4137 1.3678[torch.FloatTensor of size 3x4]>>> indices 0 2 1 2 2 0 2 0 1 1 0 1[torch.LongTensor of size 3x4]

torch.topk

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿给定dim维度返回输入张量input中 k 个最大值。 如果不指定dim，则默认为input的最后一维。 如果为largest为 False ，则返回最小的 k 个值。

返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。 如果设定布尔值sorted 为True，将会确保返回的 k 个值被排序。

参数:

• input (Tensor) – 输入张量
• k (int) – “top-k”中的k
• dim (int, optional) – 排序的维
• largest (bool, optional) – 布尔值，控制返回最大或最小值
• sorted (bool, optional) – 布尔值，控制返回值是否排序
• out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffers

>>> x = torch.arange(1, 6)>>> x 1 2 3 4 5[torch.FloatTensor of size 5]>>> torch.topk(x, 3)( 5 4 3[torch.FloatTensor of size 3], 4 3 2[torch.LongTensor of size 3])>>> torch.topk(x, 3, 0, largest=False)( 1 2 3[torch.FloatTensor of size 3], 0 1 2[torch.LongTensor of size 3])