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

QianXun (QianXun) • 2026年02月18日 07:18
                        # C# 机器学习与深度学习生态全景：六大开源框架深度对比分析

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

## 前言

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

---

## 一、框架概览与排名

| 排名 | 项目 | Stars | 类型 | 维护状态 | 核心定位 |
|------|------|-------|------|----------|----------|
| 1 | **ML.NET** | 9.3k | 原生ML框架 | ✅ 活跃 | 微软官方，企业级ML |
| 2 | **Accord.NET** | 4.6k | 原生ML框架 | ❌ 已归档 | 传统ML算法库 |
| 3 | **TensorFlow.NET** | 3.4k | TF绑定 | ⚠️ 维护模式 | TensorFlow的.NET实现 |
| 4 | **BotSharp** | 3.0k | AI Agent框架 | ✅ 活跃 | 企业级多智能体系统 |
| 5 | **TensorFlowSharp** | 3.2k | TF绑定 | ❌ 已归档 | TensorFlow C API绑定 |
| 6 | **TorchSharp** | 1.8k | PyTorch绑定 | ✅ 活跃 | PyTorch的.NET实现 |
| 7 | **Infer.NET** | 1.6k | 概率编程 | ✅ 活跃 | 贝叶斯推断框架 |

---

## 二、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 核心组件

| 组件 | 作用 |
|------|------|
| **MLContext** | 所有 ML.NET 操作的入口点，类似 EF 的 DbContext |
| **IDataView** | 核心数据抽象，延迟加载、列式存储、线程安全 |
| **IEstimator** | 转换器或训练器的蓝图 |
| **ITransformer** | 训练后的模型，可对数据进行转换 |
| **PredictionEngine** | 单次预测的便捷 API |

### 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 工具：

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

**Model Builder（Visual Studio 扩展）：**
- 可视化界面，支持分类、回归、推荐、预测、图像分类
- 自动生成训练代码和消费代码

**ML.NET CLI：**
```bash
mlnet classification --dataset "data.csv" --label-col "Label" --train-time 60
```

### 2.5 代码示例：情感分析

```csharp
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 集成

```csharp
// 图像分类（迁移学习）
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：**
```csharp
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 示例）：**
```csharp
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 模式（默认）：**
```csharp
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)));
```

| 特性 | Eager 模式 | Graph 模式 |
|------|-----------|-----------|
| 执行方式 | 立即执行 | 延迟执行（会话） |
| 调试 | 简单 | 需要 TensorBoard |
| 性能 | 稍慢 | 生产优化 |
| 用途 | 研究、训练 | 生产推理 |

### 3.4 GPU 支持

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

| 平台 | CPU 包 | GPU 包 |
|------|--------|--------|
| Windows | SciSharp.TensorFlow.Redist | SciSharp.TensorFlow.Redist-Windows-GPU |
| Linux | SciSharp.TensorFlow.Redist | SciSharp.TensorFlow.Redist-Linux-GPU |

---

## 四、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

```csharp
// 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 自定义神经网络模块

```csharp
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 提供独特的内存管理模式：

```csharp
// 推荐模式：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 支持

```csharp
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 集成

| 提供者 | 插件包 |
|--------|--------|
| Azure OpenAI | BotSharp.Plugin.AzureOpenAI |
| OpenAI (GPT-4o/o1) | BotSharp.Plugin.OpenAI |
| Anthropic Claude | BotSharp.Plugin.AnthropicAI |
| Google Gemini | BotSharp.Plugin.GoogleAI |
| DeepSeek V3 | BotSharp.Plugin.DeepSeekAI |
| Meta LLaMA | BotSharp.Plugin.LLamaSharp |
| HuggingFace | BotSharp.Plugin.HuggingFace |

### 5.3 RAG 能力

```csharp
// 知识库配置
// 通过 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 多渠道支持

| 渠道 | 插件包 |
|------|--------|
| Twilio (语音/SMS) | BotSharp.Plugin.Twilio |
| Facebook Messenger | BotSharp.Plugin.MetaMessenger |
| Telegram | BotSharp.Plugin.TelegramBots |
| 微信 | BotSharp.Plugin.WeChat |
| Web/WebSocket | BotSharp.Plugin.ChatHub |

### 5.6 创建智能体插件

```csharp
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 消息传递算法

| 算法 | 特点 | 适用场景 |
|------|------|----------|
| **Expectation Propagation (EP)** | 默认算法，零避免 | 通用场景 |
| **Variational Message Passing (VMP)** | 保证收敛，零强制 | 需要稳定性的场景 |
| **Gibbs Sampling** | 随机采样，最终收敛 | 复杂后验分布 |

### 6.3 代码示例

**两枚硬币问题：**
```csharp
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 玩家技能评分：**
```csharp
// 玩家技能变量
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 主要模块

