04-26 02:15 阅读 167

黑马程序员3天玩转Python深度学习tensorflow（第一天）

文章目录

一、深度学习的介绍

1.1 深度学习与机器学习的区别

1.1.1 特征提取方面

1.1.2 数据量和计算性能要求

1.1.3 算法代表

1.2 深度学习的应用场景

1.3 深度学习框架介绍

1.3.1 常见深度学习框架对比

1.3.2 tensorflow的特点

1.3.3 tensorflow的安装

二、tensorflow框架介绍

2.1 TF数据流图

2.1.1 案例：tensorflow实现一个加法运算

2.2 图与TensorBoard

2.2.1 什么是图结构

2.2.2 图相关操作

2.2.3 TensorBoard可视化学习

2.2.4 OP

2.3 会话

2.3.1 会话创建

2.4 张量

2.4.1 张量（Tensor）

2.4.2 创建张量的指令

2.4.3 张量的变换

2.4.4 张量的数学运算

2.5 变量OP

2.5.1 创建变量

2.5.2 使用tf.variable_scope()修改变量的命名空间

2.6 高级API

2.6.1 其他基础API

2.6.2 高级API

2.7 案例：实现线性回归

2.7.2 案例：实现线性回归的训练

2.7.3 增加其他功能

学习目标：

第一天：tensorflow框架实用

第二天：数据读取、神经网络基础

第三天：卷积神经网络、验证码识别

第一天：

学习学习介绍

tensorflow框架的使用

1）tensorflow的结构

2）tensorflow的各个组件：图、会话、张量、变量

3）简单的线性回归案例----将TensorFlow用起来

一、深度学习的介绍

1.1 深度学习与机器学习的区别

学习目标：知道深度学习与机器学习的区别

区别：深度学习没有特征提取

1.1.1 特征提取方面

机器学习的特征工程步骤是要靠手动完成的，而且需要大量领域专业知识

深度学习通常由多个层组成，它们通常将更简单的模型组合在一起，将数据从一层传递到另一层来构建更复杂的模型。通过训练大量数据自动得到模型，不需要人工特征提取环节

深度学习算法试图从数据中学习高级功能，这是深度学习的一个非常独特的部分。因此，减少了为每个问题开发新特征提取器的任务。适合用在难提取特征的图像、语音、自然语言处理领域

1.1.2 数据量和计算性能要求

机器学习需要的执行时间远少于深度学习，深度学习参数往往很庞大，需要通过大量

数据的多次优化来训练参数

第一，深度学习需要大量的训练数据集

第二，训练深度神经网络需要大量的算力

可能要花费数天、甚至数周的时间，才能使用数百万张图像的数据集训练出一个深度网络。所以深度学习通常需要强大的GPU服务器来进行计算

1.1.3 算法代表

机器学习：朴素贝叶斯，决策树

深度学习：神经网络

1.2 深度学习的应用场景

图像识别：物体识别、场景识别、车型识别、人脸检测跟踪、人脸关键点定位、人脸身份认证

自然语言处理技术：机器翻译、文本识别、聊天对话

语音技术：语音识别

1.3 深度学习框架介绍

1.3.1 常见深度学习框架对比

1.3.2 tensorflow的特点

官网：https://www.tensorflow.org/

1.3.3 tensorflow的安装

1 CPU版本

2 GPU版本：核芯数量多，更适合处理并行任务

pip install tensorflow==1.8 -i https://pypi.douban.com/simple

二、tensorflow框架介绍

2.1 TF数据流图

学习目标：说明tensorflow的数据流图结构

2.1.1 案例：tensorflow实现一个加法运算

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def tensorflow_demo():

"""

tensorflow的基本结构

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2)

b_t = tf.constant(3)

c_t = a_t + b_t

print("c_t：", c_t)

# 开启会话

with tf.Session() as sess:

c_t_value = sess.run(c_t)

print("c_t_value:", c_t_value)

return None

if __name__ == "__main__":

tensorflow_demo()

c_t： Tensor("add:0", shape=(), dtype=int32)

c_t_value: 5

2 TensorFlow结构分析

TensorFlow程序通常被组织成一个构件图阶段和一个执行图阶段。

在构建阶段，数据与操作的执行步骤被描述为一个图

在执行阶段，使用会话执行构建好的图中的操作

图：这是TensorFlow将计算表示为指令之间的依赖关系的一种表示法

会话：TensorFlow跨一个或多个本地或远程设备运行数据流图的机制

张量：TensorFlow中的基本数据对象

节点：提供图当中执行的操作

2.2 图与TensorBoard

学习目标：

说明图的基本使用

应用tf.Graph创建图，tf.get_default_graph获取默认图

知道开启TensorBoard过程

知道图当中op的名字以及命名空间

2.2.1 什么是图结构

图包含了一组tf.Operation代表的计算单元对象和tf.Tensor代表的计算单元之间流动的数据

2.2.2 图相关操作

1 默认图

通常tensorflow会默认帮我们创建一张图

查看默认图的两种方法：

通过调用**tf.get_default_graph()**访问，要将操作添加到默认图形中，直接创建OP即可

op、sess都含有graph属性，默认都在一张图中

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def graph_demo():

"""

