使用ML.Net和C＃进行机器学习

目录

介绍

背景

概述

监督

无监督

监督机器学习

二进制分类

情感分析维基百科

训练阶段

预测阶段

你有垃圾邮件

多类分类

语言检测

鸢尾花分类

版本1

版本2

结论

参考

---

Wikipedia_SentimentAnalysis.zip YouGotSpam_Analysis.zip LanguageDetection.zip IrisClassification.zip IrisClassification_uint.zip

介绍

本文介绍.Net中的机器学习，而不涉及事物的数学方面。它将重点关注.Net中数据处理的基本工作流程及其结构，以便于在开源项目ML.Net版本0.2中进行实验。

ML.Net项目版本0.2可用于.Net Core 2.0和.Net Standard 2.0，仅支持x64架构（Any CPU都不会立即编译）。因此，它应适用于.Net Standard 2.0（例如：.Net Framework 4.6.1）适用的任何框架。该项目目前正在审查中。API可能在将来发生变化。

背景

如果你想使用像C＃或VB.Net这样的面向对象语言学习机器学习的基础并不容易。因为大多数时候你必须先学习Python，然后你必须找到可以教你更多的样本数据的教程。即使看看像[1] Accord.Net，Tensor.Flow或CNTK这样的面向对象的项目也不容易，因为每个项目都有自己的API，以不同的方式实现相同的东西，等等。我对2018 Build [2]的演示文稿感到非常兴奋，因为他们表示我们可以使用通用的工作流程方法，使我们能够使用本地数据，本地.Net程序，本地模型和结果来评估主题，而无需使用服务或其他编程语言，如Python。

概述

机器学习是人工智能（AI）的一个子集，它可以回答5种类型的问题[3]：

监督

1. 分类（二进制和多类）

问题：它属于哪个类？ 

1. 回归
   问题：多少(到什么程度或多少此递归)？ 

无监督

1. 排名
   问题：接下来我该怎么办？ 
2. 聚类
   问题：这是如何组织的？ 
3. 异常检测
   问题：这有点奇怪吗？ 

每种类型的问题都有许多应用程序，为了使用正确的机器学习方法，我们必须首先尝试确定是否要回答任何给定的问题，如果是，我们是否有数据支持它。

监督机器学习

本文讨论了二进制和多类分类的.Net示例（源代码包括示例数据）。这种类型的机器学习算法假定我们可以标记一个项目以确定它是否属于：

1. 两组之一（二进制分类）或
2. 许多组中的一个（多类分类）

当您想要回答带有真或假答案的问题时，可以应用二进制分类。您通常会发现自己将项目（图像或文本）排序为2个类别之一。例如，考虑一下客户对您最近的调查反馈是否情绪良好（正面）与否（负面）的问题。

通过机器学习回答这个问题需要我们将样本项目（例如：图像或文本）标记为属于任一组。正常的工作流程需要两组独立的标记数据：

1. 训练数据集（训练机器学习算法）和
2. 评估数据集（用于测量ml算法的效率）。

带标记的文本行可能如下所示：

• 1让你有偏见的孩子长大。
• 0我希望这会有所帮助。

其中第一列中的“1”表示负面情绪，第一列中的“0”表示正面情绪。经验法则通常是，如果我们有更多的训练数据，ml算法将更好地工作。并且还应该确保训练数据和稍后使用的数据是干净且高质量的，以支持有效的算法。

使用KPI确定有效算法的总体工作流程由下面左侧的图表示，我们（理想情况下）找到最能反映我们的分类问题的模型。此处不再详细说明该模型。就ML.Net而言，它是一个zip文件，其中包含从标记的训练数据中学到的持久性事实。

