l'apprentissage de la machine bibliothèques en C#

Découvrez cette liste impressionnante sur GitHub. De la cadres de liste, Accord.NET est et de l'open source la plus populaire avec plus de 2 000 étoiles.

Aussi, découvrez l'officiel de la machine de l'apprentissage de la bibliothèque pour le .NET fourni par Microsoft: https://github.com/dotnet/machinelearning

---

VIEUX

Il y a un réseau de neurones appelé bibliothèque AForge.net sur le codeproject. (Code hébergé à Google code) (Aussi la caisse de la AForge page d'accueil - Selon la page d'accueil, la nouvelle version prend désormais en charge les algorithmes génétiques et l'apprentissage de la machine ainsi. On dirait que c'est mal progressé depuis la dernière fois que j'ai joué avec elle)

Je ne sais pas, c'est qu'il est quelque chose comme WEKA que je n'ai jamais utilisé ça.

(il y a aussi un article sur c'est l'utilisation de la)

Weka peut être utilisée en C# très facilement que Shane a déclaré, à l'aide de IKVM et certains de la "colle le code'. Suivre le tutoriel sur weka page créer '.Net version " 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);
}

Premier test montre, comment vous construire un classificateur et de classer un nouvel Exemple, avec elle, la seconde montre comment vous pouvez utiliser un persisté classificateur à partir d'un fichier de classer un exemple. Si vous avez besoin de soutien attributs discrets, quelques modifications seront necessery. Le code ci-dessus utilise 2 classes d'aide:

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

Il y a aussi un projet appelé Encog qui a le code C#. Il est maintenu par Jeff Heaton, l'auteur d'une "Introduction à Réseau de Neurones" livre que j'ai acheté il y a longtemps. Le code de base de Git est ici: https://github.com/encog/encog-dotnet-core