《动手学深度学习》(TF2.0版)第二章

最新推荐文章于 2024-02-29 16:16:34 发布
最新推荐文章于 2024-02-29 16:16:34 发布
阅读量290 收藏
点赞数
分类专栏： 深度不学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ALZFterry/article/details/113584237
版权

第二章

import tensorflow as tf
print(tf.__version__)

查看TF的版本

2.2数据操作

2.2.1 创建tensor

  1. 创建tensor
x = tf.constant(range(12))#constant 代表是常量的tensor
print(x.shape)
x
print(x)
len(x)#可以用len函数获取长度

(12,)
<tf.Tensor: id=0, shape=(12,), dtype=int32, numpy=array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])>
12
  1. 使用reshape函数
    使用reshape函数把行向量x的形状改为(3, 4)，也就是一个3行4列的矩阵，并记作X
 X = tf.reshape(x,(3,4))#第一个参数为tensor，第二个参数为()元组

上面x.reshape((3, 4))也可写成x.reshape((-1, 4))或x.reshape((3, -1))。由于x的元素个数是已知的，这里的-1是能够通过元素个数和其他维度的大小推断出来的。

  1. 创建一个各元素为0，形状为(2, 3, 4)的张量
tf.zeros((2,3,4))
  1. 创建各元素为1的张量
tf.ones((3,4))
  1. 通过Python的列表（list）指定需要创建的tensor中每个元素的值
Y = tf.constant([[2,1,4,3],[1,2,3,4],[4,3,2,1]])
Y

<tf.Tensor: id=9, shape=(3, 4), dtype=int32, numpy=
array([[2, 1, 4, 3],
       [1, 2, 3, 4],
       [4, 3, 2, 1]])>
  1. 我们需要随机生成tensor中每个元素的值。下面我们创建一个形状为(3, 4)的tensor。它的每个元素都随机采样于均值为0、标准差为1的正态分布。
x=tf.random.normal(shape=[3,4], mean=0, stddev=1)
print(x)


tf.Tensor(
[[-1.153268    0.6116716   0.9703915  -2.7604232 ]
 [ 0.48349026 -0.14327626  2.940394    0.98280823]
 [ 0.11714476 -1.9485139  -0.46181852 -0.23992358]], 
 shape=(3, 4), dtype=float32)

2.2.2运算

  1. 乘除
X + Y  #这里的X,Y有相同的形状，对应元素可以相加
X * Y#对应的元素相乘
X / Y
  1. 指数运算
Y = tf.cast(Y, tf.float32)#这里先转换tensor的类型

x=tf.reshape(tf.constant(range(12)),(3,4))
print(x)
x = tf.cast(x, tf.float32)
print(tf.exp(x))

tf.Tensor(
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]], shape=(3, 4), dtype=int32)
tf.Tensor(
[[1.0000000e+00 2.7182817e+00 7.3890562e+00 2.0085537e+01]
 [5.4598152e+01 1.4841316e+02 4.0342880e+02 1.0966332e+03]
 [2.9809580e+03 8.1030840e+03 2.2026467e+04 5.9874145e+04]], shape=(3, 4), dtype=float32)

这里注意，这里必须要cast 类型转换

  1. 矩阵的乘法，matmul函数做矩阵乘法
Y = tf.cast(Y, tf.int32)
tf.matmul(X, tf.transpose(Y))
  1. 矩阵 的转置
tf.transpose(Y)
  1. tensor 的拼接
tf.concat([X,Y],axis = 0)#行为axis=0，结果shape （6,4）
tf.concat([X,Y],axis = 1)#列为axis=1，结果shape （3,8）
  1. 判断值相等，以X == Y为例，如果X和Y在相同位置的条件判断为真（值相等），那么新的tensor在相同位置的值为1；反之为0。
tf.equal(X,Y)

<tf.Tensor: id=31, shape=(3, 4), dtype=bool, numpy=
array([[False,  True, False,  True],
       [False, False, False, False],
       [False, False, False, False]])>
  1. 求和
