TensorFlow Inference

时间：2017-04-30 16:25:39

标签： python c++ tensorflow

我一直在挖这个问题。我发现了很多文章;但是没有一个真正只显示张量流推理作为一个简单的推论。它总是＆＃34;使用服务引擎＆＃34;或使用预编码/定义的图表。

问题在于：我有一个偶尔会检查更新模型的设备。然后，它需要加载该模型并通过模型运行输入预测。

在keras中，这很简单：建立一个模型;训练模型和调用model.predict（）。在scikit中学习同样的事情。

我能够抓住一个新模型并加载它;我可以打印出所有的重量;但我在世界上如何推断它？

加载模型和打印重量的代码：

    with tf.Session() as sess:
        new_saver = tf.train.import_meta_graph(MODEL_PATH + '.meta', clear_devices=True)
        new_saver.restore(sess, MODEL_PATH)
        for var in tf.trainable_variables():
            print(sess.run(var))

我打印出了我的所有藏品，我有： [＆＃39; queue_runners＆＃39;，＆＃39;变量＆＃39;，＆＃39;损失＆＃39;，＆＃39;摘要＆＃39;，＆＃39; train_op＆＃39;，＆＃39; cond_context＆＃39;，＆＃39; trainable_variables＆＃39;]

我尝试使用sess.run(train_op);然而，刚开始完整的训练课程;这不是我想做的。我只想对我提供的不是TF记录的不同输入集进行推理。

稍微详细一点：

设备可以使用C ++或Python;只要我能产生.exe。如果我想要提供系统，我可以设置一个feed dict。我用TFRecords训练;但在生产中，我不会使用TFRecords;它是一个真实/近实时系统。

感谢您的任何意见。我将样本代码发布到此repo：https://github.com/drcrook1/CIFAR10/TensorFlow，它执行所有培训和样本推断。

任何提示都非常感谢！

------------ EDITS ----------------- 我重建模型如下：

def inference(images):
    '''
    Portion of the compute graph that takes an input and converts it into a Y output
    '''
    with tf.variable_scope('Conv1') as scope:
        C_1_1 = ld.cnn_layer(images, (5, 5, 3, 32), (1, 1, 1, 1), scope, name_postfix='1')
        C_1_2 = ld.cnn_layer(C_1_1, (5, 5, 32, 32), (1, 1, 1, 1), scope, name_postfix='2')
        P_1 = ld.pool_layer(C_1_2, (1, 2, 2, 1), (1, 2, 2, 1), scope)
    with tf.variable_scope('Dense1') as scope:
        P_1 = tf.reshape(C_1_2, (CONSTANTS.BATCH_SIZE, -1))
        dim = P_1.get_shape()[1].value
        D_1 = ld.mlp_layer(P_1, dim, NUM_DENSE_NEURONS, scope, act_func=tf.nn.relu)
    with tf.variable_scope('Dense2') as scope:
        D_2 = ld.mlp_layer(D_1, NUM_DENSE_NEURONS, CONSTANTS.NUM_CLASSES, scope)
    H = tf.nn.softmax(D_2, name='prediction')
    return H

注意我将名称'prediction'添加到TF操作中，以便稍后检索。

训练时我使用tfrecords和输入队列的输入管道。

GRAPH = tf.Graph()
with GRAPH.as_default():
    examples, labels = Inputs.read_inputs(CONSTANTS.RecordPaths,
                                          batch_size=CONSTANTS.BATCH_SIZE,
                                          img_shape=CONSTANTS.IMAGE_SHAPE,
                                          num_threads=CONSTANTS.INPUT_PIPELINE_THREADS)
    examples = tf.reshape(examples, [CONSTANTS.BATCH_SIZE, CONSTANTS.IMAGE_SHAPE[0],
                                     CONSTANTS.IMAGE_SHAPE[1], CONSTANTS.IMAGE_SHAPE[2]])
    logits = Vgg3CIFAR10.inference(examples)
    loss = Vgg3CIFAR10.loss(logits, labels)
    OPTIMIZER = tf.train.AdamOptimizer(CONSTANTS.LEARNING_RATE)

我试图在图表中加载的操作上使用feed_dict;但是现在它只是悬挂...... 

MODEL_PATH = 'models/' + CONSTANTS.MODEL_NAME + '.model'

images = tf.placeholder(tf.float32, shape=(1, 32, 32, 3))

def run_inference():
    '''Runs inference against a loaded model'''
    with tf.Session() as sess:
        #sess.run(tf.global_variables_initializer())
        new_saver = tf.train.import_meta_graph(MODEL_PATH + '.meta', clear_devices=True)
        new_saver.restore(sess, MODEL_PATH)
        pred = tf.get_default_graph().get_operation_by_name('prediction')
        rand = np.random.rand(1, 32, 32, 3)
        print(rand)
        print(pred)
        print(sess.run(pred, feed_dict={images: rand}))
        print('done')

