bibliotecas de aprendizaje automático en C # [cerrado]

Question

¿Hay bibliotecas de aprendizaje automático en C #? Busco algo como WEKA . Gracias.

Answer 1

Echa un vistazo a esta lista impresionante en GitHub. De los marcos enumerados, Accord.NET es de código abierto y el más popular con más de 2,000 estrellas.

También, consulte la biblioteca de aprendizaje automático para .NET provista por Microsoft: https://github.com/ dotnet / machinelearning

---

OLD

Hay una biblioteca de red neuronal llamada AForge.net en el proyecto de código. (Código alojado en código de Google ) (También verifique el página de inicio de AForge - Según la página de inicio, la nueva versión ahora también admite algoritmos genéticos y aprendizaje automático. Parece que ha progresado mucho desde la última vez que jugué con it)

No sé si es algo como WEKA, ya que nunca lo he usado.

(también hay un artículo en su uso )

Answer 2

También puedes usar Weka con C # . La mejor solución es usar IKVM , como en este tutorial , aunque también puedes usar software de puenteo.

Answer 3

Weka se puede usar desde C # muy fácilmente como lo indicó Shane, usando IKVM y algún 'código de pegamento'. Siga el tutorial en weka page para crear la 'versión .Net' de weka, luego puede intentar ejecuta las siguientes pruebas:

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

La primera prueba muestra, cómo construyes un clasificador y clasificas un nuevo Ejemplo con él, la segunda muestra, cómo puedes usar un clasificador persistente de un archivo para clasificar un ejemplo. Si necesita también atributos discretos, será necesaria alguna modificación. El código anterior utiliza 2 clases de ayuda:

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

Answer 4

He creado una biblioteca ML en C # que está diseñada para funcionar con objetos POCO comunes.

Answer 5

También hay un proyecto llamado Encog que tiene código C #. Es mantenido por Jeff Heaton, el autor de un " Introduction to Neural Network " Libro que compré hace un tiempo. El código base Git está aquí: https://github.com/encog/encog-dotnet-core

Answer 6

También estoy buscando bibliotecas de aprendizaje automático para .NET y encontré Infer.NET de Microsoft Research en nuget.org/machine-learning :

• Infer.NET