TensorFlow实现线性回归

2022-03-05

线性回归 ( ) 使用回归方程（函数）对一个或多个自变量（特征值）与因变量（目标值）之间的关系进行建模的一种分析方式。

特点：只有一个自变量的情况称为单变量回归，多于一个自变量的情况称为多元回归

一般公式：h(w) = w1x1+w2x2+w3x3+ …+b=wTx + b

根据数据建立回归模型，w1x1+w2x2+…..+b = y，建立实际值与预测值的误差，利用梯度下降优化损失对应的权重和偏差最小。最终确定模型的权重和偏差参数，最终可以用来进行预测。

线性回归案例：

假设 100 个点是随机分配的，只有一个特征

数据本身的分布是y = 0.7 * x + 0.8

这里确定数据分布规律是为了让我们训练的参数与真实参数匹配（即0.7和0.8）比较训练是否准确

计算接口：

操作

矩阵运算

tf.(x, w)

正方形

tf.(错误)

意思

tf.(错误)

梯度下降优化

p>

tf.train.izer()

梯度下降优化

：学习率，一般在0到1之间比较小的值

：

（损失）

:梯度下降运算

步骤分析：

1、准备数据和目标值的特征值

获取特征值目标值数据

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

2、建立基于特征值的线性回归模型（确定参数个数的形状）

根据输入数据建立模型，模型的参数必须使用变量OP创建

    def inference(self, feature):
        """
        根据输入数据建立模型
        :param feature:
        :param label:
        :return:
        """
        with tf.variable_scope("linea_model"):
            # 建立回归模型，分析别人的数据的特征数量--->权重数量， 偏置b
            # 由于有梯度下降算法优化，所以一开始给随机的参数，权重和偏置
            # 被优化的参数，必须得使用变量op去定义
            # 变量初始化权重和偏置
            # weight 2维[1, 1]    bias [1]

            # 变量op当中会有trainable参数决定是否训练
            self.weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0),
                                      name="weights")
            self.bias = tf.Variable(0.0, name='biases')
            # 建立回归公式去得出预测结果
            y_predict = tf.matmul(feature, self.weight) + self.bias
        return y_predict

3、根据模型得到预测结果，建立loss loss。

求出模型跟真实数据之间的损失

 def loss(self, y_true, y_predict):
        """
        目标值和真实值计算损失
        :return: loss
        """
        # 均方误差公式
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
        return loss

4、梯度下降优化器优化损失

使用梯度下降优化器优化

    def sgd_op(self, loss):
        """
        获取训练OP
        :return:
        """
        # 填充学习率：0 ~ 1    学习率是非常小，
        # 学习率大小决定你到达损失一个步数多少
        # 最小化损失
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
        return train_op

学习率、步长和梯度爆炸的设置

学习率越大，训练的步长越小，效果越好；学习率越小，训练的步长越大，效果越好。但是，如果学习量过大，就会出现梯度爆炸现象（极端情况下，权重值会变得太大而溢出，导致出现NaN值）

如何解决爆炸梯度问题：

1.重新设计网络

< @2.调整学习率

3.使用梯度截断（在训练过程中检查并限制梯度的大小）

4.使用激活函数

变量设置观察

参数函数，指定是否训练

weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0), name="weights", trainable=False)

增加变量显示

目的：观察模型参数、损失值等变量值的变化​​​​

1、收集变量

tf..(name=”,) 收集损失函数和准确率等单值变量，name为变量名，为值

tf..(name=”,) 收集高维变量参数

tf..image(name=”,) 收集输入图像张量以显示图像

# 收集张量的值
tf.summary.scalar("losses", loss)
tf.summary.histogram("w", self.weight)
tf.summary.histogram('b', self.bias)

2、合并变量写入事件文件

= tf..()

运行合并：= sess.run()，每次迭代都需要运行一次

加：.(,i)，i代表次数的值

# 合并变量
merged = tf.summary.merge_all()
# 生成事件文件，观察图结构
file_writer = tf.summary.FileWriter("./tmp/summary/", graph=sess.graph)
# 运行收集变量的结果
summary = sess.run(merged)
# 添加到文件
file_writer.add_summary(summary, i)

模型保存和加载

tf.train.Saver(=None,=5)

保存和加载模型（保存文件格式：文件）

：指定要保存和恢复的变量。它可以作为字典或列表传递。