图的演示

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2)

b_t = tf.constant(3)

c_t = a_t + b_t

print("c_t：", c_t)

# 查看默认图

# 方法1：调用方法

default_g = tf.get_default_graph()

print("default_g:", default_g)

# 方法2：查看属性

print("a_t的图属性：", a_t.graph)

print("c_t的图属性：", c_t.graph)

# 开启会话

with tf.Session() as sess:

c_t_value = sess.run(c_t)

print("c_t_value:", c_t_value)

print("sess的图属性：", sess.graph)

return None

if __name__ == "__main__":

graph_demo()

c_t： Tensor("add:0", shape=(), dtype=int32)

default_g: <tensorflow.python.framework.ops.Graph object at 0x000002A49DEA72B0>

a_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x000002A49DEA72B0>

c_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x000002A49DEA72B0>

c_t_value: 5

sess的图属性： <tensorflow.python.framework.ops.Graph object at 0x000002A49DEA72B0>

2 创建图

可以通过**tf.Graph()**自定义创建图

如果要在这张图中创建OP，典型用法是使用**tf.Graph.as_default()**上下文管理器

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def graph_demo():

"""

图的演示

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2)

b_t = tf.constant(3)

c_t = a_t + b_t

print("c_t：", c_t)

# 查看默认图

# 方法1：调用方法

default_g = tf.get_default_graph()

print("default_g:", default_g)

# 方法2：查看属性

print("a_t的图属性：", a_t.graph)

print("c_t的图属性：", c_t.graph)

# 开启会话

with tf.Session() as sess:

c_t_value = sess.run(c_t)

print("c_t_value:", c_t_value)

print("sess的图属性：", sess.graph)

print("--------------------------------")

# 自定义图

new_g = tf.Graph()

# 在自己的图中定义数据和操作

with new_g.as_default():

a_new = tf.constant(20)

b_new = tf.constant(30)

c_new = a_new + b_new

print("c_new:", c_new)

print("a_new的图属性：", a_new.graph)

print("c_new的图属性：", c_new.graph)

# 开启new_g的会话

with tf.Session(graph=new_g) as new_sess:

# 试图运行自定义图中的数据，操作

c_new_value = new_sess.run(c_new)

print("c_new_value:", c_new_value)

print("new_sess的图属性：", new_sess.graph)

return None

if __name__ == "__main__":

graph_demo()

c_t： Tensor("add:0", shape=(), dtype=int32)

default_g: <tensorflow.python.framework.ops.Graph object at 0x00000152C1C87400>

a_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152C1C87400>

c_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152C1C87400>

c_t_value: 5

sess的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152C1C87400>

--------------------------------

c_new: Tensor("add:0", shape=(), dtype=int32)

a_new的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152E6FFD9B0>

c_new的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152E6FFD9B0>

c_new_value: 50

new_sess的图属性： <tensorflow.python.framework.ops.Graph object at 0x00000152E6FFD9B0>

2.2.3 TensorBoard可视化学习

tensorflow可用于训练大规模深度神经网络所需的计算，使用该工具设计的计算往往复杂而深奥。为了更方便tensorflow程序的理解、调试与优化，tensorflow提供了TensorBoard可视化工具

实现程序可视化过程：

1 数据序列化-events文件

TensorBoard通过读取TensorFlow的事件文件来运行，需要将数据生成一个序列化的Summary protobuf对象

tf.summary.FileWriter(path, graph=sess.graph)

2 启动TensorBoard

tensorboard --logdir=path

例：

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def graph_demo():

"""

图的演示

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2)

b_t = tf.constant(3)

c_t = a_t + b_t

print("c_t：", c_t)

# 查看默认图

# 方法1：调用方法

default_g = tf.get_default_graph()

print("default_g:", default_g)

# 方法2：查看属性

print("a_t的图属性：", a_t.graph)

print("c_t的图属性：", c_t.graph)

# 开启会话

with tf.Session() as sess:

c_t_value = sess.run(c_t)

print("c_t_value:", c_t_value)

print("sess的图属性：", sess.graph)

# 1）将图写入本地生成events文件

tf.summary.FileWriter("summary", graph=sess.graph) # tmp文件夹下

