即看即用 && 比较操作（Comparison Ops） && Pytorch官方文档总结 && 笔记 (七)

最新推荐文章于 2024-05-30 14:40:11 发布
最新推荐文章于 2024-05-30 14:40:11 发布
阅读量148 收藏
点赞数
分类专栏： Pytorch_python 文章标签： pytorch 深度学习 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54185421/article/details/124726380
版权

（1）本文涉及函数的列表（注释在代码中）

  1. torch.eq                              # 元素是否相等
  2. torch.equal                         # 张量是否相等
  3. torch.ge                              # 元素大小关系 input >= other
  4. torch.gt                               # 元素大小关系 input > other
  5. torch.kthvalue                    # 输入张量 input 指定维上第 k 个最小值
  6. torch.le                               # 元素大小关系 input <= other
  7. torch.lt                                # 元素大小关系 input < other
  8. torch.max                          # 所有元素的最大值 / 指定维度上每行的最大值 
  9. torch.min                            # 所有元素的最小值 / 指定维度上每行的最小值
  10. torch.ne                              # 元素大小关系 input != other
  11. torch.sort                           # 升序排列 / 降序排列
  12. torch.topk                          # 排序靠前的 k 个值

注意：

  • 逐个元素比较大小和整个张量比较大小的概念不同；
  • 指定的维度（dim=0: 沿 y 轴方向）（dim=1: 沿 x 轴方向）；
  • 按降序排列：（下降）descending = True；
  • 部分函数的参数 other，可以是和 input 形状相同的张量，也可以是一个实数。

（2）代码示例（含注释）

"""
比较操作 Comparison Ops
"""
import torch

# # 逐个比较元素相等性。
# # 第二个参数可为一个数或与第一个参数同类型形状的张量。
# # 返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(相等为 true，不等为 False )
# # 返回类型： Tensor
obj1 = torch.eq(torch.tensor([1, 2, 3]), 1)

# # 如果两个张量有完全相同的形状和元素值，则返回 True ，否则 False。
obj2 = torch.equal(torch.tensor([1, 2, 3]), torch.tensor([1, 2, 4]))  # False

# # 逐元素比较 input 和 other 的大小关系，即是否 input>=other。
# # 如果两个张量有相同的形状和元素值，则返回 True ，否则 False。
# # 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
# # 返回类型： Tensor
obj3 = torch.ge(torch.tensor([[7.0, 1.0], [1.0, 3.0]]), torch.tensor([[6.0, 1.0], [2.0, 3.0]]))

# # 逐元素比较 input 和 other ，
# # 即是否 input>other 如果两个张量有相同的形状和元素值，则返回 True ，否则 False。
obj4 = torch.gt(torch.tensor([[7.0, 1.0], [1.0, 3.0]]), torch.tensor([[6.0, 1.0], [2.0, 3.0]]))

# # 取输入张量 input 指定维上第 k 个最小值。如果不指定 dim，则默认为 input 的最后一维。
# # 返回一个元组 (values,indices)，其中 indices 是原始输入张量 input 中沿 dim 维的第 k 个最小值下标。
obj5 = torch.kthvalue(torch.arange(1.0, 6.0, 0.5), k=4, dim=0)
# obj5[0]=values=tensor(2.5000)
# obj5[1]=indices=tensor(3)

# # 逐元素比较 input 和 other ，
# # 即是否 input<=other 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
obj6 = torch.le(torch.tensor([[7.0, 1.0], [1.0, 3.0]]), torch.tensor([[6.0, 1.0], [2.0, 3.0]]))

# # 逐元素比较 input 和 other ，
# # 即是否 input<other 第二个参数可以为一个数或与第一个参数相同形状和类型的张量。
obj7 = torch.lt(torch.tensor([[7.0, 1.0], [1.0, 3.0]]), torch.tensor([[6.0, 1.0], [2.0, 3.0]]))

# # 返回输入张量所有元素的最大值。
obj8 = torch.max(torch.randn(3, 4))

# # 返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。
# # torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)
obj9 = torch.max(torch.randn(3, 4), dim=0)
obj10 = torch.max(torch.randn(3, 4), dim=1)

# # 返回输入张量所有元素的最小值。
obj11 = torch.min(torch.randn(3, 4))

# # 返回输入张量给定维度上每行的最大值，并同时返回每个最小值的位置索引。
# # torch.min(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)
obj12 = torch.min(torch.randn(3, 4), dim=0)
obj13 = torch.min(torch.randn(3, 4), dim=1)

# # 逐元素比较 input 和 other ， 即是否 input!=other。
# # 第二个参数可以为一个数或与第一个参数相同形状和类型的张量。
obj14 = torch.ne(torch.arange(1.0, 3.0), torch.arange(2.0, 4.0))
obj15 = torch.ne(torch.arange(1.0, 3.0), 1.0)

