C#集成YOLOv11目标检测实战：从模型加载到性能优化

1次阅读

没有评论

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

在工业质检等场景下，C# 开发者调用 YOLOv11 目标检测模型时面临三大核心挑战：

跨语言交互成本：传统 Python 服务通过 REST API 暴露接口，引入网络延迟和序列化开销，影响实时性要求高的场景。
GPU 内存管理难题：C# 直接调用 Python 进程时，显存释放不及时会导致内存泄漏，特别是长时间运行的 Windows 服务。
后处理性能瓶颈：目标检测的 NMS（非极大抑制）操作在 Python 端处理时，数据往返拷贝消耗 20% 以上的推理时间。

对比两种主流部署方案：

TorchScript：
依赖 LibTorch 原生库，需手动处理版本匹配
移动端支持较好但 Windows 部署复杂
ONNX Runtime：
支持 DirectML/ CUDA/ TensorRT 多种后端
跨平台一致性高，NuGet 一键安装
微软官方维护，长期兼容性好

实测表明，ONNX Runtime 在 RTX 3060 上推理 640×640 图像仅需 18ms，比 Python 原生快 31%。

using Microsoft.ML.OnnxRuntime;

public class YoloV11 : IDisposable 
{
    private InferenceSession _session;

    public YoloV11(string modelPath)
    {var options = new SessionOptions()
        {
            GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_ALL,
            EnableMemoryPattern = true
        };
        options.AppendExecutionProvider_CUDA(); // GPU 加速
        _session = new InferenceSession(modelPath, options);
    }
}

关键处理步骤：

BGR 转 RGB（OpenCV 默认 BGR 格式）
归一化到 0 - 1 范围
调整维度为 NCHW 格式

public float[] Preprocess(Mat image)
{using var resized = new Mat();
    Cv2.Resize(image, resized, new Size(640, 640));

    var tensor = new float[1 * 3 * 640 * 640];
    for (int y = 0; y < 640; y++)
    {for (int x = 0; x < 640; x++)
        {var pixel = resized.Get<Vec3b>(y, x);
            tensor[y * 640 + x] = pixel.Item2 / 255f; // R 通道
            tensor[640*640 + y*640 + x] = pixel.Item1 / 255f; // G 通道 
            tensor[2*640*640 + y*640 + x] = pixel.Item0 / 255f; // B 通道
        }
    }
    return tensor;
}

public List<Detection> ParseOutput(float[] output, float confThreshold=0.5)
{var detections = new List<Detection>();

    // output 维度为 1x25200x85
    for (int i = 0; i < 25200; i++) 
    {
        int offset = i * 85;
        float conf = output[offset + 4];
        if (conf < confThreshold) continue;

        // 解析类别和坐标
        var scores = new float[80];
        Array.Copy(output, offset + 5, scores, 0, 80);
        int classId = scores.AsSpan().IndexOfMax();

        detections.Add(new Detection()
        {
            Confidence = conf,
            ClassId = classId,
            Box = ParseBox(output, offset)
        });
    }

    return NMS(detections, 0.45f);
}

private List<Detection> NMS(List<Detection> candidates, float iouThreshold)
{
    // 按置信度降序排序
    candidates.Sort((a,b) => b.Confidence.CompareTo(a.Confidence));

    var results = new List<Detection>();
    while (candidates.Count > 0)
    {var current = candidates[0];
        results.Add(current);

        candidates.RemoveAt(0);
        for (int i = candidates.Count - 1; i >= 0; i--)
        {if (CalculateIOU(current.Box, candidates[i].Box) > iouThreshold)
                candidates.RemoveAt(i);
        }
    }
    return results;
}

使用 BenchmarkDotNet 对比不同后端：

后端	平均耗时	内存分配
CPU	62ms	12MB
CUDA	18ms	4MB
TensorRT	11ms	3MB

对于 4K 大图处理：

将图像划分为 640×640 重叠网格
各块独立推理后合并结果
对边界框做全局 NMS

public List<Detection> ProcessLargeImage(Mat image, int tileSize=640)
{var allDetections = new List<Detection>();

    for (int y = 0; y < image.Height; y += tileSize/2)
    {for (int x = 0; x < image.Width; x += tileSize/2)
        {var roi = new Rect(x, y, tileSize, tileSize);
            if (roi.Right > image.Width) roi.X = image.Width - tileSize;
            if (roi.Bottom > image.Height) roi.Y = image.Height - tileSize;

            using var tile = new Mat(image, roi);
            allDetections.AddRange(Detect(tile));
        }
    }

    return NMS(allDetections, 0.3f);
}

ONNX 导出问题：
使用 opset_version=12 确保兼容性
导出时添加 --dynamic 参数支持可变输入

线程安全：

// 每个线程独立 Session
[ThreadStatic] 
private static InferenceSession _threadSession;

色域差异：

// System.Drawing 转 OpenCV 时需调整通道
using var bitmap = new Bitmap("image.jpg");
using var mat = bitmap.ToMat();
Cv2.CvtColor(mat, mat, ColorConversionCodes.BGR2RGB);