【Tensorflow1.0】實現最簡單的線性迴歸模型的預測

在一個座標系中有一些散點，大體圖像以下

從圖中很明顯的能夠看出，這些散點近似的符合直線方程 y = w * x + b

這時候若是再給定一個x，須要你求出對應的y值，那麼這就是線性迴歸的預測問題 (*1)

求解這些問題，首先咱們須要知道這個直線方程的參數w、b所對應的值(*2)，而後就能垂手可得的計算出y的值了

這裏，咱們把x看做是input(輸入)，y看做是output(輸出)，那麼w和b就是rule(規則)

咱們平時求解問題的過程就是經過input(輸入)和rule(規則)，來獲得output(輸出)的過程

而反推出w和b的過程，就是已知input(輸入)、output(輸出)，推導出rule(規則)的過程，這就是機器學習的過程

換句話說，機器學習就是在給定大量樣本（input、output）的前提下，讓機器本身學習並得出符合這些樣本的rule(規則)

====================================================

在開始着手解決這個問題以前，咱們須要一個函數來模擬這個散點的生成，這個函數中的w和b就是直線方程中的參數

定義x的範圍是0~30，對應y的值在方程 y = 5.33 * x - 23.26 這個方程後隨機加上一個噪點（-5 ~ 5）

（上圖中的散點就是利用這個函數所生成的。）

def create_data(for_train=False):
    w = 5.33
    b = -23.26
    x = random.random() * 30
    y = w * x + b

    if for_train:
        noise = (random.random() - 0.5) * 10
        y += noise

    return x, y

====================================================

接下來咱們開始利用Tensorflow來定義模型開始訓練並最驗證最終的訓練結果

1.tf.placeholder佔位

直線方程中的4個對象中，咱們知道x和y是input、output，在機器學習的過程當中，能夠從大量的數據樣本中獲取這些值，也就是說在學習的時候咱們須要向機器來「喂」這些數據，因此在tensorflow中把這些和外部有關係的變量用佔位來表示

X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)

2.tf.Variable變量

直線方程中的w和b是須要機器經過學習來求出的值，這類值在tensorflow中用變量來表示

W = tf.Variable(tf.zeros([1]))
B = tf.Variable(tf.zeros([1]))

3.模型

如今已經定義了這4個對象，下一步就是用一個模型將這4個對象關聯起來

而咱們已經知道直線方程式y = w * x + b了，因此很容易的就可以獲得這個模型

OUT = X * W + B

4.損失函數

那麼已知input、output的前提下，如何計算出參數的值呢？（求出模型的最優解）

設想已經有了一條直線（並不必定是最優的），而一個散點爲(x,y)，在相同x的狀況下會獲得兩個y（直線上的y和散點的y），這兩個y之間存在一個差值

當有多個散點的時候就會有更多的差值，這些y的差值絕對值總和爲最小值時，就說明這時候的參數w和b的值是這個模型的最優解

這時候就將問題轉化爲求這些y之間差值的絕對值總和，在數學上最簡單的解決這類問題的方法是利用方差

在機器學習中這個最小值稱爲損失值，方差函數則成爲損失函數

loss = tf.reduce_mean(tf.square(Y - OUT))

5.優化器

目前這個概念先不展開了，有興趣的同窗能夠先看一下這個資料：深度學習——優化器算法Optimizer詳解

這裏先使用tf.train.AdamOptimizer，將學習步長設爲0.005（每次訓練調整的大小），針對loss值進行最小值優化

optimizer = tf.train.AdamOptimizer(0.005).minimize(loss)

6.進行訓練

循環訓練50000次，而後預測10次結果

整個過程必須在tf.Session()的範圍下進行，而且開始訓練以前須要執行初始化操做sess.run(tf.global_variables_initializer())

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(50000):
        x_data, y_data = create_data(True)
        _, _loss, _w, _b = sess.run([optimizer, loss, W, B], feed_dict={X: x_data, Y: y_data})
        if 5000 >= epoch and 0 == epoch % 30:
            LOSS.append(_loss)
            STEP.append(epoch)
        if 0 == epoch % 5000:
            print("epoch=",epoch,"_loss=", _loss, "_w=", _w, "_n=", _b)

    print("")

    for step in range(10):
        x_data, y_data = create_data(False)
        prediction_value = sess.run(OUT, feed_dict={X: x_data})
        print("x=", x_data, "y預測=", prediction_value, "y實際=", y_data)