# # 对输入张量 input 沿着指定维按升序排序。
# # 如果不给定 dim，则默认为输入的最后一维。
# # 如果指定参数 descending 为 True，则按降序排序
# # 返回元组 (sorted_tensor, sorted_indices) ， sorted_indices 为原始输入中的下标。
obj16 = torch.sort(torch.randn(4, 5), dim=0)
obj17 = torch.sort(torch.randn(4, 5), dim=1)
obj18 = torch.sort(torch.randn(4, 5), dim=1, descending=True)

# # 沿给定 dim 维度返回输入张量 input 中 k 个最大值(即排序靠前的前k个值!!!)。
# # 如果不指定 dim，则默认为 input 的最后一维。
# # 如果为 largest 为 False ，则返回最小的 k 个值。
obj19 = torch.topk(torch.tensor([[1, 2, 3],
                                 [3, 5, 3],
                                 [2, 9, 1]]), k=1, dim=0)
obj20 = torch.topk(torch.tensor([[1, 2, 3],
                                 [3, 5, 3],
                                 [2, 9, 1]]), k=1, dim=1)
obj21 = torch.topk(torch.tensor([[1, 2, 3],
                                 [3, 5, 3],
                                 [2, 9, 1]]), k=2, dim=0)
# input (Tensor) – 输入张量
# k (int) – “top-k”中的 k
# dim (int, optional) – 排序的维
# largest (bool, optional) – 布尔值，控制返回最大或最小值
# sorted (bool, optional) – 布尔值，控制返回值是否排序
# out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffers

print("*"*20, "obj1", "*"*20, "\n", obj1, "\n")
print("*"*20, "obj2", "*"*20, "\n", obj2, "\n")
print("*"*20, "obj3", "*"*20, "\n", obj3, "\n")
print("*"*20, "obj4", "*"*20, "\n", obj4, "\n")
print("*"*20, "obj5", "*"*20, "\n", obj5, "\n")
print("*"*20, "obj6", "*"*20, "\n", obj6, "\n")
print("*"*20, "obj7", "*"*20, "\n", obj7, "\n")
print("*"*20, "obj8", "*"*20, "\n", obj8, "\n")
print("*"*20, "obj9", "*"*20, "\n", obj9, "\n", obj10, "\n")
print("*"*20, "obj11", "*"*20, "\n", obj11, "\n")
print("*"*20, "obj13", "*"*20, "\n", obj12, "\n", obj13, "\n")
print("*"*20, "obj14", "*"*20, "\n", obj14, "\n", obj15, "\n")
print("*"*20, "obj16", "*"*20, "\n", obj16, "\n", obj17, "\n", obj18, "\n")
print("*"*20, "obj19", "*"*20, "\n", obj19, "\n", obj20, "\n", obj21, "\n")

  >>>output

******************** obj1 ******************** 
 tensor([ True, False, False]) 

******************** obj2 ******************** 
 False 

******************** obj3 ******************** 
 tensor([[ True,  True],
              [False,  True]]) 

******************** obj4 ******************** 
 tensor([[ True, False],
              [False, False]]) 

******************** obj5 ******************** 
 torch.return_types.kthvalue(
values=tensor(2.5000),
indices=tensor(3)) 

******************** obj6 ******************** 
 tensor([[False,  True],
               [ True,  True]]) 

******************** obj7 ******************** 
 tensor([[False, False],
               [ True, False]]) 

******************** obj8 ******************** 
 tensor(1.3611) 

******************** obj9 ******************** 
 torch.return_types.max(
                                          values=tensor([0.8743, 1.0526, 0.4736, 1.0062]),
                                          indices=tensor([1, 2, 1, 1])) 
 torch.return_types.max(
                                          values=tensor([0.2985, 1.5670, 1.1388]),
                                          indices=tensor([0, 0, 0])) 

******************** obj11 ******************** 
 tensor(-2.6445) 

******************** obj13 ******************** 
 torch.return_types.min(
                                          values=tensor([-1.1342,  0.2821, -2.2261, -0.6704]),
                                          indices=tensor([2, 1, 1, 1])) 
 torch.return_types.min(
                                          values=tensor([-1.4479, -0.8022, -2.5090]),
                                          indices=tensor([3, 1, 2])) 

******************** obj14 ******************** 
 tensor([True, True]) 
 tensor([False,  True]) 

