tensorflow学习笔记--变量和模型保存加载

最新推荐文章于 2021-09-27 22:19:08 发布

Yohance0_0

最新推荐文章于 2021-09-27 22:19:08 发布

阅读量253

点赞数

分类专栏： tensorflow框架学习文章标签：深度学习

本文链接：https://blog.csdn.net/weixin_37411471/article/details/89790253

版权

tensorflow框架学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、变量的创建
1、变量也是一种op，是一种特殊的张量，能够进行存储持久化，它的值就是张量，默认被训练
2、注意事项
【1】变量能够持久化存储，而普通张量op是不行的
【2】当定义一个变量op的时候，一定要在会话中去运行初始化
【3】name参数：在tensorboard使用的时候显示名字，可以让相同op名字的进行区分

tf.Variable(initial_value=None,name=None,trainable=True)
# 创建一个带值initial_value新变量
assign(value)
# 为变量分配一个新值，返回新值
eval(session=None)
# 计算并返回此变量的值
# name属性表示变量的名字

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

a = tf.constant([1, 2, 3, 4, 5, 6])
var = tf.Variable(tf.random_normal([2, 3], mean=0.0, stddev=1.0))
print(a, var)
# 必须做一步显示的初始化
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
    # 必须运行初始化op
    sess.run(init_op)
    print(sess.run([a, var]))

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

a = tf.constant(3.0)
b = tf.constant(4.0)
c = tf.add(a,b)
var = tf.Variable(tf.random_normal([2, 3], mean=0.0, stddev=1.0))
print(a, var)
# 必须做一步显示的初始化
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
    # 必须运行初始化op
    sess.run(init_op)
    # 把程序的图结构写入到事件文件夹
    # graph 把指定的图写入到事件文件中
    filewriter = tf.summary.FileWriter("./",
                          graph=sess.graph)
    print(sess.run([c, var]))

在这里插入图片描述

3、变量的初始化、作用域
tf.variable_scope(<scope_name>)
创建指定名字的变量作用域
作用：让模型代码更加清晰，作用分明

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'


# 自实现一个线性回归预测
def myregression():
    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")
        y_true = tf.matmul(x, [[0.7]]) + 0.8
    with tf.variable_scope("model"):
        # 2、建立线性回归模型，1个特征，1个权重，1个偏置y = wx +b
        # 随机给一个权重和偏置的值，让她去计算损失，然后在当前状态下优化
        # 用变量定义才能优化,trainable参数:指定这个变量能跟着梯度下降一起优化

        weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0), name="w")
        bais = tf.Variable(0.0, name="b")
        y_predict = tf.matmul(x, weight) + bais

    with tf.variable_scope("loss"):
        # 3、建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4、梯度下降，优化损失,learning_rate 0~1
        train_op = tf.train.GradientDescentOptimizer(learning_rate=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(), bais.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test/", graph=sess.graph)

        # 循环训练优化
        for i in range(500):
            # 运行优化
            sess.run(train_op)
            print("第%d次优化的参数权重为：%f，偏置为：%f" % (i, weight.eval(), bais.eval()))

    return None


if __name__ == '__main__':
    myregression()

使用后在tensorboard显示的graph：
在这里插入图片描述
使用前在tensorboard显示的graph：
二、线性回归原理与实现
1、流程思路
（1）准备好特征值和目标值 100[100,1]
y=0.7*x+0.8
（2）建立模型，模型的参数必须用变量定义，随机初始化准备一个权重w，一个偏置b
y_predict = xw + b
（3）求损失函数，误差
均方误差：用公式去求
（4）梯度下降去优化损失的过程，指定学习率

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'


# 自实现一个线性回归预测
def myregression():
    # 1、准备数据，x特征量[100,1]y目标值[100]
    x = tf.random_normal([100, 1], mean=1.75, stddev=0.5, name="x_data")
    y_true = tf.matmul(x, [[0.7]]) + 0.8

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

    weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0), name="w")
    bais = tf.Variable(0.0, name="b")
    y_predict = tf.matmul(x, weight) + bais
    # 3、建立损失函数，均方误差
    loss = tf.reduce_mean(tf.square(y_true - y_predict))
    # 4、梯度下降，优化损失,learning_rate 0~1
    train_op = tf.train.GradientDescentOptimizer(learning_rate=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(), bais.eval()))
        # 循环训练优化
        for i in range(100):
            # 运行优化
            sess.run(train_op)
            print("第%d次优化的参数权重为：%f，偏置为：%f" % (i, weight.eval(), bais.eval()))

    return None


