tensorflow模型持久化保存和加载--深度学习-神经网络

2024-04-07 18:33•php•阅读 4574

模型文件的保存

tensorflow将模型保持到本地会生成4个文件：

meta文件：保存了网络的图结构，包含变量、op、集合等信息

ckpt文件：二进制文件，保存了网络中所有权重、偏置等变量数值，分为两个文件，一个是.data-00000-of-00001 文件，一个是 .index 文件

checkpoint文件：文本文件，记录了最新保持的5个模型文件列表

tf中模型保存使用 tf.train.Saver类来保存模型。使用方式：

1. 在Session外生成一个模型保存对象

saver = tf.train.Saver()

2. 在Session中以当前环境Session为参数，保存模型到本地磁盘

saver.save(sess,"./model/Model_test")

Saver类的构造函数定义：

def __init__(self,

var_list=None,

reshape=False,

sharded=False,

max_to_keep=5,

keep_checkpoint_every_n_hours=10000.0,

name=None,

restore_sequentially=False,

saver_def=None,

builder=None,

defer_build=False,

allow_empty=False,

write_version=saver_pb2.SaverDef.V2,

pad_step_number=False,

save_relative_paths=False,

filename=None):

常用的几个变量：

var_list：指定要保存的变量的序列或字典，默认为None，保存所有变量

reshape：可选参数，如果为True，表示允许变量以不同的形状保存，如果为False，表示保持的变量只能有同样一种形状和数据类型，默认为False;

max_to_keep：定义最多保存最近的多少个模型文件，默认是5个;

keep_checkpoint_every_n_hours：定义多少个小时保存模型一次，默认10000个小时;

name：可选参数，添加到操作名称前的前缀，默认None;

restore_sequentially：定义在设备上是否按照顺序恢复变量，顺序恢复可以降低内参使用，默认False;

saver_def：可选参数，用在需要重建Saver对象场合，默认None;

allow_empty：是否允许保存一个没有任何变量的空图，默认False;

saver.save函数定义：

def save(self,

sess,

save_path,

global_step=None,

latest_filename=None,

meta_graph_suffix="meta",

write_meta_graph=True,

write_state=True,

strip_default_attrs=False):

常用参数：

sess：当前的会话环境;

save_path: 模型保存路径;

global_step：训练轮次，如果添加，会在模型文件名称后加上这个轮次的后缀，默认None，不添加，最好设置这个参数，要不然模型文件就会由于重名覆盖掉之前保存的;

latest_filename： checkpoint文本文件的名称，默认为‘checkpoint’

meta_graph_suffix：保存的网络图结构文件的后缀，默认为mata;

write_meta_graph：定义是否保存网络结构，默认是True保存，由于网络结构在训练过程中是不会变的，所以保存过一次后可以设置 write_meta_graph为False，不用每次都保存图结构;

简单示例，以下程序中 X和Y是一个含有128个元素的列表，每个元素是一个二维数组，定义公式 Y = (X*w1+b1)*(w2)+b2 ，使用tensorflow网络迭代求 w和b 的最优解，完成之后保持模型到本地 model_test 文件夹。

# -*- coding: utf-8 -*-)

import tensorflow as tf

from numpy.random import RandomState

# 定义训练数据batch的大小

batch_size = 8

# 在shape上使用None表示该维度的具体数值不定

x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')

y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')

# 定义神经网络的参数

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))

w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

bias1 = tf.Variable(tf.random_normal([3], stddev=1, seed=1))

bias2 = tf.Variable(tf.random_normal([1], stddev=1, seed=1))

# 定义神经网络前向传播的过程，即操作

a = tf.nn.relu(tf.matmul(x, w1) + bias1)

y = tf.nn.relu(tf.matmul(a, w2) + bias2)

# 定义损失函数和反向传播算法

loss = tf.reduce_sum(tf.pow((y - y_), 2))

train_step = tf.train.AdamOptimizer(0.001).minimize(loss) # 梯度下降优化算法

# produce the data，通过随机数生成一个模拟数据集

rdm = RandomState(seed=1) # 设置seed = 1 ，使每次生成的随机数一样

dataset_size = 128

X = rdm.rand(dataset_size, 2)

Y = [[x1 + 10 * x2] for (x1, x2) in X]

# 生成一个保持模型对象

saver = tf.train.Saver()

# creare a session，创建一个会话来运行TensorFlow程序

with tf.Session() as sess:

# 初始化变量

sess.run(tf.global_variables_initializer())

# 设定训练的轮数

STEPS = 10000

for i in range(STEPS + 1):

# get batch_size samples data to train，每次选取batch_size个样本进行训练

start = (i * batch_size) % dataset_size

end = min(start + batch_size, dataset_size)

# 通过选取的样本训练神经网络并更新参数

sess.run(train_step, feed_dict={x: X[start: end], y_: Y[start: end]})

if i % 500 == 0:

# 每隔一段时间计算在所有数据上的loss并输出

total_cross_entropy= sess.run([loss], feed_dict={x: X, y_: Y})

print ("steps: {}, total loss: {}".format(i,total_cross_entropy))

# 在训练结束之后，保持神经网络模型

saver.save(sess, "./model_saved/model_test")

print sess.run((w1,bias1))

print('^^^^^^^^^^^^^^^^^^^^^^^^^')

print sess.run((w2,bias2))

# output:

# steps: 0, total loss: [2599.938]

# steps: 500, total loss: [873.66064]

