使用tensorflow训练模型后，把模型的所有参数保存下来，后面，直接使用就好。
首先，创建一个tf.train.Saver对象
保存所有参数：Saver 对象的 save() 函数
使用已保存的模型：Saver 对象的 restore() 函数
tensorflow API:
save(
sess,
save_path,
global_step=None,
latest_filename=None,
meta_graph_suffix='meta',
write_meta_graph=True,
write_state=True,
strip_default_attrs=False
)
saver.save(sess, 'my-model', global_step=0) ==> filename: 'my-model-0saver.save(sess, 'my-model', global_step=1000) ==> filename: 'my-model-1000'
(第一个参数，是训练模型时的session；第二个参数，是模型保存成的文件名；第三个参数可以省略，它可以给文件名加入一个step的信息)
restore( sess,
save_path
)(第一个参数，是训练模型时的session；第二个参数，是模型保存成的文件)
代码例子1：
import tensorflow as tf
import numpy as np
x = tf.placeholder(tf.float32, shape=[None, 1])
y = 4 * x + 4
w = tf.Variable(tf.random_normal([1], -1, 1))
b = tf.Variable(tf.zeros([1]))
y_predict = w * x + b
loss = tf.reduce_mean(tf.square(y - y_predict))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
isTrain = False
train_steps = 100
checkpoint_steps = 50
checkpoint_dir = 'myModelG'
saver = tf.train.Saver() # defaults to saving all variables - in this case w and b
x_data = np.reshape(np.random.rand(10).astype(np.float32), (10, 1))
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
if isTrain:
for i in range(train_steps):
sess.run(train, feed_dict={x: x_data})
if (i + 1) % checkpoint_steps == 0:
# saver.save(sess, checkpoint_dir + 'model.ckpt', global_step=i+1)
saver.save(sess, 'myModelG/model.ckpt', global_step=i + 1)
else:
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
pass
print(sess.run(w))
print(sess.run(b))
value = 3 * w + b
rrr = sess.run(value)
print(rrr)代码例子2：
import tensorflow as tf
import numpy as np
# 训练数据
Train_dataPath = 'F:\\A_Noise_20180130\\CNN\\trainingdata\\data.log'
Train_labelPath = 'F:\\A_Noise_20180130\\CNN\\trainingdata\\labels.log'
# 测试数据
Test_dataPath = 'F:\\A_Noise_20180130\\CNN\\testingdata1\\data.log'
Test_labelPath = 'F:\\A_Noise_20180130\\CNN\\testingdata1\\labels.log'
isTrain = False
train_steps = 100
checkpoint_steps = 100
checkpoint_dir = 'myModelC'
tData = []
tLable = []
with open(Train_dataPath) as file:
for line in file:
lineVal = line.strip().split(',')
val = [float(u) for u in lineVal]
tData.append(val)
with open(Train_labelPath) as file:
for line in file:
lineVal = line.strip().split(',')
val = [int(u) for u in lineVal]
tLable.append(val)
testData = []
testLable = []
with open(Test_dataPath) as file:
for line in file:
lineVal = line.strip().split(',')
val = [float(u) for u in lineVal]
testData.append(val)
with open(Test_labelPath) as file:
for line in file:
lineVal = line.strip().split(',')
val = [int(u) for u in lineVal]
testLable.append(val)
tData = np.array(tData)
tLable = np.array(tLable)
testData = np.array(testData)
testLable = np.array(testLable)
# one_hot 独热码的编码（encoding）形式
# 噪声 : 10
# 非噪声: 01
# None 表示张量（Tensor）的第一个维度可以是任何长度
input_x = tf.placeholder(tf.float32, [None, 200]) # 输入
output_y = tf.placeholder(tf.int32, [None, 2]) # 输出：标签
input_x_images = tf.reshape(input_x, [-1, 200, 1]) # 改变形状之后的输入
# 从 Test（测试）数据集里选取 3000 个手写数字的图片和对应标签
test_x = testData # 图片
test_y = testLable # 标签
# 构建我们的卷积神经网络：
# 第 1 层卷积
conv1 = tf.layers.conv1d(
inputs=input_x_images, # 形状 [200, 1]
filters=32, # 32 个过滤器，输出的深度（depth）是32
kernel_size=[5], # 过滤器在二维的大小是(5 * 1)
strides=1, # 步长是1
padding='same', # same 表示输出的大小不变，因此需要在外围补零 2 圈
activation=tf.nn.relu # 激活函数是 Relu
) # 形状 [200, 32]
# 第 1 层池化（亚采样）
pool1 = tf.layers.max_pooling1d(
inputs=conv1, # 形状 [28, 28, 32]
pool_size=[2], # 过滤器在二维的大小是（2 * 1）
strides=2 # 步长是 2
) # 形状 [100, 32]
# 第 2 层卷积
conv2 = tf.layers.conv1d(
inputs=pool1, # 形状 [14, 14, 32]
filters=64, # 64 个过滤器，输出的深度（depth）是64
kernel_size=[5], # 过滤器在二维的大小是(5 * 1)
strides=1, # 步长是1
padding='same', # same 表示输出的大小不变，因此需要在外围补零 2 圈
activation=tf.nn.relu # 激活函数是 Relu
) # 形状 [100, 64]
# 第 2 层池化（亚采样）
pool2 = tf.layers.max_pooling1d(
inputs=conv2, # 形状 [100, 64]
pool_size=[2], # 过滤器在二维的大小是（2 * 1）
strides=2 # 步长是 2
) # 形状 [50, 64]
# 平坦化（flat）
flat = tf.reshape(pool2, [-1, 50 * 64]) # 形状 [7 * 7 * 64, ]
# 1024 个神经元的全连接层
dense = tf.layers.dense(inputs=flat, units=1024, activation=tf.nn.relu)
# Dropout : 丢弃 50%, rate=0.5
dropout = tf.layers.dropout(inputs=dense, rate=0.5)
# 2 个神经元的全连接层，这里不用激活函数来做非线性化了
logits = tf.layers.dense(inputs=dropout, units=2) # 输出。形状[1, 1, 2]
# 计算误差（计算 Cross entropy（交叉熵），再用 Softmax 计算百分比概率）
loss = tf.losses.softmax_cross_entropy(onehot_labels=output_y, logits=logits)
# Adam 优化器来最小化误差，学习率 0.001
train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
# 精度。计算 预测值 和 实际标签 的匹配程度
# 返回(accuracy, update_op), 会创建两个局部变量
accuracy = tf.metrics.accuracy(
labels=tf.argmax(output_y, axis=1),
predictions=tf.argmax(logits, axis=1),)[1]
saver = tf.train.Saver() # defaults to saving all variables
with tf.Session() as sess:
# 初始化变量：全局和局部
init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
sess.run(init)
if isTrain:
for i in range(300):
# batch = mnist.train.next_batch(50) # 从 Train（训练）数据集里取“下一个” 50 个样本
# train_loss, train_op = sess.run([loss, train_op], {input_x: batch[0], output_y: batch[1]})
train_loss, train_op_ = sess.run([loss, train_op], {input_x: tData, output_y: tLable})
if i % 100 == 0:
test_accuracy = sess.run(accuracy, {input_x: test_x, output_y: test_y})
print(("Step=%d, Train loss=%.4f, [Test accuracy=%.2f]") % (i, train_loss, test_accuracy))
# 存储模型参数
if (i + 1) % checkpoint_steps == 0:
# saver.save(sess, checkpoint_dir + 'model.ckpt', global_step=i+1)
saver.save(sess, 'myModelC/model.ckpt', global_step=i + 1)
else:
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
pass
# 测试：打印 20 个预测值 和 真实值 的对
# test_output = sess.run(logits, {input_x: test_x[:20]})
test_output = sess.run(logits, {input_x: test_x[1980:2020]})
inferenced_y = np.argmax(test_output, 1)
print(inferenced_y, 'Inferenced numbers') # 推测的数字
print(np.argmax(test_y[1980:2020], 1), 'Real numbers') # 真实的数字