深度學習入門實戰（二）-用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了，由於這裏學習率選擇的比較小，因此收斂的比較慢，各位也能夠嘗試調大學習率，看看收斂的速度有何變化。