深度学习-线性回归基础-02

线性回归：

线性方程 y=kx+b

w12+w22+w33+w44+…w“n”*n
算法：线性回归
策略：均方误差
优化：梯度下降api（学习率）

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf

def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 1，准备数据,x特征值[100,1]   y目标值[100]
    x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
    # 矩阵相乘必须是二维的
    y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8

    # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
    # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
    # 用变量定义才能进行优化

    weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w")
    bias = tf.Variable(0.0,name="b")
    y_predict = tf.matmul(x,weight)+bias
    # 3,建立损失函数，均方误差
    loss = tf.reduce_mean(tf.square(y_true - y_predict))
    # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
    train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 循环训练 运行优化
        for i in range(200):
            sess.run(train_op)
            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


    return None

if __name__=="__main__":
    myregression()

tensorboard --logdir=“test” （test=你的路径）

作用域

让模型代码更加清晰，作用分明

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf

def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 建立作用域
    with tf.variable_scope("data"):
        # 1，准备数据,x特征值[100,1]   y目标值[100]
        x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
        # 矩阵相乘必须是二维的
        y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8
    with tf.variable_scope("model"):
        # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
        # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
        # 用变量定义才能进行优化
        # trainable参数：指定这个变量能否跟着梯度下降一起优化
        weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w",trainable=False)
        bias = tf.Variable(0.0,name="b")
        y_predict = tf.matmul(x,weight)+bias
    with tf.variable_scope("loos"):
        # 3,建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test",graph=sess.graph)
        # 循环训练 运行优化
        for i in range(200):
            sess.run(train_op)
            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


    return None

if __name__=="__main__":
    myregression()

增加变量显示

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf


# 1,训练参数问题：trainable
    # 学习率和步数的设置
# 2，添加权重值，损失值等在tensorboard观察情况
    # 1，收集变量 2，合并变量写入事件文件中
def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 建立作用域tf.variable_scope
    with tf.variable_scope("data"):
        # 1，准备数据,x特征值[100,1]   y目标值[100]
        x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
        # 矩阵相乘必须是二维的
        y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8
    with tf.variable_scope("model"):
        # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
        # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
        # 用变量定义才能进行优化
        # trainable参数：指定这个变量能否跟着梯度下降一起优化
        weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w",trainable=False)
        bias = tf.Variable(0.0,name="b")
        y_predict = tf.matmul(x,weight)+bias
    with tf.variable_scope("loos"):
        # 3,建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 1,收集tensor
    tf.summary.scalar("losses",loss)
    tf.summary.histogram("weights",weight)
    # 2，定义合并tensor的op
    merged = tf.summary.merge_all()


    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test",graph=sess.graph)
        # 循环训练 运行优化
        for i in range(500):
            sess.run(train_op)

            # 运行合并的tensor
            summary = sess.run(merged)
            filewriter.add_summary(summary,i)

            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


    return None

if __name__=="__main__":
    myregression()

模型的保存和加载

保存

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf


# 1,训练参数问题：trainable
    # 学习率和步数的设置
# 2，添加权重值，损失值等在tensorboard观察情况
    # 1，收集变量 2，合并变量写入事件文件中
def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 建立作用域tf.variable_scope
    with tf.variable_scope("data"):
        # 1，准备数据,x特征值[100,1]   y目标值[100]
        x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
        # 矩阵相乘必须是二维的
        y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8
    with tf.variable_scope("model"):
        # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
        # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
        # 用变量定义才能进行优化
        # trainable参数：指定这个变量能否跟着梯度下降一起优化
        weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w",trainable=False)
        bias = tf.Variable(0.0,name="b")
        y_predict = tf.matmul(x,weight)+bias
    with tf.variable_scope("loos"):
        # 3,建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 1,收集tensor
    tf.summary.scalar("losses",loss)
    tf.summary.histogram("weights",weight)
    # 2，定义合并tensor的op
    merged = tf.summary.merge_all()

    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()
    # 定义一个保存模型的实例
    saver = tf.train.Saver()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test",graph=sess.graph)

        # 循环训练 运行优化
        for i in range(500):
            sess.run(train_op)

            # 运行合并的tensor
            summary = sess.run(merged)
            filewriter.add_summary(summary,i)

            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


        saver.save(sess,"./ckpt/test_model") # 模型保存


    return None

if __name__=="__main__":
    myregression()

加载模型从上次结果开始训练

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf


# 1,训练参数问题：trainable
    # 学习率和步数的设置
# 2，添加权重值，损失值等在tensorboard观察情况
    # 1，收集变量 2，合并变量写入事件文件中
def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 建立作用域tf.variable_scope
    with tf.variable_scope("data"):
        # 1，准备数据,x特征值[100,1]   y目标值[100]
        x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
        # 矩阵相乘必须是二维的
        y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8
    with tf.variable_scope("model"):
        # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
        # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
        # 用变量定义才能进行优化
        # trainable参数：指定这个变量能否跟着梯度下降一起优化
        weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w",trainable=False)
        bias = tf.Variable(0.0,name="b")
        y_predict = tf.matmul(x,weight)+bias
    with tf.variable_scope("loos"):
        # 3,建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 1,收集tensor
    tf.summary.scalar("losses",loss)
    tf.summary.histogram("weights",weight)
    # 2，定义合并tensor的op
    merged = tf.summary.merge_all()

    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()
    # 定义一个保存模型的实例
    saver = tf.train.Saver()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test",graph=sess.graph)

        # 加载模型，覆盖模型当中随机定义的参数，从上次训练的参数结果开始
        if os.path.exists("./ckpt/checkpoint"): # 判断ckpt目录下是否存在checkpoint
            saver.restore(sess,"./ckpt/test_model") # 存在就加载模型


        # 循环训练 运行优化
        for i in range(500):
            sess.run(train_op)

            # 运行合并的tensor
            summary = sess.run(merged)
            filewriter.add_summary(summary,i)

            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


        saver.save(sess,"./ckpt/test_model") # 模型保存


    return None

if __name__=="__main__":
    myregression()

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告
import tensorflow as tf


# 1,训练参数问题：trainable
    # 学习率和步数的设置
# 2，添加权重值，损失值等在tensorboard观察情况
    # 1，收集变量 2，合并变量写入事件文件中
# 3，定义命令行参数
    # 1，首先定义有哪些参数需要在运行的时候指定
    # 2，程序当中获取定义命令行参数
# 第一参数：名字，默认值，说明
tf.flags.DEFINE_integer("max_step",100,"模型训练的步数")
tf.flags.DEFINE_string("model_dir"," ","模型的加载路径")
# 定义获取命令行参数的名字
FLAGS = tf.flags.FLAGS
def myregression():
    """
    自实现一个线性回归预测
    :return: 
    """
    # 建立作用域tf.variable_scope
    with tf.variable_scope("data"):
        # 1，准备数据,x特征值[100,1]   y目标值[100]
        x = tf.random_normal([100,1],mean=1.75,stddev=0.5,name="x_data") # 随机创建一个值 100行1列 平均值1.75 方差0.5 name是x_data
        # 矩阵相乘必须是二维的
        y_true = tf.matmul(x,[[0.7]]) + 0.8 # 假设偏置是0.8
    with tf.variable_scope("model"):
        # 2，建立线性回归模型1个特征，1个权重，一个偏置 y = x*w + b
        # 随机给一个权重和偏置的值，让他去计算损失，然后在当前状态下进行优化
        # 用变量定义才能进行优化
        # trainable参数：指定这个变量能否跟着梯度下降一起优化
        weight = tf.Variable(tf.random_normal([1,1],mean=0.0,stddev=1.0),name="w",trainable=False)
        bias = tf.Variable(0.0,name="b")
        y_predict = tf.matmul(x,weight)+bias
    with tf.variable_scope("loos"):
        # 3,建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4,梯度下降优化损失 leaning_rate:0--1,2,3,4,5
        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 1,收集tensor
    tf.summary.scalar("losses",loss)
    tf.summary.histogram("weights",weight)
    # 2，定义合并tensor的op
    merged = tf.summary.merge_all()

    # 定义一个初始化变量op
    init_op = tf.global_variables_initializer()
    # 定义一个保存模型的实例
    saver = tf.train.Saver()

    # 通过会话运行程序
    with tf.Session() as sess:  # 上下文管理器
        # 初始化变量
        sess.run(init_op)
        # 打印随机最先初始化的权重和偏置
        print("随机初始化的参数权重:%f，偏置为:%f"%(weight.eval(),bias.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test",graph=sess.graph)

        # 加载模型，覆盖模型当中随机定义的参数，从上次训练的参数结果开始
        if os.path.exists("./ckpt/checkpoint"): # 判断ckpt目录下是否存在checkpoint
            saver.restore(sess,FLAGS.model_dir) # 存在就加载模型


        # 循环训练 运行优化 步数
        for i in range(FLAGS.max_step):
            sess.run(train_op)

            # 运行合并的tensor
            summary = sess.run(merged)
            filewriter.add_summary(summary,i)

            print("第%d次优化后的参数权重:%f，偏置为:%f" % (i,weight.eval(), bias.eval()))


        saver.save(sess,FLAGS.model_dir) # 模型保存


    return None

if __name__=="__main__":
    myregression()

python 线性回归.py --max_step=300 --model_dir="/ckpt/model"