TensorFlow 实现线性回归

1、生成高斯分布的随机数

导入numpy模块，通过numpy模块内的方法生成一组在方程

y = 2 * x + 3

周围小幅波动的随机坐标。代码如下：

import numpy as np
import matplotlib.pyplot as plot


def getRandomPoints(count):
    xList = []
    yList = []
    for i in range(count):
        x = np.random.normal(0, 0.5)
        y = 2 * x + 3 + np.random.normal(0, 0.3)
        xList.append(x)
        yList.append(y)
    return xList, yList


if __name__ == '__main__':
    X, Y = getRandomPoints(1000)
    plot.scatter(X, Y)
    plot.show()

运行上述代码，输出图形如下：

2、采用TensorFlow来获取上述方程的系数

　　首先搭建基本的预估模型y = w * x + b，然后再采用梯度下降法进行训练，通过最小化损失函数的方法进行优化，最终训练得出方程的系数。

　　在下面的例子中，梯度下降法的学习率为0.2，训练迭代次数为100次。

def train(x, y):
    # 生成随机系数
    w = tf.Variable(tf.random_uniform([1], -1, 1))
    # 生成随机截距
    b = tf.Variable(tf.random_uniform([1], -1, 1))
    # 预估值
    preY = w * x + b

    # 损失值：预估值与实际值之间的均方差
    loss = tf.reduce_mean(tf.square(preY - y))
    # 优化器：梯度下降法,学习率为0.2
    optimizer = tf.train.GradientDescentOptimizer(0.2)
    # 训练：最小化损失函数
    trainer = optimizer.minimize(loss)

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        # 打印初始随机系数
        print('init w:', sess.run(w), 'b:', sess.run(b))
        # 先训练个100次：
        for i in range(100):
            sess.run(trainer)
            # 每10次打印下系数
            if i % 10 == 9:
                print('w:', sess.run(w), 'b:', sess.run(b))


if __name__ == '__main__':
    X, Y = getRandomPoints(1000)
    train(X, Y)

　　运行上面的代码，某次的最终结果为：

w = 1.9738449
b = 3.0027733

仅100次的训练迭代，得出的结果已十分接近方程的实际系数。

　　某次模拟训练中的输出结果如下：

init w: [-0.6468966] b: [0.52244043]
w: [1.0336646] b: [2.9878206]
w: [1.636582] b: [3.0026987]
w: [1.8528996] b: [3.0027785]
w: [1.930511] b: [3.0027752]
w: [1.9583567] b: [3.0027738]
w: [1.9683474] b: [3.0027735]
w: [1.9719319] b: [3.0027733]
w: [1.9732181] b: [3.0027733]
w: [1.9736794] b: [3.0027733]
w: [1.9738449] b: [3.0027733]

3、完整代码和结果

 完整测试代码：

import numpy as np
import matplotlib.pyplot as plot
import tensorflow as tf


def getRandomPoints(count, xscale=0.5, yscale=0.3):
    xList = []
    yList = []
    for i in range(count):
        x = np.random.normal(0, xscale)
        y = 2 * x + 3 + np.random.normal(0, yscale)
        xList.append(x)
        yList.append(y)
    return xList, yList


def train(x, y, learnrate=0.2, cycle=100):
    # 生成随机系数
    w = tf.Variable(tf.random_uniform([1], -1, 1))
    # 生成随机截距
    b = tf.Variable(tf.random_uniform([1], -1, 1))
    # 预估值
    preY = w * x + b

    # 损失值：预估值与实际值之间的均方差
    loss = tf.reduce_mean(tf.square(preY - y))
    # 优化器：梯度下降法
    optimizer = tf.train.GradientDescentOptimizer(learnrate)
    # 训练：最小化损失函数
    trainer = optimizer.minimize(loss)

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        # 打印初始随机系数
        print('init w:', sess.run(w), 'b:', sess.run(b))
        for i in range(cycle):
            sess.run(trainer)
            # 每10次打印下系数
            if i % 10 == 9:
                print('w:', sess.run(w), 'b:', sess.run(b))
        return sess.run(w), sess.run(b)


if __name__ == '__main__':
    X, Y = getRandomPoints(1000)
    w, b = train(X, Y)
    plot.scatter(X, Y)
    plot.plot(X, w * X + b, c='r')
    plot.show()

　　最终效果图如下，蓝色为高斯随机分布数据，红色为最终得出的直线：

本文地址：https://www.cnblogs.com/laishenghao/p/9571343.html