用于评估的第二独立数据集用于确定针对学习分类效率的KPI。此步骤通过将机器学习算法的结果与可用标记（不使用算法中的标记）进行比较，估计我们的算法将来如何对项目进行分类。例如，衡量效率的关键绩效指标是权利分类与错误分类项目的百分比。如果我们发现我们的KPI不符合我们的期望，并且我们需要优化模型的方法，我们总是可以回到培训步骤，调整参数，或者将一个算法换为另一个算法。

在培训阶段有望以一个有效模型结束，该模型应用于第二个预测阶段，以便对我们在未来看到的每个项目进行分类。该阶段需要来自前一阶段的模型和要分类的项目，其用于输出分类的预测（例如：正面或负面情绪）。

这是有人参加机器学习的工作流程的简要概述。我们需要理解这一点，以便使用下面这篇文章中讨论的代码示例。所以，让我们依次看看每个示例。

二进制分类

情感分析维基百科

本节中讨论的示例基于ML.Net教程中的“ 情感分析二进制分类方案 ”。

• Wikipedia_SentimentAnalysis.zip

训练阶段

上一节中讨论的工作流程在本文附带的演示项目中得到了一定程度的实现。演示项目包含两个可执行项目：

• 培训和
• 预测

如果我们编译并启动Training项目，我们会得到以下输出：

Training Data Set
-----------------
Not adding a normalizer.
Making per-feature arrays
Changing data from row-wise to column-wise
Processed 250 instances
Binning and forming Feature objects
Reserved memory for tree learner: 1943796 bytes
Starting to train ...
Not training a calibrator because it is not needed.

Evaluating Training Results
---------------------------

PredictionModel quality metrics evaluation
------------------------------------------
Accuracy: 61,11%
     Auc: 96,30%
 F1Score: 72,00%

我们在这里看到程序如何首先训练模型并在第二步中评估结果。

训练和预测模件共享对前面提到的Model.zip文件（大多数是手动复制的——见下文详细说明）的引用、对ML.Net库的引用以及Models项目中定义的数据输入和分类输出的通用模型：

public class ClassificationData
{
    [Column(ordinal: "0", name: "Label")]
    public float Sentiment;

    [Column(ordinal: "1")]
    public string Text;
}

public class ClassPrediction
{
    [ColumnName("PredictedLabel")]
    public bool Class;
}

在ClassificationData中定义的属性将每列映射到文本输入文件中的输入。标签列定义了包含要针对每行文本进行培训的类定义的项。Text属性本身不能被标记为“特征”，因为它是由一个以上的“列”（INT文本文件）组成。这就是我们需要在下面的管道中添加行new TextFeaturizer("Features", "Text")以将文本读入输入数据结构的原因。

ClassificationData是我们输入的粗略描述，以及如何将其映射到标签或特征。尝试删除标签列定义、编译和执行，以验证该系统将抛出一个异常，如果指定的列标签不能在输入文本中找到。

ClassPrediction状态仅是一个二进制输出结果，该结果期望是将输入映射到二进制类的Boolean值。这部分与以下内容相关：

1. 验证学习是否成功（在测试阶段已知输入）和
2. 在生产中使用其模型时，确定机器学习算法的实际分类。

总结：ClassificationData用于描述我们如何处理输入（始终由标签和特征组成），并ClassPrediction将此输入映射到学习结果。

使用ClassificationData定义消费文本输入的Training 管道如下所示：

internal static async Task<PredictionModel<ClassificationData, ClassPrediction>>
      TrainAsync(string trainingDataFile, string modelPath)
  {
      var pipeline = new LearningPipeline();

      pipeline.Add(new TextLoader(trainingDataFile).CreateFrom<ClassificationData>());

      pipeline.Add(new TextFeaturizer("Features", "Text"));

      pipeline.Add(new FastTreeBinaryClassifier() { NumLeaves = 5, NumTrees = 5, MinDocumentsInLeafs = 2 });

      PredictionModel<ClassificationData, ClassPrediction> model =
                          pipeline.Train<ClassificationData, ClassPrediction>();

      // Saves the model we trained to a zip file.
      await model.WriteAsync(modelPath);

      // Returns the model we trained to use for evaluation.
      return model;
  }

ML.Net框架带有可扩展的管道概念，其中可以插入不同的处理步骤，如上所示。TextLoader步骤从文本文件加载数据，并且TextFeaturizer步骤将给定的输入文本转换为特征向量，该特征向量是给定文本的数字表示。然后将该数字表示馈送到ML社区称为学习者的内容中。在这种情况下的学习者是FastTreeBinaryClassifier。

学习者或训练者是数值特征向量转换成可稍后被用于在未来分类输入模型中的组件。这些学习者的文档目前正在建设中，并非所有学习者都已完全实现和测试。对于二进制分类，有几个可供选择的学习者可以作为选择（只需编辑构造函数，如下所示）：

分类方法	准确性	AUC	F1Score
new AveragedPerceptronBinaryClassifier()	61.11％	81.48％	72.00％
new FastForestBinaryClassifier() { NumThreads=2, NumLeaves = 25, NumTrees = 25, MinDocumentsInLeafs = 2 }	72.22％	97.53％	78.26％
new FastTreeBinaryClassifier() { NumLeaves = 5, NumTrees = 5, MinDocumentsInLeafs = 2 }	61,11％	96,30％	72,00％
new GeneralizedAdditiveModelBinaryClassifier()	50.00％	83.95％	66.67％
new LinearSvmBinaryClassifier()	72.22％	90.12％	76.19％
new LogisticRegressionBinaryClassifier()	50.00％	86.42％	66.67％
new StochasticDualCoordinateAscentBinaryClassifier	83.33％	98.77％	85.71％
new StochasticGradientDescentBinaryClassifier()	55.56％	90.12％	69.23％

测试所有上述学习者，结果表明，根据测量的KPI ，StochasticDualCoordinateAscentBinaryClassifier工作最好。这些KPI是通过BinaryClassificationMetrics的实例衡量的，该实例还提供其他KPI，例如Precision和Recall。请注意，您仍然可以分析更多KPI，例如内存消耗和处理时间，这些也是未在此处测量的。所提出的测试相当小而简短。我们还可以使用不同的个体学习者设置，这些设置仍然可以显示出显著的改进。当我们面对大量项目（文本或图像等）的自动分类问题时，能够使用这些不同的场景似乎是一个有趣的练习。

因此，简而言之，机器学习如何发挥作用。机器消费数据（文本），将其转换为数字向量，并将矢量化数据集成到模型中。该模型是在第一阶段的主要输出。让我们看一下分类阶段，以了解完整的工作流程。

预测阶段

预测阶段是模块，它表示在生产中运行的代码，和在新项目到达系统时对数据进行分类。此部分在Wikipedia_SentimentAnalysis解决方案的Prediction项目的PredictAsync方法中实现。此方法的代码如下所示：

async Task<PredictionModel<ClassificationData, ClassPrediction>> PredictAsync(
    string modelPath,
    string[] classNames,
    IEnumerable<ClassificationData> predicts = null,
    PredictionModel<ClassificationData, ClassPrediction> model = null)
{
    if (model == null)
      model = await PredictionModel.ReadAsync<ClassificationData, ClassPrediction>(modelPath);

    if (predicts == null) // do we have input to predict a result?
        return model;

    IEnumerable<ClassPrediction> predictions = model.Predict(predicts);

    Console.WriteLine("Classification Predictions");

    IEnumerable<(ClassificationData sentiment, ClassPrediction prediction)> sentimentsAndPredictions =
        predicts.Zip(predictions, (sentiment, prediction) => (sentiment, prediction));

    foreach (var item in sentimentsAndPredictions)
    {
        string textDisplay = item.sentiment.Text;

        if (textDisplay.Length > 80)
            textDisplay = textDisplay.Substring(0, 75) + "...";

        Console.WriteLine("Prediction: {0} | Text: '{1}'",
                          (item.prediction.Class ? classNames[0] : classNames[1]), textDisplay);
    }
    Console.WriteLine();

    return model;
}

方法中的PredictionModel.ReadAsync行将模型从文件系统加载到内存中的PredictionModel：

PredictionModel<ClassificationData, ClassPrediction> model = await
                           PredictionModel.ReadAsync<ClassificationData, ClassPrediction>(modelPath);

加载的模型存储在项目的Learned文件夹中。每当我们发现显著改进并希望在预测模块中利用它时，必须从Training模块输出复制此Model.zip文件。

模型加载代码行下面的所有内容都根据加载的模型评估输入，并在方法的最后部分输出预测的分类。您可以使用交互式输入提示来测试自己的示例文本，并在小范围内测试学到的内容和不学习的内容。请记住，通常会清理学习数据（与原始输入不同），并且您只能在这样的小规模上进行测试。更好的、更合理的测试可能是从真实数据源输入最后n个文本行，得到它们的分类，并查看独立评论者是否具有紧密匹配的结果。

我们在本节中已经看到二进制分类如何在非常“简单”的场景中用于情感分析。但ml的真正强度是每种类型的问题（这里：这是A或B？）可以应用于各种各样的应用程序。让我们在下一节中再回顾一个示例，以回顾另一个二进制分类用例。

你有垃圾邮件

• YouGotSpam_Analysis.zip

这个二进制分类项目的目的是我们想知道一个给定的文本是否应该被分类为垃圾邮件。

本文附带的YouGotSpam_Analysis解决方案的源代码几乎与上一节中介绍的代码完全相同。甚至可执行项目实际上也几乎相同。这里唯一的区别是用于训练和测试评估的数据源（参见Training项目中的Data文件夹）。该培训项目产生这样的输出：

Training Data Set
-----------------
Not adding a normalizer.
Making per-feature arrays
Changing data from row-wise to column-wise
Processed 2000 instances
Binning and forming Feature objects
Reserved memory for tree learner: 24082752 bytes
Starting to train ...
Not training a calibrator because it is not needed.

Evaluating Training Results
---------------------------

PredictionModel quality metrics evaluation
------------------------------------------
Accuracy: 100,00%
     Auc: 100,00%
 F1Score: 100,00%

您可以再次使用Prediction项目从文件系统加载模型，并使用进一步的输入对其进行测试。

到目前为止讨论的项目表明ML.Net可以帮助以自动方式确定二进制分类。但是，如果我想要分类超过2个类（例如：消极，中立和积极的情绪）怎么办？下一节将介绍此用例的数据分类。

多类分类

语言检测

• LanguageDetection.zip

本节中讨论的样本数据是从http://wortschatz.uni-leipzig.de下载并预处理（删除引号字符“）以改进解析体验。

这里讨论的多类分类用例是基于给定文本检测语言。想象一下，您拥有社交媒体代理团队，并且您正尝试将不同语言的在线客户反馈（例如聊天）转发给使用该语言的正确团队。

本节附带的语言检测解决方案遵循先前讨论的二进制分类示例的结构。我们有一个培训(Training)项目，一个预测(Prediction)项目，以及一个在可执行文件之间共享的Models类库。该培训(Training)项目可以用于创建特定的学习者。然后可以将成功的模型从培训(Training)项目复制到预测(Prediction)项目，以进行未来输入的消费和多类分类。

语言检测解决方案的预测(Prediction)该项目的不同之处是，我们以何种方式定义在ClassificationData类中的LanguageClass属性和在ClassPrediction类中的Class属性。这两个属性必须是数据类型float才能支持多重分类：

public class ClassificationData
{
    [Column(ordinal: "0", name: "Label")]
    public float LanguageClass;

    [Column(ordinal: "1")]
    public string Text;
}

public class ClassPrediction
{
    [ColumnName("PredictedLabel")]
    public float Class;
}

在ClassificationData中的输入映射与二进制分类问题中的输入映射相同。唯一的区别不是我们在输入的文本文件的Label列中有两个以上的值。

在ClassPrediction中的输出映射是不同的，因为我们现在必须映射到一个float值，以便分类到多个类。

所需的培训管道如下所示：

async Task<PredictionModel<ClassificationData, ClassPrediction>>
TrainAsync(string trainingDataFile, string modelPath)
{
    var pipeline = new LearningPipeline();

    pipeline.Add(new TextLoader(trainingDataFile).CreateFrom<ClassificationData>());

    pipeline.Add(new Dictionarizer("Label"));
    pipeline.Add(new TextFeaturizer("Features", "Text"));

    pipeline.Add(new StochasticDualCoordinateAscentClassifier());
    //pipeline.Add(new LogisticRegressionClassifier());
    //pipeline.Add(new NaiveBayesClassifier());

    pipeline.Add(new PredictedLabelColumnOriginalValueConverter() { PredictedLabelColumn = "PredictedLabel" });

    // Train the pipeline based on the dataset that has been loaded, transformed.
    PredictionModel<ClassificationData, ClassPrediction> model =
                        pipeline.Train<ClassificationData, ClassPrediction>();

    await model.WriteAsync(modelPath); // Saves the model we trained to a zip file.

    return model;
}

该Dictionarizer("Label");步骤将带有标记输入值（0-5）的每一行映射到桶中。该PredictedLabelColumnOriginalValueConverter将预测值（矢量）映射到原始值的数据类型（浮点）。

编译并运行Training模块可以获得以下输出：

Training Data Set
-----------------
Not adding a normalizer.
Using 4 threads to train.
Automatically choosing a check frequency of 4.
Auto-tuning parameters: maxIterations = 48.
Auto-tuning parameters: L2 = 2.778334E-05.
Auto-tuning parameters: L1Threshold (L1/L2) = 1.
Using best model from iteration 8.
Not training a calibrator because it is not needed.

Evaluating Training Results
---------------------------

PredictionModel quality metrics evaluation
------------------------------------------
  Accuracy Macro: 98.66%
  Accuracy Micro: 98.66%
   Top KAccuracy: 0.00%
         LogLoss: 7.50%

 PerClassLogLoss:
       Class: 0 - 11.18%
       Class: 1 - 4.08%
       Class: 2 - 5.95%
       Class: 3 - 10.43%
       Class: 4 - 7.86%
       Class: 5 - 5.52%

在ML.Net版本0.2中有三个多类分类学习者。和他们的KPI比较如下： 

分类方法	产量
new StochasticDualCoordinateAscentClassifier()	精度宏：98.66％ 准确度微观：98.66％ 最高KAccuracy：0.00％ LogLoss：7.50％ PerClassLogLoss： 等级：0 - 11.18％ 等级：1 - 4.08％ 等级：2 - 5.95％ 等级：3 - 10.43％ 等级：4 - 7.86 ％ 分类：5 - 5.52％
new LogisticRegressionClassifier()	精度宏：98.52％ 准确度微观：98.52％ 最高KAccuracy：0.00％ LogLoss：8.63％ PerClassLogLoss： 等级：0 - 13.32％ 等级：1 - 4.67％ 等级：2 - 7.09％ 等级：3 - 11.50％ 等级：4 - 8.98 ％ 分类：5 - 6.19％
new NaiveBayesClassifier()	精度宏：96.58％ 准确度微观：96.58％ 最高KAccuracy：0.00％ LogLoss：3,453.88％ PerClassLogLoss： 等级：0 - 3,453.88％ 等级：1 - 3,453.88％ 等级：2 - 3,453.88％ 等级：3 - 3,453.88％ 等级：4 - 3,453.88 ％ 分类：5 - 3,453.88％

因此，这就是我们如何根据一个功能输入列进行多类别文本分类。相同的机器学习方法（多类二进制）也可用于多个功能输入列，我们将在下面看到。