tf.reduce_sum(X)

2.2.3广播机制

对两个形状相同的tensor做按元素运算。当对两个形状不同的tensor按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个tensor形状相同后再按元素运算。

2.2.4索引

在tensor中，索引（index）代表了元素的位置。tensor的索引从0开始逐一递增。例如，一个3行2列的矩阵的行索引分别为0、1和2，列索引分别为0和1。

X[1:3]
#X为3行4列，这句话等于X[1:3,:],依据左闭右开指定范围的惯例，它截取了矩阵X中行索引为1和2的两行。

<tf.Tensor: id=50, shape=(2, 4), dtype=float32, numpy=
array([[ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]], dtype=float32)>
  1. 赋值
    指定tensor中需要访问的单个元素的位置，如矩阵中行和列的索引，并为该元素重新赋值。
X = tf.Variable(X)#从常量转换为变量
X[1,2].assign(9)

<tf.Variable 'UnreadVariable' shape=(3, 4) dtype=float32, numpy=
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  9.,  7.],
       [ 8.,  9., 10., 11.]], dtype=float32)>

2.2.5 运算的内存开销

tensor 和 NumPy 相互变换

import numpy as np

P = np.ones((2,3))
D = tf.constant(P)

下面为TF 的tensor

<tf.Tensor: id=115, shape=(2, 3), dtype=float64, numpy=
array([[1., 1., 1.],
       [1., 1., 1.]])>

在转换回来
下面为np的tensor

np.array(D)

2.3自动求梯度

对函数 在这里插入图片描述求关于列向量 xx 的梯度。

x = tf.reshape(tf.Variable(range(4), dtype=tf.float32),(4,1))

在这里插入图片描述

with tf.GradientTape() as t:
    t.watch(x)
    y = 2 * tf.matmul(tf.transpose(x), x)

dy_dx = t.gradient(y, x)
dy_dx

<tf.Tensor: id=30, shape=(4, 1), dtype=float32, numpy=
array([[ 0.],
       [ 4.],
       [ 8.],
       [12.]], dtype=float32)>

with tf.GradientTape(persistent=True) as g:
    g.watch(x)
    y = x * x
    z = y * y
    dz_dx = g.gradient(z, x)  # 108.0 (4*x^3 at x = 3)
    dy_dx = g.gradient(y, x)  # 6.0
dz_dx,dy_dx

WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.
WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.

(<tf.Tensor: id=41, shape=(4, 1), dtype=float32, numpy=
 array([[  0.],
        [  4.],
        [ 32.],
        [108.]], dtype=float32)>,
 <tf.Tensor: id=47, shape=(4, 1), dtype=float32, numpy=
 array([[0.],
        [2.],
        [4.],
        [6.]], dtype=float32)>)

with tf.GradientTape(persistent=True) as g:
    g.watch(x)
    y = x * x
    z = y * y
    dz_dx = g.gradient(z, x)  # 108.0 (4*x^3 at x = 3)
    dy_dx = g.gradient(y, x)  # 6.0
dz_dx,dy_dx


WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.
WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.

(<tf.Tensor: id=41, shape=(4, 1), dtype=float32, numpy=
 array([[  0.],
        [  4.],
        [ 32.],
        [108.]], dtype=float32)>,
 <tf.Tensor: id=47, shape=(4, 1), dtype=float32, numpy=
 array([[0.],
        [2.],
        [4.],
        [6.]], dtype=float32)>)

2.4

想了解某个函数或者类的具体用法时，可以使用help函数。让我们以ones函数为例，查阅它的用法。更详细的信息，可以通过Tensorflow的API文档版本选择页，选择与自己环境中的 tensorflow 版本一致的 API 版本进行查询。

help(tf.ones)

当我们想知道一个模块里面提供了哪些可以调用的函数和类的时候，可以使用dir函数。下面我们打印dtypes和random模块中所有的成员或属性。

当我们想知道一个模块里面提供了哪些可以调用的函数和类的时候，可以使用dir函数。下面我们打印dtypes和random模块中所有的成员或属性。

