librerie di machine learning in C # [chiuse]

Esistono librerie di machine learning in C #? Sto cercando qualcosa come WEKA . Grazie.

Dai un'occhiata a questo fantastico elenco su GitHub. Tra i framework elencati, Accord.NET è open source e il più popolare con oltre 2.000 stelle.

Inoltre, controlla la libreria ufficiale di machine learning per .NET fornita da Microsoft: https://github.com/dotnet/machinelearning

VECCHIO

C'è una libreria di rete neurale chiamata AForge.net sul progetto in codice. (Codice ospitato su Google code ) ( Controlla anche la homepage di AForge - Secondo la homepage, la nuova versione ora supporta anche algoritmi genetici e apprendimento automatico. Sembra che sia progredito molto dall'ultima volta che ci ho giocato)

Non so che sia qualcosa di simile a WEKA perché non l'ho mai usato.

(c'è anche un articolo sul suo utilizzo )

Puoi anche usare Weka con C # . La soluzione migliore è utilizzare IKVM , come in questo tutorial , sebbene sia possibile utilizzare anche un software di bridging.

Weka può essere usato da C # molto facilmente come ha affermato Shane, usando IKVM e un po 'di "codice colla". Segui il tutorial sulla pagina di weka per creare la "versione .Net" di weka, quindi puoi provare a eseguire i seguenti test:

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

Il primo test mostra come costruire un classificatore e classificare un nuovo Esempio con esso, il secondo mostra come usare un classificatore persistente da un file per classificare un esempio. Se hai bisogno di supportare troppo attributi discreti, alcune modifiche saranno necessarie. Il codice sopra usa 2 classi helper:

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

Ho creato una libreria ML in C # progettata per funzionare con oggetti POCO comuni.

C'è anche un progetto chiamato Encog che ha codice C #. È mantenuto da Jeff Heaton, l'autore di un libro "Introduzione alla rete neurale" che ho acquistato qualche tempo fa. Il codebase Git è qui: https://github.com/encog/encog-dotnet-core

Sto cercando anche librerie di machine learning per .NET e ho trovato Infer.NET da Microsoft Research su nuget.org/machine-learning :

• Infer.NET