.NET 机器学习实战

// 最小示例：进程内训练一个二分类模型并立即推理
var mlContext = new MLContext(seed: 42);
var data = mlContext.Data.LoadFromTextFile<SentimentData>(
    "sentiment.csv", hasHeader: true, separatorChar: ',');

var pipeline = mlContext.Transforms.Text
    .FeaturizeText("Features", nameof(SentimentData.Text))
    .Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression(
        labelColumnName: nameof(SentimentData.Label)));

var model = pipeline.Fit(data);   // 训练完成，可立即用于预测

// 完整的训练管线：数据划分 + 特征工程 + 训练 + 评估
public sealed class ModelTrainer
{
    public (ITransformer Model, DataViewSchema Schema) Train(string dataPath)
    {
        var ctx = new MLContext(seed: 42);
        var data = ctx.Data.LoadFromTextFile<HousingData>(
            dataPath, hasHeader: true, separatorChar: ',');

        var split = ctx.Data.TrainTestSplit(data, testFraction: 0.2, seed: 42);

        var pipeline = ctx.Transforms.Categorical
            .OneHotEncoding("NeighborhoodEncoded", nameof(HousingData.Neighborhood))
            .Append(ctx.Transforms.NormalizeMinMax("SizeNorm", nameof(HousingData.Size)))
            .Append(ctx.Transforms.Concatenate("Features",
                "NeighborhoodEncoded", "SizeNorm", nameof(HousingData.Rooms)))
            .Append(ctx.Regression.Trainers.FastTree(
                labelColumnName: nameof(HousingData.Price), numberOfLeaves: 32));

        var model = pipeline.Fit(split.TrainSet);
        return (model, data.Schema);
    }
}

// 评估：用留出集计算指标，而不是训练集
var predictions = model.Transform(split.TestSet);
var metrics = ctx.Regression.Evaluate(predictions, labelColumnName: "Price");

Console.WriteLine($"RMSE: {metrics.RootMeanSquaredError:F2}");
Console.WriteLine($"R2:   {metrics.RSquared:F3}");

// 分类任务换用对应评估器
var clsMetrics = ctx.BinaryClassification.Evaluate(predictions, labelColumnName: "Label");
Console.WriteLine($"AUC: {clsMetrics.AreaUnderRocCurve:F3}");
Console.WriteLine($"F1:  {clsMetrics.F1Score:F3}");

// 交叉验证：比单次划分更稳，尤其适合数据量不大的场景
var cvResults = ctx.BinaryClassification.CrossValidate(
    data, pipeline, numberOfFolds: 5, labelColumnName: "Label");

var avgAuc = cvResults.Average(r => r.Metrics.AreaUnderRocCurve);
var stdAuc = Math.Sqrt(cvResults.Average(r =>
    Math.Pow(r.Metrics.AreaUnderRocCurve - avgAuc, 2)));
Console.WriteLine($"AUC 均值 {avgAuc:F3}，标准差 {stdAuc:F3}");
// 标准差大说明模型对数据划分敏感，需要更多数据或更简单的模型

// 网格搜索：小规模超参搜索，用交叉验证选最优
var options = new[] { (Leaves: 16, MinDocs: 10), (Leaves: 32, MinDocs: 20), (Leaves: 64, MinDocs: 50) };

var best = options
    .Select(o => new
    {
        Option = o,
        Score = ctx.Regression.CrossValidate(data, ctx.Transforms
            .Concatenate("Features", "SizeNorm", "Rooms")
            .Append(ctx.Regression.Trainers.FastTree(
                labelColumnName: "Price", numberOfLeaves: o.Leaves,
                minimumExampleCountPerLeaf: o.MinDocs)), numberOfFolds: 5)
            .Average(r => r.Metrics.RootMeanSquaredError),
    })
    .OrderBy(r => r.Score)      // RMSE 越小越好
    .First();
Console.WriteLine($"最优参数：{best.Option}，RMSE {best.Score:F2}");

// 加载 ONNX 模型并推理
public sealed class OnnxPredictor : IDisposable
{
    private readonly InferenceSession _session;

    public OnnxPredictor(string modelPath)
    {
        var options = new SessionOptions
        {
            GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_ALL,
            IntraOpNumThreads = Environment.ProcessorCount,
        };
        _session = new InferenceSession(modelPath, options);
    }

    public float[] Predict(float[] features)
    {
        // 输入名与形状必须与导出时一致，可用 session.InputMetadata 查询
        var input = new DenseTensor<float>(features, new[] { 1, features.Length });
        var inputs = new[] { NamedOnnxValue.CreateFromTensor("float_input", input) };
        using var results = _session.Run(inputs);
        return results.First().AsEnumerable<float>().ToArray();
    }

