C# C语言中的机器学习库#

C#中是否有机器学习库？我在找类似的东西。 谢谢。

在GitHub上查看。在列出的框架中，Accord.NET是开源的，最受欢迎，拥有2000多颗星星

另外，请查看Microsoft提供的.NET官方机器学习库：

---

旧的

有一个叫做codeproject的神经网络库。（代码托管于）（另请检查-根据主页，新版本现在也支持遗传算法和机器学习。看起来自从我上次玩它以来，它进步了很多）

我不知道它是什么，它有点像WEKA，因为我从来没有用过它

（还有一篇关于它的文章）

你也可以。最好的解决方案是使用，尽管你也可以使用桥接软件。

我已经在C中创建了一个用于处理普通POCO对象的插件。

Weka可以很容易地从C中使用，正如Shane所说，使用IKVM和一些“粘合代码”。按照上的教程创建.Net版本的weka，然后您可以尝试运行以下测试：

[Fact]
public void BuildAndClassify()
{
  var classifier = BuildClassifier();
  AssertCanClassify(classifier);
}

[Fact]
public void DeserializeAndClassify()
{
  BuildClassifier().Serialize("test.weka");
  var classifier = Classifier.Deserialize<LinearRegression>("test.weka");
  AssertCanClassify(classifier);
}

private static void AssertCanClassify(LinearRegression classifier)
{
  var result = classifier.Classify(-402, -1);
  Assert.InRange(result, 255.8d, 255.9d);
}

private static LinearRegression BuildClassifier()
{
  var trainingSet = new TrainingSet("attribute1", "attribute2", "class")
    .AddExample(-173, 3, -31)
    .AddExample(-901, 1, 807)
    .AddExample(-901, 1, 807)
    .AddExample(-94, -2, -86);

  return Classifier.Build<LinearRegression>(trainingSet);
}

[事实]
public void BuildAndClassify（）
{
var分类器=BuildClassifier（）；
资产分类（分类器）；
}
[事实]
public void反序列化和分类（）
{
BuildClassifier（）.Serialize（“test.weka”）；
var分类器=分类器.反序列化（“test.weka”）；
资产分类（分类器）；
}
私有静态无效资产分类（线性回归分类器）
{
var结果=分类器。分类（-402，-1）；
Assert.InRange（结果，255.8d，255.9d）；
}
私有静态线性回归BuildClassifier（）
{
var培训集=新培训集（“属性1”、“属性2”、“类别”）
.附录示例（-173,3，-31）
.AddExample（-901,1807）
.AddExample（-901,1807）
.AddExample（-94，-2，-86）；
返回分类器。构建（训练集）；
}

第一个测试显示如何构建分类器并使用它对新示例进行分类，第二个测试显示如何使用文件中的持久化分类器对示例进行分类。如果您需要支持离散属性，则需要进行一些修改。上面的代码使用2个帮助器类：

public class TrainingSet
{
    private readonly List<string> _attributes = new List<string>();
    private readonly List<List<object>> _examples = new List<List<object>>();

    public TrainingSet(params string[] attributes)
    {
      _attributes.AddRange(attributes);
    }

    public int AttributesCount
    {
      get { return _attributes.Count; }
    }

    public int ExamplesCount
    {
      get { return _examples.Count; }
    }

    public TrainingSet AddExample(params object[] example)
    {
      if (example.Length != _attributes.Count)
      {
        throw new InvalidOperationException(
          String.Format("Invalid number of elements in example. Should be {0}, was {1}.", _attributes.Count,
            _examples.Count));
      }


      _examples.Add(new List<object>(example));

      return this;
    }

    public static implicit operator Instances(TrainingSet trainingSet)
    {
      var attributes = trainingSet._attributes.Select(x => new Attribute(x)).ToArray();
      var featureVector = new FastVector(trainingSet.AttributesCount);

      foreach (var attribute in attributes)
      {
        featureVector.addElement(attribute);
      }

      var instances = new Instances("Rel", featureVector, trainingSet.ExamplesCount);
      instances.setClassIndex(trainingSet.AttributesCount - 1);

      foreach (var example in trainingSet._examples)
      {
        var instance = new Instance(trainingSet.AttributesCount);

        for (var i = 0; i < example.Count; i++)
        {
          instance.setValue(attributes[i], Convert.ToDouble(example[i]));
        }

        instances.add(instance);
      }

      return instances;
    }
}

public static class Classifier
{
    public static TClassifier Build<TClassifier>(TrainingSet trainingSet)
      where TClassifier : weka.classifiers.Classifier, new()
    {
      var classifier = new TClassifier();
      classifier.buildClassifier(trainingSet);
      return classifier;
    }

    public static TClassifier Deserialize<TClassifier>(string filename)
    {
      return (TClassifier)SerializationHelper.read(filename);
    }

    public static void Serialize(this weka.classifiers.Classifier classifier, string filename)
    {
      SerializationHelper.write(filename, classifier);
    }

    public static double Classify(this weka.classifiers.Classifier classifier, params object[] example)
    {
      // instance lenght + 1, because class variable is not included in example
      var instance = new Instance(example.Length + 1);

      for (int i = 0; i < example.Length; i++)
      {
        instance.setValue(i, Convert.ToDouble(example[i]));
      }

      return classifier.classifyInstance(instance);
    }
}

公共类培训集
{
私有只读列表_attributes=new List（）；
私有只读列表_examples=new List（）；
公共培训集（参数字符串[]属性）
{
_attributes.AddRange（属性）；
}
公共int属性计数
{
获取{return\u attributes.Count；}
}
公共int示例
{
获取{return\u examples.Count；}
}
public TrainingSet AddExample（参数对象[]示例）
{
if（example.Length！=\u attributes.Count）
{
抛出新的InvalidOperationException(
Format（“示例中的元素数无效。应为{0}，为{1}”。，_attributes.Count，
_例数）；
}
_示例。添加（新列表（示例））；
归还这个；
}
公共静态隐式运算符实例（TrainingSet TrainingSet）
{
var attributes=trainingSet.\u attributes.Select（x=>newattribute（x））.ToArray（）；
var featureVector=新的快速向量（训练集属性计数）；
foreach（属性中的var属性）
{
featureVector.addElement（属性）；
}
var实例=新实例（“Rel”、featureVector、trainingSet.ExampleSunt）；
实例.setClassIndex（trainingSet.AttributeCount-1）；
foreach（培训集中的var示例。\u示例）
{
var实例=新实例（trainingSet.AttributeCount）；
对于（var i=0；i

还有一个名为Encog的项目，它有C代码。它由杰夫·希顿（Jeff Heaton）维护，他是我不久前买的《神经网络导论》一书的作者。代码库Git在这里：

我也在搜索.NET的机器学习库，并在Microsoft Research上找到了Infer.NET：

---

不错，但至少对于不太熟悉该主题的人来说，这确实不是一个好的选择。他们的表单不使用分部类（这使得读取样本背后的代码变得困难），我也找不到合适的文档。@RCIX:我同意这并不简单，你确实需要先了解神经网络和它们背后的数学。它当然不是为了教NNs，而是在你知道自己在做什么的时候实现NNs。文档在这里-，但是是的，它们看起来确实有点稀疏。就我个人而言，我已经好几年没有使用过它了，而且从那以后它看起来确实增加了很多，所以它可能变得越来越复杂。现在，一个RGE合并到了你所说的“桥接软件”中？哪一个？我不同意这不是一个建设性的问题。我认为这是非常有用的