TensorFlow入门与线性回归-优快云博客

本文链接：https://blog.youkuaiyun.com/Michael_Cool/article/details/80530956

概览

认识Tensorflow
Tensorflow基础
Tensorfplw进阶
使用Tensorflow实现线性回归的实例

认知Tensorflow

人工智能，机器学习，深度学习的关系
- 人工智能是一种探究人类的智能活动的机理，用研究得出的理论，方法，技术，去构建智能体，这种智能体有着与人类相似的智能效果，能够像人类一样思考和行动，并进一步提升人的智能。机器学习是人工智能的实现手段，深度学习是其中一种人工神经网络技术的深度发展
深度学习
- 深度学习，是指人工神经网络的研究个应用
- 如深度神经网络，卷积神经网络和递归神经网络已经被应用到计算机视觉，语音识别，自然语言处理，音频识别与生物信息学领域并获得了极好的效果
Tensorflow
- Tensorflow是深度学习应用的框架，由谷歌公司开发，是目前最受欢迎的深度学习框架之一
- 特点：
  - 真正的可移植性：支持CPU,GPU,TPU,可以很好的运行在移动端
  - 多语言支持：c++/python
  - 高度灵活与效率
  - 大树下好乘凉：谷歌
安装：虚拟环境下：pip install tensorflow==版本号

Tensorflow基础

tensor + flow

tensor 是tensorflow中的特殊的数据类型，张量，类似numpy中的ndarry可以存储值,也可以存储操作，存储好之后是静态的，不能直接运行
需要在会话中run起来，张量之间的关系和作用像流水一样，流动起来
tensorflow是计算密集型框架，注意和django，flask,scrapy等IO密集型框架区分
示例：

...

# tensorflow实现加法运算

a_t = tf.constant(10)
b_t = tf.constant(20)

# 不提倡直接运用这种符号运算符进行计算


# 更常用tensorflow提供的函数进行计算


# c_t = a_t + b_t

c_t = tf.add(a_t, b_t)
print("tensorflow实现加法运算：\n", c_t)

# 如何让计算结果出现？


# 开启会话

with tf.Session() as sess:
    sum_t = sess.run(c_t)/Users/mengxing/Desktop/code/machine_learning/day08_tensorflow/linear_regression_tf.py
    print("在sess当中的sum_t:\n", sum_t)
...

Tensorflow进阶

图
会话
张量
变量

图

定义了程序的结构
tensorflow会默认生成一个图，由一组tensor(变量和操作)组成
调用
- tf.get_default_graph()
- operation,session,或者tenso的graph的 graph属性
也可以自定义图
- g = tf.Graph()
- 往图里添加操作
- with g.as_default():
不同的图之间不能互相访问
示例代码：

def graph_demo():
    # 图的演示
    a_t = tf.constant(10)
    b_t = tf.constant(20)
    # 不提倡直接运用这种符号运算符进行计算
    # 更常用tensorflow提供的函数进行计算
    # c_t = a_t + b_t
    c_t = tf.add(a_t, b_t)
    print("tensorflow实现加法运算：\n", c_t)

    # 获取默认图
    default_g = tf.get_default_graph()
    print("获取默认图：\n", default_g)

    # 数据的图属性
    print("a_t的graph:\n", a_t.graph)
    print("b_t的graph:\n", b_t.graph)
    # 操作的图属性
    print("c_t的graph:\n", c_t.graph)

    # 自定义图
    new_g = tf.Graph()
    print("自定义图：\n", new_g)
    # 在自定义图中去定义数据和操作
    with new_g.as_default():
        new_a = tf.constant(30)
        new_b = tf.constant(40)
        new_c = tf.add(new_a, new_b)

    # 数据的图属性
    print("new_a的graph:\n", new_a.graph)
    print("new_b的graph:\n", new_b.graph)
    # 操作的图属性
    print("new_c的graph:\n", new_c.graph)

    # 开启会话
    with tf.Session() as sess:
        sum_t = sess.run(c_t)
        print("在sess当中的sum_t:\n", sum_t)
        # 会话的图属性
        print("会话的图属性：\n", sess.graph)
        # 不同的图之间不能互相访问
        # sum_new = sess.run(new_c)
        # print("在sess当中的sum_new:\n", sum_new)

    with tf.Session(graph=new_g) as sess2:
        sum_new = sess2.run(new_c)
        print("在sess2当中的sum_new:\n", sum_new)
        print("会话的图属性：\n", sess2.graph)

    # 很少会同时开启不同的图，一般用默认的图就够了
    return None

会话

对资源的调度
默认调度默认图，也可以调度自定义图
使用格式
- 1.sess = tf.Session() sess.run(…) sess.close()
- 2.使用上下文管理器：
```
with tf.Session() as sess:
sess.run(...)
```
- 3.eval()，直接获取tensor的值，注意只有在开启的会话中才能使用
示例代码

def session_demo():
    """
    会话演示
    :return:
    """

    a_t = tf.constant(10)
    b_t = tf.constant(20)
    # 不提倡直接运用这种符号运算符进行计算
    # 更常用tensorflow提供的函数进行计算
    # c_t = a_t + b_t
    c_t = tf.add(a_t, b_t)
    print("tensorflow实现加法运算：\n", c_t)

    # 开启会话
    # 传统的会话定义
    # sess = tf.Session()
    # sum_t = sess.run(c_t)
    # print("sum_t:\n", sum_t)
    # sess.close()

    # 开启会话
    with tf.Session() as sess:
        # sum_t = sess.run(c_t)
        # 想同时执行多个tensor
        print(sess.run([a_t, b_t, c_t]))
        # 方便获取张量值的方法
        # print("在sess当中的sum_t:\n", c_t.eval())
        # 会话的图属性
        print("会话的图属性：\n", sess.graph)

    return None

def session_run_demo():
    """
    会话的run方法
    :return:
    """
    # 定义占位符
    a = tf.placeholder(tf.float32)
    b = tf.placeholder(tf.float32)
    sum_ab = tf.add(a, b)
    print("sum_ab:\n", sum_ab)
    # 开启会话
    with tf.Session() as sess:
        print("占位符的结果：\n", sess.run(sum_ab, feed_dict={a: 3.0, b: 4.0}))
    return None

交互式对话

在ipython等测试代码效果解释器中，不用每次都要写会话语句的快捷方式
tf.interactiveSession()
示例代码：

ipython环境中：
import tensorflow as tf
td.interactiveSession()
a = tf.constant(3.0)
a.eval()
out:3.0

b = tf.constant(4.0)
c = tf.multiply(a,b)
c.eval()
out:12.0

张量

张量是tensorflow管理数据的形式。从功能上讲，可以简单理解为多维数据
一个张量包含三部分信息
- 名字，形状，数据类型
- 张量的阶
  - 相当于数组的维的概念
  - 0阶对应0维数组，标量
  - 1阶对应一维数组，列表/向量
  - 2阶对应二维数组，矩阵
示例代码：

def tensor_demo():
    """
    张量的介绍
    :return:
    """
    a = tf.constant(value=30.0, dtype=tf.float32, name="a")
    b = tf.constant([[1, 2], [3, 4]], dtype=tf.int32, name="b")
    a2 = tf.constant(value=30.0, dtype=tf.float32, name="a2")
    c = tf.placeholder(dtype=tf.float32, shape=[2, 3, 4], name="c")
    sum = tf.add(a, a2, name="my_add")
    print(a, a2, b, c)
    print(sum)
    # 获取张量属性
    print("a的图属性：\n", a.graph)
    print("b的名字：\n", b.name)
    print("a2的形状：\n", a2.shape)
    print("c的数据类型：\n", c.dtype)
    print("sum的op:\n", sum.op)

    # 获取静态形状
    print("b的静态形状：\n", b.get_shape())

    # 定义占位符
    a_p = tf.placeholder(dtype=tf.float32, shape=[None, None])
    b_p = tf.placeholder(dtype=tf.float32, shape=[None, 10])
    c_p = tf.placeholder(dtype=tf.float32, shape=[3, 2])
    # 获取静态形状
    print("a_p的静态形状为：\n", a_p.get_shape())
    print("b_p的静态形状为：\n", b_p.get_shape())
    print("c_p的静态形状为：\n", c_p.get_shape())

    # 形状更新
    # a_p.set_shape([2, 3])
    # 静态形状已经固定部分就不能修改了
    # b_p.set_shape([10, 3])
    # c_p.set_shape([2, 3])
    # 静态形状已经固定的部分包括它的阶数，如果阶数固定了，就不能跨阶更新形状
    # 如果想要跨阶改变形状，就要用动态形状
    # a_p.set_shape([1, 2, 3])
    # 获取静态形状
    print("a_p的静态形状为：\n", a_p.get_shape())
    print("b_p的静态形状为：\n", b_p.get_shape())
    print("c_p的静态形状为：\n", c_p.get_shape())

    # 动态形状
    # c_p_r = tf.reshape(c_p, [1, 2, 3])
    c_p_r = tf.reshape(c_p, [2, 3])
    # 动态形状，改变的时候，不能改变元素的总个数
    # c_p_r2 = tf.reshape(c_p, [3, 1])
    print("动态形状的结果：\n", c_p_r)
    # print("动态形状的结果2：\n", c_p_r2)
    return None