******************** obj16 ******************** 
 torch.return_types.sort(
values=tensor([[-1.1032, -0.2661, -0.9461, -0.9597, -1.4905],
                          [-0.4305,  0.1166, -0.8521, -0.0462, -0.6387],
                          [-0.0587,  1.2700, -0.1314,  0.4326, -0.5871],
                          [ 0.1834,  1.4156,  0.7330,  0.7903,  1.2259]]),
indices=tensor([[3, 0, 2, 1, 0],
                          [0, 3, 3, 0, 1],
                          [1, 2, 1, 3, 3],
                          [2, 1, 0, 2, 2]])) 
 torch.return_types.sort(
values=tensor([[-1.1859, -1.0903, -0.5112, -0.0466,  1.9069],
                           [-0.9795, -0.3969, -0.2867,  0.6880,  1.2773],
                           [-1.0201, -0.3897, -0.1580,  0.1677,  1.9816],
                           [-0.3943,  0.0321,  0.5373,  0.8734,  1.2815]]),
indices=tensor([[4, 2, 3, 0, 1],
                            [3, 0, 2, 1, 4],
                            [3, 1, 0, 2, 4],
                            [1, 2, 4, 3, 0]])) 
 torch.return_types.sort(
values=tensor([[ 1.0435,  0.0428, -0.0089, -1.1555, -1.6359],
                           [ 2.0980, -0.2942, -0.4056, -1.0058, -1.1898],
                           [ 2.2949,  0.7036,  0.5235, -0.5708, -0.5717],
                           [ 2.4485,  0.4431,  0.1595, -0.3412, -1.3198]]),
indices=tensor([[4, 2, 0, 3, 1],
                            [4, 2, 1, 0, 3],
                            [0, 3, 4, 1, 2],
                            [2, 1, 4, 0, 3]])) 

******************** obj19 ******************** 
 torch.return_types.topk(
                                           values=tensor([[3, 9, 3]]),
                                           indices=tensor([[1, 2, 0]])) 
 torch.return_types.topk(
                                           values=tensor([[3],
                                                                      [5],
                                                                      [9]]),
                                           indices=tensor([[2],
                                                                       [1],
                                                                       [1]])) 
 torch.return_types.topk(
                                           values=tensor([[3, 9, 3],
                                                                      [2, 5, 3]]),
                                           indices=tensor([[1, 2, 0],
                                                                       [2, 1, 1]])) 

专栏链接直达：

https://blog.csdn.net/qq_54185421/category_11794260.html?spm=1001.2014.3001.5482icon-default.png?t=M4ADhttps://blog.csdn.net/qq_54185421/category_11794260.html?spm=1001.2014.3001.5482 >>>如有疑问，欢迎评论区一起探讨

