web-dev-qa-db-fra.com

bibliothèques d'apprentissage automatique en C #

Existe-t-il des bibliothèques d'apprentissage automatique en C #? Je cherche quelque chose comme WEKA . Merci.

c#machine-learning
113
Dervin Thunk

Découvrez cette liste impressionnante sur GitHub. Parmi les frameworks répertoriés, Accord.NET est open-source et le plus populaire avec plus de 2 000 étoiles.

Consultez également la bibliothèque officielle d'apprentissage automatique pour .NET fournie par Microsoft: https://github.com/dotnet/machinelearning

[~ # ~] ancien [~ # ~]

Il y a une bibliothèque de réseau de neurones appelée AForge.net sur le projet de code. (Code hébergé chez code Google ) (Consultez également la page d'accueil AForge - Selon la page d'accueil, la nouvelle version prend désormais également en charge les algorithmes génétiques et l'apprentissage automatique. Il semble que ce soit a beaucoup progressé depuis que j'ai joué avec)

Je ne sais pas c'est quelque chose comme WEKA car je ne l'ai jamais utilisé.

(il y a aussi un article sur c'est sage )

55
Simon P Stevens

Vous pouvez également tiliser Weka avec C # . La meilleure solution consiste à utiliser IKVM, comme dans ce tutoriel , bien que vous puissiez également utiliser un logiciel de pontage.

15
Shane

Weka peut être utilisé à partir de C # très facilement, comme l'a déclaré Shane, en utilisant IKVM et du "code de colle". Suivez le tutoriel sur page weka pour créer la 'version .Net' de weka, alors vous pouvez essayer d'exécuter les tests suivants:

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

Le premier test montre comment construire un classificateur et classer un nouvel exemple avec lui, le second montre comment utiliser un classificateur persistant à partir d'un fichier pour classer un exemple. Si vous avez également besoin de prendre en charge des attributs discrets, certaines modifications seront nécessaires. Le code ci-dessus utilise 2 classes d'assistance:

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);
    }
}
14
Gregor Slavec

J'ai créé une bibliothèque ML en C # qui est conçue pour fonctionner avec les objets POCO courants.

13
Seth Juarez

Il y a aussi un projet appelé Encog qui a du code C #. Il est maintenu par Jeff Heaton, l'auteur d'un livre "Introduction to Neural Network" que j'ai acheté il y a quelque temps. Le codebase Git est ici: https://github.com/encog/encog-dotnet-core

2
vanni.torelli

Je recherche également des bibliothèques d'apprentissage automatique pour .NET et j'ai trouvé Infer.NET de Microsoft Research sur nuget.org/machine-learning :

2
Ole Lynge