win10 环境进行 python + pytorch + yolov8 + tensorRT( c++版 ) 测试过程记录

参考博客：
    1. YOLOv8模型转换pt-＞onnx(附上代码)：https://blog.csdn.net/2303_80018785/article/details/138194961
    2. yolov8的TensorRT部署（C++版本）：https://blog.csdn.net/liujiahao123987/article/details/133892746
        test.cpp 就是使用此博客的 detect.cpp，但是需要将模型序列化部分的如下行：

        std::ifstream ifs(engine_file_path);

        换成：

        std::ifstream ifs(engine_file_path,std::ios::binary);

                否则报错：

        [runtime.cpp::nvinfer1::Runtime::parsePlan::315] Error Code 1: Serialization (Serialization assertion plan->header.size == blobSize failed.)

                因为模型 文件是二进制文件，需要以二进制方式读取，c++ 的 ifstream 不加 std::ios::binary 参数默认表示以文本方式读取。

                ps：我没有按照该博主以 cmake 的方式编译，而是使用纯 cl.exe 编译的，因为 CMakeLists.txt 语法看不懂。

        3. 部署实战 | 手把手教你在Windows下用TensorRT部署YOLOv8：https://blog.csdn.net/CV_Autobot/article/details/129002357

1. 安装 conda：略

2. 使用 conda 新建 python3.8的环境：略

3. 使用 conda 查询环境：

 conda env  list：
 env_yolov9_python_3_8

4. 进入 env_yolov9_python_3_8 环境：conda  activate env_yolov9_python_3_8

5. 确认 python 的版本号：

    python  --version
    Python 3.8.19

6. 确认 cuda 的版本：

nvcc -V：
        nvcc: NVIDIA (R) Cuda compiler driver
        Copyright (c) 2005-2022 NVIDIA Corporation
        Built on Thu_Feb_10_19:03:51_Pacific_Standard_Time_2022
        Cuda compilation tools, release 11.6, V11.6.112
        Build cuda_11.6.r11.6/compiler.30978841_0

7. 安装 pytorch：
    输入以下命令安装PyTorch（以CUDA 11.6为例）：       

 pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116

8. 安装 ultralytics：

    pip install ultralytics  -i https://pypi.tuna.tsinghua.edu.cn/simple/

9. 准备好 yolov8n.pt 文件放到 test.py 所在目录下。

10. 新建 test.py 文件，内容如下：    

    from ultralytics import YOLO
    # 加载模型
    model = YOLO('yolov8n.pt')  # 加载官方模型（示例）
    # model = YOLO('D:/Web page download/best2.pt')  # 加载自定义训练模型（示例）
    # 导出模型( Valid formats are ('torchscript', 'onnx', 'openvino', 'engine', 'coreml', 'saved_model', 'pb', 'tflite', 'edgetpu', 'tfjs', 'paddle', 'ncnn') )
    model.export(format='onnx')

11. 执行 python test.py 在当前目录下成功生成了 yolov8n.onnx

12. 使用 tensorRT 命令将 yolov8n.onnx  转换为 yolov8n.trt：     

D:\install\tensorRT\TensorRT-8.6.1.6\bin\trtexec --onnx=yolov8n.onnx --saveEngine=yolov8n.trt

    最后成功生成了 yolov8n.trt 文件

