TensorFlow实现线性回归

拟墨画扇 提交于 2021-01-22 15:28:16

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

特点:只有一个自变量的情况称为单变量回归,大于一个自变量情况的叫做多元回归

通用公式:h(w) = w1x1+w2x2+w3x3+...+b=wTx + b

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

线性回归案例:

假设随机指定100个点,只有一个特征
数据本身的分布为 y = 0.7 * x + 0.8
这里将数据分布的规律确定,是为了使我们训练出的参数跟真实的参数(即0.7和0.8)比较是否训练准确

 

TensorFlow计算API:
运算

矩阵运算
tf.matmul(x, w)
平方
tf.square(error)
均值
tf.reduce_mean(error)


梯度下降优化

tf.train.GradientDescentOptimizer(learning_rate)
梯度下降优化
learning_rate:学习率,一般为0~1之间比较小的值
method:
minimize(loss)
return:梯度下降op

 

步骤分析:
1、准备数据的特征值和目标值 inputs

获取特征值目标值数据数据

    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、根据特征值建立线性回归模型(确定参数个数形状) inference

根据输入数据建立模型,模型的参数必须使用变量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

求出模型跟真实数据之间的损失
 def loss(self, y_true, y_predict):
        """
        目标值和真实值计算损失
        :return: loss
        """
        # 均方误差公式
        loss = tf.reduce_mean(tf.square(y_true - y_predict))

        return loss

  

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

使用梯度下降优化器优化
    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. 使用激活函数

 

 

变量的trainable设置观察
trainable的参数作用,指定是否训练

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

 

增加变量显示
目的:在TensorBoard当中观察模型的参数、损失值等变量值的变化

1、收集变量
tf.summary.scalar(name=’’,tensor) 收集对于损失函数和准确率等单值变量,name为变量的名字,tensor为值
tf.summary.histogram(name=‘’,tensor) 收集高维度的变量参数
tf.summary.image(name=‘’,tensor) 收集输入的图片张量能显示图片

 

# 收集张量的值
tf.summary.scalar("losses", loss)

tf.summary.histogram("w", self.weight)
tf.summary.histogram('b', self.bias)

2、合并变量写入事件文件
merged = tf.summary.merge_all()
运行合并:summary = sess.run(merged),每次迭代都需运行
添加:FileWriter.add_summary(summary,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(var_list=None,max_to_keep=5)
保存和加载模型(保存文件格式:checkpoint文件)
var_list:指定将要保存和还原的变量。它可以作为一个dict或一个列表传递.
max_to_keep:指示要保留的最近检查点文件的最大数量。创建新文件时,会删除较旧的文件。如果无或0,则保留所有检查点文件。默认为5(即保留最新的5个检查点文件。)

指定目录+模型名字
saver.save(sess, '/tmp/ckpt/test/myregression.ckpt')
saver.restore(sess, '/tmp/ckpt/test/myregression.ckpt')
如要判断模型是否存在,直接指定目录

checkpoint = tf.train.latest_checkpoint("./tmp/model/")

saver.restore(sess, checkpoint)

 

完整代码:

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

 

训练结果:

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!