Tensorflow目标检测的推理时间

Question

Tensorflow目标检测的推理时间

pythontensorflowmachine-learningkubernetesgoogle-cloud-platform

6

我已经将我的目标检测模型部署到了Google Kubernetes Engine上。我的模型是使用faster_rcnn_resnet101_pets配置进行训练的。尽管在我的集群节点中使用了Nvidia Tesla K80 GPU，但我的模型推理时间非常长（预测的总时间约为10秒）。我正在使用gRPC从模型获取预测结果。用于进行预测请求的脚本如下：

import argparse
import os
import time
import sys
import tensorflow as tf
from PIL import Image
import numpy as np
from grpc.beta import implementations
sys.path.append("..")
from object_detection.core.standard_fields import \
    DetectionResultFields as dt_fields
from object_detection.utils import label_map_util
from argparse import RawTextHelpFormatter
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc


tf.logging.set_verbosity(tf.logging.INFO)

WIDTH = 1024
HEIGHT = 768


def load_image_into_numpy_array(input_image):
    image = Image.open(input_image)
    image = image.resize((WIDTH, HEIGHT), Image.ANTIALIAS)
    (im_width, im_height) = image.size
    image_arr = np.array(image.getdata()).reshape(
        (im_height, im_width, 3)).astype(np.uint8)
    image.close()
    return image_arr


def load_input_tensor(input_image):

    image_np = load_image_into_numpy_array(input_image)
    image_np_expanded = np.expand_dims(image_np, axis=0).astype(np.uint8)
    tensor = tf.contrib.util.make_tensor_proto(image_np_expanded)
    return tensor


def main(args):
    start_main = time.time()

    host, port = args.server.split(':')

    channel = implementations.insecure_channel(host, int(port))._channel

    stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
    request = predict_pb2.PredictRequest()
    request.model_spec.name = args.model_name

    input_tensor = load_input_tensor(args.input_image)
    request.inputs['inputs'].CopyFrom(input_tensor)
    start = time.time()

    result = stub.Predict(request, 60.0)
    end = time.time()

    output_dict = {}

    output_dict[dt_fields.detection_classes] = np.squeeze(
        result.outputs[dt_fields.detection_classes].float_val).astype(np.uint8)
    output_dict[dt_fields.detection_boxes] = np.reshape(
        result.outputs[dt_fields.detection_boxes].float_val, (-1, 4))
    output_dict[dt_fields.detection_scores] = np.squeeze(
        result.outputs[dt_fields.detection_scores].float_val)
    category_index = label_map_util.create_category_index_from_labelmap(args.label_map,
                                                                        use_display_name=True)
    classes = output_dict[dt_fields.detection_classes]
    scores = output_dict[dt_fields.detection_scores]
    classes.shape = (1, 300)
    scores.shape = (1, 300)
    print("prediction time : " + str(end-start))
    objects = []

    threshold = 0.5  # in order to get higher percentages you need to lower this number; usually at 0.01 you get 100% predicted objects
    for index, value in enumerate(classes[0]):
        object_dict = {}
        if scores[0, index] > threshold:
            object_dict[(category_index.get(value)).get('name').encode('utf8')] = \
                scores[0, index]
            objects.append(object_dict)
    print(objects)
    end_main = time.time()

    print("Overall Time : " + str(end_main-start_main))


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Object detection grpc client.",
                                     formatter_class=RawTextHelpFormatter)
    parser.add_argument('--server',
                        type=str,
                        default='localhost:9000',
                        help='PredictionService host:port')
    parser.add_argument('--model_name',
                        type=str,
                        default="my-model",
                        help='Name of the model')
    parser.add_argument('--input_image',
                        type=str,
                        default='./test_images/123.jpg',
                        help='Path to input image')
    parser.add_argument('--output_directory',
                        type=str,
                        default='./',
                        help='Path to output directory')
    parser.add_argument('--label_map',
                        type=str,
                        default="./data/object_detection.pbtxt",
                        help='Path to label map file')

    args = parser.parse_args()
    main(args)

我已经使用kubectl端口转发进行测试，所以请求端口设置为localhost:9000。

输出如下：

prediction time : 6.690936326980591
[{b'goi_logo': 0.9999970197677612}]
Overall Time : 10.25893259048462

我该怎么做才能让我的推理变得更快？我注意到推理时间是以毫秒为单位的，因此相比之下10秒是非常长的时间，不适合生产环境。我知道端口转发很慢。我还可以使用什么方法？我需要将此客户端作为API端点提供给全世界。

- user9460641

我很好奇连续进行两次预测时会发生什么。我认为第一次预测需要更长的时间，所以我总是先进行一次热身请求来避免这种情况。那么在循环中运行预测的时间是什么时候呢？谢谢。 - Ari Gold

图形的初始化和第一次推理会有一些（强烈的）开销，因此测量第一次运行不会给您推理运行时间的准确度。尝试在没有计时的情况下运行第一个，然后计时相同图像的N次迭代的循环（例如，使用N = 10），并将其用作运行时间的度量。 - GPhilo

我循环了预测请求，总共花费的时间仍然平均约为10秒。第一个请求花费了32秒，从那时起，请求花费的时间分别是10、9、8、8、12、10秒。性能仍不足以用于生产系统。 - user9460641

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Brecht Coghe · Accepted Answer

如前面的回答所述，您确实应该尝试进行多个请求，因为tf-serving第一次使用需要一些开销。您可以通过使用预热脚本来防止这种情况发生。

为了增加一些额外的选项：

- 从tf-serving v1.8开始，您还可以使用http rest API服务。然后，您可以从Google计算引擎调用您在GKE上创建的服务，以减少连接延迟。在我的情况下，它大大提高了速度，因为我的本地连接最多只能达到中等水平。除了http rest api更易于调试之外，您还可以发送更大的请求。grpc限制似乎为1.5 mb，而http则高得多。 - 您是否发送了b64编码的图像？发送图像本身比发送b64编码字符串要慢得多。我处理这个问题的方式是从图像发送b64编码字符串，并在我的网络前面创建一些额外的层，将字符串转换为jpeg图像，然后再通过模型处理它们。以下是一些帮助您入门的代码：

from keras.applications.inception_v3 import InceptionV3, preprocess_input
from keras.models import Model
import numpy as np
import cv2
import tensorflow as tf
from keras.layers import Input, Lambda
from keras import backend as K

base_model = InceptionV3(
                weights='imagenet',
                include_top=True)

model = Model(
    inputs=base_model.input,
    outputs=base_model.get_layer('avg_pool').output)



def prepare_image(image_str_tensor):
            #image = tf.squeeze(tf.cast(image_str_tensor, tf.string), axis=[0])
            image_str_tensor = tf.cast(image_str_tensor, tf.string)
            image = tf.image.decode_jpeg(image_str_tensor,
                                        channels=3)
            #image = tf.divide(image, 255)
            #image = tf.expand_dims(image, 0)
            image = tf.image.convert_image_dtype(image, tf.float32)
            return image

def prepare_image_batch(image_str_tensor):
    return tf.map_fn(prepare_image, image_str_tensor, dtype=tf.float32)

# IF BYTE STR

model.layers.pop(0)
print(model.layers[0])

input_img = Input(dtype= tf.string,
            name ='string_input',
            shape = ()
            )
outputs = Lambda(prepare_image_batch)(input_img)
outputs = model(outputs)
inception_model = Model(input_img, outputs)
inception_model.compile(optimizer = "sgd", loss='categorical_crossentropy')
weights = inception_model.get_weights()

其次，我建议您使用更大的GPU。我现在在P100上运行基本的yolo（Keras实现），当从计算引擎调用时，延迟约为0.4秒。我们注意到，C ++中的darknet实现比Keras实现要快得多。

Original Answer翻译成"最初的回答"