run_inference()

我认为这不起作用，因为原始网络是使用TFRecords训练的。在样本CIFAR数据集中，数据很小;我们的真实数据集非常庞大，我理解TFRecords是培训网络的默认最佳实践。 feed_dict从生产的角度来看是非常完美的感觉;我们可以启动一些线程并从我们的输入系统中填充那些东西。

所以我想我有一个受过训练的网络，我可以得到预测操作;但是如何告诉它停止使用输入队列并开始使用feed_dict？请记住，从生产的角度来看，我无法获得科学家所做的任何事情。他们做他们的事;并且我们使用任何商定的标准将其粘贴在生产中。

-------输入OPS --------

tf.Operation＆quot; input / input_producer / Const＆＃39; type = Const，tf.Operation＆quot; input / input_producer / Size＆＃39; type = Const，tf.Operation＆quot; input / input_producer / Greater / y＆＃39; type = Const，tf.Operation＆quot; input / input_producer / Greater＆＃39; type = Greater，tf.Operation＆quot; input / input_producer / Assert / Const＆＃39; type = Const，tf.Operation＆quot; input / input_producer / Assert / Assert / data_0＆＃39; type = Const，tf.Operation＆quot; input / input_producer / Assert / Assert＆＃39; type = Assert，tf.Operation＆quot; input / input_producer / Identity＆＃39; type = Identity，tf.Operation＆quot; input / input_producer / RandomShuffle＆＃39; type = RandomShuffle，tf.Operation＆quot; input / input_producer＆＃39; type = FIFOQueueV2，tf.Operation＆quot; input / input_producer / input_producer_EnqueueMany＆＃39; type = QueueEnqueueManyV2，tf.Operation＆quot; input / input_producer / input_producer_Close＆＃39; type = QueueCloseV2，tf.Operation＆quot; input / input_producer / input_producer_Close_1＆＃39; type = QueueCloseV2，tf.Operation＆quot; input / input_producer / input_producer_Size＆＃39; type = QueueSizeV2，tf.Operation＆quot; input / input_producer / Cast＆＃39; type = Cast，tf.Operation＆quot; input / input_producer / mul / y＆＃39; type = Const，tf.Operation＆quot; input / input_producer / mul＆＃39; type = Mul，tf.Operation＆quot; input / input_producer / fraction_of_32_full / tags＆＃39; type = Const，tf.Operation＆quot; input / input_producer / fraction_of_32_full＆＃39; type = ScalarSummary，tf.Operation＆quot; input / TFRecordReaderV2＆＃39; type = TFRecordReaderV2，tf.Operation＆quot; input / ReaderReadV2＆＃39;键入= ReaderReadV2，

------ END INPUT OPS -----

----更新3 ----

我相信我需要做的是杀死用TF Records训练的图形的输入部分，并将第一层的输入重新连接到新的输入。它有点像进行手术;但如果我使用TFRecords训练就像听起来一样疯狂，这是我能找到推理的唯一方法......

完整图表：

enter image description here

要杀人的部分：

enter image description here

所以我认为问题变成了：如何杀死图表的输入部分并将其替换为feed_dict？

对此的跟进将是：这真的是正确的方法吗？这似乎是疯子。

---- END UPDATE 3 ----

---链接到检查点文件---

https://drcdata.blob.core.windows.net/checkpoints/CIFAR_10_VGG3_50neuron_1pool_1e-3lr_adam.model.zip?st=2017-05-01T21%3A56%3A00Z&se=2020-05-02T21%3A56%3A00Z&sp=rl&sv=2015-12-11&sr=b&sig=oBCGxlOusB4NOEKnSnD%2FTlRYa5NKNIwAX1IyuZXAr9o%3D

- 检查点文件的结束链接---

-----更新4 -----

我放弃了，只是对正常的＆＃39;假设我可以让科学家只是腌制他们的模型而我们可以抓住模型泡菜，进行推理的方式;解压缩然后对其进行推理。所以为了测试，我尝试了正常的方式，假设我们已经解压缩它...它不值得一个豆... 

import tensorflow as tf
import CONSTANTS
import Vgg3CIFAR10
import numpy as np
from scipy import misc
import time

MODEL_PATH = 'models/' + CONSTANTS.MODEL_NAME + '.model'
imgs_bsdir = 'C:/data/cifar_10/train/'

images = tf.placeholder(tf.float32, shape=(1, 32, 32, 3))

logits = Vgg3CIFAR10.inference(images)

