Question

我使用过TensorRT，并且Tensorflow模型在FP16和FP32模式下转换为TensorRT引擎。

使用10张图像进行测试，FP32甚至不比FP16模式快两倍。预期至少快两倍。这是Titan RTX specs using Turing architecture

Using Titan RTX
    FP16
    msec: 0.171075
    msec: 0.134830
    msec: 0.129984
    msec: 0.128638
    msec: 0.118196
    msec: 0.123429
    msec: 0.134329
    msec: 0.119506
    msec: 0.117615
    msec: 0.127687


    FP32
    msec: 0.199235
    msec: 0.180985
    msec: 0.153394
    msec: 0.148267
    msec: 0.151481
    msec: 0.169578
    msec: 0.159987
    msec: 0.173443
    msec: 0.159301
    msec: 0.155503

EDIT_1：根据@ y.selivonchyk的回复，已在Tesla T4上进行了测试。但是FP16并不比FP32快。

Using Tesla T4
FP16
msec: 0.169800
msec: 0.136175
msec: 0.127025
msec: 0.130406
msec: 0.129874
msec: 0.122248
msec: 0.128244
msec: 0.126983
msec: 0.131111
msec: 0.138897

FP32
msec: 0.168589
msec: 0.130539
msec: 0.122617
msec: 0.120955
msec: 0.128452
msec: 0.122426
msec: 0.125560
msec: 0.130016
msec: 0.126965
msec: 0.121818

结果可接受吗？还是我需要研究什么？

在此document on page 15中，FP32和FP16之间的图像/秒差异为5倍。

我从UFF模型和推论中进行引擎序列化的代码如下所示。

def serializeandsave_engine(model_file):
    # For more information on TRT basics, refer to the introductory samples.
    with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.UffParser() as parser:
        builder.max_batch_size = 1#max_batch_size
        builder.max_workspace_size = 1 <<  30
        builder.fp16_mode = True
        builder.strict_type_constraints = True
        # Parse the Uff Network
        parser.register_input("image", (3, height, width))#UffInputOrder.NCHW
        parser.register_output("Openpose/concat_stage7")#check input output names with tf model
        parser.parse(model_file, network)
        # Build and save the engine.
        engine = builder.build_cuda_engine(network)
        serialized_engine = engine.serialize()
        with open(engine_path, 'wb') as f:
           f.write(engine.serialize())
        return

def infer(engine, x, batch_size, context):
    inputs = []
    outputs = []
    bindings = []
    stream = cuda.Stream()
    for binding in engine:
        size = trt.volume(engine.get_binding_shape(binding)) * batch_size
        dtype = trt.nptype(engine.get_binding_dtype(binding))
        # Allocate host and device buffers
        host_mem = cuda.pagelocked_empty(size, dtype)
        device_mem = cuda.mem_alloc(host_mem.nbytes)
        # Append the device buffer to device bindings.
        bindings.append(int(device_mem))
        # Append to the appropriate list.
        if engine.binding_is_input(binding):
            inputs.append(HostDeviceMem(host_mem, device_mem))
        else:
            outputs.append(HostDeviceMem(host_mem, device_mem))
    #img = np.array(x).ravel()
    np.copyto(inputs[0].host, x.flatten())  #1.0 - img / 255.0
    [cuda.memcpy_htod_async(inp.device, inp.host, stream) for inp in inputs]
    context.execute_async(batch_size=batch_size, bindings=bindings, stream_handle=stream.handle)
    # Transfer predictions back from the GPU.
    [cuda.memcpy_dtoh_async(out.host, out.device, stream) for out in outputs]
    # Synchronize the stream
    stream.synchronize()

Answer 1

Titan系列显卡始终只是功能更强大的消费类显卡的增强版本。 Titans从来没有专用的FP16内核，以使其在半精度训练下可以更快地运行。（幸运的是，与1080s不同，它们在FP16上运行不会变慢）。

此假设在接下来的2条评论中得到了证实：pugetsystems和tomshardaware，其中使用半精度浮子时，Titan RTX显示了约20％的适度改进。

简而言之，FP16仅在芯片上存在专用硬件模块时才更快，而Titan系列通常不是这种情况。但是，FP16仍然可以减少训练期间的内存消耗，甚至可以运行更大的模型。

Answer 2

转换非常基于硬件和模型，因此在 FP16 精度模式下延迟减少一半的情况并不总是如此。您可以看到一种硬件没有显着变化，但在另一种硬件上却发生了剧烈变化。我还建议使用更多图片或通过批处理让相同的图片通过模型更多次，因为进行一些热身运行总是好的。因此，为模型提供至少 200,300 张图像和 50-100 次热身以获得更好、更逼真的结果

FP16甚至不比在TensorRT中使用FP32快两倍

2 个答案: