如何在tensorflow中使用保存的模型[重复]

Question

首先，我按照人们的指示尝试恢复模型，但我还没有找到任何线索。 以下是我保存模型的代码，模型已成功保存。

import tensorflow as tf
from sklearn.utils import shuffle
EPOCHS = 10
BATCH_SIZE = 128

x = tf.placeholder(tf.float32, (None, 32, 32, 3),name='x')
y = tf.placeholder(tf.int32, (None),name='y')
one_hot_y = tf.one_hot(y, 43)

rate = 0.001

logits = LeNet(x)
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)
loss_operation = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate = rate)
training_operation = optimizer.minimize(loss_operation)

correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))
accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()

def evaluate(TrainX, trainLabels):
    num_examples = len(TrainX)
    total_accuracy = 0
    sess = tf.get_default_session()
    for offset in range(0, num_examples, BATCH_SIZE):
        batch_x, batch_y = TrainX[offset:offset+BATCH_SIZE], trainLabels[offset:offset+BATCH_SIZE]
        accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y})
        total_accuracy += (accuracy * len(batch_x))
    return total_accuracy / num_examples

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    num_examples = len(trainImages)

    print("Training...")
    print()
    for i in range(EPOCHS):
        TrainX, trainLabels = shuffle(TrainX, trainLabels)
        for offset in range(0, num_examples, BATCH_SIZE):
            end = offset + BATCH_SIZE
            batch_x, batch_y = TrainX[offset:end], trainLabels[offset:end]
            sess.run(training_operation, feed_dict={x: batch_x, y: batch_y})

        validation_accuracy = evaluate(TrainX, trainLabels)
        print("EPOCH {} ...".format(i+1))
        print("Validation Accuracy = {:.3f}".format(validation_accuracy))
        print()

    saver.save(sess, './lenet')
    print("Model saved")

培训...

时代 1 ... 验证准确度 = 0.765

时代 2 ... 验证准确度 = 0.911

第三纪元 ... 验证准确度 = 0.933

纪元 4 ... 验证准确度 = 0.958

纪元 5 ... 验证准确度 = 0.965

第 6 纪元 ... 验证准确度 = 0.973

纪元 7 ... 验证准确度 = 0.978

第 8 纪元 ... 验证准确度 = 0.986

纪元 9 ... 验证准确度 = 0.985

纪元 10 ... 验证准确度 = 0.980

模型已保存

我的问题是当我放置新的测试数据时如何使用此模型，假设我放置了 5 个测试数据以查看它们在经过训练模型时的准确度。我想看看正确适合训练模型的测试数据和标签的准确性。感谢您抽出宝贵时间，如果您有不明白的地方，我愿意为您提供更多详细信息。

Answer 1

简而言之，我建议使用tf.data 和tf.saved_model API。有 2 种机制：tf.train.Saver() 或基于前一种机制的更高级别的 API tf.saved_model。您可以在其他帖子中找到差异link1link2。我试图为您编写后者的伪代码，但我最终想出了所有以下 sn-ps。希望对你有帮助：

培训部分：

# create list of file names: ['0.csv', '1.csv', ...]
totrain_features = [os.path.join('./TrainX/', f) for f in os.listdir('./TrainX/') if f.endswith('.csv')]
totrain_img = [os.path.join('./TrainLabels/', f) for f in os.listdir('./TrainLabels/') if f.endswith('.csv')]
epoch_length = len(totrain_features)

# model starts here
file_names_ph = tf.placeholder(tf.string, shape=(None), name='file_name_ph') #create a ph to put list of file paths
in_pipeline = input_pipeline(file_names_ph) # check standalone code below
nodes = model(in_pipeline['img_next_op'], in_pipeline['label_next_op'])


with tf.Session() as sess:
    sess.run([tf.global_variables_initializer(), in_pipeline['iter_init_op']], feed_dict={file_names_ph: totrain_files})
    for step in tqdm(range(epoch_length)):
        # run train_op
        _ = sess.run(nodes['train_op'])
        # use saver to save weights
        if step % epoch_length == epoch_length - 1: #save last step
            # prepare args for simple_save
            in_dict = {
                'file_names': file_names_ph,
            }
            out_dict = {
                'predict': nodes['predict_op'],
                'diff_op': nodes['diff_op']
            }
            tf.saved_model.simple_save(sess, './savedmodel', in_dict, out_dict) # This is what you need, the pb file of the graph and variables are saved in savedmodel folder

预测部分：

# input pipeline for predict
# create list of file names: ['0.csv', '1.csv', ...]
topredict_files = [os.path.join('./predict/', f) for f in os.listdir('./predict/') if f.endswith('.csv')]
epoch_length = len(topredict_files)

# save prediction images to /results folder
if not os.path.exists('./results'):
    os.makedirs('./results')

# reset another graph as the default graph
graph2 = tf.Graph()
with graph2.as_default():
    with tf.Session() as sess:
        tf.saved_model.loader.load(
            sess,
            [tf.saved_model.tag_constants.SERVING], './savedmodel'
        ) # here's what you need
        # get operation and so on
        file_names_ph = graph2.get_tensor_by_name('file_name_ph:0')
        predict_tensor = graph2.get_tensor_by_name('Conv1/prediction:0')
        diff_tensor = graph2.get_tensor_by_name('Operations/difference:0')
        iter_init_op = graph2.get_operation_by_name('iter_init_op')

        sess.run(iter_init_op, feed_dict={file_names_ph: topredict_files})
        for step in tqdm(range(epoch_length)):
            predict, difference = sess.run([predict_tensor, diff_tensor])
            # then save your prediction and comparison
            ...

---

看看我是如何定义管道和模型的：

def input_pipeline(file_names_ph):
    # create new dataset for predict
    dataset = tf.data.Dataset.from_tensor_slices(file_names_ph)

    # apply list of file names to the py function wrapper for reading files
    dataset = dataset.map(_pyfn_wrapper, num_parallel_calls=mp.cpu_count()) # use the tf built-in csv reader or take a look how to use py_func:https://stackoverflow.com/questions/55363728/how-to-feed-h5-files-in-tf-data-pipeline-in-tensorflow-model

    # construct batch size
    dataset = dataset.batch(1).prefetch(mp.cpu_count())

    # initialize iterator
    iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
    iterator_initialize_op = iterator.make_initializer(dataset, name='iter_init_op')

    # get image and labels
    image_getnext_op, label_getnext_op = iterator.get_next()
    return {'img_next_op': image_getnext_op, 'label_next_op': label_getnext_op, 'iter_init_op': iterator_initialize_op}


def model(in_ds, out_ds):
    # a simple model
    with tf.name_scope("Conv1"):
        W = tf.get_variable("W", shape=[3, 3, 1, 1],
                             initializer=tf.contrib.layers.xavier_initializer())
        b = tf.get_variable("b", shape=[1], initializer=tf.contrib.layers.xavier_initializer())
        layer1 = tf.nn.conv2d(in_ds, W, strides=[1, 1, 1, 1], padding='SAME') + b
        prediction = tf.nn.relu(layer1, name='prediction')

    with tf.name_scope("Operations"):
        global_step = tf.Variable(0, name='global_step', trainable=False)
        loss = tf.reduce_mean(tf.losses.mean_squared_error(labels=out_ds, predictions=prediction), name='loss')
        train_op = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(loss, name='train_op', global_step=global_step)
        difference_op = tf.cast(tf.equal(prediction, out_ds), dtype=tf.int32, name='difference')
    # I really like dictionary, it's easy to handle
    return {'global_step': global_step, 'loss': loss, 'train_op': train_op, 'diff_op': difference_op, 'predict_op': prediction}