变量

变量是一种特殊的张量，用来保存需要更新的参数，需要指定初始化值进行初始化
创建
- tf.Variable(initial_value=None, name= None, trainable=True):创建一个带值initial_value的新变量
- assign(value):为变量分配一个新值，返回新值
- eval(sesson=None):计算并返回此变量的值
初始化
- tf.global_variables_initializer():添加一个初始化所有变量的op,在会话中开启
示例代码：

def variable_demo():
    """
    变量的演示
    :return:
    """
    # 定义变量
    a = tf.Variable(initial_value=30)
    b = tf.Variable(initial_value=40)
    sum = tf.add(a, b)

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

    # 开启会话
    with tf.Session() as sess:
        # 变量初始化
        sess.run(init)
        print("sum:\n", sess.run(sum))

    return None

tensorboard

可视化查看tensor的flow过程
使用步骤
- 数据序列化
- 写入事件到指定目录
- 开启
示例代码：

def tensorboard_demo():
    """
    TensorBoard可视化演示
    :return:
    """
    # 定义变量
    a = tf.Variable(initial_value=30, name="a")
    b = tf.Variable(initial_value=40, name="b")
    sum = tf.add(a, b, name="sum")

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

    # 开启会话
    with tf.Session() as sess:
        # 变量初始化
        sess.run(init)
        print("sum:\n", sess.run(sum))
        tf.summary.FileWriter(logdir="./tmp/summary", graph=sess.graph)
    return None

在终端输入：
tensorboard    --logdir=“/tmp/tensorflow/summary/test/”

在浏览器：
127.0.0.1:6006

线性回归实例

代码：

import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'



def linear_regression1():
    """
    自实现一个线性回归
    :return:
    """
    # 1、准备好训练集：造一个真实数据
    # 100样本 x_true (100, 1)
    # y_true = 0.7*x_true + 0.8
    # x_true = tf.Variable(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
    # tf.constant传参 value或者list
    # x_true = tf.constant(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
    x_true = tf.random_normal(shape=[100, 1], mean=2, stddev=3)
    # (100, 1) * (1, 1) = (100, 1)
    y_true = tf.matmul(x_true, [[0.7]]) + 0.8

    # 2、构造模型
    # 定义权重值和偏置值
    weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    # 变量的trainable参数如果为False，就不能被更新迭代
    # weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), trainable=False)
    bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    # (100, 1) * (1, 1)
    y_predict = tf.matmul(x_true, weights) + bias

    # 3、构造损失函数
    # 求平均(y_predict - y_true)^2 —— 均方误差
    loss = tf.reduce_mean(tf.square(y_predict - y_true))

    # 4、梯度下降优化
    # 学习率的选择 选择合适的学习率，防止梯度爆炸
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
    # optimizer = tf.train.GradientDescentOptimizer(learning_rate=5).minimize(loss)

    # 初始化全局变量
    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(500):
            sess.run(optimizer)
            print("第%d次训练的误差为：%f, 权重值为：%f, 偏置值为：%f" % (i+1, loss.eval(), weights.eval(), bias.eval()))

    return None


def linear_regression2():
    """
    对代码1增加功能，添加变量显示
    :return:
    """
    # 1、准备好训练集：造一个真实数据
    # 100样本 x_true (100, 1)
    # y_true = 0.7*x_true + 0.8
    # x_true = tf.Variable(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
    # tf.constant传参 value或者list
    # x_true = tf.constant(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
    x_true = tf.random_normal(shape=[100, 1], mean=2, stddev=3)
    # (100, 1) * (1, 1) = (100, 1)
    y_true = tf.matmul(x_true, [[0.7]]) + 0.8

    # 2、构造模型
    # 定义权重值和偏置值
    weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    # 变量的trainable参数如果为False，就不能被更新迭代
    # weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), trainable=False)
    bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    # (100, 1) * (1, 1)
    y_predict = tf.matmul(x_true, weights) + bias

    # 3、构造损失函数
    # 求平均(y_predict - y_true)^2 —— 均方误差
    loss = tf.reduce_mean(tf.square(y_predict - y_true))

    # 4、梯度下降优化
    # 学习率的选择 选择合适的学习率，防止梯度爆炸
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
    # optimizer = tf.train.GradientDescentOptimizer(learning_rate=5).minimize(loss)

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

    # 3）合并收集到的变量
    merged = 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="./linear_model/summary", graph=sess.graph)

        # 循环使用优化器
        for i in range(500):
            sess.run(optimizer)
            print("第%d次训练的误差为：%f, 权重值为：%f, 偏置值为：%f" % (i+1, loss.eval(), weights.eval(), bias.eval()))
            # 4）运行合并收集变量op
            if i % 10 == 0:
                summary = sess.run(merged)
                file_writer.add_summary(summary, i)

    return None

