【youcans的深度学习 10】PyTorch入门教程:张量的统计运算与比较运算

这篇具有很好参考价值的文章主要介绍了【youcans的深度学习 10】PyTorch入门教程:张量的统计运算与比较运算。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

欢迎关注『youcans的深度学习』系列,持续更新中…
【youcans的深度学习 01】安装环境之 miniconda
【youcans的深度学习 02】PyTorch CPU版本安装与环境配置
【youcans的深度学习 03】PyTorch CPU版本安装与环境配置
【youcans的深度学习 04】PyTorch入门教程:基础知识
【youcans的深度学习 05】PyTorch入门教程:快速入门
【youcans的深度学习 06】PyTorch入门教程:张量的基本操作 1
【youcans的深度学习 07】PyTorch入门教程:张量的基本操作 2
【youcans的深度学习 08】PyTorch入门教程:张量的就地操作和广播机制
【youcans的深度学习 09】PyTorch入门教程:张量的逐点运算
【youcans的深度学习 10】PyTorch入门教程:张量的统计运算与比较运算

PyTorch 中支持 100 多种张量操作,包括转置、索引、切⽚、数学运算、线性代数、随机数等等,详见【PyTorch官方文档】。

3. 张量的统计分析运算

张量的归约运算,是对张量进行某种聚合总结,而得到计算结果的函数。规约运算主要包含数据科学领域内的诸多统计分析函数,如均值、极值、方差、中位数函数等等。

3.1 均值、方差与求和

函数原型:

torch.sum(input, dim, keepdim=False, *, dtype=None) → Tensor # 张量求和
torch.mean(input, dim, keepdim=False, *, dtype=None, out=None) → Tensor # 张量的均值
torch.nanmean(input, dim=None, keepdim=False, *, dtype=None) → Tensor # 非Nan元素的均值
torch.var(input, dim=None, *, correction=1, keepdim=False, out=None) → Tensor # 张量的方差
torch.std(input, dim=None, *, correction=1, keepdim=False, out=None) → Tensor # 张量的标准差
torch.var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) # 张量的方差和均值

参数说明:

  • input,张量,输入张量。
  • dim,整数或整型元组,指定维度。
  • out,张量,输出张量。
  • keepdim,布尔值,输出张量是否保留 dim,可选项,默认为 False
  • correction,整数,可选项,默认值为 1 表示 Bessel 校正

函数说明:
(1)函数返回张量沿指定维度 dim 的所有元素的均值、方差与求和。参数 dim 缺省时,函数默认对张量的所有元素进行计算,返回 0 维张量。参数 dim 为整数或整型元组时,按照 dim 指定维度的所有元素进行计算。
(2)函数 torch.var_mean、torch.std_mean 返回一个元组,元组的元素分别是方差和均值。
(3)函数 torch.nanmean 返回张量沿指定维度的非Nan元素的平均值。

# (10) 张量的统计分析运算:均值、方差与求和
# 张量求和
x = torch.arange(1, 16).reshape(3, 5)  # torch.Size([3, 5])
print(x)
s1 = torch.sum(x)  # 张量所有元素求和
s2 = torch.sum(x, dim=0)  # 按指定dim求和
s3 = torch.sum(x, dim=1)  # 按指定dim求和
print("sum(x):", s1)  # torch.Size([])
print("sum(x,0):", s2)  # torch.Size([5])
print("sum(x,1):", s3)  # torch.Size([3])
print(s1.shape, s2.shape, s3.shape)
# tensor([[ 1,  2,  3,  4,  5],
#         [ 6,  7,  8,  9, 10],
#         [11, 12, 13, 14, 15]])
# sum(x): tensor(120)
# sum(x,0): tensor([18, 21, 24, 27, 30])
# sum(x,1): tensor([15, 40, 65])
# torch.Size([]) torch.Size([5]) torch.Size([3])

