提供一下c++端调用onnx模型并通过tensorRT加速推理的代码案例并注释

以下是一个简单的C++代码示例，演示如何使用ONNX模型进行推理，并使用TensorRT进行加速。该示例使用TensorRT 5.1.5和CUDA 10.0进行编译。

首先，我们需要加载ONNX模型并创建推理引擎：

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <numeric>
#include <chrono>
#include "NvInfer.h"
#include "NvOnnxParser.h"
using namespace nvinfer1;
using namespace nvonnxparser;

// Load the ONNX model from file and create inference engine
ICudaEngine* createEngine(const char* onnxModelPath, int maxBatchSize)
{
    // Load ONNX model from file
    IBuilder* builder = createInferBuilder(gLogger);
    INetworkDefinition* network = builder->createNetworkV2(0U);
    auto parser = createParser(*network, gLogger);
    parser->parseFromFile(onnxModelPath, static_cast<int>(ILogger::Severity::kERROR));

    // Set up engine builder and build engine
    builder->setMaxBatchSize(maxBatchSize);
    builder->setMaxWorkspaceSize(1 << 28); // 256MB
    builder->setFp16Mode(true);
    builder->setInt8Mode(false);
    builder->setStrictTypeConstraints(true);
    ICudaEngine* engine = builder->buildCudaEngine(*network);
    network->destroy();
    parser->destroy();
    builder->destroy();
    return engine;
}

下一步是创建输入和输出缓冲区，并将输入数据复制到缓冲区中：

// Create input and output buffers for inference
void* createBuffer(int size)
{
    void* buffer;
    cudaMalloc(&buffer, size);
    return buffer;
}

void* createInputBuffer(int batchSize, int inputSize)
{
    return createBuffer(batchSize * inputSize * sizeof(float));
}

void* createOutputBuffer(int batchSize, int outputSize)
{
    return createBuffer(batchSize * outputSize * sizeof(float));
}

void copyInputToDevice(void* buffer, const std::vector<float>& input, int batchSize, int inputSize)
{
    cudaMemcpy(buffer, input.data(), batchSize * inputSize * sizeof(float), cudaMemcpyHostToDevice);
}

然后，我们可以运行推理并将结果从设备内存复制到主机内存：

// Run inference and copy output to host memory
void doInference(ICudaEngine* engine, const std::vector<float>& input, std::vector<float>& output, int batchSize, int inputSize, int outputSize)
{
    IExecutionContext* context = engine->createExecutionContext();
    void* inputBuffer = createInputBuffer(batchSize, inputSize);
    void* outputBuffer = createOutputBuffer(batchSize, outputSize);

    // Copy input to device
    copyInputToDevice(inputBuffer, input, batchSize, inputSize);

    // Run inference
    const int nbBindings = engine->getNbBindings();
    std::vector<void*> buffers(nbBindings);
    int inputIndex = engine->getBindingIndex("input");
    int outputIndex = engine->getBindingIndex("output");
    buffers[inputIndex] = inputBuffer;
    buffers[outputIndex] = outputBuffer;
    context->execute(batchSize, &buffers[0]);

    // Copy output to host
    output.resize(batchSize * outputSize);
    cudaMemcpy(output.data(), outputBuffer, batchSize * outputSize * sizeof(float), cudaMemcpyDeviceToHost);

    // Clean up
    cudaFree(inputBuffer);
    cudaFree(outputBuffer);
    context->destroy();
}

最后，我们可以使用以下代码将上述函数组合在一起，以加载模型并运行推理：

int main(int argc, char** argv)
{
    // Load ONNX model and create inference engine
    const char* onnxModelPath = "model.onnx";
    int maxBatchSize = 1;
    ICudaEngine* engine = createEngine(onnxModelPath, maxBatchSize);

    // Set up input and output buffers
    int inputSize = 784;
    int outputSize = 10;
    std::vector<float> input(inputSize);
    std::vector<float> output(outputSize);

    // Generate random input data
    std::generate(input.begin(), input.end(), []() { return static_cast<float>(rand() % 256) / 255.f; });

    // Run inference
    doInference(engine, input, output, maxBatchSize, inputSize, outputSize);

    // Print output
    std::cout << "Output: ";
    for (float f : output) {
        std::cout << f << " ";
    }
    std::cout << std::endl;

    // Clean up
    engine->destroy();
    return 0;
}

请注意，此示例假定输入张量的名称为“input”，输出张量的名称为“output”。如果您的ONNX模型使用不同的名称，则需要相应地更改代码。

此外，TensorRT还提供了其他优化技术，例如混合精度和动态批量大小，以进一步加速推理。有关更详细的示例，请参见TensorRT SDK中的示例代码。