TensorFlow实现线性回归

1.线性回归原理

根据数据建立回归模型，w1x1+w2x2+……+b = y，通过真实值与预测值之间建立误差，使用梯度下降优化得到损失函数最小对应的权重和偏置，最终确定模型的权重和偏置参数。最后可以用这些参数进行预测。

2.实现线性回归的训练

需求:

• 假设随机指定100个点，只有一个特征
• 数据本身的分布为 y = 0.8 * x + 0.7

2.1 步骤分析

• 1 准备好数据集：y = 0.8x + 0.7 100个样本
• 2 建立线性模型
  • 随机初始化W1和b1
  • y = W·X + b，目标：求出权重W和偏置b
• 3 确定损失函数(预测值与真实值之间的误差)-均方误差
• 4 梯度下降优化损失：需要指定学习率(超参数)

2.2 代码实现

2.2.1 面向过程代码:

import tensorflow as tf
import os

# 定义一些常用的命令行参数
# 训练步数
# tf.flags.DEFINE_integer(, , )
tf.flags.DEFINE_integer("max_step", 0, "训练模型的步数")

# 定义模型的路径
# tf.flags.DEFINE_string(, , )
tf.flags.DEFINE_string("model_path", "./linear_regression/", "模型保存的路径和文件名")

# 获取命令行参数
FLAGS = tf.app.flags.FLAGS

def linear_regression():
    """
    实现线性回归
    """
    # 1. 准备好数据集:y=0.8x+0.7 100个样本
    with tf.variable_scope("original_data"):
        X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name='original_data_x')
        # 矩阵乘法
        y_true = tf.matmul(X, [[0.8]], name='original_matmul') + 0.7

    # 2.建立线性模型 y = w*X+b 目标:求出权重w和偏置b
    # 3.初始化w1和b1
    with tf.variable_scope("linear_model"):
        weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1), name="weights"))
        bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1), name="bias"))
        y_pred = tf.matmul(X, weights, name="model_matmul") + bias
    # 4.确定损失函数->均方误差
    with tf.variable_scope("loss"):
        error = tf.reduce_mean(tf.square(y_pred - y_true), name="error_op")
    # 5.梯度下降优化损失函数:需要指定学习率
    with tf.variable_scope("gd_optimizer"):
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)

    # 收集变量
    # tf.summary.scalar(, )：通过标量的方式来统计数据（简单一点有点像曲线图的方式，一般用于loss、accuary的收集）
    tf.summary.scalar("error", error)
    # tf.summary.histogram(, )：直方图的形式展示、一般用于高纬度的数据收集。
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bias", bias)

    # 合并变量
    merge = tf.summary.merge_all()

    # 初始化变量
    init = tf.global_variables_initializer()

    # 创建Saver对象
    saver = tf.train.Saver()

    # 开启会话进行训练
    with tf.Session() as sess:
        sess.run(init)
        print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))
        # 当存在checkpoint文件，就加载模型
        if os.path.exists("./linear_regression/checkpoint"):
            saver.restore(sess, FLAGS.model_path)
        # 1.创建事件文件
        file_writer = tf.summary.FileWriter(logdir="./summary", graph=sess.graph)

        # 2.训练模型
        for i in range(FLAGS.max_step):
            sess.run(optimizer)
            print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))

            # 运行变量OP
            summary = sess.run(merge)
            file_writer.add_summary(summary, i)
            if i % 10 == 0:
                saver.save(sess, FLAGS.model_path)
    return None


def main(argv):
    print("这是main函数")
    print(argv)
    print(FLAGS.model_path)
    linear_regression()
    
if __name__ == '__main__':
    tf.app.run()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

2.2.2 面向对象代码

import tensorflow as tf
import os

# 定义命令行参数
# 训练步数
tf.flags.DEFINE_integer("max_step", 50, "训练模型的步数")
# 模型保存路径
tf.flags.DEFINE_string("model_path", './linear_regression/', "模型保存的路径+模型的名称")
FLAGS = tf.flags.FLAGS


class MyLinearRegression():
    """
    实现线性回归
    """

    def __init__(self):
        # 初始化权重和偏置
        self.weight = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name='weight')
        self.bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")

    def inputs(self):
        """
        获取特征值和目标值
        y = 0.7*X + 0.8
        """
        x_data = tf.random_normal(shape=(100, 1), mean=1.0, stddev=1.0, name="x_data")
        y_true = tf.matmul(x_data, [[0.8]], name="y_true") + 0.7
        return x_data, y_true

    def inference(self, feature):
        """
        根据输入数据建立模型
        :param feature:
        :return:
        """
        with tf.variable_scope("linear_model"):
            # 预测结果
            y_pred = tf.matmul(feature, self.weight) + self.bias
        return y_pred

    def loss(self, y_true, y_pred):
        """
        损失函数:均方误差
        :param y_true:
        :param y_pred:
        :return:
        """
        return tf.reduce_mean(tf.square(y_true - y_pred), name="loss")

    def sgd_op(self, loss):
        """
        获取训练OP
        :param loss:
        :return:
        """
        return tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(loss)

    def merge_summary(self, loss):
        """
        收集参数
        :param loss:
        :return:
        """
        tf.summary.scalar("loss", loss)
        tf.summary.histogram("weight", self.weight)
        tf.summary.histogram("bias", self.bias)
        merge = tf.summary.merge_all()
        return merge

    def train(self):
        """
        训练linear model
        """
        g = tf.get_default_graph()

        with g.as_default():
            # 1. 获取数据
            x_data, y_true = self.inputs()
            # 2.根据输入数据建立模型,预测结果
            y_pred = self.inference(x_data)
            # 3.求解损失函数
            loss = self.loss(y_true, y_pred)
            # 梯度下降求解
            train_op = self.sgd_op(loss)
            # 收集参数
            merge = self.merge_summary(loss)

            # 创建Saver对象
            saver = tf.train.Saver()

            # 开启会话,开始训练
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                print("初始化的权重：%f, 偏置：%f" % (self.weight.eval(), self.bias.eval()))
                # 当存在checkpoint文件，就加载模型
                if os.path.exists("./linear_regression/checkpoint/"):
                    saver.restore(sess, FLAGS.model_path)

                 # 开始训练
                for i in range(FLAGS.max_step):
                    sess.run(train_op)

                    # 生成事件文件,观察图结构
                    file_writer = tf.summary.FileWriter(logdir='./summary/', graph=sess.graph)
                    print("训练第%d步之后的损失:%f, 权重：%f, 偏置：%f" % (i, loss.eval(), self.weight.eval(), self.bias.eval()))

                    # 运行收集变量的结果
                    summary = sess.run(merge)

                    # 添加到文件
                    file_writer.add_summary(summary, i)

                    if i % 10 == 0:
                        # 保存的是会话当中的变量op值，其他op定义的值不保存
                        saver.save(sess, FLAGS.model_path)


if __name__ == '__main__':
    linear_regression = MyLinearRegression()
    linear_regression.train()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

3.总结

• 线性回归实现整体流程:读取数据->训练模型->预测结果->模型优化(求解最优权重和偏置)
• 模型的保存与加载: tf.train.Saver(var_list=None,max_to_keep=5)
• 命令行参数使用:tf.flags