tensorflow实现线性回归

import tensorflow as tf
# 实现线性回归训练
class MyLinearRegression(object):
    """
    实现线性回归训练
    """
    def __init__(self):
        self.leaning_rate = 10

    def inputs(self):
        """
        获取需要训练的数据
        :return:
        """
        # x: [100, 1]  y_true = x * 0.7 + 0.8
        x_data = tf.random_normal(shape=[100, 1], mean=0.0, stddev=1.0, name='x_data')

        # [100, 1] * [1, 1] = [100, 1]
        y_true = tf.matmul(x_data, [[0.7]]) + 0.8

        return x_data, y_true

    def inference(self, feature):
        """
        根据数据特征值，建立线性回归模型
        :param feature: 数据特征值 [100, 1]
        :return: y_predict
        """
        # 定义一个命名空间
        with tf.variable_scope("linear_model"):
            # w, b
            # x [100, 1] * w [1, 1] + b = y_predict
            # 随机初始化权重和偏置
            # 权重和偏置必须使用tf.Variable去定义，应为只有Variable才能被梯度下降所训练
            self.weight = tf.Variable(tf.random_normal(shape=[1, 1],
                                                       mean=0.0,
                                                       stddev=1.0),
                                      name="weight")

            self.bias = tf.Variable(tf.random_normal(shape=[1],
                                                       mean=0.0,
                                                       stddev=1.0), name="bias")
            # 建立模型预测
            y_predict = tf.matmul(feature, self.weight) + self.bias

        return y_predict

    def loss(self, y_true, y_predict):
        """
        根据预测值和真实值求出均方误差损失
        :param y_true: 真实值
        :param y_predict: 预测值
        :return: loss
        """
        # 定义一个命名空间
        #  sum((y_true - y_predict)^2) mean()
        with tf.variable_scope("losses"):

            # 求出损失
            # tf.reduce_mean 对列表中的数据求和之后求出平均值
            loss = tf.reduce_mean(tf.square(y_true - y_predict))

        return loss

    def sgd_op(self, loss):
        """
        利用梯度下降优化器去优化损失（优化模型参数）
        :param loss: 损失大小
        :return: 梯度下降OP
        """
        # 定义一个命名空间
        with tf.variable_scope("train_op"):

            train_op = tf.train.GradientDescentOptimizer(self.leaning_rate).minimize(loss)

        return train_op


    def train(self):
        """
        用于训练的函数
        :return: None
        """
        # 获取默认的图
        g = tf.get_default_graph()

        # 在默认图当中去做操作
        with g.as_default():

            # 进行训练
            # 1、获取数据
            x_data, y_true = self.inputs()

            # 2、利用模型得出预测结果
            y_predict = self.inference(x_data)

            # 3、损失计算
            loss = self.loss(y_true, y_predict)

            # 4、优化损失
            train_op = self.sgd_op(loss)

            # 开启回话去训练
            with tf.Session() as sess:

                # 初始化变量
                sess.run(tf.global_variables_initializer())

                # 创建events文件

                # 打印模型没有训练的初始化的参数
                print("模型初始化的参数权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))
                # 打印模型没有训练的初始化的参数
                print("第一次加载保存的模型参数变为权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))
                print("以模型当中的参数继续去进行训练")

                # 接下来？
                for i in range(500):
                    sess.run(train_op)
                    print("第 %d 步，总损失变化：%f , 模型优化参数权重：%f ,  偏置为：%f " % (
                        i,
                        loss.eval(),
                        self.weight.eval(),
                        self.bias.eval()
                    ))
if __name__ == '__main__':
    lr = MyLinearRegression()
    lr.train()

增加保存模型代码

import tensorflow as tf

# 实现线性回归训练
class MyLinearRegression(object):
    """
    实现线性回归训练
    """
    def __init__(self):
        self.leaning_rate = 0.01

    def inputs(self):
        """
        获取需要训练的数据
        :return:
        """
        # x: [100, 1]  y_true = x * 0.7 + 0.8
        x_data = tf.random_normal(shape=[100, 1], mean=0.0, stddev=1.0, name='x_data')

        # [100, 1] * [1, 1] = [100, 1]
        y_true = tf.matmul(x_data, [[0.7]]) + 0.8

        return x_data, y_true

    def inference(self, feature):
        """
        根据数据特征值，建立线性回归模型
        :param feature: 数据特征值 [100, 1]
        :return: y_predict
        """
        # 定义一个命名空间
        with tf.variable_scope("linear_model"):
            # w, b
            # x [100, 1] * w [1, 1] + b = y_predict
            # 随机初始化权重和偏置
            # 权重和偏置必须使用tf.Variable去定义，应为只有Variable才能被梯度下降所训练
            self.weight = tf.Variable(tf.random_normal(shape=[1, 1],
                                                       mean=0.0,
                                                       stddev=1.0),
                                      # trainable=False,
                                      name="weight")

            self.bias = tf.Variable(tf.random_normal(shape=[1],
                                                       mean=0.0,
                                                       stddev=1.0), name="bias")
            # 建立模型预测
            y_predict = tf.matmul(feature, self.weight) + self.bias

        return y_predict

    def loss(self, y_true, y_predict):
        """
        根据预测值和真实值求出均方误差损失
        :param y_true: 真实值
        :param y_predict: 预测值
        :return: loss
        """
        # 定义一个命名空间
        #  sum((y_true - y_predict)^2) mean()
        with tf.variable_scope("losses"):

            # 求出损失
            # tf.reduce_mean 对列表中的数据求和之后求出平均值
            loss = tf.reduce_mean(tf.square(y_true - y_predict))

        return loss

    def sgd_op(self, loss):
        """
        利用梯度下降优化器去优化损失（优化模型参数）
        :param loss: 损失大小
        :return: 梯度下降OP
        """
        # 定义一个命名空间
        with tf.variable_scope("train_op"):

            train_op = tf.train.GradientDescentOptimizer(self.leaning_rate).minimize(loss)

        return train_op
    def train(self):
        """
        用于训练的函数
        :return: None
        """
        # 获取默认的图
        g = tf.get_default_graph()

        # 在默认图当中去做操作
        with g.as_default():

            # 进行训练
            # 1、获取数据
            x_data, y_true = self.inputs()

            # 2、利用模型得出预测结果
            y_predict = self.inference(x_data)

            # 3、损失计算
            loss = self.loss(y_true, y_predict)

            # 4、优化损失
            train_op = self.sgd_op(loss)

            # 定义一个保存文件的saverOP
            saver = tf.train.Saver()

            # 开启回话去训练
            with tf.Session() as sess:

                # 初始化变量
                sess.run(tf.global_variables_initializer())

                # 打印模型没有训练的初始化的参数
                print("模型初始化的参数权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))

                # 加载模型，从模型当中找出与当前训练的模型代码当中（名字一样的OP操作）,覆盖原来的值
                ckpt = tf.train.latest_checkpoint("./tmp/model/")

                # 判断模型是否存在
                if ckpt:
                    saver.restore(sess, ckpt)

                # 打印模型没有训练的初始化的参数
                print("第一次加载保存的模型参数变为权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))
                print("以模型当中的参数继续去进行训练")

                # 接下来？
                for i in range(500):

                    sess.run(train_op)

                    print("第 %d 步，总损失变化：%f , 模型优化参数权重：%f ,  偏置为：%f " % (
                        i,
                        loss.eval(),
                        self.weight.eval(),
                        self.bias.eval()
                    ))

                    # 每隔100步保存一次模型
                    if i % 100 == 0:

                        # 要指定路径+名字
                        saver.save(sess,"./tmp/model/" )


if __name__ == '__main__':
    lr = MyLinearRegression()
    lr.train()

命令行参数使用

import tensorflow as tf
tf.app.flags.DEFINE_integer("tran_step", 0, "训练模型的步数")

tf.app.flags.DEFINE_string("model_dir", " ", "模型保存的路径")

FLAGS = tf.app.flags.FLAGS

# 实现线性回归训练
class MyLinearRegression(object):
    """
    实现线性回归训练
    """
    def __init__(self):
        self.leaning_rate = 0.01

    def inputs(self):
        """
        获取需要训练的数据
        :return:
        """
        # x: [100, 1]  y_true = x * 0.7 + 0.8
        x_data = tf.random_normal(shape=[100, 1], mean=0.0, stddev=1.0, name='x_data')

        # [100, 1] * [1, 1] = [100, 1]
        y_true = tf.matmul(x_data, [[0.7]]) + 0.8

        return x_data, y_true

    def inference(self, feature):
        """
        根据数据特征值，建立线性回归模型
        :param feature: 数据特征值 [100, 1]
        :return: y_predict
        """
        # 定义一个命名空间
        with tf.variable_scope("linear_model"):
            # w, b
            # x [100, 1] * w [1, 1] + b = y_predict
            # 随机初始化权重和偏置
            # 权重和偏置必须使用tf.Variable去定义，应为只有Variable才能被梯度下降所训练
            self.weight = tf.Variable(tf.random_normal(shape=[1, 1],
                                                       mean=0.0,
                                                       stddev=1.0),
                                      # trainable=False,
                                      name="weight")

            self.bias = tf.Variable(tf.random_normal(shape=[1],
                                                       mean=0.0,
                                                       stddev=1.0), name="bias")
            # 建立模型预测
            y_predict = tf.matmul(feature, self.weight) + self.bias

        return y_predict

    def loss(self, y_true, y_predict):
        """
        根据预测值和真实值求出均方误差损失
        :param y_true: 真实值
        :param y_predict: 预测值
        :return: loss
        """
        # 定义一个命名空间
        #  sum((y_true - y_predict)^2) mean()
        with tf.variable_scope("losses"):

            # 求出损失
            # tf.reduce_mean 对列表中的数据求和之后求出平均值
            loss = tf.reduce_mean(tf.square(y_true - y_predict))

        return loss

    def sgd_op(self, loss):
        """
        利用梯度下降优化器去优化损失（优化模型参数）
        :param loss: 损失大小
        :return: 梯度下降OP
        """
        # 定义一个命名空间
        with tf.variable_scope("train_op"):

            train_op = tf.train.GradientDescentOptimizer(self.leaning_rate).minimize(loss)

        return train_op
    def train(self):
        """
        用于训练的函数
        :return: None
        """
        # 获取默认的图
        g = tf.get_default_graph()

        # 在默认图当中去做操作
        with g.as_default():

            # 进行训练
            # 1、获取数据
            x_data, y_true = self.inputs()

            # 2、利用模型得出预测结果
            y_predict = self.inference(x_data)

            # 3、损失计算
            loss = self.loss(y_true, y_predict)

            # 4、优化损失
            train_op = self.sgd_op(loss)

            # 定义一个保存文件的saverOP
            saver = tf.train.Saver()

            # 开启回话去训练
            with tf.Session() as sess:

                # 初始化变量
                sess.run(tf.global_variables_initializer())

                # 打印模型没有训练的初始化的参数
                print("模型初始化的参数权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))

                # 加载模型，从模型当中找出与当前训练的模型代码当中（名字一样的OP操作）,覆盖原来的值
                ckpt = tf.train.latest_checkpoint("./tmp/model/")

                # 判断模型是否存在
                if ckpt:
                    saver.restore(sess, ckpt)

                # 打印模型没有训练的初始化的参数
                print("第一次加载保存的模型参数变为权重：%f ,  偏置为：%f " % (
                    self.weight.eval(),
                    self.bias.eval()
                ))
                print("以模型当中的参数继续去进行训练")

                # 接下来？
                for i in range(FLAGS.tran_step):

                    sess.run(train_op)

                    print("第 %d 步，总损失变化：%f , 模型优化参数权重：%f ,  偏置为：%f " % (
                        i,
                        loss.eval(),
                        self.weight.eval(),
                        self.bias.eval()
                    ))

                    # 每隔100步保存一次模型
                    if i % 100 == 0:

                        # 要指定路径+名字
                        saver.save(sess,FLAGS.model_dir)


if __name__ == '__main__':
    lr = MyLinearRegression()
    lr.train()

python day_14.py --tran_step=100 --model_dir='tmp/model'