| 模块 | 功能 |
|------|------|
| Accord.MachineLearning | SVM、神经网络、决策树 |
| Accord.Statistics | 统计分布、假设检验 |
| Accord.Imaging | 计算机视觉、特征检测 |
| Accord.Vision | 人脸检测、目标跟踪 |
| Accord.Audio | 音频信号处理 |
| Accord.Neuro | 深度信念网络、RBM |

### 7.3 统一学习模式

```csharp
// 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 技术特性对比

| 特性 | ML.NET | TensorFlow.NET | TorchSharp | BotSharp | Infer.NET |
|------|--------|----------------|------------|----------|-----------|
| **原生 .NET** | ✅ | ❌ (绑定) | ❌ (绑定) | ✅ | ✅ |
| **深度学习** | ⚠️ (通过集成) | ✅ | ✅ | ❌ | ❌ |
| **传统 ML** | ✅ | ❌ | ❌ | ❌ | ⚠️ |
| **GPU 支持** | ✅ | ✅ | ✅ | ✅ | ❌ |
| **AutoML** | ✅ | ❌ | ❌ | ❌ | ❌ |
| **可视化工具** | ✅ Model Builder | ❌ | ❌ | ✅ Web UI | ⚠️ |
| **生产就绪** | ✅ | ⚠️ | ✅ | ✅ | ✅ |
| **活跃维护** | ✅ | ⚠️ | ✅ | ✅ | ✅ |

### 8.3 API 风格对比

**ML.NET（管道式）：**
```csharp
var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", "Text")
    .Append(mlContext.BinaryClassification.Trainers.FastTree());
var model = pipeline.Fit(data);
```

**TensorFlow.NET（Keras 风格）：**
```csharp
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 风格）：**
```csharp
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 性能对比

| 场景 | 推荐框架 | 原因 |
|------|----------|------|
| 大规模表格数据 | ML.NET | 内存效率高，Lazy 加载 |
| 图像分类 | TorchSharp / TensorFlow.NET | GPU 加速，预训练模型 |
| NLP 文本分类 | ML.NET (TextClassification) | 内置 NAS-BERT |
| 实时推理 | TorchSharp / TensorFlow.NET | 优化后推理性能好 |
| 概率建模 | Infer.NET | 专门的贝叶斯推断 |

---

## 九、选型决策树

```
开始选型
    │
    ├── 需要构建 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 快速开始

```bash
# 安装 NuGet 包
dotnet add package Microsoft.ML

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

```csharp
// 最小示例
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 快速开始

```bash
# CPU 版本
dotnet add package TorchSharp

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

# 计算机视觉
dotnet add package TorchVision
```

```csharp
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 快速开始

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

```csharp
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 快速开始

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

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

---

## 十一、生态与社区

### 11.1 NuGet 下载量（近似）

| 包名 | 下载量 |
|------|--------|
| Microsoft.ML | 500万+ |
| Microsoft.ML.AutoML | 200万+ |
| TensorFlow.NET | 100万+ |
| TorchSharp | 50万+ |
| BotSharp | 10万+ |

### 11.2 SciSharp 生态系统

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

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

### 11.3 社区活跃度

| 项目 | 提交频率 | Issue 响应 | 文档质量 |
|------|----------|-----------|----------|
| ML.NET | 高 | 快 | 优秀 |
| TorchSharp | 中 | 中 | 良好 |
| TensorFlow.NET | 低 | 慢 | 良好 |
| BotSharp | 高 | 快 | 良好 |
| Infer.NET | 中 | 中 | 优秀 |

---

## 十二、总结与建议

### 新项目选型建议

| 场景 | 首选 | 备选 |
|------|------|------|
| 企业级传统 ML | **ML.NET** | - |
| 深度学习研究 | **TorchSharp** | TensorFlow.NET |
| 图像/视频处理 | **TorchSharp + TorchVision** | ML.NET (迁移学习) |
| NLP 任务 | **ML.NET (TextClassification)** | TorchSharp |
| AI Agent / Chatbot | **BotSharp** | - |
| 概率建模 | **Infer.NET** | - |
| 快速原型 | **ML.NET AutoML** | - |

### 迁移建议

| 从 | 到 | 难度 |
|----|----|----|
| Accord.NET | ML.NET | 中 |
| TensorFlowSharp | TensorFlow.NET | 低 |
| Python TensorFlow | TensorFlow.NET | 低 |
| Python PyTorch | TorchSharp | 中 |

### 未来展望

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

---

## 参考资料

- [ML.NET 官方文档](https://docs.microsoft.com/dotnet/machine-learning/)
- [TensorFlow.NET GitHub](https://github.com/SciSharp/TensorFlow.NET)
- [TorchSharp GitHub](https://github.com/dotnet/TorchSharp)
- [BotSharp GitHub](https://github.com/SciSharp/BotSharp)
- [Infer.NET 文档](https://dotnet.github.io/infer/)
- [Accord.NET 归档说明](https://github.com/accord-net/framework)

---

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

0 条回复
还没有人回复，快来发表你的看法吧！
需要登录才能发表回复
登录注册