深度学习入门实战（二）-用TensorFlow训练线性回归

时间 2019-11-20

原文原文链接

欢迎你们关注腾讯云技术社区-博客园官方主页，咱们将持续在博客园为你们推荐技术精品文章哦~python

做者：董超git

上一篇文章咱们介绍了 MxNet 的安装，但 MxNet 有个缺点，那就是文档不太全，用起来多是要看源代码才能理解某个方法的含义，因此今天咱们就介绍一下 TensorFlow，这个由谷歌爸爸出品的深度学习框架，文档比较全～之后的咱们也都使用这个框架～github

0x00 概要

TensorFlow是谷歌爸爸出的一个开源机器学习框架，目前已被普遍应用，谷歌爸爸出品即便性能不是最强的（其实性能也不错），但绝对是用起来最方便的，毕竟谷歌有Jeff Dean坐镇，这波稳。算法

0x01 TensorFlow安装

官方有一个Mac上TensorFlow的安装指南，点这里
咱们如今就照着这个安装指南操做一把，官方推荐在virtualenv中安装TF，咱们就在virtualenv安装吧，你们也能够直接安装。前几天TF发布1.0版了，咱们就安装1.0版吧～shell

1.先安装下pip和sixapi

$ sudo easy_install --upgrade pip
$ sudo easy_install --upgrade six

2.安装下virtualenvbash

$ sudo pip install --upgrade virtualenvsession

3.接下来, 创建一个全新的 virtualenv 环境。这里将环境建在 ~/tensorflow目录下, 执行:框架

$ virtualenv --system-site-packages ~/tensorflow
$ cd ~/tensorflow

4.而后, 激活 virtualenv:机器学习

$ source bin/activate # 若是使用 bash $ source bin/activate.csh # 若是使用 csh

(tensorflow)$ # 终端提示符应该发生变化
若是要退出虚拟环境能够执行

(tensorflow)$ deactivate

也能够直接在shell里执行下面的代码激活

source ~/tensorflow/bin/activate

5.在 virtualenv 内, 安装 TensorFlow:
由于我用的是Python 2.x因此执行

$ sudo pip install --upgrade https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.0.0-py2-none-any.whl

要是使用Python3能够执行

$ pip3 install --upgrade https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.0.0-py3-none-any.whl

固然也能够执行下面这个命令直接安装最新版

pip install --upgrade tensorflow

等命令执行完TF就安装好了

安装完成后能够在python中执行如下代码

import tensorflow as tf hello = tf.constant('Hello, TensorFlow!') sess = tf.Session() print(sess.run(hello))

若是输出

Hello, TensorFlow!

就说明安装成功啦

PS:运行脚本的时候会提示不支持SSE xxx指令集的提示，这是由于咱们是经过pip直接安装的编译好的版本致使的，若是想针对机器优化，能够直接从GitHub上的源代码编译安装。但这样会复杂些，并且我以为其实提高不大，用CPU都很慢。。。不如直接上GPU性能提高快。

PS2:若是想安装GPU版会复杂些，首先要有一块支持CUDA的N卡，再安装CUDA驱动啥的，各位看官能够谷歌一下查询相关资料。若是不想搜索，也能够看本系列后续文章，之后也会介绍如何在Mac下安装GPU版。

0x02 TensorFlow基本使用

在介绍样例以前，咱们先介绍一下TensorFlow的一些基本概念

1.placehoder（占位符）

tf.placeholder(dtype, shape=None, name=None)
Args:
    dtype: The type of elements in the tensor to be fed.     shape: The shape of the tensor to be fed (optional). If the shape is not specified, you can feed a tensor of any shape.     name: A name for the operation (optional).

dytpe:占位符的数据类型
shape:占位符的纬度，例如[2,2]表明2x2的二维矩阵，None能够表明任意维度，例如[None,2]则表明任意行数，2列的二维矩阵
name:占位符的名字

