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

学习目标：

• 第一天：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

总结