Flying Bulldog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
regnet 学习笔记
jacke121的专栏
04-17 3555
https://github.com/signatrix/regnet
Pytorch中比较大小的相关函数：torch.gt()、torch.ge、torch.lt()、torch.le()、torch.eq()、torch.ne()
wrjwww的博客
08-12 924
这里只以torch.gt()函数举例，其他函数用法与torch.gt()函数类似。Pytorch官方介绍：torch.gt()函数原型：返回值为input与other大小比较的结果。若input大于other返回True，否则返回False。如果input与other的shape相同，那么则在对应位置进行比较；如果input与other的shape不同，则会用到广播机制。当input与other的shape相同时，直接对应位置的值进行比较。
python入门之函数调用第一关_Python入门基础之map()、reduce()函数使用
weixin_39681171的博客
11-21 142
本文环境都是基于python3.X的，毕竟要学会拥抱未来，拥抱新的知识。Python3 现在已经发展的差不多了。1、 map()函数map()是 python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的object并返回。（python2返回列表，Python3返回迭代对象）map（）的使用方法形如map(f(x),It...
PyTorch学习笔记
潜心
11-19 769
Python API 目录 一、torch包 1.Tensors 2.Creation Ops 3.Indexing, Slicing, Joining, Mutating Ops 4.Generators 5.Random sampling 二、torch.nn包 1.Containers 2.Convolution Layers 3.Pooling layers 4.Padding Layers 5.Non-linear Activations (weighted sum, n
PyTorch Python API详解大全（持续更新ing...）
诸神缄默不语的博客
04-23 5574
个人学习及记录使用。简单的PyTorch Python API解释一览表，持续更新。
PyTorch学习记录（十）关于CIFAR-10的一些学习笔记
djy2069的博客
09-25 1653
前言 在B站中看完了《PyTorch深度学习实践》完结合集——刘二大人前11个视频，想来自己动手实践试试，边实践边学习。 首先复习一下 一般我们主要有以下几个步骤： （一）准备数据集 在这个步骤中，我们首先需要用到torchvision 1、torchvision:包含了流行的数据集、模型架构和用于计算机视觉的常见图像转换。 （1）torchvision.datasets（数据）：MNIST、Fashion-MNIST、COCO、LSUN、ImageFolder、Imagenet-12、CIFAR、STL
【深度学习笔记】2 PyTorch基础
NirReb的博客
06-07 1763
文章目录Pytorch 与 Numpy 比较 Pytorch 与 Numpy 比较
PyTorch 2.2 中文官方教程（二）
龙哥盟
02-04 1405
在 YouTube 上介绍 PyTorch PyTorch 介绍 - YouTube 系列 原文：pytorch.org/tutorials/beginner/introyt.html 译者：飞龙 协议：CC BY-NC-SA 4.0 介绍 || 张量 || 自动微分 || 构建模型 || TensorBoard 支持 || 训练模型 || 模型理解 作者：Brad Heintz 本教程与 YouTube 上的PyTorch 初学者系列一起进行。 本教程假定您对 Python 和深度学习概念有基本了解。
pytorch常用函数
lhwjgs123456789的博客
06-11 718
torch 本笔记引用自PyTorch中文文档 包torch包含了多维疑是的数据结构及基于其上的多种数学操作。 1. 张量Tensors torch.is_tensor(obj): 如果obj是一个pytorch张量，则返回True torch.is_storage(obj): 如果obj是一个pytorch storage对象，则返回True torch.numel(input): 返回input张量中的元素个数。 2. 创建操作 torch.eye(n, m=None, out
Pytorch学习之torch用法----比较操作(Comparison Ops)
09-16
主要介绍了Pytorch学习之torch用法----比较操作(Comparison Ops)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Pytorch学习之torch用法—-比较操作(Comparison Ops)
12-17
说明： 比较元素是否相等，第二个参数可以是一个数，或者是第一个参数同类型形状的张量 参数： input(Tensor) —- 待比较张量 other(Tenosr or float) —- 比较张量或者数 out(Tensor,可选的) —- 输出张量 返回值：...
O&O DiskRecovery 12（32＼64位 二合一）汉化单文件版.exe
09-02
能辨别修复包括Word 文档、Excel表格、Access数据库和各种常用图形、图像、电影、音乐(JPEG,AVI,MPEG,MP3,WAV,BMP,TIFF,Corel Draw,Photoshop,Framemaker,Adobe Illustrator,and many more)在内300余种文件格式。...
Implementation & Comparison of RDMA Over Ethernet.pdf
03-07
Implementation & Comparison of RDMA Over Ethernet.pdf 高清完整版
ISO&IEC 18000-6C 简析
08-15
the comparison of ISO/IEC 18000-6A, ISO/IEC 18000-6B, a n d ISO/IEC 1 80 0 0 -6C, a nd p rop o s e d some v a lu ab l e s u g g e s t i o n s o n t h e a p p l i c a t i o n - l e v e l UH F R FI D ...
Pytorch创建张量
qq_44815135的博客
05-27 1016
torch.normal() 是 PyTorch 中用于创建具有指定均值和标准差的正态分布随机值的张量的函数。torch.randn() 是 PyTorch 中用于创建具有正态分布（高斯分布）随机值的张量的函数。torch.zeros() 函数是 PyTorch 中用于创建元素全为零的张量的函数。torch.ones() 函数是 PyTorch 中用于创建元素全为一的张量的函数。torch.rand() 是 PyTorch 中用于创建具有随机值的张量的函数。
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
最新发布
惊鸿若梦一书生
05-30 195
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
Pytorch 笔记
985小菜鸡
05-28 957
就地操作会直接修改原始张量的值，通常以a.mul_(b)：就地进行元素级相乘非就地操作会创建新的张量并返回结果，而不改变输入张量的值。这些不同的乘法操作方式在不同的应用场景中有不同的用途，根据需要选择适合的乘法方式。
Pytorch-Reduction Ops
qq_44815135的博客
05-29 715
torch.argmax() 是 PyTorch 中的一个函数，用于在指定维度上获取张量中最大值的索引。input：输入张量。dim：可选参数，指定在哪个维度上进行操作。如果未指定，则默认在最后一个维度上进行操作。keepdim：可选参数，指定是否保持输出张量的维度与输入张量相同。默认为 False，表示不保持维度"""# 创建一个张量# 沿着第一个维度获取最大值的索引print(max_indices) # 输出: tensor([1, 1, 1])
warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses] if ((buf[123] == (halfresult>>8)&0xFF) && (buf[124] == halfresult&0xFF) && (buf[0] == '^'))
05-25
这个warning提示需要在比较运算符`&`的两侧加上括号，以明确运算的优先级，建议修改为以下代码： ``` if (((buf[123] == ((halfresult >> 8) & 0xFF)) && (buf[124] == (halfresult & 0xFF))) && (buf[0] == '^')) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Flying Bulldog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值