变量在定义时要初始化，但可能有些变量咱们一开始定义的时候并不必定知道该变量的值，只有当真正开始运行程序的时候才由外部输入，好比咱们须要训练的数据，因此就用占位符来占个位置，告诉TensorFlow，等到真正运行的时候再经过输入数据赋值。
例如

x = tf.placeholder(tf.float32, [2, 2])

就是生成了一个2x2的二维矩阵，矩阵中每一个元素的类型都是tf.float32（也就是浮点型）。

有时候定义须要训练的参数时候，会定义一个[input_size,output_size]大小的矩阵，其中input_size数输入数据的维度，output_size是输出数据的维度

2.Variable（变量）

官方说明有些长，我就不引用啦，这里介绍一个简单的用法，有一点变量在声明的时候要有一个初始值

x = tf.Variable(tf.zeros([2,2])) # 声明一个2x2的矩阵，并将矩阵中的全部元素的值赋为0，默认每一个元素都是tf.float32类型的数据 y = tf.Variable(1.0, tf.float32) # 声明一个tf.float32的变量，并将初始值设为1.0

咱们通常还须要运行下global_variables_initializer真正在TensorFlow的Session中初始化全部变量，后面的样例中也会有体现。

3.Constant（常量）

官方说明一样不引用啦，这里介绍一个简单的用法

x = tf.constant(3.0, tf.float32) # 定义一个值为3.0的浮点型常量

4.Session（会话）

TensorFlow全部的操做都必须在Session中运行，才能真正起做用，能够将Session看成TensorFlow运行的环境，Session运行完须要close～

#用close()关闭 sess = tf.Session() sess.run(...) sess.close() #使用with..as..语句关闭 with tf.Session() as sess:     sess.run(...)

5.简单使用

咱们介绍下3+5应该如何在TensorFlow中实现

import tensorflow as tf x = tf.Variable(3, tf.int16) // 声明一个整型变量3 y = tf.Variable(5, tf.int16) // 声明一个整型变量5 z = tf.add(x,y) // z = x + y init = tf.global_variables_initializer() // 初始化变量的操做 with tf.Session() as sess: sess.run(init) // 在Session中初始化变量 print(sess.run(z)) // 输出计算出的z值

0x03 样例

Github上有一个比较好的Demo合集，有注释有源代码还蛮好的，但今天咱们不讲上面的代码，咱们讲如何用TF实现线性回归模型。

所谓线性回归模型就是y = W * x + b的形式的表达式拟合的模型。

咱们若是想经过深度学习拟合一条直线 y = 3 * x 应该怎么作呢？咱不讲虚的先展现下代码！而后咱们在逐步分析。

#coding=utf-8 import tensorflow as tf x = tf.placeholder(tf.float32) W = tf.Variable(tf.zeros([1])) b = tf.Variable(tf.zeros([1])) y_ = tf.placeholder(tf.float32) y = W * x + b lost = tf.reduce_mean(tf.square(y_-y)) optimizer = tf.train.GradientDescentOptimizer(0.0000001) train_step = optimizer.minimize(lost) sess = tf.Session() init = tf.global_variables_initializer() sess.run(init) steps = 1000 for i in range(steps): xs = [i] ys = [3 * i] feed = { x: xs, y_: ys } sess.run(train_step, feed_dict=feed) if i % 100 == 0 : print("After %d iteration:" % i) print("W: %f" % sess.run(W)) print("b: %f" % sess.run(b)) print("lost: %f" % sess.run(lost, feed_dict=feed))

1.先导入须要使用的python库。

#coding=utf-8 import tensorflow as tf

毕竟是基于TensorFlow的，那咱们确定要导入TensorFlow滴，导入以后取个别名tf，以后用起来方便些。

2.定义须要的变量，咱们看看y = W * x + b中都有哪些变量。

x = tf.placeholder(tf.float32) W = tf.Variable(tf.zeros([1])) b = tf.Variable(tf.zeros([1])) y_ = tf.placeholder(tf.float32)

x：咱们训练时须要输入的真实数据x
W: 咱们须要训练的W，这里咱们定义了一个1维的变量（其实吧，就是一个普普统统的数，直接用tf.float32也行）并将其初值赋为0
b : 咱们须要训练的b，定义一个1维变量，并将其初值赋为0
y_ ：咱们训练时须要输入的x对应的y