print("--------------------------------")

# 自定义图

new_g = tf.Graph()

# 在自己的图中定义数据和操作

with new_g.as_default():

a_new = tf.constant(20)

b_new = tf.constant(30)

c_new = a_new + b_new

print("c_new:", c_new)

print("a_new的图属性：", a_new.graph)

print("c_new的图属性：", c_new.graph)

# 开启new_g的会话

with tf.Session(graph=new_g) as new_sess:

# 试图运行自定义图中的数据，操作

c_new_value = new_sess.run(c_new)

print("c_new_value:", c_new_value)

print("new_sess的图属性：", new_sess.graph)

return None

if __name__ == "__main__":

graph_demo()

之后，在终端输入：

得到链接，点击网址链接

成功！

2.2.4 OP

即操作对象

1 常见OP

那些是OP

操作函数操作对象

tf.constant(Tensor对象) 输入Tensor对象-Const输出 Tensor对象

tf.add(Tensor对象1，Tensor对象2) 输入(Tensor对象1，Tensor对象2) ，add对象，输出 Tensor对象3

一个图一个命名空间，互不干扰影响

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def graph_demo():

"""

图的演示

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2, name="a_t")

b_t = tf.constant(3, name="b_t")

c_t = tf.add(a_t, b_t, name="c_t")

print("c_t：", c_t)

# 查看默认图

# 方法1：调用方法

default_g = tf.get_default_graph()

print("default_g:", default_g)

# 方法2：查看属性

print("a_t的图属性：", a_t.graph)

print("c_t的图属性：", c_t.graph)

# 开启会话

with tf.Session() as sess:

c_t_value = sess.run(c_t)

print("c_t_value:", c_t_value)

print("sess的图属性：", sess.graph)

# 1）将图写入本地生成events文件

tf.summary.FileWriter("logs", graph=sess.graph)

print("--------------------------------")

# 自定义图

new_g = tf.Graph()

# 在自己的图中定义数据和操作

with new_g.as_default():

a_new = tf.constant(20, name="a_new")

b_new = tf.constant(30, name="b_new")

c_new = tf.add(a_new, b_new, name="c_new")

print("c_new:", c_new)

print("a_new的图属性：", a_new.graph)

print("c_new的图属性：", c_new.graph)

tf.summary.FileWriter("log2", graph=sess.graph)

# 开启new_g的会话

with tf.Session(graph=new_g) as new_sess:

# 试图运行自定义图中的数据，操作

c_new_value = new_sess.run(c_new)

print("c_new_value:", c_new_value)

print("new_sess的图属性：", new_sess.graph)

return None

if __name__ == "__main__":

graph_demo()

2.3 会话

学习目标：

应用sess.rn或者eval运行图程序并获取张量值

应用feed_dict机制实现运行时填充数据

应用placeholder实现创建占位符

2.3.1 会话创建

tf.Session：用于完整的程序当中

tf.InteractiveSession：用于交互式上下文中的TensorFlow，例如shell

上下文管理器：

with tf.Session() as sess:

sess.run(sth)

target：如果将此参数留空（默认设置），会话将仅使用本地计算机中的设备。可以指定grpc://网址，以便指定TensorFlow服务器的地址，这使得会话可以访问该服务器控制的计算机上的所有设备

graph：默认情况下，新的tf.Session将绑定到当前的默认图

config：此参数允许您指定一个tf.ConfigProto以便控制会话的行为。例如，ConfigProto协议用于打印设备使用信息

# 运行会话并打印设备信息

sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))

2 会话的run()

通过使用sess.run(0)来运行operation

run(fetches, feed_dict=None, options=None, run_metadata=None)

fetches：单一的operation，或者列表、元组（其他不属于tensorflow的类型不行）

feed_dict：参数运行调用者覆盖图中张量的值，运行时赋值，与tf.placeholder搭配使用，则会检查值的形式是否与占位符兼容

# 创建图

a = tf.constant(5.0)

b = tf.constant(6.0)

c = a + b

# 创建会话

sess = tf.Session()

# 计算C的值

print(sess.run(c))

print(c.eval(session=sess))

3 feed操作

placeholder提供占位符，run时候通过feed_dict指定参数

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def session_demo():

"""

会话的演示：打印设备信息

:return:

"""

# tensorflow实现加法运算

a_t = tf.constant(2, name="a_t")

b_t = tf.constant(3, name="b_t")

c_t = tf.add(a_t, b_t, name="c_t")

print("a_t", a_t)

print("b_t", b_t)

print("c_t：", c_t)

print("------------------------------")

# 定义占位符

a_ph = tf.placeholder(tf.float32)

b_ph = tf.placeholder(tf.float32)

c_ph = tf.add(a_ph, b_ph)

print("a_ph:", a_ph)

print("b_ph:", b_ph)

print("c_ph:", c_ph)

print("------------------------------")

# 查看默认图

# 方法1：调用方法

default_g = tf.get_default_graph()

print("default_g:", default_g)

# 方法2：查看属性

print("a_t的图属性：", a_t.graph)

print("c_t的图属性：", c_t.graph)

print("-------------------------------")

# 开启会话

with tf.Session(config=tf.ConfigProto(allow_soft_placement=True,

log_device_placement=True)) as sess:

# 运行placeholder

c_ph_value = sess.run(c_ph, feed_dict={a_ph:3.9, b_ph:4.8})

print('c_ph_value', c_ph_value)

print("------------------------------")

abc = sess.run([a_t, b_t, c_t]) # 传入列表，返回列表

print("abc:", abc)

print("c_t_value；", c_t.eval())

print("sess的图属性：", sess.graph)

#tf.summary.FileWriter("logs", graph=sess.graph) # 1）将图写入本地生成events文件

if __name__ == "__main__":

session_demo()

a_t Tensor("a_t:0", shape=(), dtype=int32)

b_t Tensor("b_t:0", shape=(), dtype=int32)

c_t： Tensor("c_t:0", shape=(), dtype=int32)

------------------------------

a_ph: Tensor("Placeholder:0", dtype=float32)

b_ph: Tensor("Placeholder_1:0", dtype=float32)

c_ph: Tensor("Add:0", dtype=float32)

------------------------------

default_g: <tensorflow.python.framework.ops.Graph object at 0x000001618EF65748>

a_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x000001618EF65748>

c_t的图属性： <tensorflow.python.framework.ops.Graph object at 0x000001618EF65748>

-------------------------------

Device mapping: no known devices.

Add: (Add): /job:localhost/replica:0/task:0/device:CPU:0

c_t: (Add): /job:localhost/replica:0/task:0/device:CPU:0

Placeholder_1: (Placeholder): /job:localhost/replica:0/task:0/device:CPU:0

Placeholder: (Placeholder): /job:localhost/replica:0/task:0/device:CPU:0

b_t: (Const): /job:localhost/replica:0/task:0/device:CPU:0

a_t: (Const): /job:localhost/replica:0/task:0/device:CPU:0

c_ph_value 8.700001

------------------------------

abc: [2, 3, 5]

c_t_value； 5

sess的图属性： <tensorflow.python.framework.ops.Graph object at 0x000001618EF65748>

2.4 张量

学习目标：

知道常见的TensorFlow创建张量

知道常见的张量数学运算操作

说明numpy的数组与张量相同性

说明张量的两种形状改变特点

应用set_shape和tf.reshape山西爱你张量形状的修改

应用tf.matmul实现张量的矩阵运算修改

应用tf.cast实现张量的类型

2.4.1 张量（Tensor）

TensorFlow的张量就是一个N维数组，类型为tf.Tensor。

张量：在计算机当中如何存储？N维数组

标量：一个数字----0阶张量

向量：一维数组-----1阶张量

矩阵：二维数组------2阶张量

type：数据类型

shape：形状（阶）

1 张量的类型

2 张量的阶

未指定类型时，默认类型：

整型：tf.int32

浮点型：tf.float32

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def tensor_demo():

"""

张量的演示

:return:

"""

tensor1 = tf.constant(4.0)

tensor2 = tf.constant([1,2,3,4]) # 未指定类型，默认类型

linear_squares = tf.constant([[4],[9],[16],[25]],dtype=tf.int32)

print("tensor1:", tensor1)

print("tensor2:", tensor2)

print("linear_square:", linear_squares)

return None

if __name__ == "__main__":

tensor_demo()

tensor1: Tensor("Const:0", shape=(), dtype=float32)

tensor2: Tensor("Const_1:0", shape=(4,), dtype=int32)

linear_square: Tensor("Const_2:0", shape=(4, 1), dtype=int32)

2.4.2 创建张量的指令

固定值张量

1 创建多个0

tf.zeros(shape, dtype=tf.float32, name=None)

2 创建多个1

tf.ones(shape, dtype=tf.float32, name=None)

3 创建常数张量

tf.constant(value, dtype=tf.float32, name='Const')

用.eval可以查看值

2.4.3 张量的变换

1 类型改变

tf.string_to_number(string_tensor, out_type=None, name=None)

tf.to_double(x, name=‘ToDouble’)

tf.to_float(x, name=‘ToFloat’)

tf.to_bfloat16(x, name=“ToBFloat16”)

tf.to_int32(x, name=‘Tolnt32’)

tf.to_int64(x, name=‘Tolnt64’)

tf.cast(x, dtype, name=None)，通用类型转换

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def tensor_demo():

"""

