bibliothèques d'apprentissage automatique en C # [fermé]


116

Existe-t-il des bibliothèques d'apprentissage automatique en C #? Je suis après quelque chose comme WEKA . Je vous remercie.


89
Je ne suis pas d'accord pour dire que ce n'est pas une question constructive. Je pense qu'il est très utile d'avoir un ensemble de suggestions de bibliothèques sélectionnées par l'utilisateur sur les résultats automatisés d'une recherche Google. Je ne vois pas pourquoi les suggestions de la bibliothèque ne peuvent pas être accompagnées de "faits, références et expertise spécifique" comme décrit dans les notes de fin.
Ismail Degani

2
@IsmailDegani Pouvez-vous voter pour la réouverture alors?
James Ko

4
TOUTE PERSONNE RECHERCHE DES CADRES: Les réponses ci-dessous sont datées car la question est verrouillée. Il existe un framework d'apprentissage machine C # populaire et open-source appelé Accord.NET et voici sa page Web: accord-framework.net
James Ko

2
ML.NET est un domaine dans lequel Microsoft investit beaucoup. J'ai créé cette vidéo d'une heure qui peut vous aider à démarrer avec ML.NET en utilisant C # youtube.com/watch?v=83LMXWmzRDM
Shivprasad Koirala

1
Consultez également scisharpstack.org , un effort pour porter les bibliothèques d'apprentissage automatique les plus populaires de Python vers C #
henon

Réponses:


59

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

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


VIEUX

Il existe une bibliothèque de réseaux neuronaux appelée AForge.net sur le projet de code. (Code hébergé chez Google code ) (Consultez également la page d'accueil d'AForge - Selon la page d'accueil, la nouvelle version prend désormais en charge les algorithmes génétiques et l'apprentissage automatique.

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

(il y a aussi un article sur son utilisation )


1
Pas mal, mais au moins pour quelqu'un qui ne connaît pas très bien le sujet, ce n'est vraiment pas un bon choix. Ils n'utilisent pas de classes partielles pour leurs formulaires (ce qui rend difficile la lecture du code derrière leurs exemples), et je ne trouve pas de documentation décente pour cela.
RCIX

@RCIX: Je suis d'accord que ce n'est pas tout à fait simple, vous devez d'abord comprendre les réseaux de neurones et les mathématiques derrière eux. Il n'est certainement pas conçu pour enseigner les NN mais plutôt pour les implémenter lorsque vous savez ce que vous faites. Les documents sont ici - aforgenet.com/framework/docs , mais oui, ils ont l'air un peu clairsemés. Personnellement, je ne l'ai pas utilisé depuis plusieurs années, et il semble que cela ait beaucoup été ajouté depuis, donc il est probablement devenu plus complexe.
Simon P Stevens

1
AForge est maintenant fusionné dans github.com/accord-net/framework
Nikolay Kostov


14

Weka peut être utilisé à partir de C # très facilement, comme l'a déclaré Shane, en utilisant IKVM et un certain «code glu». Suivez le tutoriel sur la page weka pour créer la `` version .Net '' de weka, puis 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 vous construisez un classificateur et classifiez un nouvel exemple avec lui, le second montre comment vous pouvez utiliser un classificateur persistant à partir d'un fichier pour classer un exemple. Si vous avez trop besoin de prendre en charge les 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);
    }
}



En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.