TensorFlow基础操作+手写回归+模型的保存于加载

深度学习介绍

什么是深度学习？

• 先把这四个字拆解成两个词，“深度”和“学习”，然后在逐一说明。

• 学习
  • “学习”是我们从小就接触的词，每天听着好好学习，天天向上的教诲。小时候的学习就是上课，做题，最终通过考试验证了学习的效果。抽象的说，学习就是认知的过程，从未知到已知的探索和思考。比如从最早的学习，1+1=2，想想我们是怎么学习的?伸出一只手指，再伸出一只手指，数一数，两只手指那就是2。
  • 学习就是从未知到已知的探索和思考。这里提前再定义一个概念，输入和输出，输入就是已知的信息，输出就是最终获得的认知的结果。这里的1和加号+，就是输入，而得到的计算结果2就是输出。所以，任何的从已经有的信息，无论是通过计算，判断，推理而后得到一个认知的过程都可以称为“学习”。
  • 那么为什么有的人学习能力好，成绩高，但有的人成绩就没那么好呢。这经常的被解释为学习方法，思考过程，经验不同而导致的差异，可以统一归为“学习策略”，好的学习策略会更快更准确的得到认知的结果，而不好的学习策略可能会花费更多的时间或者获得错误的结论。那么在计算机的学习中，有没有一个比较好的学习策略呢？
  • 神经网络：
    • 现实世界中很多的问题都可以归为分类或者回归的问题。而研究此类问题，学术界研究出来一种叫做“神经网络”的学习策略。
    • 这个词听起来，就知道和人脑有着一些关系。在人脑中负责活动的基本单元是“神经元”，它以细胞体为主体，由许多向周围延伸的不规则树枝状纤维构成的神经细胞，我们把神经元的结构想象成一棵枯树的枝干就可以了。人脑中含有上百亿个神经元，而这些神经元互相连接成一个更庞大的结构，就称为“神经网络”。学术界试图模仿人脑的“神经网络“建立一个类似的学习策略，也取名为”神经网络“。下图就是一个神经网络的大致结构

　　　　　　　　

• • • 从x1,x2,x3输入到输出的过程，这里又定义了一个层次的概念，譬如上图就包括四层，包含最左边的输入层，和最右边的输出层，如果这是一道选择题的话，那么题目就是输入层，而ABCD的选择结果就是输出层，如上图的L1和L4分别是输入层和输出层。而选择题解题的过程是不写出来的，这个解题过程我们叫做”隐藏层“，这里L2和L3就是隐藏层，题目越难，给出的解题条件的信息可能是越多的，而解题所需要的过程就越复杂的，也就可能需要更多的”隐藏层“来计算最终的结果。

• 深度
  • 最终要来解释什么是深度学习的”深度“了，就是从”输入层“到”输出层“所经历层次的数目，即”隐藏层“的层数，层数越多，网络的深度也越深。所以越是复杂的选择问题，越需要深度和层次越多。当然，除了层数多外，每层”神经元“，也就是如上图，橙色小圆圈的数目也要多。例如，AlphaGo的策略网络是13层。每一层的神经元数量为192个。

总结一句话，深度学习就是用多层次的分析和计算手段，得到结果的一种方法

深度学习代表性的应用

• 图像识别（图像理解）
  • 给机器一张图片让机器可以理解图片的内容
    • 人脸识别
    • 验证码识别
• 语音识别
• 自然语言处理NLP
  • 理解人类的语言
    • 情感分析
    • 智能对话
    • 图像识别和NLP的结合：

　　　　　　　　

• 机器自主（无人驾驶）

机器学习和深度学习的区别

• 算法方面：
  • 机器学习的算法主要是处理回归和分类的相关问题
  • 深度学习算法主要是处理较为复杂的相关事物的处理，比如NLP，图像识别，语音识别等等
• 应用领域方面：
  • 在NLP，图像识别，语音识别等领域中使用机器学习处理效果不好，甚至有时候还不如人工的识别，但是深度学习可以达到很好的效果。且深度学习已经被应用到了计算机的视觉、语音识别、NLP、音频识别于生物信息学等领域并获取了极好的结果。