鸢尾花分类

版本1

• IrisClassification.zip

本节中讨论的多类分类问题是模式识别领域中众所周知的参考测试[4]。原始数据库由Ronald Fisher于1936年创建，此处回顾的ML.Net示例来自ML.Net教程的“入门”部分。问题陈述是创建一个算法，该算法将接受多个浮点值的输入向量（表示花的属性），并且该算法的输出应该是花的最可能的名称。

在ML.Net中执行此操作需要我们创建具有多个列的输入映射：

public class ClassificationData
{
    [Column("0")]
    public float SepalLength;

    [Column("1")]
    public float SepalWidth;

    [Column("2")]
    public float PetalLength;

    [Column("3")]
    public float PetalWidth;

    [Column("4")]
    [ColumnName("Label")]
    public string Label;
}

我们正在输入一组特征列（名称为SepalLength，SepalWidth，PetalLength，PetalWidth），这些特征列稍后组合成一个特征向量。在这种情况下，Label是一个字符串，作为最后一列给出，以在算法的训练和测试阶段识别每个数据行。

预测类的结果应该（毫不奇怪）是一个字符串：

public class ClassPrediction
{
    [ColumnName("PredictedLabel")]
    public string Class;
}

此案例的培训代码与上一节非常相似：

async Task<PredictionModel<ClassificationData, ClassPrediction>>
    TrainAsync(string trainingDataFile, string modelPath)
{
    var pipeline = new LearningPipeline();

    pipeline.Add(new TextLoader(trainingDataFile).CreateFrom<ClassificationData>(separator: ','));

    pipeline.Add(new Dictionarizer("Label"));

    pipeline.Add(new ColumnConcatenator("Features", "SepalLength", "SepalWidth", "PetalLength", "PetalWidth"));

    pipeline.Add(new StochasticDualCoordinateAscentClassifier());

    pipeline.Add(new PredictedLabelColumnOriginalValueConverter() { PredictedLabelColumn = "PredictedLabel" });

    // Train the pipeline based on the dataset that has been loaded, transformed.
    PredictionModel<ClassificationData, ClassPrediction> model =
                        pipeline.Train<ClassificationData, ClassPrediction>();

    await model.WriteAsync(modelPath);

    return model;
}

这里只有两件新事物。在这种情况下，原始输入数据是逗号分隔的列表，因此，在从管道中的文本文件加载数据时，我们必须separator: ','参数。并且我们使用ColumnConcatenator将特征列集转换为一列，其中包含名为Features的向量。

输出类似于我们之前看到的（我们可以再次尝试其他两个学习者，如上一节所示）：

Training Data Set
-----------------
Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Using 4 threads to train.
Automatically choosing a check frequency of 4.
Auto-tuning parameters: maxIterations = 45452.
Auto-tuning parameters: L2 = 2.667051E-05.
Auto-tuning parameters: L1Threshold (L1/L2) = 0.
Using best model from iteration 1956.
Not training a calibrator because it is not needed.

Evaluating Training Results
---------------------------

PredictionModel quality metrics evaluation
------------------------------------------
  Accuracy Macro: 95.73%
  Accuracy Micro: 95.76%
   Top KAccuracy: 0.00%
         LogLoss: 8.19%

 PerClassLogLoss:
       Class: 0 - 0.72%
       Class: 1 - 10.62%
       Class: 2 - 13.43%

同样，我们可以使用IrisClassification解决方案的培训(Training)模块来培训不同的学习者和设置，并使用预测(Prediction)模块使用先前确定的模型预测新的分类。

我们在本节中已经看到如何使用ColumnConcatenator转换器将4个输入列（SepalLength，SepalWidth，PetalLength，PetalWidth）转换为一个矢量化特征列。不需要我们在管道代码中使用ColumnConcatenator的等效方法是使用以下输入类定义：