    public void Dispose() => _session.Dispose();
}

# 训练侧：用 skl2onnx 把 scikit-learn 模型导出为 ONNX
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

onnx_model = convert_sklearn(
    clf,
    initial_types=[("float_input", FloatTensorType([None, n_features]))],
    target_opset=17)
with open("model.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

// 模型注册表：把模型文件与元数据一起管理
public sealed record ModelArtifact(
    string Name,
    string Version,
    string Path,
    string Sha256,
    DateTimeOffset TrainedAt,
    IReadOnlyDictionary<string, double> Metrics,
    string FeatureSchemaVersion);

public sealed class ModelRegistry(string root)
{
    public ModelArtifact? Resolve(string name, string? version = null)
    {
        var dir = Path.Combine(root, name);
        if (!Directory.Exists(dir)) return null;

        var target = version ?? Directory.GetDirectories(dir)
            .OrderByDescending(Path.GetFileName).First();
        var meta = Path.Combine(target, "metadata.json");
        return JsonSerializer.Deserialize<ModelArtifact>(File.ReadAllText(meta));
    }
}

// 在 ASP.NET Core 中托管模型：单例加载 + 热更新
builder.Services.AddSingleton<ModelRegistry>(_ => new ModelRegistry("/models"));
builder.Services.AddSingleton<IModelProvider>(sp =>
{
    var artifact = sp.GetRequiredService<ModelRegistry>().Resolve("sentiment", "latest")
        ?? throw new InvalidOperationException("模型未注册");
    return new OnnxModelProvider(artifact);   // 内部持有 InferenceSession
});

app.MapPost("/predict", (PredictRequest req, IModelProvider provider) =>
    Results.Ok(provider.Predict(req.Features)));

# Python 侧导出「特征契约」，与模型一起交付
import json

feature_contract = {
    "version": "3",
    "features": [
        {"name": "size", "type": "float32", "impute": "median", "scale": "minmax"},
        {"name": "rooms", "type": "float32", "impute": "median", "scale": "none"},
        {"name": "neighborhood", "type": "category",
         "categories": ["downtown", "suburb", "rural"]},
    ],
    "target": {"name": "price", "type": "float32"},
}
with open("feature_contract.json", "w", encoding="utf-8") as f:
    json.dump(feature_contract, f, ensure_ascii=False, indent=2)

// .NET 侧按契约构建特征向量，顺序与类型严格对齐
public sealed class FeatureBuilder(FeatureContract contract)
{
    public float[] Build(HousingInput input)
    {
        var values = new List<float>(contract.Features.Count);
        foreach (var f in contract.Features)
        {
            values.Add(f.Name switch
            {
                "size" => (float)((input.Size - f.Min) / (f.Max - f.Min)),  // minmax
                "rooms" => input.Rooms,
                "neighborhood" => f.Categories.IndexOf(input.Neighborhood), // 与训练同序
                _ => throw new InvalidOperationException($"未知特征 {f.Name}"),
            });
        }
        return values.ToArray();
    }
}

// 批处理推理：攒批 + 单次 Run，吞吐远高于逐条调用
public sealed class BatchPredictor(InferenceSession session) : IDisposable
{
    private readonly Channel<(float[][] Input, TaskCompletionSource<float[][]> Tcs)> _queue
        = Channel.CreateBounded<(float[][], TaskCompletionSource<float[][]>)>(1000);

    public Task<float[][]> PredictAsync(float[][] features)
    {
        var tcs = new TaskCompletionSource<float[][]>(
            TaskCreationOptions.RunContinuationsAsynchronously);
        if (!_queue.Writer.TryWrite((features, tcs)))
            tcs.SetException(new InvalidOperationException("推理队列已满"));
        return tcs.Task;
    }

    public async Task RunAsync(CancellationToken ct)
    {
        var buffer = new List<(float[][], TaskCompletionSource<float[][]>)>(64);
        while (await _queue.Reader.WaitToReadAsync(ct))
        {
            buffer.Clear();
            while (buffer.Count < 64 && _queue.Reader.TryRead(out var item))
                buffer.Add(item);
            if (buffer.Count == 0) continue;

            var flat = buffer.SelectMany(b => b.Item1).SelectMany(x => x).ToArray();
            var tensor = new DenseTensor<float>(flat,
                new[] { buffer.Sum(b => b.Item1.Length), buffer[0].Item1[0].Length });
            using var results = session.Run(new[]
            {
                NamedOnnxValue.CreateFromTensor("float_input", tensor),
            });
            _ = results;   // 拆分结果并按序完成各 Task，此处省略
        }
    }

    public void Dispose() => session.Dispose();
}