关于深度学习:深度学习TensorFlow实现线性回归代码演示全md文档笔记代码文档已分享

本系列文章 md 笔记（已分享）次要探讨深度学习相干常识。能够让大家熟练掌握机器学习根底, 如分类、回归（含代码），熟练掌握 numpy,pandas,sklearn 等框架应用。在算法上，把握神经网络的数学原理，手动实现简略的神经网络构造，在利用上熟练掌握 TensorFlow 框架应用，把握神经网络图像相干案例。具体包含：TensorFlow 的数据流图构造，神经网络与 tf.keras，卷积神经网络 (CNN)，商品物体检测我的项目介绍，YOLO 与 SSD，商品检测数据集训练和模型导出与部署。

全套笔记和代码自取移步 gitee 仓库：gitee 仓库获取残缺文档和代码

感兴趣的小伙伴能够自取哦，欢送大家点赞转发~

共 9 章，60 子模块

TensorFlow 介绍

 阐明 TensorFlow 的数据流图构造
利用 TensorFlow 操作图
说明会话在 TensorFlow 程序中的作用
利用 TensorFlow 实现张量的创立、形态类型批改操作
利用 Variable 实现变量 op 的创立
利用 Tensorboard 实现图构造以及张量值的显示
利用 tf.train.saver 实现 TensorFlow 的模型保留以及加载
利用 tf.app.flags 实现命令行参数增加和应用
利用 TensorFlow 实现线性回归 

2.7 案例：实现线性回归

学习指标

• 指标

  • 利用 op 的 name 参数实现 op 的名字批改
  • 利用 variable_scope 实现图程序作用域的增加
  • 利用 scalar 或 histogram 实现张量值的跟踪显示
  • 利用 merge_all 实现张量值的合并
  • 利用 add_summary 实现张量值写入文件
  • 利用 tf.train.saver 实现 TensorFlow 的模型保留以及加载
  • 利用 tf.app.flags 实现命令行参数增加和应用
  • 利用 reduce_mean、square 实现均方误差计算
  • 利用 tf.train.GradientDescentOptimizer 实现有梯度降落优化器创立
  • 利用 minimize 函数优化损失
  • 晓得梯度爆炸以及常见解决技巧

• 利用

  • 实现线性回归模型

• 内容预览

  • 2.7.1 线性回归原理温习
  • 2.7.2 案例：实现线性回归的训练

  • 2.7.3 减少其余性能

    • 1 减少变量显示
    • 2 减少命名空间
    • 3 模型的保留与加载
    • 4 命令行参数应用

2.7.1 线性回归原理温习

依据数据建设回归模型，w1x1+w2x2+…..+b = y，通过实在值与预测值之间建设误差，应用梯度降落优化失去损失最小对应的权重和偏置。最终确定模型的权重和偏置参数。最初能够用这些参数进行预测。

2.7.2 案例：实现线性回归的训练

1 案例确定

• 假如随机指定 100 个点，只有一个特色

• 数据自身的散布为 y = 0.8 * x + 0.7

  这里将数据分布的法则确定，是为了使咱们训练出的参数跟实在的参数（即 0.8 和 0.7）比拟是否训练精确

2 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

3 步骤剖析

• 1 筹备好数据集：y = 0.8x + 0.7 100 个样本

• 2 建设线性模型

  • 随机初始化 W1 和 b1
  • y = W·X + b，指标：求出权重 W 和偏置 b
• 3 确定损失函数（预测值与实在值之间的误差）- 均方误差
• 4 梯度降落优化损失：须要指定学习率（超参数）

4 实现残缺性能

import tensorflow as tf
import os

def linear_regression():
    """
    自实现线性回归
    :return: None
    """
    # 1）筹备好数据集：y = 0.8x + 0.7 100 个样本
    # 特征值 X, 目标值 y_true
    X = tf.random_normal(shape=(100, 1), mean=2, stddev=2)
    # y_true [100, 1]
    # 矩阵运算 X（100，1）*（1, 1）= y_true(100, 1)
    y_true = tf.matmul(X, [[0.8]]) + 0.7
    # 2）建设线性模型：# y = W·X + b，指标：求出权重 W 和偏置 b
    # 3）随机初始化 W1 和 b1
    weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)))
    bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)))
    y_predict = tf.matmul(X, weights) + bias
    # 4）确定损失函数（预测值与实在值之间的误差）- 均方误差
    error = tf.reduce_mean(tf.square(y_predict - y_true))
    # 5）梯度降落优化损失：须要指定学习率（超参数）# W2 = W1 - 学习率 *(方向)
    # b2 = b1 - 学习率 *(方向)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)

    # 初始化变量
    init = tf.global_variables_initializer()
    # 开启会话进行训练
    with tf.Session() as sess:
        # 运行初始化变量 Op
        sess.run(init)
        print("随机初始化的权重为 %f，偏置为 %f" % (weights.eval(), bias.eval()))
        # 训练模型
        for i in range(100):
            sess.run(optimizer)
            print("第 %d 步的误差为 %f，权重为 %f，偏置为 %f" % (i, error.eval(), weights.eval(), bias.eval()))

    return None

6 变量的 trainable 设置察看

trainable 的参数作用，指定是否训练

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

2.7.3 减少其余性能

• 减少命名空间
• 命令行参数设置

2 减少命名空间

是代码构造更加清晰，Tensorboard 图构造分明

with tf.variable_scope("lr_model"):