def linear_regression3():
    """
    对代码2增加功能，添加作用域
    :return:
    """

    with tf.variable_scope("prepare_data"):
        # 1、准备好训练集：造一个真实数据
        # 100样本 x_true (100, 1)
        # y_true = 0.7*x_true + 0.8
        # x_true = tf.Variable(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        # tf.constant传参 value或者list
        # x_true = tf.constant(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        x_true = tf.random_normal(shape=[100, 1], mean=2, stddev=3, name="x_data")
        # (100, 1) * (1, 1) = (100, 1)
        y_true = tf.matmul(x_true, [[0.7]]) + 0.8

    with tf.variable_scope("create_model"):
        # 2、构造模型
        # 定义权重值和偏置值
        weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="w")
        # 变量的trainable参数如果为False，就不能被更新迭代
        # weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), trainable=False)
        bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="b")
        # (100, 1) * (1, 1)
        y_predict = tf.matmul(x_true, weights) + bias


    with tf.variable_scope("loss"):
        # 3、构造损失函数
        # 求平均(y_predict - y_true)^2 —— 均方误差
        loss = tf.reduce_mean(tf.square(y_predict - y_true))

    with tf.variable_scope("gd_optimizer"):
        # 4、梯度下降优化
        # 学习率的选择 选择合适的学习率，防止梯度爆炸
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
        # optimizer = tf.train.GradientDescentOptimizer(learning_rate=5).minimize(loss)

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

    # 3）合并收集到的变量
    merged = 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="./linear_model/summary", graph=sess.graph)

        # 循环使用优化器
        for i in range(500):
            sess.run(optimizer)
            print("第%d次训练的误差为：%f, 权重值为：%f, 偏置值为：%f" % (i+1, loss.eval(), weights.eval(), bias.eval()))
            # 4）运行合并收集变量op
            if i % 10 == 0:
                summary = sess.run(merged)
                file_writer.add_summary(summary, i)

    return None



def linear_regression4():
    """
    对代码3增加功能，添加模型保存和加载
    :return:
    """

    with tf.variable_scope("prepare_data"):
        # 1、准备好训练集：造一个真实数据
        # 100样本 x_true (100, 1)
        # y_true = 0.7*x_true + 0.8
        # x_true = tf.Variable(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        # tf.constant传参 value或者list
        # x_true = tf.constant(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        x_true = tf.random_normal(shape=[100, 1], mean=2, stddev=3, name="x_data")
        # (100, 1) * (1, 1) = (100, 1)
        y_true = tf.matmul(x_true, [[0.7]]) + 0.8

    with tf.variable_scope("create_model"):
        # 2、构造模型
        # 定义权重值和偏置值
        weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="w")
        # 变量的trainable参数如果为False，就不能被更新迭代
        # weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), trainable=False)
        bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="b")
        # (100, 1) * (1, 1)
        y_predict = tf.matmul(x_true, weights) + bias


    with tf.variable_scope("loss"):
        # 3、构造损失函数
        # 求平均(y_predict - y_true)^2 —— 均方误差
        loss = tf.reduce_mean(tf.square(y_predict - y_true))

    with tf.variable_scope("gd_optimizer"):
        # 4、梯度下降优化
        # 学习率的选择 选择合适的学习率，防止梯度爆炸
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
        # optimizer = tf.train.GradientDescentOptimizer(learning_rate=5).minimize(loss)

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

    # 3）合并收集到的变量
    merged = tf.summary.merge_all()

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

    # 实例化一个Saver对象
    saver = tf.train.Saver()

    # 开启会话
    with tf.Session() as sess:
        # 运行初始化变量op
        sess.run(init)
        # 未训练前的权重值和偏置值
        print("未训练前的权重值为%f, 偏置值为%f" % (weights.eval(), bias.eval()))

        # 1）实例化事件文件对象
        file_writer = tf.summary.FileWriter(logdir="./linear_model/summary", graph=sess.graph)

        # 加载模型
        if os.path.exists("./linear_model/linear_regression/checkpoint"):
            saver.restore(sess, "./linear_model/linear_regression/my_model")

        # 循环使用优化器
        for i in range(500):
            sess.run(optimizer)
            print("第%d次训练的误差为：%f, 权重值为：%f, 偏置值为：%f" % (i+1, loss.eval(), weights.eval(), bias.eval()))
            # 4）运行合并收集变量op
            summary = sess.run(merged)
            file_writer.add_summary(summary, i)
            if i % 10 == 0:
                # 保存模型
                saver.save(sess, "./linear_model/linear_regression/my_model")

    return None

