从保存的张量流变量进行预测答案

【问题标题】：Prediction from saved tensorflow variables从保存的张量流变量进行预测
【发布时间】：2020-04-14 19:00:29
【问题描述】：

我对 phyton 编程非常陌生。我在训练时保存了 tensorflow 神经网络：

n_hidden_1 =200
n_hidden_2 =100 # 1st layer num features
n_hidden_3 = 100 # 2nd layer num features
n_input = 128  n_output = 128

X = tf.placeholder("float", [None, n_input])
Y = tf.placeholder("float", [None, n_output])

def encoder(x):
    weights = {                    
        'encoder_w1': tf.Variable(tf.random.truncated_normal([n_input, n_hidden_1],stddev=0.1),name='encoder_w1'),
        'encoder_w2': tf.Variable(tf.random.truncated_normal([n_hidden_1, n_hidden_2],stddev=0.1),name='encoder_w2'),
        'encoder_w3': tf.Variable(tf.random.truncated_normal([n_hidden_2, n_hidden_3],stddev=0.1),name='encoder_w3'),
        'encoder_w4': tf.Variable(tf.random.truncated_normal([n_hidden_3, n_output],stddev=0.1),name='encoder_w4'),            
    }

    biases = {            
        'encoder_b1': tf.Variable(tf.random.truncated_normal([n_hidden_1],stddev=0.1),name='encoder_b1'),
        'encoder_b2': tf.Variable(tf.random.truncated_normal([n_hidden_2],stddev=0.1),name='encoder_b2'),
        'encoder_b3': tf.Variable(tf.random.truncated_normal([n_hidden_3],stddev=0.1),name='encoder_b3'),
        'encoder_b4': tf.Variable(tf.random.truncated_normal([n_output],stddev=0.1),name='encoder_b4'),          
    }

    # Encoder Hidden layer with sigmoid activation #1
    #layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']), biases['encoder_b1']))
    layer_1 = tf.nn.relu(tf.add(tf.matmul(x, weights['encoder_w1']), biases['encoder_b1']))
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, weights['encoder_w2']), biases['encoder_b2']))
    layer_3 = tf.nn.relu(tf.add(tf.matmul(layer_2, weights['encoder_w3']), biases['encoder_b3']))
    layer_4 = tf.nn.sigmoid(tf.add(tf.matmul(layer_3, weights['encoder_w4']), biases['encoder_b4']))
    return layer_4

y_pred = encoder(X)
y_true = Y

# Define loss and optimizer, minimize the squared error
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
learning_rate = tf.placeholder(tf.float32, shape=[])
optimizer = tf.train.RMSPropOptimizer(learning_rate=learning_rate).minimize(cost)

saver = tf.train.Saver(max_to_keep=1) 
with tf.Session(config=config) as sess:

  sess.run(init)
  traing_epochs = 100
  learning_rate_current = 0.001   #0.01

  for epoch in range(traing_epochs):

> # Code Block.................

