如何部署基于MinkowskiEngine的神经网络用于C#应用？

一、WSL环境下的模型部署流程 #

1. 复刻本地环境

   • 更新WSL Ubuntu包：sudo apt update && sudo apt upgrade -y
   • 安装Python3.11：sudo apt install python3.11 python3.11-venv python3.11-dev -y
   • 创建并激活虚拟环境：

     python3.11 -m venv mink_env
     source mink_env/bin/activate
     

   • 安装MinkowskiEngine 0.5：
     • CPU版本：pip install -U MinkowskiEngine==0.5 --install-option="--cpu_only"
     • GPU版本：先安装对应CUDA版本的PyTorch，再执行上述命令（去掉--cpu_only）
   • 复制本地模型文件、推理代码到WSL（可通过cp命令或Windows挂载目录/mnt/c/...操作）

2. 验证环境可用性
   在WSL中运行本地测试过的推理脚本，确认模型能正常加载并输出结果，确保环境配置无误。

二、对接C#应用的方案（因MinkowskiEngine不支持ONNX导出） #

方案1：Python HTTP服务 + C#接口调用 #

将模型封装为HTTP接口，C#通过网络请求调用推理结果，适合大多数场景。

Python服务端代码（FastAPI示例）

from fastapi import FastAPI
from pydantic import BaseModel
import torch
import MinkowskiEngine as ME

app = FastAPI()

# 加载预训练模型（替换为你的模型结构）
model = ME.MinkowskiNet(in_channels=3, out_channels=10)
model.load_state_dict(torch.load("your_model.pth"))
model.eval()

# 定义输入数据结构（根据你的模型输入调整）
class InferenceRequest(BaseModel):
    coords: list[list[int]]  # 稀疏张量坐标
    feats: list[list[float]] # 对应特征值

@app.post("/infer")
async def infer(request: InferenceRequest):
    # 转换为MinkowskiEngine输入格式
    coords = torch.tensor(request.coords, dtype=torch.int32)
    feats = torch.tensor(request.feats, dtype=torch.float32)
    input_tensor = ME.SparseTensor(feats, coords=coords)

    # 推理计算
    with torch.no_grad():
        output = model(input_tensor)

    # 序列化结果返回
    return {
        "output_coords": output.coords.tolist(),
        "output_feats": output.features.tolist()
    }

• 启动服务：uvicorn main:app --host 0.0.0.0 --port 8000
• 获取WSL IP：执行ip addr show eth0，或配置端口转发后用localhost访问

C#客户端代码

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;

class Program
{
    static async System.Threading.Tasks.Task Main(string[] args)
    {
        using var client = new HttpClient();
        // 构造请求数据（替换为你的实际输入）
        var requestData = new
        {
            coords = new int[][] { new int[] {0,0,0}, new int[] {1,1,1} },
            feats = new float[][] { new float[] {1.0f,2.0f,3.0f}, new float[] {4.0f,5.0f,6.0f} }
        };

        var jsonPayload = JsonSerializer.Serialize(requestData);
        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

        var response = await client.PostAsync("http://<WSL_IP>:8000/infer", content);
        var resultJson = await response.Content.ReadAsStringAsync();
        var inferenceResult = JsonSerializer.Deserialize<InferenceResult>(resultJson);

        // 处理推理结果
        Console.WriteLine("推理完成，输出坐标数量：" + inferenceResult.OutputCoords.Length);
    }
}

public class InferenceResult
{
    public int[][] OutputCoords { get; set; }
    public float[][] OutputFeats { get; set; }
}

方案2：Python.NET直接调用（低延迟场景） #

通过Python.NET让C#直接加载Python环境并调用MinkowskiEngine代码，适合对延迟要求高的场景。

1. 环境准备

   • WSL Python环境安装pythonnet：pip install pythonnet
   • C#项目安装NuGet包：Install-Package Python.Runtime

2. Python推理脚本（inference_script.py）

import torch
import MinkowskiEngine as ME

# 全局加载模型
model = ME.MinkowskiNet(in_channels=3, out_channels=10)
model.load_state_dict(torch.load("your_model.pth"))
model.eval()

def infer(coords, feats):
    coords_tensor = torch.tensor(coords, dtype=torch.int32)
    feats_tensor = torch.tensor(feats, dtype=torch.float32)
    input_tensor = ME.SparseTensor(feats_tensor, coords=coords_tensor)
    with torch.no_grad():
        output = model(input_tensor)
    return {
        "output_coords": output.coords.tolist(),
        "output_feats": output.features.tolist()
    }

3. C#调用代码

using Python.Runtime;

class Program
{
    static void Main(string[] args)
    {
        // 设置WSL Python环境路径（替换为你的虚拟环境Python路径）
        Runtime.PythonDLL = "/home/xxx/mink_env/bin/python3.11";
        PythonEngine.Initialize();

        using (Py.GIL())
        {
            // 加载推理脚本
            var inferenceModule = Py.Import("inference_script");
            
            // 构造输入数据
            var coords = new int[][] { new int[] {0,0,0}, new int[] {1,1,1} };
            var feats = new float[][] { new float[] {1.0f,2.0f,3.0f}, new float[] {4.0f,5.0f,6.0f} };
            
            // 调用推理函数
            var result = inferenceModule.infer(coords, feats);
            
            // 解析结果
            var outputCoords = result["output_coords"].As<int[][]>();
            var outputFeats = result["output_feats"].As<float[][]>();
            
            Console.WriteLine("推理完成，输出特征数量：" + outputFeats.Length);
        }

        PythonEngine.Shutdown();
    }
}

三、部署注意事项 #

• GPU加速：确保WSL2启用CUDA支持（Windows11默认支持，需安装对应版本的CUDA驱动和工具包）
• 性能优化：将模型文件放在WSL本地文件系统，避免使用Windows挂载目录带来的IO延迟
• 服务稳定性：若使用HTTP服务，可通过Nginx反向代理或systemd配置守护进程，实现开机自启

内容的提问来源于stack exchange，提问作者yijian shi