C# 机器学习与深度学习生态全景：六大开源框架深度对比分析

一文读懂 .NET 平台上的机器学习与深度学习框架选型

前言

在机器学习和深度学习领域，Python 长期占据主导地位。然而，对于企业级 .NET 应用开发者而言，在现有技术栈中集成机器学习能力是一种自然的需求。本文将深入分析 GitHub 上最受欢迎的 C# 机器学习/深度学习开源框架，帮助你做出正确的技术选型。

一、框架概览与排名

二、ML.NET：微软官方的机器学习框架

2.1 架构设计

ML.NET 采用管道式（Pipeline）架构，核心设计理念是让 .NET 开发者无需 ML 专业知识即可构建机器学习应用。

┌─────────────────────────────────────────────────────────────────┐
│                        ML.NET 架构图                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   MLContext (入口点)                                             │
│       │                                                         │
│       ├── DataOperationsCatalog    (数据加载/保存)               │
│       ├── TransformsCatalog        (数据转换)                    │
│       ├── BinaryClassificationCatalog                            │
│       ├── MulticlassClassificationCatalog                        │
│       ├── RegressionCatalog                                      │
│       ├── ClusteringCatalog                                      │
│       ├── AnomalyDetectionCatalog                                │
│       ├── RecommendationCatalog                                  │
│       └── TimeSeriesCatalog                                      │
│                                                                 │
│   管道流程:                                                       │
│   IDataView → IEstimator → ITransformer → PredictionEngine       │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

2.2 核心组件

2.3 支持的算法

分类任务：

• 二分类：FastTree、LightGBM、SDCA、L-BFGS Logistic Regression、SVM
• 多分类：LightGBM、SDCA、Naive Bayes、One-Versus-All

• 线性回归、SDCA、FastTree、LightGBM、GAM

• K-Means

• 异常检测（PCA）
• 推荐系统（矩阵分解）
• 时间序列预测（SSA）
• 图像分类（TensorFlow 迁移学习）

2.4 AutoML 能力

ML.NET 提供三种 AutoML 工具：

// 代码式 AutoML
var experiment = mlContext.Auto()
    .CreateBinaryClassificationExperiment(trainingTimeInSeconds: 60);
var result = experiment.Execute(trainingDataView);
var bestModel = result.BestRun.Model;

Model Builder（Visual Studio 扩展）：

• 可视化界面，支持分类、回归、推荐、预测、图像分类
• 自动生成训练代码和消费代码

mlnet classification --dataset "data.csv" --label-col "Label" --train-time 60

2.5 代码示例：情感分析

using Microsoft.ML;
using Microsoft.ML.Data;

// 1. 创建 MLContext
var mlContext = new MLContext();

// 2. 加载数据
IDataView trainingData = mlContext.Data
    .LoadFromTextFile<SentimentData>(dataPath, hasHeader: true);

// 3. 构建管道
var pipeline = mlContext.Transforms.Text
    .FeaturizeText("Features", nameof(SentimentData.Text))
    .Append(mlContext.BinaryClassification.Trainers
        .LbfgsLogisticRegression("Label", "Features"));

// 4. 训练模型
ITransformer model = pipeline.Fit(trainingData);

// 5. 预测
var engine = mlContext.Model
    .CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var prediction = engine.Predict(new SentimentData { Text = "This is great!" });

Console.WriteLine($"预测结果: {prediction.Prediction}, 概率: {prediction.Probability:P}");

2.6 TensorFlow/ONNX 集成

// 图像分类（迁移学习）
var pipeline = mlContext.Transforms.LoadImages("Image", "", "ImagePath")
    .Append(mlContext.Transforms.ResizeImages("Image", 224, 224))
    .Append(mlContext.Transforms.ExtractPixels("Image"))
    .Append(mlContext.MulticlassClassification.Trainers.ImageClassification(
        new ImageClassificationTrainer.Options()
        {
            Arch = ImageClassificationTrainer.Architecture.ResnetV2101,
            MetricsCallback = metrics => Console.WriteLine(metrics)
        }))
    .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

2.7 最新特性（ML.NET 5.0+）

• GenAI 集成：CausalLMPipelineChatClient 支持
• 新 Tokenizer：SentencePiece、Phi-4、ByteLevel BPE（DeepSeek）、Tiktoken（GPT-4）
• LightGBM 增强：确定性选项、NumberOfLeaves 参数

三、TensorFlow.NET：TensorFlow 的完整 .NET 实现

3.1 架构设计

TensorFlow.NET 通过 P/Invoke 绑定到 TensorFlow 的原生 C API，提供与 Python TensorFlow 几乎相同的 API 体验。

┌─────────────────────────────────────────────────────────────────┐
│                    TensorFlow.NET 架构                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   TensorFlow.Keras (高级 API)                                    │
│   ├── Sequential API                                            │
│   ├── Functional API                                            │
│   └── Subclassing API                                           │
│                                                                 │
│   TensorFlow.NET (核心绑定)                                      │
│   ├── P/Invoke 声明                                             │
│   ├── Tensor 操作                                               │
│   └── 会话管理                                                   │
│                                                                 │
│   SciSharp.TensorFlow.Redist (原生库)                           │
│   └── TensorFlow C Library                                      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

3.2 Keras API 支持

Sequential API：

var model = keras.Sequential();
model.add(keras.layers.Dense(64, activation: "relu", input_shape: (784,)));
model.add(keras.layers.Dense(64, activation: "relu"));
model.add(keras.layers.Dense(10, activation: "softmax"));

model.compile(optimizer: "adam", loss: "sparse_categorical_crossentropy");
model.fit(x_train, y_train, epochs: 5);

Functional API（ResNet 示例）：

var inputs = keras.Input(shape: (32, 32, 3), name: "img");
var x = layers.Conv2D(32, 3, activation: "relu").Apply(inputs);
var x = layers.Conv2D(64, 3, activation: "relu").Apply(x);
var block_1_output = layers.MaxPooling2D(3).Apply(x);

// 残差连接
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(block_1_output);
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(x);
var block_2_output = layers.Add().Apply(new Tensors(x, block_1_output));

var outputs = layers.Dense(10).Apply(x);
var model = keras.Model(inputs, outputs, name: "toy_resnet");

3.3 Eager Execution vs Graph Mode

Eager 模式（默认）：

tf.enable_eager_execution();

var W = tf.Variable(-0.06f, name: "weight");
var b = tf.Variable(-0.73f, name: "bias");

using var g = tf.GradientTape();
var pred = W * X + b;
var loss = tf.reduce_sum(tf.pow(pred - Y, 2)) / (2 * n_samples);
var gradients = g.gradient(loss, (W, b));
optimizer.apply_gradients(zip(gradients, (W, b)));

3.4 GPU 支持

// 检查 GPU
var gpus = tf.config.list_physical_devices("GPU");
Console.WriteLine($"可用 GPU 数量: {gpus.Length}");

四、TorchSharp：PyTorch 的 .NET 桥梁

4.1 架构设计

TorchSharp 通过四层架构连接 .NET 和 PyTorch：

