【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()