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

是谷歌爸爸开发的开源机器学习框架。它已被广泛使用。即使 Dad 的性能不是最强的（其实性能也不错），但绝对是最方便使用的。毕竟谷歌已经让 Jeff Dean 坐稳了，这波稳了。

0x01 安装

官方有Mac上的安装指南，点这里

我们现在将遵循此安装指南。官方建议在 .前几天TF发布了1.0版本，我们来安装1.0版本~

1.先安装pip和六

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

2.安装

$ sudo pip —

3.接下来，设置一个全新的环境。这里环境搭建在~/目录下，执行：

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

4.然后，激活：

$ source bin/activate  # 如果使用 bash
$ source bin/activate.csh  # 如果使用 csh

()$ # 终端提示应该改变

如果要退出虚拟环境，可以执行

()$

也可以在shell中直接执行以下代码来激活

~//bin/

5.在里面，安装：

执行因为我使用 2.x

$ sudo pip —

如果你使用它，你可以执行它

$ pip3 —

当然也可以执行以下命令直接安装最新版本

点-

命令执行后会安装TF

安装完成后，可以在中执行如下代码

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

如果输出

你好！

安装成功

PS：运行脚本时会提示不支持SSE xxx指令集。这是因为我们直接通过 pip 安装了编译后的版本。如果要针对本机进行优化，可以直接从上面下载源码编译安装。但是这样会比较复杂，而且我觉得提升其实不是很大，而且CPU很慢。 . 最好直接上GPU来提升性能。

PS2：如果要安装GPU版本，会比较复杂。首先你要有支持CUDA的N卡，然后安装CUDA驱动。你可以一下相关信息。不想搜索的也可以看本系列的后续文章，以后还会介绍如何在Mac下安装GPU版本。

0x02 基本用法

在介绍示例之前，我们先介绍一些基本概念

1.（占位符）

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]表示2×2二维矩阵，None可以表示任意维度，例如[None,2]表示任意行数的二维矩阵和 2 列

p>

name：占位符的名称

变量在定义的时候必须要初始化，但是可能有一些变量我们在第一次定义的时候不一定知道变量的值。只有当我们真正开始运行程序的时候，它是从外面输入的，比如我们需要训练的数据，所以就用一个占位符占据一个位置，告诉它，然后通过输入的数据给它赋值实际运行。

例如

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

是生成一个2×2的二维矩阵，矩阵中每个元素的类型为tf。 （即浮点数）。

有时在定义需要训练的参数时，会定义一个大小为[,]的矩阵，其中输入数据的维度就是输出数据的维度

2.（变量）

官方说明有点长，就不引用了。这是一个简单的用法，一个小变量在声明时必须有一个初始值

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

我们在实际运行中一般还需要初始化所有变量，这也会体现在下面的例子中。

3.（常数）

官方说明也没有引用，这里是一个简单的用法

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

4.（会话）

所有操作都必须在里面运行，才能真正起作用，可以作为运行环境，需要关闭~

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

5.易于使用

我们介绍3+5应该如何实现

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 示例

上有一个很好的演示集合

。有注释和源码就好了，不过今天不讲上面的代码，讲讲如何使用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.先导入需要的库。

#coding=utf-8
import tensorflow as tf

毕竟是基于的，所以一定要导入drops，导入后取一个别名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，这里我们定义一个一维变量（其实就是一个普通的数，可以直接用tf.）并将它的初值赋给0

b ：我们需要训练b，定义一个一维变量，并将其初始值赋为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)

丢失 = tf.(tf.(y- y))

损失函数（Lost）用于评估我们的预测值与真实值之间的差距。损失函数的写法有很多种。这里我们使用(y – y real)^2 然后取平均值作为我们的损失函数（使用这个函数是有原因的，因为我们使用梯度下降进行学习）损失函数的值越小越好，有些教程也叫成本

= tf.train.izer(0.)

优化函数表示我们想如何优化我们需要学习的值。在本例中，它指的是 W 和 b。有许多类型的优化函数。您可以在官方网站上查看它们。通常，我们更频繁地使用 izer。以此类推，这里我们使用最常用最基础的izer（梯度下降），后面传入的值就是学习效率。通常是小于1的数。值越小收敛越慢，但不代表值越大收敛越快。如果值太大，它甚至可能不会收敛。 . .

让我们简单介绍一下什么是梯度下降。梯度，顾名思义，就是函数某一点的导数，即该点的变化率。梯度下降，顾名思义，就是沿着梯度下降的方向求解最小值。

详细解释可以自己~当然可以看这篇文章。当然，由于性能原因，梯度下降有很多变体，例如随机梯度下降（ ）、小批量梯度下降（Mini-Batch）。本文示例使用 SGD，一次只输入一个数据。

= .（丢失）

这代表了每次训练迭代的目的。在这种情况下，我们的目的是最小化loss的值，也就是让损失函数的值尽可能的小

5.变量初始化

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

这个前面已经介绍过了，实际操作下我们需要实际初始化变量。

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作为训练数据。

我们所有的pass定义的值，我们需要在训练的时候传入数据。

然后我们每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.非常接近3，b也达到了0.也比较接近0，因为学习率这里的选择比较少，所以收敛比较慢。也可以尝试提高学习率，看看收敛速度如何变化。