# 张量均值
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
m1 = torch.mean(x)  # 张量所有元素求均值
m2 = torch.mean(x, dim=0)  # 按指定dim求均值
m3 = torch.mean(x, dim=1)  # 按指定dim求均值
print("mean(x):", m1)  # torch.Size([])
print("mean(x,0):", m2)  # torch.Size([5])
print("mean(x,1):", m3)  # torch.Size([3])
print(m1.shape, m2.shape, m3.shape)
# mean(x): tensor(8.)
# mean(x,0): tensor([ 6.,  7.,  8.,  9., 10.])
# mean(x,1): tensor([ 3.,  8., 13.])
# torch.Size([]) torch.Size([5]) torch.Size([3])

# 张量方差
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
v1 = torch.var(x)  # 张量所有元素求方差
v2 = torch.var(x, dim=0)  # 按指定dim求方差
v3 = torch.var(x, dim=1)  # 按指定dim求方差
print("var(x):", v1)  # torch.Size([])
print("var(x,0):", v2)  # torch.Size([5])
print("var(x,1):", v3)  # torch.Size([3])
print(v1.shape, v2.shape, v3.shape)
# var(x): tensor(20.)
# var(x,0): tensor([25., 25., 25., 25., 25.])
# var(x,1): tensor([2.5000, 2.5000, 2.5000])
# torch.Size([]) torch.Size([5]) torch.Size([3])

# 张量标准差
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
s1 = torch.std(x)  # 张量所有元素求标准差
s2 = torch.std(x, dim=0)  # 按指定dim求标准差
s3 = torch.std(x, dim=1)  # 按指定dim求标准差
print("std(x):", s1)  # torch.Size([])
print("std(x,0):", s2)  # torch.Size([5])
print("std(x,1):", s3)  # torch.Size([3])
print(s1.shape, s2.shape, s3.shape)
# std(x): tensor(4.4721)
# std(x,0): tensor([5., 5., 5., 5., 5.])
# std(x,1): tensor([1.5811, 1.5811, 1.5811])
# torch.Size([]) torch.Size([5]) torch.Size([3])

3.2 最大值与最小值

函数原型:

torch.max(input, dim, keepdim=False, *, out=None) → out # 张量的最大值
torch.max(input, other, *, out=None) → out # 两个张量的最大值
torch.min(input, dim, keepdim=False, *, out=None) → out # 张量的最小值
torch.min(input, other, *, out=None) → out # 两个张量的最小值
torch.argmax(input, dim, keepdim=False) → Tensor # 张量的最大值索引
torch.argmin(input, dim, keepdim=False) → Tensor # 张量的最小值索引
torch.topk(input, k, dim=None, largest=True, sorted=True, *, out=None) # k 个最大/小值
torch.median(input, dim, keepdim=False, *, out=None) → out # 张量的中值

参数说明:

  • input,张量,输入张量。
  • dim,整数或整型元组,指定维度。
  • out,张量,输出张量。
  • keepdim,布尔值,输出张量是否保留 dim,可选项,默认为 False
  • other,张量,另一个输入张量,形状与 input 相同
  • k,整数,top-k 的 k 值
  • largest,布尔值,控制返回最大值或最小值
  • sorted,布尔值,控制返回元素是否排序

函数说明:
(1)函数返回张量沿指定维度 dim 的所有元素的最大值或最小值。
(2)参数 dim 缺省时,函数默认对张量的所有元素进行计算,返回 0 维张量。参数 dim 为整数或整型元组时,按照 dim 指定维度的所有元素进行计算,返回值是带有 2 个 key( values, indices)的字典。
(3)函数 torch.topk 的返回值是带有 2 个 key( values, indices)的字典。
(4)对于具有偶数个元素的输入张量,中值不是唯一的,函数 torch.median 返回两个中值中较小的一个。


# (11) 张量的统计分析运算: 最大值与最大值索引
# 张量最大值
x = torch.arange(1.0, 16.0).reshape(3, 5)  # torch.Size([3, 5])
max1 = torch.max(x)  # 张量所有元素求最大值
print("max(x):", max1)  # torch.Size([])
# max(x): tensor(15.)
max2 = torch.max(x, dim=0)  # 按指定dim求最大值
print(max2)  # 返回值是字典, 有两个key: values和indices
# torch.return_types.max(
# values=tensor([11., 12., 13., 14., 15.]),
# indices=tensor([2, 2, 2, 2, 2]))
print(max2.values)  # torch.Size([5])
# tensor([11., 12., 13., 14., 15.])
print(max2.indices)  # torch.Size([5])
# tensor([2, 2, 2, 2, 2])

# 两个张量的最大值
a = torch.tensor((1, 2, -1))
b = torch.tensor((3, 0, 6))
print(torch.max(a, b))  # tensor([3, 2, 6])
print(torch.maximum(a, b))  # tensor([3, 2, 6])

# 张量的最大值索引
x = torch.arange(1.0, 16.0).reshape(3, 5)  # torch.Size([3, 5])
arg1 = torch.argmax(x)  # 张量所有元素求最大值索引
print("argmax(x):", arg1)  # torch.Size([])
# argmax(x): tensor(14)
arg2 = torch.argmax(x, dim=0)  # 按指定dim求最大值
print("argmax(x,0):", arg2)  # torch.Size([5])
# argmax(x,0): tensor([2, 2, 2, 2, 2])
arg3 = torch.argmax(x, dim=1)  # 按指定dim求最大值
print("argmax(x,1):", arg3)  # torch.Size([3])
# argmax(x,1): tensor([4, 4, 4])

# 返回 k 个最大值
x = torch.arange(1.0, 10.0)  # torch.Size([3, 5])
x_topk = torch.topk(x, k=2)  # 返回值是字典, 有两个key: values和indices
print(x_topk)
# torch.return_types.topk(
# values=tensor([9., 8.]),
# indices=tensor([8, 7]))
print(x_topk.values)  # tensor([9., 8.])
print(x_topk.indices)  # tensor([8, 7])

3.3 累积乘与累积和

函数原型:

torch.cumprod(input, dim, *, dtype=None, out=None) → Tensor # 张量的累积乘
torch.cumsum(input, dim, *, dtype=None, out=None) → Tensor # 张量的累积和

张量累积乘/累积和函数,返回维度dim中输入元素的累积乘积/累积和。如果输入是大小为N的向量,则结果也将是大小为N的向量,其中包含元素。

# (12) 张量的统计分析运算: 累积乘与累积和
x = torch.arange(1.0, 6.0)
x_cumprod = torch.cumprod(x, dim=0)
x_cumsum = torch.cumsum(x, dim=0)
print("x_cumprod:", x_cumprod)
# x_cumprod: tensor([  1.,   2.,   6.,  24., 120.])
print("x_cumsum:", x_cumsum)
# x_cumsum: tensor([ 1.,  3.,  6., 10., 15.])

4. 张量的比较操作

张量的比较操作,是指对多个张量进行比较运算的方法。

函数原型:

torch.equal(input, other) → bool # 比较两个张量是否相等
torch.eq(input, other, *, out=None) → Tensor # 比较两个张量的元素是否相同
torch.ne(input, other, *, out=None) → Tensor # 比较两个张量的元素是否相同
torch.gt(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足大于关系
torch.ge(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足大于等于关系
torch.lt(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足小于关系
torch.le(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足小于等于关系
torch.isnan(input) → Tensor # 检查张量的元素是否为NaN
torch.sort(input, dim=-1, descending=False, stable=False, *, out=None) # 对张量的元素按升序排列

参数说明:

  • input,张量,输入张量。
  • other,张量或浮点数,第二个输入张量。
  • out,张量,输出张量,布尔类型。

函数说明:
(1)函数 torch.equal 比较两个张量是否相等,结果是一个布尔值。函数 torch.eq 比较两个张量的逐个元素,结果是一个布尔型张量。
(2)函数 torch.gt、torch.ge、torch.lt、torch.le 逐个元素比较张量 input 与 other 的大小,结果是一个布尔型张量。
(3)函数 torch.sort 将输入张量的元素沿给定维度按值升序排列,返回值是带有 2 个 key( values, indices)的字典。

# (13) 张量的比较操作
x = torch.tensor([[1,2,3],[4,5,6]])
y = torch.tensor([[1,2,3],[4,5,6]])
z = torch.tensor([[0,2,3],[0,5,6]])

# 比较两个张量是否相等
x_equal_y = torch.equal(x, y)
x_equal_z = torch.equal(x, z)
print("x equal y:", x_equal_y)  # x equal y: True
print("x equal z:", x_equal_z)  # x equal z: False

# 比较两个张量的逐个元素是否相等
x_eq_y = torch.eq(x, y)
x_eq_z = torch.eq(x, z)
print("x eq y:", x_eq_y)
# x eq y: tensor([[True, True, True], [True, True, True]])
print("x eq z:", x_eq_z)
# x eq z: tensor([[False, True, True], [False, True, True]])

# 检查张量元素的性质
x = torch.tensor([1, float('nan'), 2])
print("isnan(x):", torch.isnan(x))  # 检查是否为 NaN
# isnan(x): tensor([False,  True, False])
print("isfinite(x):", torch.isfinite(x))  # 检查是否为有界数值
# isfinite(x): tensor([ True, False,  True])
print("isinf(x):", torch.isinf(x))  # 检查是否为无界数值
# isinf(x): tensor([False, False, False])

# 对张量的元素排序
x = torch.tensor([[1, 4, 7], [3, 0, 6]])
print(x)
print(torch.sort(x))
# torch.return_types.sort(
# values=tensor([[1, 4, 7], [0, 3, 6]]),
# indices=tensor([[0, 1, 2], [1, 0, 2]]))
print(torch.sort(x, dim=0))  #
# torch.return_types.sort(
# values=tensor([[1, 0, 6], [3, 4, 7]]),
# indices=tensor([[0, 1, 1], [1, 0, 0]]))
print(torch.sort(x, dim=1))  #
# torch.return_types.sort(
# values=tensor([[1, 4, 7], [0, 3, 6]]),
# indices=tensor([[0, 1, 2], [1, 0, 2]]))

5. 张量的线性代数运算

BLAS(Basic Linear Algeria Subprograms)和 LAPACK(Linear Algeria Package)模块提供了完整的线性代数基本方法,包括:

  1. 矩阵的形变及特殊矩阵的构造方法:包括矩阵的转置、对角矩阵的创建、单位矩阵的创建、上/下三角矩阵的创建等;
  2. 矩阵的基本运算:包括矩阵乘法、向量内积、矩阵和向量的乘法等,当然,此处还包含了高维张量的基本运算,将着重探讨矩阵的基本方法
  3. 运算拓展至三维张量中的基本方法;
  4. 矩阵的线性代数运算:包括矩阵的迹、矩阵的秩、逆矩阵的求解、伴随矩阵和广义逆矩阵等;
  5. 矩阵分解运算:特征分解、奇异值分解和SVD分解等。

版权声明:
欢迎关注『youcans的深度学习』系列,转发请注明原文链接:
【youcans的深度学习 10】PyTorch入门教程:张量的统计运算(https://youcans.blog.csdn.net/article/details/130745989)
Copyright 2023 youcans, XUPT
Crated:2023-05-18文章来源地址https://www.toymoban.com/news/detail-474232.html

到了这里,关于【youcans的深度学习 10】PyTorch入门教程:张量的统计运算与比较运算的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Google Earth Engine(GEE)深度学习入门教程- GEE导出篇

    官方教程:TFRecord 和地球引擎 在GEE的JS Code Editor中,我们按照我们的需要去处理对应的遥感影像,得到处理后Image影像。为了导出后读取数据,在导出前 一定清楚每个波段的名称(不然没法读取) 。深度学习数据集所需数据以为patch为单位,所以需要对整个遥感影像进行裁剪

    2024年02月03日
    浏览(49)
  • 【PyTorch教程】pytorch入门系列 ——土堆教程的目录及索引

    一、几句题外话 深度学习上手已经很长时间了,还记得最初的入门是跟着 B站up小土堆 的一步步学起来的,从起初的环境配置,到现在调整整个模型的进阶,非常感谢土堆的贡献。 写这个博客的初衷是为了自己 看着方便 ,由于多台电脑多个环境下查看这些内容很麻烦,所以

    2024年03月17日
    浏览(50)
  • 【深度学习】【三维重建】windows10环境配置PyTorch3d详细教程

    本人windows10下使用【Code for Neural Reflectance Surfaces (NeRS)】算法时需要搭建PyTorch3d环境,故此以详细教程以该算法依赖的环境版本为参照。 应很多朋友的要求,博主将自己的pytorch3d的conda环境打包放在【百度云盘;提取码:3tyw 】供大家参考,注意环境版本要求保持一致,并不适合

    2024年02月11日
    浏览(53)
  • Pytorch DistributedDataParallel(DDP)教程一:快速入门理论篇

    一、 写在前面 随着深度学习技术的不断发展,模型的训练成本也越来越高。训练一个高效的通用模型,需要大量的训练数据和算力。在很多非大模型相关的常规任务上,往往也需要使用多卡来进行并行训练。在多卡训练中,最为常用的就是分布式数据并行(DistributedDataPara

    2024年04月15日
    浏览(36)
  • C++引用10分钟入门教程

    我们知道,参数的传递本质上是一次赋值的过程,赋值就是对内存进行拷贝。所谓内存拷贝,是指将一块内存上的数据复制到另一块内存上。 对于像 char、bool、int、float 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。而数组、结构体、

    2024年01月19日
    浏览(41)
  • Windows 10教程_编程入门自学教程_菜鸟教程-免费教程分享

    Windows 10入门教程 - 从简单的步骤了解Windows 10,从基本到高级概念,包括概述,安装,入门,GUI基础知识,导航,开始菜单,任务栏,平板电脑模式,文件资源管理器,Cortana,通知,快速操作,云,通用应用程序,多个桌面,用户管理,安全性,家长控制,应用程序,Web浏览

    2024年02月02日
    浏览(41)
  • mmdetection基于 PyTorch 的目标检测开源工具箱 入门教程

    MMDetection 支持在 Linux,Windows 和 macOS 上运行。它需要 Python 3.7 以上,CUDA 9.2 以上和 PyTorch 1.8 及其以上。 步骤 0.  从官方网站下载并安装 Miniconda。 步骤 1.  创建并激活一个 conda 环境。 步骤 2.  基于 PyTorch 官方说明安装 PyTorch。 在 GPU 平台上: 步骤 3.  使用 MIM 安装 MMEng

    2024年02月11日
    浏览(41)
  • Pytorch DistributedDataParallel(DDP)教程二:快速入门实践篇

    一、简要回顾DDP 在上一篇文章中,简单介绍了Pytorch分布式训练的一些基础原理和基本概念。简要回顾如下: 1,DDP采用Ring-All-Reduce架构,其核心思想为:所有的GPU设备安排在一个逻辑环中,每个GPU应该有一个左邻和一个右邻,设备从它的左邻居接收数据,并将数据汇总后发送

    2024年04月15日
    浏览(39)
  • pytorch中分布式训练DDP教程(新手快速入门!)

    PyTorch是深度学习领域广泛使用的开源深度学习框架之一。随着深度学习模型的不断增大和数据集的不断增长,单机训练往往不能满足我们的需求。为了加速训练过程,我们可以使用分布式训练技术。在PyTorch中,分布式数据并行(Distributed Data Parallel,简称DDP)是一种常见的分

    2024年02月16日
    浏览(43)
  • Windows 10开发教程_编程入门自学教程_菜鸟教程-免费教程分享

    Windows 10开发教程 Windows 10开发 - 简介 Windows 10开发 - UWP Windows 10开发 - 第一个应用程序 Windows 10开发 - 存储 Windows 10开发 - XAML控件 Windows 10开发 - 数据绑定 Windows 10 Dev - XAML性能 Windows 10开发 - 自适应设计 Windows 10开发 - 自适应UI Windows 10开发 - 自适应代码 Windows10开发 - 文件管理

    2023年04月19日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包