訓練過程以下：

以前定義的w和b的值爲 w = 5.33 b = -23.26，能夠看出訓練的結果已經很接近了

epoch= 0 _loss= 6535.513 _w= [0.005] _n= [0.005]
epoch= 5000 _loss= 90.0896 _w= [4.2593937] _n= [-1.7201818]
epoch= 10000 _loss= 100.52192 _w= [4.7439947] _n= [-11.816676]
epoch= 15000 _loss= 17.476357 _w= [5.1670055] _n= [-19.59391]
epoch= 20000 _loss= 2.2600362 _w= [5.3230166] _n= [-22.696983]
epoch= 25000 _loss= 4.6579065 _w= [5.31661] _n= [-23.181973]
epoch= 30000 _loss= 9.24592 _w= [5.2802496] _n= [-23.276373]
epoch= 35000 _loss= 0.84757626 _w= [5.329259] _n= [-23.303928]
epoch= 40000 _loss= 8.161284 _w= [5.3306417] _n= [-23.249054]
epoch= 45000 _loss= 1.6442517 _w= [5.309767] _n= [-23.131523]

損失值的降低過程以下：

預測結果以下：

x= 27.438008047915964 y預測= [123.47453] y實際= 122.98458289539208
x= 19.146292250299492 y預測= [79.19505] y實際= 78.78973769409629
x= 23.361374627634643 y預測= [101.70447] y實際= 101.25612676529263
x= 14.531277040716512 y預測= [54.549923] y實際= 54.191706627019
x= 2.980825966174611 y預測= [-7.131872] y實際= -7.372197600289326
x= 13.53211464630262 y預測= [49.21419] y實際= 48.866171064792965
x= 17.132962728625294 y預測= [68.44347] y實際= 68.05869134357282
x= 19.142881910257685 y預測= [79.17685] y實際= 78.77156058167346
x= 25.69039828346153 y預測= [114.14195] y實際= 113.66982285084994
x= 1.7769451159225813 y預測= [-13.560844] y實際= -13.788882532132643

====================================================

完整代碼以下，在python3.6.八、tensorflow1.13環境下成功運行

https://github.com/yukiti2007/sample/blob/master/python/tensorflow/wx_b.py

import random

import matplotlib.pyplot as plt
import tensorflow as tf


def create_data(for_train=False):
    w = 5.33
    b = -23.26
    x = random.random() * 30
    y = w * x + b

    if for_train:
        noise = (random.random() - 0.5) * 10
        y += noise

    return x, y


def draw():
    x_data, y_data = [], []
    for _ in range(100):
        x, y = create_data(True)
        x_data.append(x)
        y_data.append(y)
    plt.figure()
    plt.scatter(x_data, y_data)
    plt.show()


def run():
    LOSS=[]
    STEP=[]
    X = tf.placeholder(tf.float32)
    Y = tf.placeholder(tf.float32)

    W = tf.Variable(tf.zeros([1]))
    B = tf.Variable(tf.zeros([1]))
    OUT = X * W + B

    loss = tf.reduce_mean(tf.square(Y - OUT))
    optimizer = tf.train.AdamOptimizer(0.005).minimize(loss)

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for epoch in range(50000):
            x_data, y_data = create_data(True)
            _, _loss, _w, _b = sess.run([optimizer, loss, W, B], feed_dict={X: x_data, Y: y_data})
            if 5000 >= epoch and 0 == epoch % 30:
                LOSS.append(_loss)
                STEP.append(epoch)
            if 0 == epoch % 5000:
                print("epoch=",epoch,"_loss=", _loss, "_w=", _w, "_n=", _b)

        print("")

        for step in range(10):
            x_data, y_data = create_data(False)
            prediction_value = sess.run(OUT, feed_dict={X: x_data})
            print("x=", x_data, "y預測=", prediction_value, "y實際=", y_data)

    plt.figure()
    plt.scatter(STEP,LOSS)
    plt.show()

if __name__ == "__main__":
    draw()
    run()