Pytorch学习之torch----比较操作
人工智能 Pytorch 编程框架
Pytorch
发布日期:   2019-07-14
文章字数:   1.8k
阅读时长:   8 分
阅读次数:  

1. torch.eq(input, other, out=None)

说明： 比较元素是否相等，第二个参数可以是一个数，或者是第一个参数同类型形状的张量

参数：

  • input(Tensor) —- 待比较张量
  • other(Tenosr or float) —- 比较张量或者数
  • out(Tensor,可选的) —- 输出张量

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

>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.eq(a, b)
tensor([[1, 0],
        [0, 1]], dtype=torch.uint8)

2. torch.equal(tensor1, tensor2, out=None)

说明： 如果两个张量有相同的形状和元素值，则返回true，否则False

参数：

  • tensor1(Tenosr) —- 比较张量1
  • tensor2(Tensor) —- 比较张量2
  • out(Tensor,可选的) —- 输出张量
>>> a = torch.Tensor([1, 2])
>>> b = torch.Tensor([1, 2])
>>> torch.equal(a, b)
True

3. torch.ge(input, other, out=None)

说明： 逐元素比较input和other，即是否input >= other。

参数：

  • input(Tensor) —- 待对比的张量
  • other(Tensor or float) —- 对比的张量或float值
  • out(Tensor,可选的) —- 输出张量，
>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.ge(a, b)
tensor([[1, 1],
        [0, 1]], dtype=torch.uint8)

4. torch.gt(input, other, out=None)

说明： 逐元素比较input和other，即是否input > other

参数：

  • input(Tensor) —- 要对比的张量
  • other(Tensor or float) —- 要对比的张量或float值
  • out(Tensor,可选的) —- 输出张量
>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.gt(a, b)
tensor([[0, 1],
        [0, 0]], dtype=torch.uint8)

5. torch.kthvalue(input, k, dim=None, out=None)

说明： 取输入张量input指定维度上第k个最小值。如果不指定dim。默认为最后一维。返回一个元组(value, indices), 其中indices是原始输入张量中沿dim维的第k个最小值下标。

参数：

  • input(Tensor) —- 要对比的张量
  • k(int) —- 第k个最小值
  • dim(int, 可选的) —- 沿着此维度进行排序
  • out(tuple,可选的) —- 输出元组
>>> x = torch.arange(1, 6)
>>> x
tensor([1, 2, 3, 4, 5])
>>> torch.kthvalue(x, 4)
torch.return_types.kthvalue(
values=tensor(4),
indices=tensor(3))
>>> torch.kthvalue(x, 1)
torch.return_types.kthvalue(
values=tensor(1),
indices=tensor(0))

6. torch.le(input, other, out=None)

说明： 逐元素比较input和other，即是否input <= other.

参数：

  • input(Tenosr) —- 要对比的张量
  • other(Tensor or float) —- 对比的张量或float值
  • out(Tensor,可选的) —- 输出张量
>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.le(a, b)
tensor([[1, 0],
        [1, 1]], dtype=torch.uint8)

7. torch.lt(input, other, out=None)

说明： 逐元素比较input和other，即是否input < other

参数：

  • input(Tensor) —- 要对比的张量
  • other(Tensor or float) —- 对比的张量或float值
  • out(Tensor,可选的) —- 输出张量
>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.lt(a, b)
tensor([[0, 0],
        [1, 0]], dtype=torch.uint8)

8. torch.max(input)

说明： 返回输入张量所有元素的最大值

参数：

  • input(Tensor) —- 输入张量
>>> a = torch.randn(1, 3)
>>> a
tensor([[ 0.1553, -0.4140,  1.8393]])
>>> torch.max(a)
tensor(1.8393)

9. torch.max(input, dim, max=None, max_indices=None)

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

参数：

  • input(Tensor) —- 输入张量
  • dim(int) —- 指定的维度
  • max(Tensor,可选的) —- 结果张量，包含给定维度上的最大值
  • max_indices(LongTensor,可选的) —- 结果张量，包含给定维度上每个最大值的位置的索引。
>>> a = torch.randn(4, 4)
>>> a
tensor([[ 0.4067, -0.7722, -0.6560, -0.9621],
        [-0.8754,  0.0282, -0.7947, -0.1870],
        [ 0.4300,  0.5444,  0.3180,  1.2647],
        [ 0.0775,  0.5886,  0.1662,  0.8986]])
>>> torch.max(a, 1)
torch.return_types.max(
values=tensor([0.4067, 0.0282, 1.2647, 0.8986]),
indices=tensor([0, 1, 3, 3]))

10. torch.max(input, other, out=None)

说明： 返回两个元素的最大值。

参数：

  • input(Tensor) —- 待比较张量
  • other(Tensor) —- 比较张量
  • out(Tensor,可选的) —- 结果张量
>>> a = torch.randn(4)
>>> a
tensor([ 0.5767, -1.0841, -0.0942, -0.9405])
>>> b = torch.randn(4)
>>> b
tensor([-0.6375,  1.4165,  0.2738, -0.8996])
>>> torch.max(a, b)
tensor([ 0.5767,  1.4165,  0.2738, -0.8996])

11.torch.min(input)

说明： 返回输入张量所有元素的最小值

参数：

  • input(Tensor) —- 输入张量
>>> a = torch.randn(1, 4)
>>> a
tensor([[-0.8142, -0.9847, -0.3637,  0.5191]])
>>> torch.min(a)
tensor(-0.9847)

12. torch.min(input, dim, min=None, min_indices=None)

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

参数：

  • input(Tensor) —- 输入张量
  • dim(int) —- 指定的维度
  • min(Tensor,可选的) —- 结果张量，包含给定维度上的最小值
  • min_indices(LongTensor,可选的) —- 结果张量，包含给定维度上每个最小值的位置索引。
>>> a = torch.randn(4, 4)
>>> a
tensor([[-0.0243, -0.7382,  0.3102,  0.9720],
        [-0.3805, -0.7999, -1.2856,  0.2657],
        [-1.0284, -0.1638, -0.8840,  1.2679],
        [-1.0347, -2.3428,  0.3107,  1.0575]])
>>> torch.min(a, 1)
torch.return_types.min(
values=tensor([-0.7382, -1.2856, -1.0284, -2.3428]),
indices=tensor([1, 2, 0, 1]))

13. torch.ne(input, other, out=None)

说明： 逐元素比较input和other，即是否input 不等于 other。第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数：

  • input(Tensor) —- 待对比的张量
  • other(Tensor or float) —- 对比的张量或float值
  • out(Tensor, 可选的) —- 输出张量

** 返回值：** 一个torch.ByteTensor 张量，包含了每个位置的比较结果，如果tensor和other不相等为True，返回1.

>>> import torch
>>> a = torch.Tensor([[1, 2], [3, 4]])
>>> b = torch.Tensor([[1, 1], [4, 4]])
>>> torch.ne(a, b)
tensor([[0, 1],
        [1, 0]], dtype=torch.uint8)

14. torch.sort(input, dim=None, descending=False, out=None)

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

参数：

  • input(Tensor) —- 要排序的张量
  • dim(int,可选的) —- 沿着此维度排序
  • descending(bool,可选的) —- 布尔值，控制升序排序
  • out(tuple,可选的) —- 输出张量

返回值： 为ByteTensor类型或与tensor相同类型，为元组(sorted_tensor,sorted_indices)，sorted_indices为原始输入中的下标

>>> x = torch.randn(3, 4)
>>> x
tensor([[-0.3613, -0.2583, -0.4276, -1.3106],
        [-1.1577, -0.7505,  1.7217, -0.6247],
        [-0.1338,  0.4423,  0.0280, -1.4796]])
>>> sorted, indices = torch.sort(x)
>>> sorted
tensor([[-1.3106, -0.4276, -0.3613, -0.2583],
        [-1.1577, -0.7505, -0.6247,  1.7217],
        [-1.4796, -0.1338,  0.0280,  0.4423]])
>>> indices
tensor([[3, 2, 0, 1],
        [0, 1, 3, 2],
        [3, 0, 2, 1]])

15. torch.topk(input, dim=None, largest=True, sorted=True, out=None)

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

参数：

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

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

>>> x = torch.arange(1, 6)
>>> x
tensor([1, 2, 3, 4, 5])
>>> torch.topk(x, 3)
torch.return_types.topk(
values=tensor([5, 4, 3]),
indices=tensor([4, 3, 2]))
>>> torch.topk(x, 3, 0, largest=False)
torch.return_types.topk(
values=tensor([1, 2, 3]),
indices=tensor([0, 1, 2]))
赏

   转载规则


《Pytorch学习之torch----比较操作》 由 G&L 采用 知识共享署名 4.0 国际许可协议 进行许可。
 上一篇
AI圣经《深度学习》读书笔记----第一章：引言 AI圣经《深度学习》读书笔记----第一章：引言
深度学习领域的一本经典书籍，被称为”AI圣经“。这本书是很值得阅读的，但是感觉有点难。
2019-08-15 读书笔记
人工智能 深度学习 读书笔记
下一篇 
Pytorch学习之torch----Reduction Ops Pytorch学习之torch----Reduction Ops
1. torch.cumprod(input, dim, out=None)说明： 返回输入沿指定维度的累积积。如果输入是一个N元向量，则结果也是一个N元向量，第i个输出元素值为 $$y_{i} = x_{1} * x_{2} * … *
2019-07-14 Pytorch
人工智能 Pytorch 编程框架
  目录