if __name__ == '__main__':
    myregression()

在这里插入图片描述
2、tensorflow运算API
矩阵运算
tf.matmul（x，w）
平方
tf.square（error）
均值
tf.reduce_mean（error）
梯度下降API（learning_rate学习率）
tf.train.GradientDescentOptimizer(learning_rate)
3、trainable参数:指定这个变量能跟着梯度下降一起优化
4、学习率、梯度爆炸

5、关于梯度爆炸/梯度消失
在极端的情况下，权重的值变得非常大，以至于溢出，导致NaN值
解决办法（深度神经网络（如RNN中更加容易出现））：
（1）重新设置网络
（2）调整学习率
（3）使用梯度截断（在训练的过程中检查和限制梯度的大小）
（4）使用激活函数
6、添加权重参数，损失值等在tensorboard观察的情况

（1）增加变量显示
目标：观察模型的参数、损失值等变量值的变化
1）收集变量

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

2）合并变量写入事件文件

merged = tf.summary.merge_all()
# 运行合并，每次迭代都需要运行
summary = sess.run(merged)
# 添加 i表示第几次的值
FileWriter.add_summary(summary,i)

3）模型的保存和加载
保存模型的文件：checkpoint文件，检查点文件

tf.train.Saver(var_list=None, max_to_keep=5)
var_list：指定将要保存和还原的变量，它可以作为一个dict或一个列表传递
max_to_keep：指示要保留的最近检查点文件的最大数量，创建新文件时，删除较旧的文件，如果无或者0，则保留所有的检查点文件，默认为5（即保留最新的五个检查点文件）

# 模型的保存
saver.save(sess,"./ckpt/model")
# 模型的加载
saver.restore(sess,"./ckpt/model")

4）

# 定义命令行参数
# 1、首先定义有哪些参数需要在运行的时候指定
# 2、程序当中获取定义命令行参数
# 第一个参数：名字、默认值、说明
tf.flags.DEFINE_integer()
tf.flags.DEFINE_string()
tf.flags.DEFINE_boolean()
tf.flags.DEFINE_float()

它支持应用从命令行接受参数，可以用来指定集群配置等
在tf.flags在flags中有一个FLAGS标志，它在程序中可以调用我们前面具体定义的flag_name

通过tf.app.run（）来启动main（argv）函数

总的代码：

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# 实现一个线性回归预测

tf.flags.DEFINE_integer("max_step", 100, "模型训练的步数")
tf.flags.DEFINE_string("model_dir", " ", "模型文件的加载路径")
FALGS = tf.flags.FLAGS


def myregression():
    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")
        y_true = tf.matmul(x, [[0.7]]) + 0.8
    with tf.variable_scope("model"):
        # 2、建立线性回归模型，1个特征，1个权重，1个偏置y = wx +b
        # 随机给一个权重和偏置的值，让她去计算损失，然后在当前状态下优化
        # 用变量定义才能优化,trainable参数:指定这个变量能跟着梯度下降一起优化

        weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0), name="w")
        bais = tf.Variable(0.0, name="b")
        y_predict = tf.matmul(x, weight) + bais

    with tf.variable_scope("loss"):
        # 3、建立损失函数，均方误差
        loss = tf.reduce_mean(tf.square(y_true - y_predict))
    with tf.variable_scope("optimizer"):
        # 4、梯度下降，优化损失,learning_rate 0~1
        train_op = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)
    # 1、收集tensor,合并变量写入事件文件
    tf.summary.scalar("losses", loss)
    tf.summary.histogram("weights", weight)
    # 定义合并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(), bais.eval()))
        # 建立事件文件
        filewriter = tf.summary.FileWriter("./test/", graph=sess.graph)
        # 加载模型，覆盖模型当中随机定义的参数，从上次训练的参数结果开始
        if os.path.exists("./ckpt/model/checkpoint"):
            saver.restore(sess, FALGS.model_dir)

        # 循环训练优化
        for i in range(FALGS.max_step):
            # 运行优化
            sess.run(train_op)
            # 运行合并的tensor
            summary = sess.run(merged)
            filewriter.add_summary(summary, i)
            print("第%d次优化的参数权重为：%f，偏置为：%f" % (i, weight.eval(), bais.eval()))
        saver.save(sess, FALGS.model_dir)

    return None


if __name__ == '__main__':
    myregression()