C# 结合 YOLOv8 实现 GPU 加速推理的实战优化方案

1次阅读

没有评论

共计 3496 个字符，预计需要花费 9 分钟才能阅读完成。

在目标检测应用中，YOLOv8 以其高效的检测性能受到广泛关注。然而，对于 C# 开发者来说，传统的 CPU 推理方式往往面临严重的性能瓶颈。在实际项目中，我们发现以下几个主要问题：

CPU 推理速度慢，尤其是在处理高分辨率图像时，推理时间可能达到数百毫秒
内存占用高，当需要处理大量图像时容易导致内存溢出
无法充分利用现代 GPU 的强大计算能力

这些问题严重限制了 YOLOv8 在生产环境中的应用。特别是在需要实时处理的场景下，如视频监控、工业质检等，性能瓶颈更加明显。

为了解决这些问题，我们评估了多种 GPU 加速方案：

ONNX Runtime：
优点：跨平台支持良好，C# 集成简单，支持多种硬件加速
缺点：性能优化空间不如专用框架
TensorRT：
优点：极致优化性能，专为 NVIDIA GPU 设计
缺点：集成复杂度高，C# 支持有限
DirectML：
优点：Windows 原生支持，兼容多种 GPU
缺点：性能不如 CUDA 方案

综合考虑开发效率和性能需求，我们选择了 ONNX Runtime + CUDA 的组合方案。这一选择基于以下考量：

ONNX Runtime 提供良好的 C# API 支持
CUDA 加速可以提供可观的性能提升
方案具有较好的可维护性和扩展性

首先需要安装必要的 NuGet 包：

Install-Package Microsoft.ML.OnnxRuntime
Install-Package Microsoft.ML.OnnxRuntime.Gpu

// 初始化推理会话
var sessionOptions = new SessionOptions();
sessionOptions.AppendExecutionProvider_CUDA();  // 启用 CUDA 加速
var session = new InferenceSession("yolov8n.onnx", sessionOptions);

// 获取输入输出信息
var inputName = session.InputMetadata.Keys.First();
var inputShape = session.InputMetadata[inputName].Dimensions;
var outputName = session.OutputMetadata.Keys.First();

// 图像缩放和归一化
using var image = Image.Load<Rgb24>("input.jpg");
image.Mutate(x => x.Resize(new ResizeOptions
{Size = new Size(inputShape[2], inputShape[3]),
    Mode = ResizeMode.Stretch
}));

// 转换为 Tensor 并归一化
var inputTensor = new DenseTensor<float>(new[] {1, 3, inputShape[2], inputShape[3] });
image.ProcessPixelRows(accessor =>
{for (int y = 0; y < accessor.Height; y++)
    {var row = accessor.GetRowSpan(y);
        for (int x = 0; x < accessor.Width; x++)
        {inputTensor[0, 0, y, x] = row[x].R / 255f;
            inputTensor[0, 1, y, x] = row[x].G / 255f;
            inputTensor[0, 2, y, x] = row[x].B / 255f;
        }
    }
});

// 创建输入
var inputs = new List<NamedOnnxValue>
{NamedOnnxValue.CreateFromTensor(inputName, inputTensor)
};

// 执行推理
using var results = session.Run(inputs);
var outputTensor = results.First().AsTensor<float>();

// 解析输出结果
var predictions = new List<Prediction>();
for (int i = 0; i < outputTensor.Dimensions[1]; i++)
{var confidence = outputTensor[0, i, 4];
    if (confidence < confidenceThreshold) continue;

    // 解析边界框和类别
    var x = outputTensor[0, i, 0];
    var y = outputTensor[0, i, 1];
    var w = outputTensor[0, i, 2];
    var h = outputTensor[0, i, 3];

    // 转换坐标到原图尺寸
    // ...

    predictions.Add(new Prediction(x, y, w, h, confidence, classId));
}

// 批量处理多张图片
var batchSize = 4;
var batchInputTensor = new DenseTensor<float>(new[] {batchSize, 3, inputShape[2], inputShape[3] });

// 填充批量数据
// ...

// 执行批量推理
var batchInputs = new List<NamedOnnxValue>
{NamedOnnxValue.CreateFromTensor(inputName, batchInputTensor)
};

// 使用异步提高吞吐量
async Task<IReadOnlyCollection<Prediction>> DetectAsync(Image<Rgb24> image)
{
    // 预处理
    var inputTensor = await PreprocessImageAsync(image);

    // 异步推理
    var inputs = new List<NamedOnnxValue>
    {NamedOnnxValue.CreateFromTensor(inputName, inputTensor)
    };

    using var results = await Task.Run(() => session.Run(inputs));

    // 后处理
    return Postprocess(results);
}

// 复用内存对象
private static readonly DenseTensor<float> SharedInputTensor = 
    new DenseTensor<float>(new[] {1, 3, inputShape[2], inputShape[3] });

// 在预处理时直接填充共享 Tensor
image.ProcessPixelRows(accessor => 
{for (int y = 0; y < accessor.Height; y++)
    {var row = accessor.GetRowSpan(y);
        for (int x = 0; x < accessor.Width; x++)
        {SharedInputTensor[0, 0, y, x] = row[x].R / 255f;
            // ...
        }
    }
});