def run_inference():
'''Runs inference against a loaded model'''
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        new_saver = tf.train.import_meta_graph(MODEL_PATH + '.meta')#, import_scope='1', input_map={'input:0': images})
        new_saver.restore(sess, MODEL_PATH)
        pred = tf.get_default_graph().get_operation_by_name('prediction')
        enq = sess.graph.get_operation_by_name(enqueue_op)
        #tf.train.start_queue_runners(sess)
        print(rand)
        print(pred)
        print(enq)
        for i in range(1, 25):
            img = misc.imread(imgs_bsdir + str(i) + '.png').astype(np.float32) / 255.0
            img = img.reshape(1, 32, 32, 3)
            print(sess.run(logits, feed_dict={images : img}))
            time.sleep(3)
        print('done')

run_inference()

Tensorflow最终使用加载模型中的推理函数构建新图形;然后它将所有其他东西从其他图形追加到它的末尾。那么当我填充feed_dict期望得到推论时;我只是得到一堆随机垃圾，好像它是第一次通过网络......

再次;这看起来很疯狂;我是否真的需要编写自己的框架来序列化和反序列化随机网络？这必须在......之前完成。

-----更新4 -----

再次;谢谢！

2 个答案:

答案 0 :(得分：16)

好吧，这花了太多时间才弄明白;所以这是世界其他地方的答案。

快速提醒：我需要保留一个可以动态加载和推断的模型，而不知道它是如何工作的内部或内部。

第1步：将模型创建为类，理想情况下使用接口定义

class Vgg3Model:

    NUM_DENSE_NEURONS = 50
    DENSE_RESHAPE = 32 * (CONSTANTS.IMAGE_SHAPE[0] // 2) * (CONSTANTS.IMAGE_SHAPE[1] // 2)

    def inference(self, images):
        '''
        Portion of the compute graph that takes an input and converts it into a Y output
        '''
        with tf.variable_scope('Conv1') as scope:
            C_1_1 = ld.cnn_layer(images, (5, 5, 3, 32), (1, 1, 1, 1), scope, name_postfix='1')
            C_1_2 = ld.cnn_layer(C_1_1, (5, 5, 32, 32), (1, 1, 1, 1), scope, name_postfix='2')
            P_1 = ld.pool_layer(C_1_2, (1, 2, 2, 1), (1, 2, 2, 1), scope)
        with tf.variable_scope('Dense1') as scope:
            P_1 = tf.reshape(P_1, (-1, self.DENSE_RESHAPE))
            dim = P_1.get_shape()[1].value
            D_1 = ld.mlp_layer(P_1, dim, self.NUM_DENSE_NEURONS, scope, act_func=tf.nn.relu)
        with tf.variable_scope('Dense2') as scope:
            D_2 = ld.mlp_layer(D_1, self.NUM_DENSE_NEURONS, CONSTANTS.NUM_CLASSES, scope)
        H = tf.nn.softmax(D_2, name='prediction')
        return H

    def loss(self, logits, labels):
        '''
        Adds Loss to all variables
        '''
        cross_entr = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels)
        cross_entr = tf.reduce_mean(cross_entr)
        tf.summary.scalar('cost', cross_entr)
        tf.add_to_collection('losses', cross_entr)
        return tf.add_n(tf.get_collection('losses'), name='total_loss')

第2步：使用您想要的任何输入训练您的网络;在我的例子中，我使用了Queue Runners和TF Records。请注意，此步骤由不同的团队完成，该团队对模型进行迭代，构建，设计和优化。这也会随着时间而改变。它们产生的输出必须能够从远程位置拉出，因此我们可以在设备上动态加载更新的模型（重新刷新硬件是一种痛苦，特别是如果它在地理上分布的话）。在这种情况下;团队删除与图形保护程序关联的3个文件;但也是用于该培训课程的模型的泡菜

model = vgg3.Vgg3Model()

def create_sess_ops():
    '''
    Creates and returns operations needed for running
    a tensorflow training session
    '''
    GRAPH = tf.Graph()
    with GRAPH.as_default():
        examples, labels = Inputs.read_inputs(CONSTANTS.RecordPaths,
                                          batch_size=CONSTANTS.BATCH_SIZE,
                                          img_shape=CONSTANTS.IMAGE_SHAPE,
                                          num_threads=CONSTANTS.INPUT_PIPELINE_THREADS)
        examples = tf.reshape(examples, [-1, CONSTANTS.IMAGE_SHAPE[0],
                                     CONSTANTS.IMAGE_SHAPE[1], CONSTANTS.IMAGE_SHAPE[2]], name='infer/input')
        logits = model.inference(examples)
        loss = model.loss(logits, labels)
        OPTIMIZER = tf.train.AdamOptimizer(CONSTANTS.LEARNING_RATE)
        gradients = OPTIMIZER.compute_gradients(loss)
        apply_gradient_op = OPTIMIZER.apply_gradients(gradients)
        gradients_summary(gradients)
        summaries_op = tf.summary.merge_all()
        return [apply_gradient_op, summaries_op, loss, logits], GRAPH

