Bibliotheken für maschinelles Lernen in C # [geschlossen]

Gibt es in C # Bibliotheken für maschinelles Lernen? Ich bin nach so etwas wie WEKA . Danke dir.

Schauen Sie sich diese fantastische Liste auf GitHub an. Von den aufgeführten Frameworks ist Accord.NET Open Source und mit über 2.000 Sternen das beliebteste.

Schauen Sie sich auch die offizielle Bibliothek für maschinelles Lernen für .NET an, die von Microsoft bereitgestellt wird: https://github.com/dotnet/machinelearning

ALT

Es gibt eine neuronale Netzwerkbibliothek namens AForge.net im Codeprojekt. (Code, der bei Google gehostet wird ) ( Schauen Sie sich auch die AForge-Homepage an - Laut der Homepage unterstützt die neue Version jetzt auch genetische Algorithmen und maschinelles Lernen. Es sieht so aus, als ob es seit meinem letzten Spiel viel Fortschritte gemacht hat.)

Ich weiß nicht, dass es so etwas wie WEKA ist, da ich das nie benutzt habe.

(Es gibt auch einen Artikel über seine Verwendung )

Sie können Weka auch mit C # verwenden . Die beste Lösung ist die Verwendung von IKVM wie in diesem Lernprogramm . Sie können jedoch auch Bridging-Software verwenden.

Weka kann sehr einfach von C # aus verwendet werden, wie Shane sagte, mit IKVM und etwas 'Klebercode'. Befolgen Sie das Tutorial auf der Weka-Seite , um die '.Net-Version' von Weka zu erstellen. Anschließend können Sie versuchen, die folgenden Tests auszuführen:

[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);
}

Der erste Test zeigt, wie Sie einen Klassifikator erstellen und damit ein neues Beispiel klassifizieren, der zweite zeigt, wie Sie einen persistierten Klassifikator aus einer Datei verwenden können, um ein Beispiel zu klassifizieren. Wenn Sie auch diskrete Attribute unterstützen möchten, sind einige Änderungen erforderlich. Der obige Code verwendet 2 Hilfsklassen:

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);
    }
}

Ich habe eine ML-Bibliothek in C # erstellt, die für die Verwendung mit gängigen POCO-Objekten ausgelegt ist.

Es gibt auch ein Projekt namens Encog mit C # -Code. Es wird von Jeff Heaton gepflegt, dem Autor eines Buches "Introduction to Neural Network", das ich vor einiger Zeit gekauft habe. Die Codebasis Git ist hier: https://github.com/encog/encog-dotnet-core

Ich suche auch nach Bibliotheken für maschinelles Lernen für .NET und habe Infer.NET von Microsoft Research unter nuget.org/machine-learning gefunden :

• Infer.NET