：表示要保留的最近检查点文件的最大数量。创建新文件时，会删除旧文件。如果 None 或 0，保留所有检查点文件。默认为 5 个（即保留最新的 5 个检查点文件。）

指定目录+型号名称

saver.save(sess, ‘/tmp/ckpt/test/.ckpt’)

saver.(sess, ‘/tmp/ckpt/test/.ckpt’)

判断模型是否存在，直接指定目录

= tf.train.(“./tmp/model/”)

saver.(sess, )

完整代码：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
# 定义一些常用的命令行参数
# 训练步数
tf.app.flags.DEFINE_integer("max_step", 10, "训练模型的步数")
# 定义模型的路径
tf.app.flags.DEFINE_string("model_dir", "./tmp/model/myregression.ckpt ", "模型保存的路径+模型名字")
FLAGS = tf.app.flags.FLAGS

class MyLinearRegression(object):
    """
    自实现线性回归
    """
    def __init__(self):
        pass
    def inputs(self):
        """
        获取特征值目标值数据
        :return:
        """
        x_data = tf.random_normal([100, 1], mean=1.0, stddev=1.0, name="x_data")
        y_true = tf.matmul(x_data, [[0.7]]) + 0.8
        return x_data, y_true
    def inference(self, feature):
        """
        根据输入数据建立模型
        建立回归模型，分析别人的数据的特征数量--->权重数量， 偏置b
        :param feature:
        :return:
        """
        with tf.variable_scope("linea_model"):
            # 由于有梯度下降算法优化，所以一开始给随机的参数，权重和偏置
            # 被优化的参数，必须得使用变量op去定义
            # 变量初始化权重和偏置
            # weight 2维[1, 1]    bias [1]
            # 变量op当中会有trainable参数决定是否训练
            self.weight = tf.Variable(
                tf.random_normal([1, 1], mean=0.0, stddev=1.0),
                name="weights"
            )
            self.bias = tf.Variable(0.0, name='biases')
            # 建立回归公式去得出预测结果
            y_predict = tf.matmul(feature, self.weight) + self.bias
        return y_predict
    def loss(self, y_true, y_predict):
        """
        目标值和真实值计算损失
        求出我们模型跟真实数据之间的损失
        :return: loss
        """
        # 均方误差公式
        loss = tf.reduce_mean(tf.square(y_true - y_predict))

        return loss
    def merge_summary(self, loss):
        # 1、收集张量的值
        tf.summary.scalar("losses", loss)
        tf.summary.histogram("w", self.weight)
        tf.summary.histogram('b', self.bias)
        # 2、合并变量
        merged = tf.summary.merge_all()
        return merged
    def sgd_op(self, loss):
        """
        获取训练OP
        :return:
        """
        # 使用梯度下降优化器优化
        # 填充学习率：0 ~ 1    学习率是非常小，
        # 学习率大小决定你到达损失一个步数多少
        # 最小化损失
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
        return train_op
    def train(self):
        """
        训练模型
        :param loss:
        :return:
        """
        g = tf.get_default_graph()
        with g.as_default():
            x_data, y_true = self.inputs()
            y_predict = self.inference(x_data)
            loss = self.loss(y_true, y_predict)
            train_op = self.sgd_op(loss)
            # 收集观察的结果值
            merged = self.merge_summary(loss)

            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 = tf.train.latest_checkpoint("./tmp/model/")
                if checkpoint:
                    print('Restoring', checkpoint)
                    saver.restore(sess, checkpoint)
                # 开启训练
                # 训练的步数（依据模型大小而定）
                print(FLAGS.max_step)
                for i in range(FLAGS.max_step):
                    sess.run(train_op)
                    # 生成事件文件，观察图结构
                    file_writer = tf.summary.FileWriter("./tmp/summary/", graph=sess.graph)
                    print("训练第%d步之后的损失:%f, 权重：%f, 偏置：%f" % (
                        i,
                        loss.eval(),
                        self.weight.eval(),
                        self.bias.eval()))
                    # 运行收集变量的结果
                    summary = sess.run(merged)
                    # 添加到文件
                    file_writer.add_summary(summary, i)
                    if i % 100 == 0:
                        # 保存的是会话当中的变量op值，其他op定义的值不保存
                        print(sess)
                        saver.save(sess, FLAGS.model_dir)
if __name__ == '__main__':
    lr = MyLinearRegression()
    lr.train()

训练结果：

分类：

技术要点：

相关文章：