动手学深度学习-预备知识-数据操作

这篇具有很好参考价值的文章主要介绍了动手学深度学习-预备知识-数据操作。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

动手学深度学习,笔记

第一章:预备知识

第一节数据操作:

(1)入门操作:

1.首先导入torch库,我们使用pytorch主要使用这个库的函数

import torch

张量表示一个由数值组成的数组,这个数组可能有多个维度。具有一个轴的张量对应数学上的向量(vector); 具有两个轴的张量对应数学上的矩阵(matrix);具有两个轴以上的张量没有特殊的数学名称。

我们来创建一个张量,可以使用 arange 创建一个行向量 x。

这个行向量包含以0开始的前12个整数,它们默认创建为整 数。也可指定创建类型为浮点数。张量中的每个值都称为张量的 元素(element)。

x = torch.arange(12)
print(x)
## tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

可以通过张量的shape属性来访问张量(沿每个轴的长度)的形状

print(x.shape)
#结果:torch.Size([12])

如果只想知道张量中元素的总数,即形状的所有元素乘积,可以检查它的大小(size)。因为这里在处理的是 一个向量,所以它的shape与它的size相同。

print(x.numel())
#12

 要想改变一个张量的形状而不改变元素数量和元素值,可以调用reshape函数。例如,可以把张量x从形状为 (12,)的行向量转换为形状为(3,4)的矩阵。这个新的张量包含与转换前相同的值,但是它被看成一个3行4列 的矩阵。要重点说明一下,虽然张量的形状发生了改变,但其元素值并没有变。注意,通过改变张量的形状, 张量的大小不会改变。

X = x.reshape(3, 4)
print(X)

# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11]])

有时,我们希望使用全0、全1、其他常量,或者从特定分布中随机采样的数字来初始化矩阵。我们可以创建 一个形状为(2,3,4)的张量,其中所有元素都设置为0。代码如下:

x2 = torch.zeros((2, 3, 4))
print(x2)
'''
tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])
'''

同样,我们可以创建一个形状为(2,3,4)的张量,其中所有元素都设置为1。代码如下:

x3 = torch.ones((2, 3, 4))
print(x3)
# tensor([[[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]],

#         [[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]]])

我们想要随机获取一些值,以下代码创建一个形状为(3,4)的张量。其中的 每个元素都从均值为0、标准差为1的标准高斯分布(正态分布)中随机采样。

x4 = torch.randn(3, 4)
print(x4)
# tensor([[-0.2421, -1.4333,  0.1154, -0.2187],
#         [-0.6590, -0.1766,  1.9008, -0.7222],
#         [ 1.2284, -0.5664,  0.6310, -1.3181]])

创建确定的张量内容,为张量内每个元素确定值

x5 = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(x5)
# tensor([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])

(2)运算符

我们可以对张量进行加减乘除和幂运算

import torch

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])

print("x+y=", x + y)
print("x-y=", x - y)
print("x*y=", x * y)
print("x/y=", x / y)
print("x^y=", x**y)
# x+y= tensor([ 3.,  4.,  6., 10.])
# x-y= tensor([-1.,  0.,  2.,  6.])
# x*y= tensor([ 2.,  4.,  8., 16.])
# x/y= tensor([0.5000, 1.0000, 2.0000, 4.0000])
# x^y= tensor([ 1.,  4., 16., 64.])

使用自然对数e^(x)的函数

print("exp(x)=", torch.exp(x))
# exp(x)= tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

将两个张量进行拼接在一起,cat函数

比如(1,4)和(1,4)的张量,cat中dim=0,拼接后的张量1+1=2 shape=(2,4)

比如(1,4)和(1,4)的张量,cat中dim=1,拼接后的张量4+4=8 shape=(1,8)

