深度学习入门实战(二)-用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,因为学习率这里的选择比较少,所以收敛比较慢。也可以尝试提高学习率,看看收敛速度如何变化。

© 版权声明
THE END
喜欢就支持一下吧
点赞13 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片