tf.app.flags.DEFINE_string("model_path", "./linear_model/linear_regression/my_model", "模型地址")
tf.app.flags.DEFINE_string("name", "abc", "名字")

FLAGS = tf.app.flags.FLAGS

def linear_regression5():
    """
    对代码4增加功能，添加自定义命令行参数
    :return:
    """

    with tf.variable_scope("prepare_data"):
        # 1、准备好训练集：造一个真实数据
        # 100样本 x_true (100, 1)
        # y_true = 0.7*x_true + 0.8
        # x_true = tf.Variable(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        # tf.constant传参 value或者list
        # x_true = tf.constant(tf.random_normal(shape=[100, 1], mean=2, stddev=3))
        x_true = tf.random_normal(shape=[100, 1], mean=2, stddev=3, name="x_data")
        # (100, 1) * (1, 1) = (100, 1)
        y_true = tf.matmul(x_true, [[0.7]]) + 0.8

    with tf.variable_scope("create_model"):
        # 2、构造模型
        # 定义权重值和偏置值
        weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="w")
        # 变量的trainable参数如果为False，就不能被更新迭代
        # weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), trainable=False)
        bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="b")
        # (100, 1) * (1, 1)
        y_predict = tf.matmul(x_true, weights) + bias


    with tf.variable_scope("loss"):
        # 3、构造损失函数
        # 求平均(y_predict - y_true)^2 —— 均方误差
        loss = tf.reduce_mean(tf.square(y_predict - y_true))

    with tf.variable_scope("gd_optimizer"):
        # 4、梯度下降优化
        # 学习率的选择 选择合适的学习率，防止梯度爆炸
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
        # optimizer = tf.train.GradientDescentOptimizer(learning_rate=5).minimize(loss)

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

    # 3）合并收集到的变量
    merged = tf.summary.merge_all()

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

    # 实例化一个Saver对象
    saver = tf.train.Saver()

    # 开启会话
    with tf.Session() as sess:
        # 运行初始化变量op
        sess.run(init)
        # 未训练前的权重值和偏置值
        print("未训练前的权重值为%f, 偏置值为%f" % (weights.eval(), bias.eval()))

        # 1）实例化事件文件对象
        file_writer = tf.summary.FileWriter(logdir="./linear_model/summary", graph=sess.graph)

        # 加载模型
        if os.path.exists("./linear_model/linear_regression"):
            saver.restore(sess, FLAGS.model_path)

        # 循环使用优化器
        for i in range(500):
            sess.run(optimizer)
            print("第%d次训练的误差为：%f, 权重值为：%f, 偏置值为：%f" % (i+1, loss.eval(), weights.eval(), bias.eval()))
            # 4）运行合并收集变量op
            summary = sess.run(merged)
            file_writer.add_summary(summary, i)
            if i % 10 == 0:
                # 保存模型
                saver.save(sess, FLAGS.model_path)

    return None

def main(argv):
    print("argv:\n", argv)

    print("自定义命令行参数model_path：\n", FLAGS.model_path)
    print("name:\n", FLAGS.name)
    return None


if __name__ == "__main__":
    # 代码1：自实现一个线性回归
    # linear_regression1()
    # 代码2：对代码1增加功能，添加变量显示
    # linear_regression2()
    # 代码3：对代码2增加功能，添加作用域
    # linear_regression3()
    # 代码4：对代码3增加功能，添加模型保存和加载
    # linear_regression4()
    # 代码5：对代码4增加功能，添加自定义命令行参数
    # linear_regression5()
    tf.app.run()