张量的演示

:return:

"""

tensor1 = tf.constant(4.0)

tensor2 = tf.constant([1,2,3,4]) # 未指定类型，默认类型

linear_squares = tf.constant([[4],[9],[16],[25]],dtype=tf.int32)

print("tensor1:", tensor1)

print("tensor2:", tensor2)

print("linear_square:", linear_squares)

print("----------------")

# 张量类型的修改：不会改变原始的Tensor

l_cast = tf.cast(linear_squares, dtype=tf.float32)

print("linear_square_after:", linear_squares)

print('l_cast:', l_cast)

return None

if __name__ == "__main__":

tensor_demo()

tensor1: Tensor("Const:0", shape=(), dtype=float32)

tensor2: Tensor("Const_1:0", shape=(4,), dtype=int32)

linear_square: Tensor("Const_2:0", shape=(4, 1), dtype=int32)

----------------

linear_square_after: Tensor("Const_2:0", shape=(4, 1), dtype=int32)

l_cast: Tensor("Cast:0", shape=(4, 1), dtype=float32)

2 形状改变

tensorflow的张量具有两种形状变换，动态形状和静态形状

tf.reshape：改变动态形状

tf.set_shape：改变静态形状

静态形状：初始创建张量时的形状

动态形状：

什么情况下可以改变静态形状：只有在形状还没有完全固定下来的情况下；转换形状的时候，只能一维到一维，二维到二维，而不能跨维度改变形状

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def tensor_demo():

"""

张量的演示

:return:

"""

tensor1 = tf.constant(4.0)

tensor2 = tf.constant([1,2,3,4]) # 未指定类型，默认类型

linear_squares = tf.constant([[4],[9],[16],[25]],dtype=tf.int32)

print("tensor1:", tensor1)

print("tensor2:", tensor2)

print("linear_square:", linear_squares)

print("----------------")

# 张量类型的修改：不会改变原始的Tensor

l_cast = tf.cast(linear_squares, dtype=tf.float32)

print("linear_square_after:", linear_squares)

print('l_cast:', l_cast)

print('------------------')

# 更新、改变静态形状

# 定义占位符

a_p = tf.placeholder(dtype=tf.float32, shape=[None, None]) # 形状没有完全固定下来的静态形状

b_p = tf.placeholder(dtype=tf.float32, shape=[None, 10])

c_p = tf.placeholder(dtype=tf.float32, shape=[3, 2])

print("a_p:", a_p)

print("b_p:", b_p)

print("c_p:", c_p)

print("-----------------------")

# 更新形状未确定的部分

a_p.set_shape([2,3])

b_p.set_shape([2,10])

print("a_p:", a_p)

print("b_p:", b_p)

print('-------------')

# 动态形状修改

a_p_reshape = tf.reshape(a_p, shape=[2, 3, 1])

print("a_p:", a_p)

print("a_p_reshape:", a_p_reshape)

c_p_reshape = tf.reshape(c_p, shape=[2, 3, 1]) # 必须保持改变前后元素的数量一致

print("c_p:", c_p)

print("c_p_reshape:", c_p_reshape)

return None

if __name__ == "__main__":

tensor_demo()

tensor1: Tensor("Const:0", shape=(), dtype=float32)

tensor2: Tensor("Const_1:0", shape=(4,), dtype=int32)

linear_square: Tensor("Const_2:0", shape=(4, 1), dtype=int32)

----------------

linear_square_after: Tensor("Const_2:0", shape=(4, 1), dtype=int32)

l_cast: Tensor("Cast:0", shape=(4, 1), dtype=float32)

------------------

a_p: Tensor("Placeholder:0", shape=(?, ?), dtype=float32)

b_p: Tensor("Placeholder_1:0", shape=(?, 10), dtype=float32)

c_p: Tensor("Placeholder_2:0", shape=(3, 2), dtype=float32)

-----------------------

a_p: Tensor("Placeholder:0", shape=(2, 3), dtype=float32)

b_p: Tensor("Placeholder_1:0", shape=(2, 10), dtype=float32)

-------------

a_p: Tensor("Placeholder:0", shape=(2, 3), dtype=float32)

a_p_reshape: Tensor("Reshape:0", shape=(2, 3, 1), dtype=float32)

c_p: Tensor("Placeholder_2:0", shape=(3, 2), dtype=float32)

c_p_reshape: Tensor("Reshape_1:0", shape=(2, 3, 1), dtype=float32)

2.4.4 张量的数学运算

算术运算符

基本数学函数

矩阵运算

reduce操作

序列索引操作

2.5 变量OP

学习目标：

说明变量op的特殊作用

说明变量op的trainable参数的作用

应用global_variables_initializer实现变量op的初始化

变量的特点：

存储持久化

可修改值

可指定被训练

2.5.1 创建变量

tf.Variable(initia_value=None, trainable=True, collections=None, name=None)

initial_value：初始化的值

trainable：是否被训练

collections：新变量将添加到列出的图的集合中collections，默认为[GraphKeys.GLOBAL_VARIABLES]，如果trainable是True变量也被添加到图形集合GraphKeys.TRAINABLE_VARIABLES

变量需要显示初始化，才能运行值

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def variable_demo():

"""

变量的演示

:return:

"""

# 创建变量

a = tf.Variable(initial_value=50)

b = tf.Variable(initial_value=40)

c = tf.add(a, b)

print("a:", a)

print("b", b)

print("c", c)

print('----------------------')

# 初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 运行初始化

sess.run(init)

a_value, b_value, c_value = sess.run([a,b,c])

print("a_value:", a_value)

print("b_value", b_value)

print("c_value", c_value)

return None

if __name__ == "__main__":

variable_demo()

a: <tf.Variable 'Variable:0' shape=() dtype=int32_ref>

b <tf.Variable 'Variable_1:0' shape=() dtype=int32_ref>

c Tensor("Add:0", shape=(), dtype=int32)

----------------------

a_value: 50

b_value 40

c_value 90

2.5.2 使用tf.variable_scope()修改变量的命名空间

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def variable_demo():

"""

变量的演示

:return:

"""

# 创建变量

with tf.variable_scope("my_scope"):

a = tf.Variable(initial_value=50)

b = tf.Variable(initial_value=40)

with tf.variable_scope("your_scope"):

c = tf.add(a, b)

print("a:", a)

print("b", b)

print("c", c)

print('----------------------')

# 初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 运行初始化

sess.run(init)

a_value, b_value, c_value = sess.run([a,b,c])

print("a_value:", a_value)

print("b_value", b_value)

print("c_value", c_value)

return None

if __name__ == "__main__":

variable_demo()

a: <tf.Variable 'my_scope/Variable:0' shape=() dtype=int32_ref>

b <tf.Variable 'my_scope/Variable_1:0' shape=() dtype=int32_ref>

c Tensor("your_scope/Add:0", shape=(), dtype=int32)

----------------------

a_value: 50

b_value 40

c_value 90

2.6 高级API

2.6.1 其他基础API

1 tf.app

这个模块相当于为TensorFlow进行的脚本提供一个main函数入口，可以定义脚本运行的flags

2 tf.image

TensorFlow的图像处理操作。主要是一些颜色变换、变形和图像的编码和解码

3 tf.gfile

这个模块提供了一组文件操作函数

4 tf.summary

用来生成TensorBoard可用的统计日志，目前Summary主要提供了4种类型：

audio、image、histogram、scalar

5 tf.python_io

用来读写TFRecords文件

6 tf.train

这个模块提供了一些训练器，与tf.nn结合起来，实现一些网络的优化计算

7 tf.nn

这个模块提供了一些构建神经网络的底层函数。TensorFlow构建网络的核心模块，其中包含了添加各种层的函数，比如添加卷积层、池化层等。

2.6.2 高级API

1 tf.keras

Kears本来是一个独立的深度学习库，tensorflow将其学习过来，增加这部分模块在于快速构建模型

2 tf.layers

高级API，以便高级的概念层来定义一个模型。类似tf.kears

3 tf.contrib

tf.contrib.layers提供够将计算图中的网络层、正则化、摘要操作，是构建计算图的高级操作，但是tf.contrib包含不稳定和实验代码，有可能以后API会改变

4 tf.estimator

一个estimator相当于model + training + evaluate 的合体。在模块中，已经实现了几种简单的分类器和回归其，包括：Baseline，learning 和 DNN。这里的DNN的网络，只是全连接网络，没有提供卷积之类的

2.7 案例：实现线性回归

学习目标：

应用op的name参数实现op的名字修改

应用variable_scope实现图程序作用域的添加

应用scalar或histogram实现张良志的跟踪显示

应用merge_all实现张量值的合并

应用add_summary实现张量值的写入文件

应用tf.train.saver实现TensorFlow的模型保存以及加载

应用tf.app.flags实现命令行参数添加和使用

应用reduce_mean、square实现均方误差计算

应用tf.train.GradientDescentOptimizer实现有梯度下降优化器创建

应用minimize函数优化损失

知道梯度爆炸以及常见解决技巧

2.7.2 案例：实现线性回归的训练

1）构建模型

2）构建损失函数：均方误差

3）优化损失：梯度下降

准备真实数据：

x：特征值，形状：（100,1）

y_true：目标值（100,1）

y_true = 0.8x + 0.7 ，100个样本

假设满足： y =kx + b

流程分析：

（100，1） * （1，1） = （100，1）

y_predict = x * weight(1,1) + bias(1,1)

1）构建模型

y_predict = tf.matmul(x, weights) + bias

2）构造损失函数

error = tf.reduce_mean(tf.square(y_predict - y_true))

3）优化损失：梯度下降优化器

optimizer = tf.train.GrandientDescentOptimizer(learning_rate=0.01).minimize(error)

运算：

矩阵运算：tf.matmu(x,w)

平方：tf.square(error)

均方：tf.reduce_mean(error)

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def linear_regression():

"""