• 总结：机器学习和深度学习主要的区别就是算法和效率的不同。
• 深度学习框架：
  • TensorFlow
  • Caffe
  • Torch
  • ...
  • TensorFlow在众多框架中的受关注度和使用人数是最多的一个框架，因此我们主要对其进行学习！

TensorFlow

• 认识TensorFlow(中文社区：http://www.tensorfly.cn/)
  • 谷歌大脑的产物，谷歌大脑最初是由吴恩达带领的。
  • 在谷歌内部很多产品中都应用了TensorFlow，比如AlphaGo，Gmail，谷歌地图等等。
  • 于2015年11月开源问世，17年2月发布了1.0版本
  • 最新版本2.0，但是建议使用1.0版本，较为稳定
• TensorFlow的特点：
  • 真正的可移植性
    • 引入各种计算设备的支持，包括CPU，GPU，以及能够很好的运行在各种系统的移动端
  • 多语言支持
    • 支持C++，python，R语言等
  • 高度的灵活性和效率
    • 边学习边体验
  • 支持
    • 由谷歌提供支持，谷歌希望其可以成为机器学习研究和开发人员通用的语言。

环境安装

• cpu和gpu的区别
  • CPU，在电脑中起着控制计算机运行的作用，是电脑的中央处理器。
  • GPU是一个附属型的处理器，主要处理计算机中与图形计算有关的工作，并将数据更好地呈现在显示器中。
    • 总结：使用GPU的数据处理要比CUP效率更快
  • TensorFlow可以选择性的安装基于CPU的和GPU的。目前windows的GPU对TensorFlow的包容性不是特别好，会有效部分的bug，因此课上我们使用cpu版本。
    • 在cpu版本和gpu版本的代码编写几乎一致，如果想把cpu编程gpu需要要添加一行代码即可！

• 安装教程：
  • pip install -U --ignore-installed wrapt enum34 simplejson netaddr
  • pip install --upgrade setuptools
  • pip install tensorflow==1.14.0

Tensorflow进阶

• 使用 TensorFlow, 你必须明白 TensorFlow:

  • 图：TensorFlow 是一个编程系统（一个编程语言），使用图 (graph) 来表示一个计算任务或者计算单元.
    • 计算任务：实现一个加法器，那任意值的加法运算就是一个计算任务
  • 会话Session：图必须要在会话中进行执行
  • tensor（张量：数组，阶：维度）：就是numpy中的nd.array（数组），只不过从新起了一个名字而已！因此tensor一种数据类型。每个 Tensor 是一个类型化的数组. 或者是op的返回值，就是TensorFlow中的数据。tensor也可以被称为张量，那么张量的阶就是数组的维度。
  • 节点op（operation）：图表示TensorFlow的计算任务，而一个计算任务的具体实现操作就是op。一个op需要使用0个或者多个Tensor来执行计算且会产生0个会多个Tensor，简单点来说TensorFlow的API定义的函数都是op。

• 综述：

  • 图描述了tensorflow计算的过程。为了进行计算, 图必须在会话里被启动.会话将图的op分发到诸如 CPU 或 GPU 之类的设备上, 图同时提供执行op的方法. 这些方法执行后, 将产生的 tensor 返回。

• 实现一个加法运算
  • add(a,b)

定义a,b俩个tensor(张量)

import tensorflow as tf

tf.__version__  # '1.14.0'

# 定义a,b俩个tensor(张量)
a = tf.constant(1.0)
b = tf.constant(2.0)
print(a,b)

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

调用add的函数（op）实现两数相加

# 调用add的函数（op）实现两数相加
import tensorflow as tf

a = tf.constant(3)
b = tf.constant(4)

# 定义了一个op
sum = tf.add(a,b)
print(sum)

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

在会话中启动图

# 在会话中启动图
import tensorflow as tf

# 定义a,b两个tensor（张量）
a = tf.constant(3)
b = tf.constant(4)

# 定义了一个op图，图对应一系列操作
sum = tf.add(a,b)

# 开启一个绘画,在绘画中执行图
with tf.Session() as sess:
    print(sess.run(sum))  # 7

获取图

• tf.get_default_graph()
• op,session,tensor的graph属性

# 在会话中启动图
import tensorflow as tf

# 定义a,b两个tensor（张量）
a = tf.constant(3)
b = tf.constant(4)

# 定义了一个op图，图对应一系列操作
sum = tf.add(a,b)

# 开启一个绘画,在绘画中执行图
with tf.Session() as sess:
    print(sess.run(sum))  # 7
    print(tf.get_default_graph()) # 返回当前的图
    print(sum.graph) # 返回当前的图
    print(a.graph) # 返回当前的图
    print(b.graph) # 返回当前的图
    print(sess.graph) # 返回当前的图

7
<tensorflow.python.framework.ops.Graph object at 0xb376c7048>
<tensorflow.python.framework.ops.Graph object at 0xb376c7048>
<tensorflow.python.framework.ops.Graph object at 0xb376c7048>
<tensorflow.python.framework.ops.Graph object at 0xb376c7048>

创建新图（创建一个单独的计算任务单元）

• tf.Graph()：新图对应的操作必须作用在上下文中！
• 上下文写法：with g.as_default()

import tensorflow as tf

g = tf.Graph() # 创建一个新图
with g.as_default():
    d = tf.constant([1,2,3])
    c = tf.constant([4,5,6])
    sum_ = tf.add(c,d)
    print(d.graph)
    
a = tf.constant(3)
b = tf.constant(4)
sum = tf.add(a,b)
with tf.Session() as sess: # 这里如果不采取操作，用的还是默认图
    print(sess.run(sum))
    print(sess.graph)

<tensorflow.python.framework.ops.Graph object at 0x0000021AA4A13B00>
7
<tensorflow.python.framework.ops.Graph object at 0x0000021AA49347F0>

会话Session

• 会话就是运行图的一个资源类，运行的是默认的图，当然也可以单独运行指定的图
• 会话的资源包含如下资源，会话结束后需要关闭对应的资源，因此需要在上下文资源管理器中使用会话
  • tf.Variable
  • tf.QueueBase
  • tf.ReaderBase
• TensorFlow可以分为前端系统和后端系统
  • 前端系统：定义图的结构（定义张量tensor，定义op等）
  • 后端系统：运行图

　　　　　　

• 会话的作用：
  • 运行图的结构
  • 分配计算资源
  • 掌握资源：会话只可以运行其对应图中的资源
    • Session(graph=g)指定图

g = tf.Graph() # 创建一个新图
with g.as_default():
    d = tf.constant([1,2,3])
    c = tf.constant([4,5,6])
    sum_ = tf.add(c,d)
    print(d.graph)
    
a = tf.constant(3)
b = tf.constant(4)
sum = tf.add(a,b)
with tf.Session(graph=g) as sess: # 参数指定新图
    print(sess.run(sum_))
    print(sess.graph)

<tensorflow.python.framework.ops.Graph object at 0x0000021AA4BAA240>
[5 7 9]
<tensorflow.python.framework.ops.Graph object at 0x0000021AA4BAA240>

重载运算符

• session只可以运行op或者tensor，不可以运行其他类型的数据，但是如果一个tensor或者op使用某一个运算符和其他类型数据相加，则返回的为op或者tensor类型

a = tf.constant(3)
b = 4
sum = a + b
print(sum)

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

run方法

• s.run(fetches, feed_dict=None,graph)
  • fetches:就是运行的op和tensor，例如run(sum)也可以run([a,b,sum])
  • feed_dict:程序在执行的时候，不确定输入数据是什么，提前使用placeholder占个位
    • 给session提供实时运行的数据

# 应用场景：训练模型的时候，样本数量不固定，那么如何运行样本数据呢？
import tensorflow as ts
# 创建了一个op，placeholder为占位对象，现在占据了一个n行三列的位置
feature = ts.placeholder(dtype=tf.float32,shape=(None,3))# None为任意行数
with tf.Session() as s:
    print(s.run(feature,feed_dict={feature:[[1,2,3],[4,5,6],[4,5,6]]}))

[[1. 2. 3.]
 [4. 5. 6.]
 [4. 5. 6.]]

张量相关的api

• 自动生成张量：
  • tf.zeros(shape=(3,2))
  • tf.ones()
  • tf.random_normal(shape,mean,stddev)
    • mean:平均值
    • 方差
• 改变类型：
  • tf.cast(x,dtype)

arr = tf.zeros(shape = (4,5))
rand_arr = tf.random_normal(shape=(3,4),mean=2,stddev=2)
print(rand_arr)

Tensor("random_normal_5:0", shape=(3, 4), dtype=float32)

变量

• 概念：变量也是一种op，是一种特殊的张量，能够进行持久化存储（普通张量不行），变量的值为张量。
• API：tf.Variable(initial_value,name,trainable,)
  • initial_value变量接收的值（张量）
  • 在手写线性回归时讲解
• 必须进行变量的显示的初始化，返回一个初始化变量的op:
  • init_op = tf.global_variables_initializer()

import tensorflow as tf

# 变量使用步骤
# 1.实例化变量对象，给它赋一个默认的输入值
# 2.对变量进行显示化的展示
# 3.通过绘画，对显示化的变量进行展示，才能够使用定义好的变量

# 1.实例化变量对象，给它赋一个默认的输入值
a = tf.constant([1,2,3,4,5])
var = tf.Variable(initial_value=a)
# 2.对变量进行显示化的展示
# 显示的初始化
init_op = tf.global_variables_initializer()
with tf.Session() as s:
    # 3.通过绘画，对显示化的变量进行展示，才能够使用定义好的变量
    s.run(init_op)
    print(s.run(var))  
    print(a.eval())  # 相当于s.run(a)

[1 2 3 4 5]
[1 2 3 4 5]

线性回归原理回顾

• 找寻目标值和特征值之间存在的关系，求出w和b即可。
• y = (x1w1 + x2w2...+xn*wn)+b
• 损失函数(均方误差)：表示真实值和预测值之间的误差
• 使用梯度下降将损失函数的误差值最小即可

实现流程

• 准备最简单的特征值和目标值
  • y = 0.8*x+1.5，然后我们需要让手写的线性回归求出w（0.8）和b（1.5）
• 建立模型
  • 随机初始化一个w和b
    • 因为模型一开始也不知道w和b应该是什么，只能随机初始化一个，然后随着梯度下降逐步迭代更新w和b
  • 然后求出预测值：y_pred = wx+b
• 求出损失函数（误差）的结果
  • 均方误差：y是真实值y'是预测值
    • ((y1-y1')^2+(y2-y2')^2+...+(yn-yn')^2)/n
• 使用梯度下降降低损失（梯度下降不需要手动实现，TensorFlow中有对应的API，只需要指定学习率即可）

• TensorFlow运算的API
  • 矩阵运算：tf.matmul(a,b)
  • 平方：tf.square(x)
  • 均值：tf.reduce_mean()

• 梯度下降API
  • 类：tf.train.GradientDescentOptimizer(learning_rate)
    • learning_rate:需要手动指定学习率

注意：

• 线性回归是一个迭代算法，那么意味着在每次梯度下降的过程中y=wx+b中的w和b是在不停的变化的逐步在优化这两个值。因此记住，w和b是需要不断变化的在梯度下降的过程中！
• 结论：
  • 在TensorFlow中随机初始化的w和b只可以用变量定义不可以用张量，因为，变量可以自身变化，而张量不行！
  • 或者说模型的参数只可以用变量定义不可以用张量定义！！！
• tf.Variable(initial_value=None,trainable=True)
  • trainable=True表示的含义就是在训练的过程中变量的值可以跟随训练而实时变化！！！

import tensorflow as tf

# 第一步：准备数据
# tf.random_normal 返回一个指定形状的张量
x = tf.random_normal(shape=(100,1),mean=1.5,stddev=0.75) # 特征数据
y_true = tf.matmul(x,[[0.8]])+1.5 # 标签数据 w=0.8,b=1.5

# 第二步：建立模型，随机初始化一个w和b
weight = tf.Variable(tf.random_normal(shape=(1,1),mean=1.2,stddev=0.5))
b = tf.Variable(2.5)
# 预测结果
y_pred = tf.matmul(x,weight)+b

# 第三步：损失函数就是均方误差
loss = tf.reduce_mean(tf.square(y_true - y_pred))

# 第四步.梯度下降优化损失
train_op = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

# 定义的变量进行显示初始化
init_op = tf.global_variables_initializer()

with tf.Session() as s:
    s.run(init_op) # 先运行变量的初始化操作
    print('随机初始化的w=%f,b=%f'%(weight.eval(),s.run(b)))
    for i in range(1,401):# 固定迭代的次数
        s.run(train_op)
        if i%20 == 0:
            print('第%d次优化后的w=%f,b=%f'%(i,weight.eval(),b.eval()))

随机初始化的w=0.816529,b=2.500000
第20次优化后的w=0.572955,b=1.896295
第40次优化后的w=0.680251,b=1.720152
第60次优化后的w=0.734756,b=1.615458
第80次优化后的w=0.764612,b=1.561906
第100次优化后的w=0.780714,b=1.533197
第120次优化后的w=0.789753,b=1.517574
第140次优化后的w=0.794484,b=1.509686
第160次优化后的w=0.797118,b=1.505182
第180次优化后的w=0.798350,b=1.502849
第200次优化后的w=0.799147,b=1.501556
第220次优化后的w=0.799511,b=1.500829
第240次优化后的w=0.799743,b=1.500452
第260次优化后的w=0.799859,b=1.500251
第280次优化后的w=0.799925,b=1.500136
第300次优化后的w=0.799960,b=1.500069
第320次优化后的w=0.799978,b=1.500037
第340次优化后的w=0.799988,b=1.500021
第360次优化后的w=0.799994,b=1.500011
第380次优化后的w=0.799996,b=1.500006
第400次优化后的w=0.799998,b=1.500003

模型保存与加载

代码报错（NotFindError），问题在于模型加载的路径或者在代码头部加上tf.reset_default_graph()

• 保存的其实就是w和b

• 定义saver的op
  • saver = tf.train.Saver()
• 在会话中运行保存函数：
  • saver.save(session,'path')
    • path：表示保存模型的路径，携带模型的名称（任意名称）
• 在会话运行时加载模型：
  • if os.path.exists('./xxx/checkpoint'):
    • saver.restore(session,'path')

• 模型的加载

import os

tf.reset_default_graph()  # 如果加载保存好的模型时出现notfinderror就加上该行代码

# 第一步：准备数据
x = tf.random_normal(shape=(100,1),mean=1.5,stddev=0.75) # 特征数据
y_true = tf.matmul(x,[[0.8]])+1.5 # 标签数据 w=0.8,b=1.5

# 第二步：建立模型，随机初始化一个w和b
weight = tf.Variable(tf.random_normal(shape=(1,1),mean=1.2,stddev=0.5),name='w')
b = tf.Variable(2.5,name='b')
# 预测结果
y_pred = tf.matmul(x,weight)+b

# 第三步：损失函数就出均方误差
loss = tf.reduce_mean(tf.square(y_true-y_pred))

# 第四步.梯度下降优化损失
train_op = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

# 定义的变量进行初始化
init_op = tf.global_variables_initializer()
# 保存模型的op
saver = tf.train.Saver()
with tf.Session() as s:
    s.run(init_op) # 先运行变量的初始化操作
    if os.path.exists('./imgs/checkpoint'):# 加载模型
        print('模型已经加载读取完毕')
        saver.restore(s,'./imgs/model')
        w = s.run('w:0')
        b = s.run('b:0')
        print(w,b) # 就是从保存好的模型文件中读取出来的两个值
    else: # 保存模型
        print('随机初始化的w=%f,b=%f'%(weight.eval(),s.run(b)))
        for i in range(1,401):# 固定迭代的次数
            s.run(train_op)
            if i%20 == 0:
                print('第%d次优化后的w=%f,b=%f'%(i,weight.eval(),b.eval()))
        saver.save(s,'./imgs/model')