┌─────────────────────────────────────────────────────────────────┐
│ Layer 1: Managed .NET API (C#/F#)                               │
│ - Tensor 类、nn.Module、优化器                                   │
├─────────────────────────────────────────────────────────────────┤
│ Layer 2: P/Invoke Bridge                                        │
│ - extern 方法声明、类型封送                                      │
├─────────────────────────────────────────────────────────────────┤
│ Layer 3: Native C++ (LibTorchSharp)                            │
│ - THSTensor_*, THSNN_* 包装函数                                 │
├─────────────────────────────────────────────────────────────────┤
│ Layer 4: LibTorch (PyTorch C++ Backend)                        │
│ - at::Tensor 操作、CUDA 内核、Autograd 引擎                      │
└─────────────────────────────────────────────────────────────────┘

4.2 Tensor 操作与 Autograd

// Tensor 创建
var zeros = torch.zeros(3, 4);
var ones = torch.ones(2, 3, 4);
var randn = torch.randn(64, 1000);
var fromArray = torch.tensor(new[] { 1, 2, 3 });

// GPU 支持
var cudaTensor = torch.randn(10).cuda();

// Autograd 自动微分
var x = torch.randn(3, 4, requires_grad: true);
var y = torch.randn(3, 4, requires_grad: true);

var z = x * 2 + y;
var loss = z.pow(2).sum();

loss.backward();

Console.WriteLine($"∂loss/∂x = {x.grad()}");
Console.WriteLine($"∂loss/∂y = {y.grad()}");

4.3 自定义神经网络模块

using TorchSharp;
using static TorchSharp.torch.nn;

public class MNISTModel : Module<Tensor, Tensor>
{
    private readonly Module<Tensor, Tensor> conv1, conv2, fc1, fc2;
    
    public MNISTModel() : base("MNIST")
    {
        conv1 = Conv2d(1, 32, kernelSize: 3, stride: 1);
        conv2 = Conv2d(32, 64, kernelSize: 3, stride: 1);
        fc1 = Linear(9216, 128);
        fc2 = Linear(128, 10);
        RegisterComponents();  // 必须调用！
    }

    public override Tensor forward(Tensor input)
    {
        using var x1 = conv1.forward(input);
        using var x2 = relu(x1);
        using var x3 = max_pool2d(x2, 2);
        using var x4 = conv2.forward(x3);
        using var x5 = relu(x4);
        using var x6 = max_pool2d(x5, 2);
        using var x7 = flatten(x6, 1);
        using var x8 = fc1.forward(x7);
        using var x9 = relu(x8);
        return log_softmax(fc2.forward(x9), dim: 1);
    }
}

4.4 内存管理：DisposeScope

TorchSharp 提供独特的内存管理模式：

// 推荐模式：DisposeScope
using (var d = torch.NewDisposeScope())
{
    var result = complexComputation();
    return result.MoveToOuterDisposeScope();  // 保留结果
}  // 其他中间张量自动释放

// Sequential 构建
var model = Sequential(
    ("conv1", Conv2d(1, 32, kernelSize: 3)),
    ("relu1", ReLU()),
    ("pool1", MaxPool2d(2)),
    ("flatten", Flatten()),
    ("fc1", Linear(32 * 13 * 13, 128)),
    ("fc2", Linear(128, 10))
);

4.5 TorchVision 支持

using static TorchSharp.torchvision.transforms;

var transform = transforms.Compose(
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ConvertImageDtype(torch.ScalarType.Float32),
    transforms.Normalize(
        mean: new[] { 0.485f, 0.456f, 0.406f },
        std: new[] { 0.229f, 0.224f, 0.225f })
);

// 加载预训练模型
var resnet = torchvision.models.resnet18(
    numClasses: 1000,
    weights: torchvision.models.ResNet18_Weights.IMAGENET1K_V1
);

五、BotSharp：企业级 AI 多智能体框架

5.1 架构设计

BotSharp 是专为 .NET 设计的AI 多智能体框架，采用插件化架构：

┌─────────────────────────────────────────────────────────────────┐
│                      BotSharp 架构                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   用户请求 → Router Agent → Task Agent(s) → LLM Provider        │
│                                                                 │
│   核心模块:                                                       │
│   ├── Plugin Loader (插件加载器)                                 │
│   ├── Hook System (钩子系统)                                     │
│   ├── Agent Profile (智能体配置)                                 │
│   ├── Conversation & State (会话状态管理)                        │
│   ├── Routing & Planning (路由规划)                              │
│   ├── Templating (Liquid 模板)                                   │
│   └── LLM Provider Abstraction (LLM 提供者抽象)                  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

5.2 LLM 集成

5.3 RAG 能力

// 知识库配置
// 通过 API 上传文档：POST /knowledge/{agentId}

// RAG 组件:
// - BotSharp.Plugin.KnowledgeBase (核心知识管理)
// - BotSharp.Plugin.Qdrant (向量数据库)
// - 文本嵌入: fastText, LLamaSharp, BERT

5.4 MCP (Model Context Protocol) 支持

BotSharp 在 r5.0 版本中添加了 MCP 集成：

• 可视化 MCP 管理
• 支持大模型调用外部工具
• 与 mcp.so 等主流服务集成

5.5 多渠道支持

5.6 创建智能体插件

namespace BotSharp.Plugin.PizzaBot;

public class PizzaBotPlugin : IBotSharpPlugin
{
    public void RegisterDI(IServiceCollection services, IConfiguration config)
    {
        services.AddScoped<IFunctionCallback, MakePaymentFn>();
        services.AddScoped<IAgentHook, PizzaBotAgentHook>();
    }
}

// 函数定义 (JSON)
{
    "name": "make_payment",
    "description": "call this function to make payment",
    "visibility_expression": "{% if states.order_number != empty %}visible{% endif %}",
    "parameters": {
        "type": "object",
        "properties": {
            "order_number": { "type": "string", "description": "order number" },
            "total_amount": { "type": "string", "description": "total amount" }
        },
        "required": ["order_number", "total_amount"]
    }
}

5.7 最新特性

• 图像生成与处理（r5.2）
• 图表生成（ChartHandler）
• 实时语音（Realtime Voice）
• Python 解释器
• Playwright WebDriver（浏览器自动化）
• SQL Driver（数据库助手）

六、Infer.NET：贝叶斯推断与概率编程

6.1 核心概念

Infer.NET 是微软开发的概率编程框架，用于贝叶斯推断。与传统的预构建算法不同，你可以定义自己的统计模型。

┌─────────────────────────────────────────────────────────────────┐
│                    Infer.NET 架构                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   模型定义 (用户代码)                                            │
│       │                                                         │
│       ▼                                                         │
│   模型编译器 (源代码生成)                                        │
│       │                                                         │
│       ▼                                                         │
│   编译后的算法                                                   │
│       │                                                         │
│       ▼                                                         │
│   推理引擎 (执行) ← 观测值 (数据)                                │
│       │                                                         │
│       ▼                                                         │
│   查询结果 (分布)                                                │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

6.2 消息传递算法

6.3 代码示例

两枚硬币问题：

using Microsoft.ML.Probabilistic;
using Microsoft.ML.Probabilistic.Models;

Variable<bool> firstCoin = Variable.Bernoulli(0.5);
Variable<bool> secondCoin = Variable.Bernoulli(0.5);
Variable<bool> bothHeads = firstCoin & secondCoin;

InferenceEngine engine = new InferenceEngine();
Console.WriteLine(engine.Infer(bothHeads));
// 输出: Bernoulli(0.25)

TrueSkill 玩家技能评分：

// 玩家技能变量
var playerSkills = Variable.Array<double>(player);
playerSkills[player] = Variable.GaussianFromMeanAndVariance(6, 9).ForEach(player);

// 比赛表现 = 技能 + 噪声
var winnerPerformance = Variable.GaussianFromMeanAndVariance(
    playerSkills[winners[game]], 1.0);
var loserPerformance = Variable.GaussianFromMeanAndVariance(
    playerSkills[losers[game]], 1.0);

// 约束：获胜者表现更好
Variable.ConstrainTrue(winnerPerformance > loserPerformance);

// 推断
var inferredSkills = inferenceEngine.Infer<Gaussian[]>(playerSkills);

6.4 与 ML.NET 的关系

Infer.NET 现在是 ML.NET 的一部分，通过 NuGet 包分发：

• Microsoft.ML.Probabilistic
• Microsoft.ML.Probabilistic.Compiler
• Microsoft.ML.Probabilistic.Learners

七、Accord.NET：已归档的经典框架

7.1 历史与现状

Accord.NET 始于 2007 年，是 .NET 平台上最早的综合机器学习框架之一，于 2020 年 11 月归档。

归档原因：

1. Microsoft 发布 ML.NET，使其最终过时
2. 作者攻读博士，无法维护
3. 学术界普遍使用 Python，C# 在 ML 领域认可度低

7.2 主要模块

7.3 统一学习模式

// Accord.NET 的学习模式
var learner = new SupportVectorLearning< Gaussian >();
var svm = learner.Learn(inputs, outputs);  // 训练
var prediction = svm.Decide(newInput);      // 预测

7.4 迁移建议

• 新项目：使用 ML.NET
• 需要 TensorFlow/PyTorch：使用 TensorFlow.NET 或 TorchSharp
• 现有 Accord.NET 项目：可继续使用，但不推荐新功能开发

八、框架对比分析

8.1 功能定位对比

┌─────────────────────────────────────────────────────────────────┐
│                     应用场景光谱                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  传统ML      深度学习        LLM应用        AI Agent             │
│    │            │              │              │                  │
│    ▼            ▼              ▼              ▼                  │
│  ML.NET    TensorFlow.NET   BotSharp      BotSharp              │
│  Accord.NET  TorchSharp                                        │
│  Infer.NET                                                     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

8.2 技术特性对比

8.3 API 风格对比

ML.NET（管道式）：

var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", "Text")
    .Append(mlContext.BinaryClassification.Trainers.FastTree());
var model = pipeline.Fit(data);

TensorFlow.NET（Keras 风格）：

var model = keras.Sequential();
model.add(keras.layers.Dense(64, activation: "relu"));
model.compile(optimizer: "adam", loss: "mse");
model.fit(x, y, epochs: 10);

TorchSharp（PyTorch 风格）：

public class Net : Module<Tensor, Tensor> {
    private Module<Tensor, Tensor> fc1 = Linear(784, 128);
    public override Tensor forward(Tensor x) => fc1.forward(x);
}
var model = new Net().to(torch.CUDA);

8.4 性能对比

九、选型决策树

开始选型
    │
    ├── 需要构建 AI Agent / 聊天机器人？
    │   └── 是 → BotSharp
    │
    ├── 需要概率编程 / 贝叶斯推断？
    │   └── 是 → Infer.NET
    │
    ├── 需要深度学习（自定义网络）？
    │   ├── 熟悉 PyTorch？ → TorchSharp
    │   └── 熟悉 TensorFlow？ → TensorFlow.NET
    │
    ├── 需要传统机器学习？
    │   ├── 想要 AutoML？ → ML.NET
    │   ├── 需要图像分类（迁移学习）？ → ML.NET
    │   └── 通用 ML 任务？ → ML.NET
    │
    └── 维护旧项目？
        └── Accord.NET → 考虑迁移到 ML.NET

十、快速入门指南

10.1 ML.NET 快速开始

# 安装 NuGet 包
dotnet add package Microsoft.ML

# 可选：AutoML
dotnet add package Microsoft.ML.AutoML

// 最小示例
var mlContext = new MLContext();
var data = mlContext.Data.LoadFromEnumerable(yourData);
var pipeline = mlContext.Regression.Trainers.Sdca(labelColumnName: "Label");
var model = pipeline.Fit(data);

10.2 TorchSharp 快速开始

# CPU 版本
dotnet add package TorchSharp

# GPU 版本 (Windows)
dotnet add package TorchSharp-cuda-windows

# 计算机视觉
dotnet add package TorchVision

using TorchSharp;
using static TorchSharp.torch.nn;

var model = Sequential(
    Linear(784, 128),
    ReLU(),
    Linear(128, 10)
);

var optimizer = optim.Adam(model.parameters(), lr: 0.001f);

10.3 TensorFlow.NET 快速开始

dotnet add package TensorFlow.NET
dotnet add package TensorFlow.Keras
dotnet add package SciSharp.TensorFlow.Redist

using static Tensorflow.KerasApi;

var model = keras.Sequential();
model.add(keras.layers.Dense(10, activation: "softmax"));
model.compile(optimizer: "adam", loss: "sparse_categorical_crossentropy");

10.4 BotSharp 快速开始

git clone https://github.com/SciSharp/BotSharp
cd BotSharp
dotnet run --project ./src/WebStarter/WebStarter.csproj

访问 http://localhost:5500 进入管理界面。

十一、生态与社区

11.1 NuGet 下载量（近似）

11.2 SciSharp 生态系统

SciSharp 组织维护了多个重要的 .NET ML/DL 项目：

• TensorFlow.NET
• NumSharp（NumPy 移植）
• Pandas.NET（Pandas 移植）
• BotSharp
• Keras.NET

11.3 社区活跃度

十二、总结与建议

新项目选型建议

迁移建议

未来展望

1. ML.NET 将继续作为微软官方框架，获得持续投入
2. TorchSharp 随着 .NET 9 的发布，性能和兼容性将进一步提升
3. BotSharp 在 AI Agent 热潮下，将成为 .NET 生态中的重要力量
4. TensorFlow.NET 需要新的维护者加入，未来发展存在不确定性

参考资料

• ML.NET 官方文档
• TensorFlow.NET GitHub
• TorchSharp GitHub
• BotSharp GitHub
• Infer.NET 文档
• Accord.NET 归档说明

本文基于 GitHub 2025 年数据编写，框架版本可能已有更新。建议在实际选型前查阅各项目的最新文档和 Release Notes。