实现线性回归

:return:

"""

# 1）准备数据

X = tf.random_normal(shape=[100, 1]) # 形状：100行1列

y_true = tf.matmul(X, [[0.8]]) + 0.7 # y_true = 0.8x + 0.7

# 2）构造模型

# 定义模型参数，用变量

weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))

bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))

y_predict = tf.matmul(X, weights) + bias

# 3）构造损失函数

error = tf.reduce_mean(tf.square(y_predict - y_true))

# 4）优化损失

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)

# 显式地初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 初始化变量

sess.run(init)

# 查看初始化模型参数之后的值

print("训练前模型参数为：权重%f，偏置%f，损失为%f" %

(weights.eval(), bias.eval(), error.eval()))

# 开始训练

for i in range(200):

sess.run(optimizer)

print("第%d训练后模型参数为：权重%f，偏置%f，损失为%f" %

(i+1, weights.eval(), bias.eval(), error.eval()))

return None

if __name__ == "__main__":

linear_regression()

...

第195训练后模型参数为：权重0.784588，偏置0.704202，损失为0.000298

第196训练后模型参数为：权重0.784881，偏置0.704130，损失为0.000259

第197训练后模型参数为：权重0.785245，偏置0.704024，损失为0.000256

第198训练后模型参数为：权重0.785542，偏置0.703911，损失为0.000219

第199训练后模型参数为：权重0.785778，偏置0.703855，损失为0.000218

第200训练后模型参数为：权重0.786084，偏置0.703762，损失为0.000211

5 学习率的设置、步数的设置与梯度爆炸

学习率越大，训练

2.7.3 增加其他功能

变量TensorBoard显示

增加命名空间

模型保存于加载

命令行参数设置

1 增加变量显示

目的：在TensorBoard当中观察模型的参数、损失值等变量值的变化

1）创建事件文件

2）收集变量

3）合并变量

4）每次迭代运行合并变量

5）每次迭代将summary事件写入事件文件

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def linear_regression():

"""

实现线性回归

:return:

"""

# 1）准备数据

X = tf.random_normal(shape=[100, 1]) # 形状：100行1列

y_true = tf.matmul(X, [[0.8]]) + 0.7 # y_true = 0.8x + 0.7

# 2）构造模型

# 定义模型参数，用变量

weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))

bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))

y_predict = tf.matmul(X, weights) + bias

# 3）构造损失函数

error = tf.reduce_mean(tf.square(y_predict - y_true))

# 4）优化损失

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)

# 2）收集变量

tf.summary.scalar("error", error)

tf.summary.histogram("weights", weights)

tf.summary.histogram("bias", bias)

# 3)合并变量

merged = tf.summary.merge_all()

# 显式地初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 初始化变量

sess.run(init)

# 1）创建事件文件

file_writer = tf.summary.FileWriter('logs', graph=sess.graph)

# 查看初始化模型参数之后的值

print("训练前模型参数为：权重%f，偏置%f，损失为%f" %

(weights.eval(), bias.eval(), error.eval()))

# 开始训练

for i in range(100):

sess.run(optimizer)

print("第%d训练后模型参数为：权重%f，偏置%f，损失为%f" %

(i+1, weights.eval(), bias.eval(), error.eval()))

# 运行合并变量操作

summary = sess.run(merged)

# 每次迭代后的变量写入事件

file_writer.add_summary(summary, i)

return None

if __name__ == "__main__":

linear_regression()

2 增加命名空间

使得代码结构更加信息，TensorBoard图结构更加清楚

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def linear_regression():

"""

实现线性回归

:return:

"""

with tf.variable_scope("prepare_data"):

# 1）准备数据

X = tf.random_normal(shape=[100, 1], name='feature') # 形状：100行1列

y_true = tf.matmul(X, [[0.8]]) + 0.7 # y_true = 0.8x + 0.7

with tf.variable_scope("create_model"):

# 2）构造模型

# 定义模型参数，用变量

weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Weights")

bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Bias")

y_predict = tf.matmul(X, weights) + bias

with tf.variable_scope("loss_function"):

# 3）构造损失函数

error = tf.reduce_mean(tf.square(y_predict - y_true))

with tf.variable_scope("optimizer"):

# 4）优化损失

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)

# 2）收集变量

tf.summary.scalar("error", error)

tf.summary.histogram("weights", weights)

tf.summary.histogram("bias", bias)

# 3)合并变量

merged = tf.summary.merge_all()

# 显式地初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 初始化变量

sess.run(init)

# 1）创建事件文件

file_writer = tf.summary.FileWriter('logs', graph=sess.graph)

# 查看初始化模型参数之后的值

print("训练前模型参数为：权重%f，偏置%f，损失为%f" %

(weights.eval(), bias.eval(), error.eval()))

# 开始训练

for i in range(100):

sess.run(optimizer)

print("第%d训练后模型参数为：权重%f，偏置%f，损失为%f" %

(i+1, weights.eval(), bias.eval(), error.eval()))

# 运行合并变量操作

summary = sess.run(merged)

# 每次迭代后的变量写入事件

file_writer.add_summary(summary, i)

return None

if __name__ == "__main__":

linear_regression()

3 模型的保存与加载

步骤：

1）实例化Saver

2）保存：saver.save(sess, path)

3）加载：saver.restore(sess, path)

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def linear_regression():

"""

实现线性回归

:return:

"""

with tf.variable_scope("prepare_data"):

# 1）准备数据

X = tf.random_normal(shape=[100, 1], name='feature') # 形状：100行1列

y_true = tf.matmul(X, [[0.8]]) + 0.7 # y_true = 0.8x + 0.7

with tf.variable_scope("create_model"):

# 2）构造模型

# 定义模型参数，用变量

weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Weights")

bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Bias")

y_predict = tf.matmul(X, weights) + bias

with tf.variable_scope("loss_function"):

# 3）构造损失函数

error = tf.reduce_mean(tf.square(y_predict - y_true))

with tf.variable_scope("optimizer"):

# 4）优化损失

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(error)

# 2）收集变量

tf.summary.scalar("error", error)

tf.summary.histogram("weights", weights)

tf.summary.histogram("bias", bias)

# 3)合并变量

merged = tf.summary.merge_all()

# 创建Saver对象

saver = tf.train.Saver()

# 显式地初始化变量

init = tf.global_variables_initializer()

# 开启会话

with tf.Session() as sess:

# 初始化变量

sess.run(init)

# 1）创建事件文件

file_writer = tf.summary.FileWriter('logs', graph=sess.graph)

# 查看初始化模型参数之后的值

print("训练前模型参数为：权重%f，偏置%f，损失为%f" %

(weights.eval(), bias.eval(), error.eval()))

# # 开始训练

# for i in range(100):

# sess.run(optimizer)

# print("第%d训练后模型参数为：权重%f，偏置%f，损失为%f" %

# (i+1, weights.eval(), bias.eval(), error.eval()))

# # 运行合并变量操作

# summary = sess.run(merged)

# # 每次迭代后的变量写入事件

# file_writer.add_summary(summary, i)

# # 保存模型

# if i % 10 == 0:

# saver.save(sess, "model/my_Linear.ckpt")

# 加载模型

if os.path.exists("model/checkpoint"):

saver.restore(sess, "model/my_Linear.ckpt")

print("训练后模型参数为：权重%f，偏置%f，损失为%f" %

(weights.eval(), bias.eval(), error.eval()))

return None

if __name__ == "__main__":

linear_regression()

训练前模型参数为：权重-0.726173，偏置-1.391275，损失为6.139051

训练后模型参数为：权重0.800000，偏置0.700000，损失为0.000000

4 命令行参数设置

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

# 1）定义命令行参数

tf.app.flags.DEFINE_integer("max_step", 100, "训练模型的步数")

tf.app.flags.DEFINE_string("model_dir", "Unknown", "模型保存的路径+模型的名字")

# 2）简化变量名

FLAGS = tf.app.flags.FLAGS

def command_demo():

"""

命令行参数演示

:return:

"""

print("max_step:", FLAGS.max_step)

print("model_dir:", FLAGS.model_dir)

return None

if __name__ == "__main__":

command_demo()

import tensorflow as tf

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 去警告

def main(argv):

print(argv)

print("code start")

return None

if __name__ == "__main__":

tf.app.run() # 自动运行main函数

#command_demo()

['D:/programming_software/pycharm/PycharmProjects/deep_learning/day01_deeplearning.py']

code start

总结

————————————————

原文链接：https://blog.csdn.net/qq_39236499/article/details/116020801