3.定义线性模型

y = W * x + b

4.定义损失函数和优化方法

lost = tf.reduce_mean(tf.square(y_-y)) optimizer = tf.train.GradientDescentOptimizer(0.0000001) train_step = optimizer.minimize(lost)

lost = tf.reducemean(tf.square(y- y))

损失函数(Lost Function)是用来评估咱们预测的值和真实的值之间的差距是多少，损失函数有不少种写法，咱们这里使用（y预测-y真实)^2再取平均数来做为咱们的损失函数（用这个函数是有缘由的，由于咱们用的是梯度降低法进行学习）损失函数的值越小越好，有些教程也叫Cost Function

optimizer = tf.train.GradientDescentOptimizer(0.0000001)

优化函数表明咱们要经过什么方式去优化咱们须要学习的值，这个例子里指的是W和b，优化函数的种类有不少，你们到官网查阅，平时咱们用的比较多的是GradientDescentOptimizer和AdamOptimizer等，这里咱们选用最经常使用也是最最基本的GradientDescentOptimizer（梯度降低），后面传入的值是学习效率。通常是一个小于1的数。越小收敛越慢，但并非越大收敛越快哈，取值太大甚至可能不收敛了。。。

咱们简单介绍下什么是梯度降低，梯度顾名思义就是函数某一点的导数，也就是该点的变化率。梯度降低则顾名思义就是沿梯度降低的方向求解极小值。

详细解释你们能够自行谷歌一下～固然能够能够看这篇文章，固然因为性能的缘由梯度降低有不少种变种，例如随机梯度降低 (Stochastic Gradient Descent)，小批梯度降低 (Mini-Batch Gradient Descent)。本文样例采用的是SGD，每次只输入一个数据。

train_step = optimizer.minimize(lost)

这个表明咱们每次训练迭代的目的，本例咱们的目的就是尽可能减少lost的值，也就是让损失函数的值尽可能变小

5.变量初始化

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

这个以前有所介绍了，咱们须要在Session中真正运行下global_variables_initializer才会真正初始化变量。

6.开始训练

steps = 1000 for i in range(steps): xs = [i] ys = [3 * i] feed = { x: xs, y_: ys } sess.run(train_step, feed_dict=feed) if i % 100 == 0 : print("After %d iteration:" % i) print("W: %f" % sess.run(W)) print("b: %f" % sess.run(b)) print("lost: %f" % sess.run(lost, feed_dict=feed))

咱们定义一个训练迭代次数1000次。

这里咱们图方便，每次迭代都直接将i做为x，3*i做为y直接当成训练数据。

咱们全部经过placeholder定义的值，在训练时咱们都须要经过feed_dict来传入数据。

而后咱们每隔100次迭代，输出一次训练结果，看看效果如何～

After 0 iteration: W: 0.000000 b: 0.000000 lost: 0.000000 After 100 iteration: W: 0.196407 b: 0.002951 lost: 78599.671875 After 200 iteration: W: 1.249361 b: 0.009867 lost: 122582.625000 After 300 iteration: W: 2.513344 b: 0.015055 lost: 21310.636719 After 400 iteration: W: 2.960238 b: 0.016392 lost: 252.449890 After 500 iteration: W: 2.999347 b: 0.016484 lost: 0.096061 After 600 iteration: W: 2.999971 b: 0.016485 lost: 0.000001 After 700 iteration: W: 2.999975 b: 0.016485 lost: 0.000001 After 800 iteration: W: 2.999978 b: 0.016485 lost: 0.000001 After 900 iteration: W: 2.999981 b: 0.016485 lost: 0.000000

能够看到在迭代了500次以后效果就很好了，w已经达到2.999347很接近3了，b也达到了0.016484也比较接近0了，由于这里学习率选择的比较小，因此收敛的比较慢，各位也能够尝试调大学习率，看看收敛的速度有何变化。