input_labels.append(x) 
input_samples.append(y)
batch_x = np.asarray(input_samples)
batch_y = np.asarray(input_labels

 _,c = sess.run([optimizer,cost], feed_dict={X:batch_x, Y:batch_y, learning_rate:learning_rate_current})

训练后，我将训练后的网络打印变量加载为：

with tf.Session() as sess2:
  saver2= tf.train.import_meta_graph('../my_model.ckpt.meta')
  saver2.restore(sess2,'../my_model.ckpt')
savevariable=tf.all_variables()

我在训练后看到保存的变量，存在 48 个变量（为什么 8 个初始参数增加到 48 个值我不明白）我有 4 个权重和 4 个偏差用于第 1 层、第 2 层和第 3 层以及第 4 层的初始值.为了预测我应该从这个保存的值中使用哪个 4 个权重和 4 个偏差？我很困惑。在此处打印保存变量：

 <tf.Variable 'encoder_w1:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w2:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w4:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_b1:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4:0' shape=(128,) dtype=float32_ref>,
 <tf.Variable 'encoder_w1/RMSProp:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w1/RMSProp_1:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w2/RMSProp:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w2/RMSProp_1:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3/RMSProp:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3/RMSProp_1:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w4/RMSProp:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_w4/RMSProp_1:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_b1/RMSProp:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b1/RMSProp_1:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2/RMSProp:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2/RMSProp_1:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3/RMSProp:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3/RMSProp_1:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4/RMSProp:0' shape=(128,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4/RMSProp_1:0' shape=(128,) dtype=float32_ref>,
 <tf.Variable 'encoder_w1:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w2:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w4:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_b1:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4:0' shape=(128,) dtype=float32_ref>,
 <tf.Variable 'encoder_w1/RMSProp:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w1/RMSProp_1:0' shape=(128, 200) dtype=float32_ref>,
 <tf.Variable 'encoder_w2/RMSProp:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w2/RMSProp_1:0' shape=(200, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3/RMSProp:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w3/RMSProp_1:0' shape=(100, 100) dtype=float32_ref>,
 <tf.Variable 'encoder_w4/RMSProp:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_w4/RMSProp_1:0' shape=(100, 128) dtype=float32_ref>,
 <tf.Variable 'encoder_b1/RMSProp:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b1/RMSProp_1:0' shape=(200,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2/RMSProp:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b2/RMSProp_1:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3/RMSProp:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b3/RMSProp_1:0' shape=(100,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4/RMSProp:0' shape=(128,) dtype=float32_ref>,
 <tf.Variable 'encoder_b4/RMSProp_1:0' shape=(128,) dtype=float32_ref>

你能给我建议吗？

【问题讨论】：

您的问题必须是可重现的，所以请提供一些简单的工作代码和示例数据，您接受过培训。

标签： python tensorflow deep-learning artificial-intelligence

【解决方案1】：

首先你犯了一个错误：

input_labels.append(x) 
input_samples.append(y)

应该是：

input_samples.append(x)
input_labels.append(y)

回答您的问题：

实际上你应该有 24 个变量（见下文），但是当你开始第二个会话时，原始的 Tensorflow 变量仍然存在，并且新加载的变量已在这些变量上创建。所以做这样的事情总是好的：

tf.keras.backend.clear_session()

你的batch定义有点问题，所以我也在我的示例代码中修复了它：

注意： OP 在我回答时没有提供可重现的示例，因此我根据初始数据创建了一个基础并根据 OP 的问题对其进行了评论：

导入所有模块

import numpy as np
from numpy import random as random
import tensorflow as tf

tf.compat.v1.disable_eager_execution()

清除所有会话数据，这些数据很容易在交互环境中累积。

tf.keras.backend.clear_session()

定义我们稍后需要的所有元素：

X_train = random.rand(100, 128)
y_train = random.rand(100, 128)

n_hidden_1 =200
n_hidden_2 =100 # 1st layer num features
n_hidden_3 = 100 # 2nd layer num features
n_input = 128  
n_output = 128

X = tf.compat.v1.placeholder("float", [None, n_input])
Y = tf.compat.v1.placeholder("float", [None, n_output])

def encoder(x):
    weights = {                    
        'encoder_w1': tf.Variable(tf.random.truncated_normal([n_input, n_hidden_1],stddev=0.1),name='encoder_w1'),
        'encoder_w2': tf.Variable(tf.random.truncated_normal([n_hidden_1, n_hidden_2],stddev=0.1),name='encoder_w2'),
        'encoder_w3': tf.Variable(tf.random.truncated_normal([n_hidden_2, n_hidden_3],stddev=0.1),name='encoder_w3'),
        'encoder_w4': tf.Variable(tf.random.truncated_normal([n_hidden_3, n_output],stddev=0.1),name='encoder_w4'),            
    }

    biases = {            
        'encoder_b1': tf.Variable(tf.random.truncated_normal([n_hidden_1],stddev=0.1),name='encoder_b1'),
        'encoder_b2': tf.Variable(tf.random.truncated_normal([n_hidden_2],stddev=0.1),name='encoder_b2'),
        'encoder_b3': tf.Variable(tf.random.truncated_normal([n_hidden_3],stddev=0.1),name='encoder_b3'),
        'encoder_b4': tf.Variable(tf.random.truncated_normal([n_output],stddev=0.1),name='encoder_b4'),          
    }

    # Encoder Hidden layer with sigmoid activation #1
    #layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']), biases['encoder_b1']))
    layer_1 = tf.nn.relu(tf.add(tf.matmul(x, weights['encoder_w1']), biases['encoder_b1']))
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, weights['encoder_w2']), biases['encoder_b2']))
    layer_3 = tf.nn.relu(tf.add(tf.matmul(layer_2, weights['encoder_w3']), biases['encoder_b3']))
    layer_4 = tf.nn.sigmoid(tf.add(tf.matmul(layer_3, weights['encoder_w4']), biases['encoder_b4']))
    return layer_4


y_pred = encoder(X)
y_true = Y

# Define loss and optimizer, minimize the squared error
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
learning_rate = tf.compat.v1.placeholder(tf.float32, shape=[])
optimizer = tf.compat.v1.train.RMSPropOptimizer(learning_rate=learning_rate).minimize(cost)

saver = tf.compat.v1.train.Saver(max_to_keep=1) 
init = tf.compat.v1.global_variables_initializer()

开始培训课程：

with tf.compat.v1.Session() as sess:
    sess.run(init)

    traing_epochs = 100
    learning_rate_current = 0.001   #0.01
    # define batch size
    batch_size = 10
    num_samples = (X_train.shape[0])

    # starting training loop
    for epoch in range(traing_epochs):
        print("Epoch " + str(epoch))

        # starting per batch training loop
        for i in range(int(num_samples/batch_size)):
            print("{}/{}".format(batch_size * i, num_samples))

            # get batches
            batch_x = X_train[i * batch_size:(i + 1) * batch_size]
            batch_y = y_train[i * batch_size:(i + 1) * batch_size]
            _,c = sess.run([optimizer,cost], 
                           feed_dict={X: batch_x, Y: batch_y,
                                      learning_rate: learning_rate_current})
    saver.export_meta_graph('../my_model.ckpt.meta')
    saver.save(sess, '../my_model.ckpt')

输出：

清除所有以前的会话数据，同时删除 tensorflow 变量

tf.keras.backend.clear_session()

重新加载之前保存的会话：

init = tf.compat.v1.global_variables_initializer()
with tf.compat.v1.Session() as sess2:
    sess2.run(init)
    saver2 = tf.compat.v1.train.import_meta_graph('../my_model.ckpt.meta')
    saver2.restore(sess2,'../my_model.ckpt')
    savevariable = tf.compat.v1.all_variables()

for i, variable in enumerate(savevariable):
    print("Variable {}: {}".format(i, variable))

解释我们的输出：

Out:
INFO:tensorflow:Restoring parameters from ../my_model.ckpt

您预期的 8 个权重和偏差变量：

Variable 0: <tf.Variable 'encoder_w1:0' shape=(128, 200) dtype=float32>
Variable 1: <tf.Variable 'encoder_w2:0' shape=(200, 100) dtype=float32>
Variable 2: <tf.Variable 'encoder_w3:0' shape=(100, 100) dtype=float32>
Variable 3: <tf.Variable 'encoder_w4:0' shape=(100, 128) dtype=float32>
Variable 4: <tf.Variable 'encoder_b1:0' shape=(200,) dtype=float32>
Variable 5: <tf.Variable 'encoder_b2:0' shape=(100,) dtype=float32>
Variable 6: <tf.Variable 'encoder_b3:0' shape=(100,) dtype=float32>
Variable 7: <tf.Variable 'encoder_b4:0' shape=(128,) dtype=float32>

2 x 8 权重和偏差变量作为优化器的累加器变量，我们可以重新加载实际的优化器状态以从该状态继续：

Variable 8: <tf.Variable 'encoder_w1/RMSProp:0' shape=(128, 200) dtype=float32>
Variable 9: <tf.Variable 'encoder_w1/RMSProp_1:0' shape=(128, 200) dtype=float32>
Variable 10: <tf.Variable 'encoder_w2/RMSProp:0' shape=(200, 100) dtype=float32>
Variable 11: <tf.Variable 'encoder_w2/RMSProp_1:0' shape=(200, 100) dtype=float32>
Variable 12: <tf.Variable 'encoder_w3/RMSProp:0' shape=(100, 100) dtype=float32>
Variable 13: <tf.Variable 'encoder_w3/RMSProp_1:0' shape=(100, 100) dtype=float32>
Variable 14: <tf.Variable 'encoder_w4/RMSProp:0' shape=(100, 128) dtype=float32>
Variable 15: <tf.Variable 'encoder_w4/RMSProp_1:0' shape=(100, 128) dtype=float32>
Variable 16: <tf.Variable 'encoder_b1/RMSProp:0' shape=(200,) dtype=float32>
Variable 17: <tf.Variable 'encoder_b1/RMSProp_1:0' shape=(200,) dtype=float32>
Variable 18: <tf.Variable 'encoder_b2/RMSProp:0' shape=(100,) dtype=float32>
Variable 19: <tf.Variable 'encoder_b2/RMSProp_1:0' shape=(100,) dtype=float32>
Variable 20: <tf.Variable 'encoder_b3/RMSProp:0' shape=(100,) dtype=float32>
Variable 21: <tf.Variable 'encoder_b3/RMSProp_1:0' shape=(100,) dtype=float32>
Variable 22: <tf.Variable 'encoder_b4/RMSProp:0' shape=(128,) dtype=float32>
Variable 23: <tf.Variable 'encoder_b4/RMSProp_1:0' shape=(128,) dtype=float32>

更新回答 OP 的其他问题：

这些变量是初始值还是上次更新后的值？会话已保存？：

这些是我们在重新加载后打印出来的最后更新值。

事实上，确切的一点是，当我在另一个中重新加载会话时 python 文件，我想预测训练后网络的输出变量。我应该使用从变量 0 到变量 7 的变量还是我应该使用 16 个优化器累加器变量吗？

当您将使用重新加载的模型参数进行预测时，您将只需要前 8 个变量，其他变量仅用于继续训练。

关于优化器的状态变量：它取决于给定的优化器，例如它可以是iteration 和momentum 等。

【讨论】：