x1 = torch.cat((x, y), dim=0)
x2 = torch.cat((x, y), dim=1)
print("dim = 0 ", x1)
print("dim = 1", x2)
print("cat前的大小 x.shape=", x.shape, "y.shape=", y.shape)
print("cat后的大小 x1.shape=", x1.shape, "x2.shape=", x2.shape)
# dim = 0  tensor([[1, 2, 4, 8],
#         [2, 2, 2, 2]])
# dim = 1 tensor([[1, 2, 4, 8, 2, 2, 2, 2]])
# cat前的大小 x.shape= torch.Size([1, 4]) y.shape= torch.Size([1, 4])
# cat后的大小 x1.shape= torch.Size([2, 4]) x2.shape= torch.Size([1, 8])

对于张量的逻辑操作

比如x==y ,x!=y

 x =[1, 2, 4, 8]
  y = [2, 2, 2, 2]
x1 = x == y
x2 = x != y
print("x==y", x1)
print("x!=y", x2)
# x==y tensor([[False,  True, False, False]])
# x!=y tensor([[ True, False,  True,  True]])

张量的降维,求和,计算张量的总和,变成一个标量 sum函数

x1 = x.sum()
print(x1)
print(type(x1))
# tensor(15)
# <class 'torch.Tensor'>

(3) 广播机制

 通过适当复制元素来扩展一个或者两个数组,以便转换之后,两个张量具有相同的形状,方便元素操作

例如x 和y张量 ,x张量复制出额外的列,元素012,变成3行2列。

y张量复制出额外的行,元素01,变成3行2列。

然后张量按照行列相加。

总而言之,矩阵x复制列,矩阵y复制行,然后按照元素相加。

x = torch.tensor([[0], [1], [2]])
y = torch.tensor([[0, 1]])

print(x + y)
# tensor([[0, 1], 
#         [1, 2], 
#         [2, 3]])

(4) 节省内存

在pytorch中进行新的操作会为新结果分配内存,例如,如果我们用Y =Y+1,我们将取消引用Y指向的张量, 而是指向新分配的内存处的张量。

import torch

Y = torch.tensor([[1], [2]])
before = id(Y)
Y = Y + 1
flag = id(Y) == before
print(flag)

这里的结果是False,表示内存位置不一样,Python的id()函数演示了这一点,它给我们提供了内存中引用对象的确切地址。运 行Y = Y + 1后,我们会发现id(Y)指向另一个位置。这是因为Python首先计算Y + 1,为结果分配新的内存, 然后使Y指向内存中的这个新位置。

这可能是不可取的,原因有两个: 1. 首先,我们不想总是不必要地分配内存。在机器学习中,我们可能有数百兆的参数,并且在一秒内多次 更新所有参数。通常情况下,我们希望原地执行这些更新; 2. 如果我们不原地更新,其他引用仍然会指向旧的内存位置,这样我们的某些代码可能会无意中引用旧 的参数。

执行原地址操作的代码

Z = torch.zeros_like(Y)
print(id(Z))
Z[:] = Y + 1
print(id(Z))
# 2104847078848
# 2104847078848

或者

before = id(Y)
Y += 1
print(before == id(Y))
# True

或者

before = id(Y)
Y[:] = Y + 1
print(before == id(Y))
# True

这样就会在原内存地址操作,减少内存的开销。

 文章来源地址https://www.toymoban.com/news/detail-751110.html

到了这里,关于动手学深度学习-预备知识-数据操作的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • 深度学习基础知识-pytorch数据基本操作

    1.1.1 数据结构 机器学习和神经网络的主要数据结构,例如                 0维:叫标量,代表一个类别,如1.0                 1维:代表一个特征向量。如  [1.0,2,7,3.4]                 2维:就是矩阵,一个样本-特征矩阵,如: [[1.0,2,7,3.4 ]                   

    2024年02月11日
    浏览(34)
  • 动手学深度学习——数据预处理

    为了能用深度学习来解决现实世界的问题,我们经常从预处理原始数据开始,而不是从那些准备好的张量格式数据开始。 在Python中常用的数据分析工具中,我们通常使用 pandas 软件包。像庞大的Python生态系统中的许多其他扩展包一样, pandas 可以与张量兼容。 举一个例子,我

    2024年02月16日
    浏览(45)
  • 【动手学深度学习】--机器翻译与数据集

    学习视频:机器翻译数据集【动手学深度学习v2】 官方笔记:机器翻译与数据集 机器翻译 (machine translation)指的是 将序列从一种语言自动翻译成另一种语言。 事实上,这个研究领域可以追溯到数字计算机发明后不久的20世纪40年代, 特别是在第二次世界大战中使用计算机破

    2024年02月09日
    浏览(29)
  • 动手学深度学习(2)-3.5 图像分类数据集

    这里主要是看一下如何加载数据集,并且生成批次训练的数据。 最大的收获是,知道了如何在训练阶段提高模型训练的性能 增加batch_size 增加num_worker 数据预加载 图像分类数据集 主要包介绍 这个模块主要是将如何加载数据集,并且生成一个迭代器,每一次访问都会俺批次生

    2024年02月09日
    浏览(31)
  • 11、动手学深度学习——语言模型和数据集:代码详解

    我们了解了如何将文本数据映射为词元,以及将这些词元可以视为一系列离散的观测,例如单词或字符。 假设长度为 T T T 的文本序列中的词元依次为 x 1 , x 2 , … , x T x_1, x_2, ldots, x_T x 1 ​ , x 2 ​ , … , x T ​ 。于是, x t x_t x t ​ ( 1 ≤ t ≤ T 1 leq t leq T 1 ≤ t ≤ T )可以

    2024年02月17日
    浏览(28)
  • 《动手学深度学习 Pytorch版》 8.3 语言模型和数据集

    依靠在 8.1 节中对序列模型的分析,可以在单词级别对文本数据进行词元化。基本概率规则如下: P ( x 1 , x 2 , … , x T ) = ∏ t = 1 T P ( x t ∣ x 1 , … , x t − 1 ) P(x_1,x_2,dots,x_T)=prod^T_{t=1}P(x_t|x_1,dots,x_{t-1}) P ( x 1 ​ , x 2 ​ , … , x T ​ ) = t = 1 ∏ T ​ P ( x t ​ ∣ x 1 ​ , … , x t −

    2024年02月07日
    浏览(27)
  • 电力系统知识预备及学习方向

    由于电源点与负荷中心多数处于不同地区,也无法大量储存,故其生产、输送、分配和消费都在同一时间内完成,并在同一地域内有机地组成一个整体,电能生产必须时刻保持与消费平衡。因此,电能的集中开发与分散使用,以及电能的连续供应与负荷的随机变化,就制约了

    2024年02月09日
    浏览(30)
  • 三 动手学深度学习v2 —— Softmax回归+损失函数+图片分类数据集

    softmax回归 损失函数 1. softmax回归 回归vs分类: 回归估计一个连续值 分类预测一个离散类别 从回归到多类分类 回归 单连续数值输出 自然区间R 跟真实值的误差作为损失 分类 通常多个输出 输出i是预测为第i类的置信度 总结: 2. 损失函数 L2 loss 均方损失 l ( y , y ′ ) = 1 2 ( y −

    2024年02月14日
    浏览(24)
  • 【Linux学习】信号——预备知识 | 信号产生 | 核心转储

    🐱作者:一只大喵咪1201 🐱专栏:《Linux学习》 🔥格言: 你只管努力,剩下的交给时间! 从生活中入手,例如发令枪,闹钟,红绿灯等等,这些都是信号。信号必须都是 动态 的,像路标就不能称之为信号。 以红绿灯为例,一看到红绿灯我们就知道红灯行,绿灯停,我们不

    2023年04月11日
    浏览(23)
  • 【Node.js学习 day2——预备知识】

    1、概念 Buffer是一个类似于数组的对象,用于表示固定长度的字节序列 Buffer本质是一段内存空间,专门用来处理二进制数据 2、特点 Buffer大小规定且无法调整 Buffer性能较好,可以直接对计算机内存进行操作 每个元素的大小为1字节(byte) 3、使用 创建Buffer(3种方式) 4、 B

    2024年01月25日
    浏览(33)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包