def linear_regression():
    # 1）筹备好数据集：y = 0.8x + 0.7 100 个样本
    # 特征值 X, 目标值 y_true
    with tf.variable_scope("original_data"):
        X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")
        # y_true [100, 1]
        # 矩阵运算 X（100，1）*（1, 1）= y_true(100, 1)
        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_predict = tf.matmul(X, weights, name="model_matmul") + bias
    # 4）确定损失函数（预测值与实在值之间的误差）- 均方误差
    with tf.variable_scope("loss"):
        error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")
    # 5）梯度降落优化损失：须要指定学习率（超参数）# W2 = W1 - 学习率 *(方向)
    # b2 = b1 - 学习率 *(方向)
    with tf.variable_scope("gd_optimizer"):
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)

    # 2）收集变量
    tf.summary.scalar("error", error)
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bias", bias)

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

    # 初始化变量
    init = tf.global_variables_initializer()
    # 开启会话进行训练
    with tf.Session() as sess:
        # 运行初始化变量 Op
        sess.run(init)
        print("随机初始化的权重为 %f，偏置为 %f" % (weights.eval(), bias.eval()))
        # 1）创立事件文件
        file_writer = tf.summary.FileWriter(logdir="./summary", graph=sess.graph)
        # 训练模型
        for i in range(100):
            sess.run(optimizer)
            print("第 %d 步的误差为 %f，权重为 %f，偏置为 %f" % (i, error.eval(), weights.eval(), bias.eval()))
            # 4）运行合并变量 op
            summary = sess.run(merge)
            file_writer.add_summary(summary, i)

    return None

3 模型的保留与加载

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

4 命令行参数应用

• 1、
• 2、tf.app.flags., 在 flags 有一个 FLAGS 标记，它在程序中能够调用到咱们

后面具体定义的 flag_name

• 3、通过 tf.app.run() 启动 main(argv) 函数

  
  
# 定义一些罕用的命令行参数
  
  
  
  
# 训练步数
  
  
tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
  
  
# 定义模型的门路
  
  
tf.app.flags.DEFINE_string("model_dir", ""," 模型保留的门路 + 模型名字 ")

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

  
  
# 开启训练
  
  
  
  
# 训练的步数（根据模型大小而定）for i in range(FLAGS.max_step):
     sess.run(train_op)

残缺代码

import tensorflow as tf
import os

tf.app.flags.DEFINE_string("model_path", "./linear_regression/", "模型保留的门路和文件名")
FLAGS = tf.app.flags.FLAGS


def linear_regression():
    # 1）筹备好数据集：y = 0.8x + 0.7 100 个样本
    # 特征值 X, 目标值 y_true
    with tf.variable_scope("original_data"):
        X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")
        # y_true [100, 1]
        # 矩阵运算 X（100，1）*（1, 1）= y_true(100, 1)
        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_predict = tf.matmul(X, weights, name="model_matmul") + bias
    # 4）确定损失函数（预测值与实在值之间的误差）- 均方误差
    with tf.variable_scope("loss"):
        error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")
    # 5）梯度降落优化损失：须要指定学习率（超参数）# W2 = W1 - 学习率 *(方向)
    # b2 = b1 - 学习率 *(方向)
    with tf.variable_scope("gd_optimizer"):
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)

    # 2）收集变量
    tf.summary.scalar("error", error)
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bias", bias)

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

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

    # 开启会话进行训练
    with tf.Session() as sess:
        # 运行初始化变量 Op
        sess.run(init)
        # 未经训练的权重和偏置
        print("随机初始化的权重为 %f，偏置为 %f" % (weights.eval(), bias.eval()))
        # 当存在 checkpoint 文件，就加载模型

        # 1）创立事件文件
        file_writer = tf.summary.FileWriter(logdir="./summary", graph=sess.graph)
        # 训练模型
        for i in range(100):
            sess.run(optimizer)
            print("第 %d 步的误差为 %f，权重为 %f，偏置为 %f" % (i, error.eval(), weights.eval(), bias.eval()))
            # 4）运行合并变量 op
            summary = sess.run(merge)
            file_writer.add_summary(summary, i)

    return None


def main(argv):
    print("这是 main 函数")
    print(argv)
    print(FLAGS.model_path)
    linear_regression()

if __name__ == "__main__":
    tf.app.run()

作业：将面向过程改为面向对象

参考代码

  
  
# 用 tensorflow 自实现一个线性回归案例
  
  

  
  
# 定义一些罕用的命令行参数
  
  
  
  
# 训练步数
  
  
tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
  
  
# 定义模型的门路
  
  
tf.app.flags.DEFINE_string("model_dir", ""," 模型保留的门路 + 模型名字 ")

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):
        """
        依据输出数据建设模型
        :param feature:
        :param label:
        :return:
        """with tf.variable_scope("linea_model"):
            # 2、建设回归模型，剖析他人的数据的特色数量 ---> 权重数量，偏置 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

    def loss(self, y_true, y_predict):
        """
        目标值和实在值计算损失
        :return: loss
        """
        # 3、求出咱们模型跟实在数据之间的损失
        # 均方误差公式
        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:
        """
        # 4、应用梯度降落优化器优化
        # 填充学习率：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()))

                # 开启训练
                # 训练的步数（根据模型大小而定）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 __name__ == '__main__':
    lr = MyLinearRegression()
    lr.train()

未完待续，同学们请期待下一期

全套笔记和代码自取移步 gitee 仓库：gitee 仓库获取残缺文档和代码

感兴趣的小伙伴能够自取哦，欢送大家点赞转发~