def main():
    '''
    Run and Train CIFAR 10
    '''
    print('starting...')
    ops, GRAPH = create_sess_ops()
    total_duration = 0.0
    with tf.Session(graph=GRAPH) as SESSION:
        COORDINATOR = tf.train.Coordinator()
        THREADS = tf.train.start_queue_runners(SESSION, COORDINATOR)
        SESSION.run(tf.global_variables_initializer())
        SUMMARY_WRITER = tf.summary.FileWriter('Tensorboard/' + CONSTANTS.MODEL_NAME, graph=GRAPH)
        GRAPH_SAVER = tf.train.Saver()

        for EPOCH in range(CONSTANTS.EPOCHS):
            duration = 0
            error = 0.0
            start_time = time.time()
            for batch in range(CONSTANTS.MINI_BATCHES):
                _, summaries, cost_val, prediction = SESSION.run(ops)
                error += cost_val
            duration += time.time() - start_time
            total_duration += duration
            SUMMARY_WRITER.add_summary(summaries, EPOCH)
            print('Epoch %d: loss = %.2f (%.3f sec)' % (EPOCH, error, duration))
            if EPOCH == CONSTANTS.EPOCHS - 1 or error < 0.005:
                print(
                'Done training for %d epochs. (%.3f sec)' % (EPOCH, total_duration)
            )
                break
        GRAPH_SAVER.save(SESSION, 'models/' + CONSTANTS.MODEL_NAME + '.model')
        with open('models/' + CONSTANTS.MODEL_NAME + '.pkl', 'wb') as output:
            pickle.dump(model, output)
        COORDINATOR.request_stop()
        COORDINATOR.join(THREADS)

第3步：运行一些推理。加载你的酸洗模型;通过在新占位符中管道到logits来创建一个新图形;然后调用会话恢复。不要恢复整个图形;只是变量。

MODEL_PATH = 'models/' + CONSTANTS.MODEL_NAME + '.model'
imgs_bsdir = 'C:/data/cifar_10/train/'

images = tf.placeholder(tf.float32, shape=(1, 32, 32, 3))
with open('models/vgg3.pkl', 'rb') as model_in:
model = pickle.load(model_in)
logits = model.inference(images)

def run_inference():
    '''Runs inference against a loaded model'''
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        new_saver = tf.train.Saver()
        new_saver.restore(sess, MODEL_PATH)
        print("Starting...")
        for i in range(20, 30):
            print(str(i) + '.png')
            img = misc.imread(imgs_bsdir + str(i) + '.png').astype(np.float32) / 255.0
            img = img.reshape(1, 32, 32, 3)
            pred = sess.run(logits, feed_dict={images : img})
            max_node = np.argmax(pred)
            print('predicted label: ' + str(max_node))
        print('done')

run_inference()

绝对有办法通过界面改进这一点，并且可能更好地打包一切;但这是有效的，并为我们如何向前发展奠定了基础。

最终注释当我们最终将其推向生产时，我们最终不得不将愚蠢的`mymodel_model.py文件向下发送以构建图表。因此，我们现在为所有模型强制执行命名约定，并且还有生产模型运行的编码标准，以便我们可以正确地执行此操作。

祝你好运！

答案 1 :(得分：5)

虽然它不像model.predict（）那样剪切和干燥，但它仍然非常简单。

在你的模型中，你应该有一个张量来计算你感兴趣的最终输出，让我们命名张量output。您目前可能只有一个损失功能。如果是这样，则创建另一个张量（模型中的变量），它实际上计算出你想要的输出。

例如，如果您的损失函数是：

tf.nn.sigmoid_cross_entropy_with_logits(last_layer_activation, labels)

并且您希望您的输出在每个类的[0,1]范围内，创建另一个变量：

output = tf.sigmoid(last_layer_activation)

现在，当您致电sess.run(...)时，只需申请output张量。不要求您通常会训练它的优化OP。当您请求此变量时，tensorflow将执行生成该值所需的最少工作（例如，它不会打扰backprop，损失函数以及所有这些因为简单的前馈传递是计算output所需的全部内容。

因此，如果您正在创建一个服务来返回模型的推断，那么您需要将模型保存在内存/ gpu中，并重复：

sess.run(output, feed_dict={X: input_data})

您不需要为标签提供它，因为tensorflow不会费心计算生成您请求的输出所不需要的操作。您无需更改模型或任何其他内容。

虽然这种方法可能不如model.predict(...)那么明显，但我认为它的灵活性要大得多。如果你开始玩更复杂的模型，你可能会学会喜欢这种方法。 model.predict()就像“在盒子里思考。”

相关问题
最新问题