# steps: 1000, total loss: [667.79114]

# steps: 1500, total loss: [483.07538]

# steps: 2000, total loss: [300.2436]

# steps: 2500, total loss: [159.57596]

# steps: 3000, total loss: [74.0152]

# steps: 3500, total loss: [30.022282]

# steps: 4000, total loss: [10.848581]

# steps: 4500, total loss: [3.8684735]

# steps: 5000, total loss: [1.6775348]

# steps: 5500, total loss: [0.87090385]

# steps: 6000, total loss: [0.47393078]

# steps: 6500, total loss: [0.2628175]

# steps: 7000, total loss: [0.13229856]

# steps: 7500, total loss: [0.058554076]

# steps: 8000, total loss: [0.022747971]

# steps: 8500, total loss: [0.007896027]

# steps: 9000, total loss: [0.002599821]

# steps: 9500, total loss: [0.0007222026]

# steps: 10000, total loss: [0.00021833208]

# (array([[-0.8113182 , 0.741788 , -0.06654923],

# [-2.4427042 , 1.7258024 , 3.505848 ]], dtype=float32), array([-0.8113182 , 0.9206883 , -0.00473781], dtype=float32))

# ^^^^^^^^^^^^^^^^^^^^^^^^^

# (array([[-0.8113182],

# [ 1.5360606],

# [ 2.0962803]], dtype=float32), array([-1.4044524], dtype=float32))

经过10000次迭代之后完成训练，在本地model_test目录下创建了模型的4个文件：

模型文件的加载

模型文件的图结构跟数据是分开保存的，加载模型时候可以先加载图结构，再加载图中的参数(在Session中操作)：

saver=tf.train.import_meta_graph('./model_saved/model_test.meta')

saver.restore(sess, tf.train.latest_checkpoint('./model_saved'))

或者一次性加载：

saver = tf.train.Saver()

saver.restore(sess, './model_saved/model_test')

或：

saver.restore(sess, tf.train.latest_checkpoint('./model_saved'))

‘model_test’是保存的模型文件名称（前缀名，不带后缀）

更加安全一点的加载方式，先判断模型文件是否存在判断（推荐使用这种方式）：

ckpt = tf.train.get_checkpoint_state('./model_saved')

if ckpt and ckpt.model_checkpoint_path:

saver.restore(sess, ckpt.model_checkpoint_path)

# -*- coding: utf-8 -*-)

import tensorflow as tf

from numpy.random import RandomState

# 定义训练数据batch的大小

batch_size = 8

# 在shape上使用None表示该维度的具体数值不定

x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')

y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')

# 定义神经网络的参数

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))

w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

bias1 = tf.Variable(tf.random_normal([3], stddev=1, seed=1))

bias2 = tf.Variable(tf.random_normal([1], stddev=1, seed=1))

# 定义神经网络前向传播的过程，即操作

a = tf.nn.relu(tf.matmul(x, w1) + bias1)

y = tf.nn.relu(tf.matmul(a, w2) + bias2)

# produce the data，通过随机数生成一个模拟数据集

rdm = RandomState(seed=1) # 设置seed = 1 ，使每次生成的随机数一样

dataset_size = 128

X = rdm.rand(dataset_size, 2)

Y = [[x1 + 10 * x2] for (x1, x2) in X]

# creare a session，创建一个会话来运行TensorFlow程序

with tf.Session() as sess:

saver = tf.train.import_meta_graph('./model_saved/model_test.meta')

saver.restore(sess, tf.train.latest_checkpoint('./model_saved'))

# 初始化变量

sess.run(tf.global_variables_initializer())

print(sess.run(y,feed_dict={x: X[0: 10], y_: Y[0: 10]}))

# output:

# [[2.4518511]

# [1.4534602]

# [1.7382364]

# [1.8725655]

# [2.3733683]

# [2.4501202]

# [2.0117776]

# [1.582149 ]

# [2.4224167]

# [1.7438407]]

tf.train.Saver常用函数列表：

操作描述

类tf.train.Saver(Saving and Restoring Variables)

tf.train.Saver.__init__(var_list=None, reshape=False,

sharded=False, max_to_keep=5,

keep_checkpoint_every_n_hours=10000.0,

name=None, restore_sequentially=False,

saver_def=None, builder=None) 创建一个存储器Saver

var_list定义需要存储和恢复的变量

tf.train.Saver.save(sess, save_path, global_step=None,

latest_filename=None, meta_graph_suffix=’meta’,

write_meta_graph=True) 保存变量

tf.train.Saver.restore(sess, save_path) 恢复变量

tf.train.Saver.last_checkpoints 列出最近未删除的checkpoint 文件名

tf.train.Saver.set_last_checkpoints(last_checkpoints) 设置checkpoint文件名列表

tf.train.Saver.set_last_checkpoints_with_time(last_checkpoints_with_time) 设置checkpoint文件名列表和时间戳

---------------------

上一篇 »React-Native 中将 redux中的数据持久化
下一篇 »debian iptables持久化

tensorflow模型持久化保存和加载--深度学习-神经网络

相关推荐

Lua数据持久化

ubuntu使用iptables 持久化

Python基于TensorFlow接口实现深度学习神经网络回归

Tensorflow2.1 完成权重或模型的保存和加载

tensorflow 基础学习七：模型的持久化

一文详解GO如何实现Redis的AOF持久化？

TensorFlow模型加载与保存 - 影醉阏轩窗

Tensorflow模型保存与加载