13. 新建 test.cpp 文件：

    #include
    #include
    #include 
    #include 
    #include
    #include "NvInfer.h"
    #include "processing.hpp"
    //#include "logging.h"

    using namespace nvinfer1;
    using namespace std;

    const int model_width = 640;
    const int model_height = 640;

    class MyLogger : public nvinfer1::ILogger
    {
        public:
        explicit MyLogger(nvinfer1::ILogger::Severity severity =nvinfer1::ILogger::Severity::kWARNING) : severity_(severity) {}

        void log(nvinfer1::ILogger::Severity severity, const char *msg) noexcept override
        {
            if (severity <= severity_) {
                std::cerr << msg << std::endl;
            }
        }
        nvinfer1::ILogger::Severity severity_;
    };

    int main()
    {
    //一、图像处理
        string image_path = "./street.jpg";  //填写自己图片路径(需要绝对路径)
        cv::Mat input_image = cv::imread(image_path);

        float* input_blob = new float[model_height * model_width * 3];
        cv::Mat resize_image;
    	//比例
        const float _ratio = std::min(model_width / (input_image.cols * 1.0f),
                                model_height / (input_image.rows * 1.0f));
        // 等比例缩放
        const int border_width = input_image.cols * _ratio;
        const int border_height = input_image.rows * _ratio;
        // 计算偏移值
        const int x_offset = (model_width - border_width) / 2;
        const int y_offset = (model_height - border_height) / 2;

        //将输入图像缩放至resize_image
        cv::resize(input_image, resize_image, cv::Size(border_width, border_height));
        //复制图像并且制作边界
        cv::copyMakeBorder(resize_image, resize_image, y_offset, y_offset, x_offset,
                            x_offset, cv::BORDER_CONSTANT, cv::Scalar(114, 114, 114));
        // 转换为RGB格式
        cv::cvtColor(resize_image, resize_image, cv::COLOR_BGR2RGB);

        //归一化
        const int channels = resize_image.channels();
        const int width = resize_image.cols;
        const int height = resize_image.rows;
        for (int c = 0; c < channels; c++) {
            for (int h = 0; h < height; h++) {
                for (int w = 0; w < width; w++) {
                    input_blob[c * width * height + h * width + w] =
                        resize_image.at(h, w)[c] / 255.0f;  //at 是 OpenCV 中用于访问图像像素的一种方法，使用 at 获取彩色图像中特定位置的像素颜色值
                }
            }
        }

    //二、模型反序列化
        MyLogger logger;
        //读取trt信息
        const std::string engine_file_path = "./yolov8n.trt";  //填写自己trt文件路径(需要绝对路径)
        std::stringstream engine_file_stream;
        engine_file_stream.seekg(0, engine_file_stream.beg);  //从起始位置偏移0个字节，指针移动到文件流的开头
        std::ifstream ifs(engine_file_path,std::ios::binary);
        engine_file_stream << ifs.rdbuf();  //将读取到的数据流交给engine_file_stream
        ifs.close();

        engine_file_stream.seekg(0, std::ios::end); //先把文件输入流指针定位到文档末尾来获取文档的长度
        const int model_size = engine_file_stream.tellg();  //获取文件流的总长度
        engine_file_stream.seekg(0, std::ios::beg);
        void *model_mem = malloc(model_size);               //开辟一样长的空间
        engine_file_stream.read(static_cast(model_mem), model_size);    //将内容读取到model_mem中

        nvinfer1::IRuntime *runtime = nvinfer1::createInferRuntime(logger);
        nvinfer1::ICudaEngine *engine = runtime->deserializeCudaEngine(model_mem, model_size);

        free(model_mem);

    //三、模型推理
        nvinfer1::IExecutionContext *context = engine->createExecutionContext();

        void *buffers[2];
        // 获取模型输入尺寸并分配GPU内存
        nvinfer1::Dims input_dim = engine->getBindingDimensions(0);
        int input_size = 1;
        for (int j = 0; j < input_dim.nbDims; ++j) {
            if(input_dim.d[j] < 0)
                input_size *= -input_dim.d[j];
            else
                input_size *= input_dim.d[j];
        }
        cudaMalloc(&buffers[0], input_size * sizeof(float));

        // 获取模型输出尺寸并分配GPU内存
        nvinfer1::Dims output_dim = engine->getBindingDimensions(1);

        int output_size = 1;
        for (int j = 0; j < output_dim.nbDims; ++j) {
            if(output_dim.d[j] < 0)
                output_size *= -output_dim.d[j];
            else
                output_size *= output_dim.d[j];
        }
        cudaMalloc(&buffers[1], output_size * sizeof(float));

        // 给模型输出数据分配相应的CPU内存
        float *output_buffer = new float[output_size];
        //数据投入
        cudaStream_t stream;
        cudaStreamCreate(&stream);
        // 拷贝输入数据
        cudaMemcpyAsync(buffers[0], input_blob, input_size * sizeof(float),
                        cudaMemcpyHostToDevice, stream);
        // 执行推理
        if(context->enqueueV2(buffers, stream, nullptr))
        {
            cout << "enqueueV2执行推理成功" << endl;
        }
        else{
            cout << "enqueueV2执行推理失败" << endl;
            return -1;
        }
        // 拷贝输出数据
        cudaMemcpyAsync(output_buffer, buffers[1], output_size * sizeof(float),
                        cudaMemcpyDeviceToHost, stream);

        cudaStreamSynchronize(stream);

        delete context;
        delete engine;
        delete runtime;
        delete[] input_blob;

    //四、输出结果output_buffer，放入objs  xywh为中心点坐标 和宽高
        float *ptr = output_buffer;     // 1x84x8400  =  705600
        vector> temp(84, vector(8400));
        vector> outVec(8400, vector(84));
        for(int i = 0; i < 705600; i++)
        {
            temp[i/8400][i%8400] = *ptr;
            ptr++;
        }
        for(int i = 0; i < 84; i++)
        {
            for(int j = 0; j < 8400; j++)
            {
                outVec[j][i] = temp[i][j];
            }
        }
        std::vector