dir(tf.dtypes)


['DType',
 'QUANTIZED_DTYPES',
 '__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__path__',
 '__spec__',
 '_sys',
 'as_dtype',
 'bfloat16',
 'bool',
 'cast',
 'complex',
 'complex128',
 'complex64',
 'double',
 'float16',
 'float32',
 'float64',
 'half',
 'int16',
 'int32',
 'int64',
 'int8',
 'qint16',
 'qint32',
 'qint8',
 'quint16',
 'quint8',
 'resource',
 'saturate_cast',
 'string',
 'uint16',
 'uint32',
 'uint64',
 'uint8',
 'variant']
Cv_Terry
关注
专栏目录
深度学习系列资料总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
07-17 2万+
说明本系列深度学习资料集合包含机器学习、深度学习等各系列教程，主要以计算机视觉资料为主，包括图像识别、分类、检测、分割等，内容参考Github及网络资源，仅供个人学习。深度学习定义一般是指通过训练多层网络结构对未知数据进行分类或回归深度学习分类有监督学习方法——深度前馈网络、卷积神经网络、循环神经网络等；无监督学习方法——深度信念网、深度玻尔兹曼机，深度自编码器等。手写机器学习笔记github机器学习算法公式推导以及numpy实现github人工智能相关术语link。..................
《计算传播学导论》读书笔记——第二章文本分析简介
Bai_yxi的博客
10-05 1112
文本分析的研究现状、常见文本分析方法、常用的Python文本分析库等
动手学深度学习（2）
01-06
动手学深度学习（2） 过拟合和欠拟合 接下来，我们将探究模型训练中经常出现的两类典型问题： 一类是模型无法得到较低的训练误差，我们将这一现象称作欠拟合（underfitting）； 另一类是模型的训练误差远小于它在测试数据集上的误差，我们称该现象为过拟合（overfitting）。 在实践中，我们要尽可能同时应对欠拟合和过拟合。虽然有很多因素可能导致这两种拟合问题，在这里我们重点讨论两个因素：模型复杂度和训练数据集大小。 卷积神经网络参数计算 Convolutional Neural Networks 使用全连接层的局限性： 图像在同一列邻近的像素在这个向量中可能相距较远。它们构成的模式可
动手学深度学习（二）
no-bug
02-14 166
一 文本预处理； 文本是一类序列数据，一篇文章可以看作是字符或单词的序列，本节将介绍文本数据的常见预处理步骤，预处理通常包括四个步骤： 读入文本 分词 建立字典，将每个词映射到一个唯一的索引（index） 将文本从词的序列转换为索引的序列，方便输入模型 二语言模型； 一段自然语言文本可以看作是一个离散时间序列，给定一个长度为 T 的词的序列 w1,w2,…,wT ，语言模型的目标就是评估该序列...
《动手学深度学习（Dive into Deeplearning）》（第二版）——启程
def_Mark_Heng的私房菜
07-21 285
《动手学深度学习（Dive into Deeplearning）》启程篇 今天是我第一天开始在CSDN上发表内容，还是熟悉的markdown编辑方式哈哈哈哈，想想当初第一次接触markdown编辑还是大数据技术基础这门课的老师推荐的typora编辑器，还是十分好用的。 上学期的深度学习课只有半个学期，感觉一下子就把内容过了一遍，学完之后虽然自己动手实现了训练图片翻译的模型并且效果还不错（如果有时间我会考虑放上来哈哈哈），但是像是一晃而过一样真正深度学习讲了些什么我还是一知半解的，所以我打算趁着这个暑假在学校
《动手学深度学习（Dive into Deeplearning）》（第二版）——准备
def_Mark_Heng的私房菜
07-22 962
《动手学深度学习（Dive into Deeplearning）》（第二版）序言安装符号 序言 前面主要铺垫了一些前期介绍，下面说明一下代码部分。 为了避免不必要的重复，书中将导入和引用的函数、类等封装在 d2l 包中。对于要保存到包中的任何代码块，比如一个函数、一个类或者多个导入，标记为#@save。在 sec_d2l 中能够找到这些函数和类的详细描述。d2l软件包是轻量级的，仅需要以下软件包和模块作为依赖项： #@save import collections import hashlib import
动手学深度学习（第二版）学习笔记 第二章
qq_52370024的博客
02-20 926
动手学深度学习（第二版）学习笔记
《动手学深度学习》tensorflow2.0版 第三章笔记
xu_aml的博客
04-11 856
《动手学深度学习》tensorflow2.0版 第三章笔记线性回归训练图像分类数据集（Fashion-MNIST）训练误差（training error）和泛化误差（generalization error）。 作为一名tensorflow新手，用最基本的函数去完成一些任务是必要的，即使现在pytorch如日中天，还是认为目前一段时间工业界对tensorflow的需求还是会有很多，但是鄙人特别擅长反向押宝????。文中的代码没有实测运行。 线性回归训练 只利用Tensor和GradientTape来实现一个
第3章(3.11～3.16节)模型细节/Kaggle实战【深度学习基础】--动手学深度学习【Tensorflow2.0版本】
土豆洋芋山药蛋的博客
01-31 1483
项目地址：https://github.com/TrickyGo/Dive-into-DL-TensorFlow2.0 UC 伯克利李沐的《动手学深度学习》开源书一经推出便广受好评。很多开发者使用了书的内容，并采用各种各样的深度学习框架将其复现。 现在，《动手学深度学习》书又有了一个新的复现代码版本——TensorFlow2.0 版，短时间内成为了github上千star项目，欢迎关注。 3....
第3章(3.2～3.7节)线性/Softmax回归实现【深度学习基础】--动手学深度学习【Tensorflow2.0版本】
土豆洋芋山药蛋的博客
01-30 817
项目地址：https://github.com/TrickyGo/Dive-into-DL-TensorFlow2.0 UC 伯克利李沐的《动手学深度学习》开源书一经推出便广受好评。很多开发者使用了书的内容，并采用各种各样的深度学习框架将其复现。 现在，《动手学深度学习》书又有了一个新的复现代码版本——TensorFlow2.0 版，短时间内成为了github上千star项目，欢迎关注。 文章...
d2l_zh:《动手学深度学习》第二版PyTorch版本
03-28
d2l_zh 《动手学深度学习》第二版PyTorch版本 运行环境：Google Colab
DAY2-《动手学深度学习》(PyTorch版)
01-07
Task03： 过拟合和欠拟合 一类是模型无法得到较低的训练误差，我们将这一现象称作欠拟合（underfitting）； 另一类是模型的训练误差远小于它在测试数据集上的误差，我们称该现象为过拟合（overfitting）。 在实践中，我们要尽可能同时应对欠拟合和过拟合。虽然有很多因素可能导致这两种拟合问题，在这里我们重点讨论两个因素：模型复杂度和训练数据集大小。 模型复杂度 为了解释模型复杂度，我们以多项式函数拟合为例。给定一个由标量数据特征x和对应的标量标签y组成的训练数据集，多项式函数拟合的目标是找一个K阶多项式函数 来近似 y。在上式中，wk是模型的权重参数，b是偏差参数。与线性回归
《动手学深度学习》第二版（2.预备知识）笔记
最新发布
努力学习
02-29 139
《动手学深度学习》第二版（2.预备知识）笔记
《动手学深度学习（Dive into Deeplearning）》（第二版）——第二章 _2.2 数据预处理
def_Mark_Heng的私房菜
07-23 913
《动手学深度学习（Dive into Deeplearning）》（第二版）——第二章 _2.2 数据预处理第二章 预备知识§ 前期回顾§ 2.2 数据预处理2.2.1 读取数据集2.2.2 处理缺失值2.2.3 转换为张量格式2.2.4 总结*课后练习* 第二章 预备知识 § 前期回顾   上一节我们学习了torch中张量的一些基本操作，接下来一节我们将学习数据预处理。同样放上视频传送门： 04 数据操作 + 数据预处理【动手学深度学习v2】 该视频和上一节的视频是同一个哈，那么让我们开始这一节的学
《动手学深度学习》第二版（1.引言）笔记
努力学习
02-26 1079
《动手学深度学习》学习笔记——1.引言
《动手学深度学习》第二版 学习记录
st1124455488的博客
08-30 314
本人初次接触python，主要用于记录自己在学习本书时遇到的问题。可能解决办法还有很多种，也希望各位多多指教！也肯定会有许多地方不专业，也希望多多海涵。
动手学深度学习（第二版）学习笔记 第三章
qq_52370024的博客
02-27 491
在单层网络中(一层线性回归层)，将权重初始化为零时可以的，但是网络层数加深后，在全连接的情况下，在反向传播的时候，由于权重的对称性会导致出现隐藏神经元的对称性，使得多个隐藏神经元的作用就如同1个神经元，算法还是有效的，但是效果不大好。另外，我们将更多的数学运算放到库中，而无须自己编写那么多的计算，从而减少了出错的可能性。解析解可以进行很好的数学分析，但解析解对问题的限制很严格，导致它无法广泛应用在深度学习里。然而，顾名思义，全连接层是“完全”连接的，可能有很多可学习的参数。个输出的全连接层， 参数开销为。
李沐d2l《动手学深度学习》第二版——风格迁移源码详解
Polaris的博客
01-21 7107
本文是对李沐Dive to DL《动手学深度学习》第二版13.12节风格迁移的源码详解，整体由Jupyter+VSCode完成，几乎所有重要代码均给出了注释，一看就懂。需要的同学可以在文末链接处下载原文件。 话不多说，我们开始。 图1中的内容图像为本书作者在西雅图郊区的雷尼尔山国家公园拍摄的风景照，而风格图像则是一幅主题为秋天橡树的油画。最终输出的合成图像应用了风格图像的油画笔触让整体颜色更加鲜艳，同时保留了内容图像中物体主体的形状。 图1 风格迁移效果示意图 1.一种简单的风格迁移方法 (1) 初始
动手学深度学习（第二版）注释后代码【持续更新】
亦梦亦醒乐逍遥的博客
07-17 1257
动手学深度学习的代码中用到一些python的特性，但是并没有解释，而且一些torch库函数也并没有做解释，自己也在各大库的官方文档里都查了，做出注释，让人可以看懂每一步。
tf2.0 深度学习实战4
08-28
TF 2.0深度学习实战4主要介绍了在TensorFlow 2.0版本中如何实现深度学习的相关内容。首先，TensorFlow 2.0版本相比之前的版本有很大的改进和优化，使得我们在构建、训练和部署深度学习模型时更加方便和高效。 在这本书中，我们可以学习到如何使用TF 2.0来构建卷积神经网络（CNN）、循环神经网络（RNN）和转移学习模型等。通过书中的实例代码，我们可以学习到如何使用TF 2.0来训练这些模型，并使用它们来解决实际的问题，比如图像分类、文本生成和语音识别等。 与此同时，本书还介绍了如何使用TF 2.0的低级API和高级API来构建深度学习模型。低级API提供了更加灵活和底层的操作，可以满足一些特定需求；而高级API则提供了更加简单和易于使用的接口，可以加速开发过程。通过书中的实例代码，读者可以学习到如何使用这些API来构建不同类型的深度学习模型。 此外，书中还介绍了TF 2.0版本的Eager Execution（即动态图计算），这是TF 2.0的一个重要特性，使得我们可以实时调试和追踪代码中的计算过程。通过学习如何使用Eager Execution，读者可以更好地理解和调试深度学习模型，并且能够更快地迭代和调整模型的结构和参数。 总之，TF 2.0深度学习实战4是一本介绍如何使用TensorFlow 2.0版本来实践深度学习的实用书籍。通过学习本书，读者可以了解到TF 2.0的优势和特性，并能够熟练地使用TF 2.0构建、训练和部署深度学习模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值