public class ClassificationData
{
    public float SepalLength
    {
      get { return Features[0]; }
      set { Features[0] = value; }
    }
    
    public float SepalWidth 
    {
      get { return Features[1]; }
      set { Features[1] = value; }
    }
    
    public float PetalLength
    {
      get { return Features[2]; }
      set { Features[2] = value; }
    }
    
    public float PetalWidth 
    {
      get { return Features[3]; }
      set { Features[3] = value; }
    }

    [Column("0-3")]
    [ColumnName("Features")]
    [VectorType(4)] public float[] Features = new float[4];

    [Column("4")]
    [ColumnName("Label")]
    public string Label;
}

但是如上所示，通过ClassificationData定义来定义实际特征集是一种糟糕的实践。因此，我们应该删除该[ColumnName("Features")]行并添加new ColumnConcatenator("Features", nameof(Digit.Features)) 到管道代码中。在尝试评估不同的功能配置时，此设计可以为我们提供更多灵活性。

版本2

• IrisClassification_uint.zip

让我们假设我们不希望机器学习算法处理字符串（因为我们真的想要本地化应用程序的那一部分）。回到处理整数值并将每个整数作为索引来指示分类（花的类型）将是更好的做法。但究竟能做到这一点呢？我们可以改变输入和预测输出的定义，如下所示：

public class ClassificationData
{
    public float SepalLength
    {
      get { return Features[0]; }
      set { Features[0] = value; }
    }
    
    public float SepalWidth
    {
      get { return Features[1]; }
      set { Features[1] = value; }
    }
    
    public float PetalLength
    {
      get { return Features[2]; }
      set { Features[2] = value; }
    }
    
    public float PetalWidth
    {
      get { return Features[3]; }
      set { Features[3] = value; }
    }

    [Column("0-3")]
    [ColumnName("Features")]
    [VectorType(4)] public float[] Features = new float[4];

    [Column("4")]
    [ColumnName("Label")]
    public float Label;
}

public class ClassPrediction
{
    [ColumnName("PredictedLabel")]
    public uint Class;
}

接下来，我们将不得不从之前的解决方案的管道中删除PredictedLabelColumnOriginalValueConverter，这就是我们如何调整这种情况（假设我们也调整了数据）。此方法也可以在附加的IrisClassification_uint解决方案中进行验证。

结论

经过审核的示例应用程序表明，当ML.NET将机器学习交付到.NET框架中时，它有一个有趣的值（即使在0.2版本中也是如此）。我们已经看到二进制和多类分类可以基于不同类型的输入和输出。此输入和输出始终需要：

• 一个标签和一个特征列作为输入，并
• 一个PredictedLabel列作为输出。

输入和输出的数据类型是灵活的，因为当将输入馈送到引擎时，转换器可用于将值转换为数字和向量，并且当我们必须解释分类的结果时，显然可以进行相同的转换。

参考

• [1]机器学习框架
  • ML.Net
  • Accord.Net
  • Tensor Flow
  • Microsoft认知工具包（CNTK）
• [2]建造2018年的ML.Net
  • 介绍ML.NET：Build 2018
  • 探索ML.NET的有趣方式：Build 2018
  • 介绍ML.NET
• [3]绝对初学者的机器学习
  • 初学者数据科学视频1：数据科学答案的5个问题
  • 揭开机器的神秘面纱，为开发人员深入学习：建立2018年
  • ML.Net Gloassary
• [4]使用虹膜数据集进行模式识别
  • 鸢尾花数据集（维基百科）
  • 用Keras实现简单神经网络 - 用Python实例
  • 使用CNTK和C＃批量训练虹膜数据
  • Java机器学习库（Java-ML）Java机器学习库（Java-ML）
  • 在matlab中使用mlp的鸢尾花分类

 

原文地址：https://www.codeproject.com/Articles/1249611/Machine-Learning-with-ML-Net-and-Csharp-VB-Net