ML.NET

Machine Learning für .NET
15
Jul

ML.NET 1.0 – Machine Learning mit .NET Core 3

Mit .NET Core werden nicht nur WPF und WinForms Teil der neuen quelloffenen Implementierung von .NET, Microsoft möchte nun auch Machine Learning für jedermann einsetzbar machen. Darum hält nunmehr Machine Learning mit dem ML.NET Framework Einzug in .NET Core. Aber was kann ML.NET 1.0, welche Möglichkeiten gibt es dem Entwickler an die Hand, wie sehen das Tooling und die APIs aus und was passiert eigentlich unter der Haube?

Mit ML.NET (Machine Learning für .NET) veröffentlicht Microsoft ein für die Softwareentwicklung revolutionäres Framework. Möchte man maschinelles Lernen in den eigenen Anwendungen einsetzen, ist es nicht länger notwendig, sich im Detail mit der Mathematik und der Implementierung von z. B. Transformations-, Klassifikations-, Regressions- oder SVM-Algorithmen auszukennen oder sich damit auseinanderzusetzen, denn all das bringt ML.NET mit. Das Tooling um das Framework herum tut seinen Rest: Es war nie einfacher, den richtigen Algorithmus für den gewünschten Anwendungsfall auszusuchen, die eigenen Daten darauf zu trainieren und schließlich in den eigenen Anwendungen einzusetzen. Damit dreht Microsoft den Spieß um: Daten und Anwendungsfall stehen im Vordergrund, nicht länger die Implementierung.

Kurze Rede, schnell zum Sinn: Ein Beispiel sagt mehr als tausend Worte. Starten wir also mit einer praktischen Demo, um das Gesagte zu untermauern.

Los geht’s

Um ein Cross-Plattform-Developer-Tooling anzubieten, bringt ML.NET ein Command Line Interface (CLI) mit. Wir werden später etwas mehr darüber erfahren. Für das erste schnelle
Beispiel werden wir jedoch Visual Studio und die Model Builder Extension heranziehen. Die
Erweiterung für Visual Studio benutzt unter der Haube seinerseits das CLI.

Die Extension kann über das Hauptmenü EXTENSIONS | MANAGE EXTENSIONS installiert oder
alternativ heruntergeladen werden. Für diese erste Demo benutzen wir Visual Studio 2019.
Nach erfolgreicher Installation beginnen wir mit einer einfachen, leeren .NET-Core-
Konsolenanwendung. Im Kontextmenü des Projektknotens im Solution Explorer befindet sich ein
neuer Eintrag: ADD | MACHINE LEARNING. Die Auswahl öffnet den ML.NET Model Builder, wie in
Abbildung 1 zu sehen.

Abbildung 1: Model Builder Extension in Visual Studio

Der Model Builder bietet einen einfachen Assistenten, der durch fünf Schritte führt. Zuerst wählen wir das Szenario aus, in diesem Fall SENTIMENT ANALYSIS. Schritt zwei verlangt von uns die Daten, mit denen das neue Machine Learning Model erstellt und trainiert werden soll. Dazu laden wir das Wikipedia Detox Dataset herunter. Dieses enthält Userkommentare und eine Klassifikation, ob der Kommentar positive oder negative Aussagen im Sinne von Emotionalität enthält. Das ML Model soll mit diesen Daten trainiert werden, um zu bestimmen, ob ein beliebiger anderer Kommentar positive oder negative Aussagen enthält. Nach dem Download wählen wir die Datei im zweiten Schritt des Model Builders aus. Eine kleine Vorschau wird angezeigt, und die vorherzusagende Spalte muss ausgewählt werden. Für dieses Beispiel ist das die Spalte SENTIMENT.

Es folgt Schritt drei – das Trainieren des Models. Ein Klick auf den Button START TRAINING genügt und der Model Builder beginnt sofort damit, verschiedenste ML-Algorithmen zu durchlaufen und den für unser Problem am besten passenden auszuwählen, um anschließend das Model zu trainieren. So viel sei an dieser Stelle verraten: Unter der Haube wird AutoML für die Algorithmenselektion eingesetzt. Eventuell sollte man hier ein wenig mehr Zeit einplanen, als die vorgegebenen 10 Sekunden. Nach 30 Sekunden Trainingszeit findet der Model Builder einen Algorithmus mit einer Genauigkeit von 88,24 Prozent. Das bedeutet, dass das erzeugte Model bei 88,24 Prozent aller Vorhersagen in der Trainingsphase richtig lag.

Schritt vier des Assistenten zeigt uns anschließend eine Zusammenfassung des durchgeführten Prozesses, und ein paar Kennwerte zur Performance des Models. Mehr dazu später in diesem Artikel.

Schließlich werden in Schritt fünf das finale Model und der zugehörige Code in Form von zwei neuen Projekten generiert und der Solution hinzugefügt. Das Codebeispiel in Listing 1 zeigt, wie einfach das Model für Vorhersagen in der eigenen Anwendung benutzt werden kann.

var context = new MLContext();
var model = context.Model.Load(GetAbsolutePath(MODEL_FILEPATH), out DataViewSchema inputSchema);
var engine = context.Model.CreatePredictionEngine<ModelInput, ModelOutput>(model);
var input = new ModelInput()
{
  Sentiment = false,
  SentimentText = "This is not correct and very stupid."
};
var output = engine.Predict(input);
var outputAsText = output.Prediction == true ? "negative" : "positive";

Console.WriteLine($"The sentence '{input.SentimentText}' has a {outputAsText} sentiment with a probability of {output.Score}.");


Führt man den Code aus Listing 1 mit dem trainierten Model aus, lautet die Ausgabe: The sentence ‚This is not correct and very stupid.‘ has a negative sentiment with a probability of 0.7026196. Der eine oder andere Leser wird sicher zustimmen, dass es schon fast gar nicht mehr einfacher geht, Machine Learning in die eigene Anwendung zu integrieren. Eine detaillierte Beschreibung und Guidelines für die Optimierung der erzeugten Models findet man hier.

Bevor wir uns nun aber in die Details der Algorithmen, Models, APIs und des Toolings stürzen, soll ein Überblick über ML.NET das Gesamtbild vermitteln.

Überblick

ML.NET war ursprünglich ein Projekt von Microsoft Research. Laut Microsoft hat sich dieses Projekt seit über einer Dekade bewährt und zunehmend etabliert. Es gewann für viele Bereiche innerhalb von Microsoft an Wichtigkeit und hielt Einzug in bekannte Produkte des Unternehmens (z. B. in Windows, Power BI, Office, Defender, Outlook und Bing). ML.NET soll nunmehr seinen Weg in die breite Öffentlichkeit finden und hält daher Einzug in .NET Core.

Verschaffen Sie sich den Zugang zur .NET- und Microsoft-Welt mit unserem kostenlosen Newsletter!

Version 1.0 wurde im April 2019 veröffentlicht, seit Juni steht Version 1.1 (beinhaltet Bugfixes und Performanceoptimierungen) zur Verfügung. ML.NET läuft auf .NET Core 2.1 und setzt die Installation der entsprechenden Runtime und des SDKs voraus.

Als Teil von .NET Core wird ML.NET unter dem Dach der .NET Foundation als Open-Source-Projekt gemeinsam mit der Community auf GitHub entwickelt. Das Framework ist plattformunabhängig und kann unter Windows, Linux und Mac verwendet werden. Abbildung 2 zeigt eine Übersicht von Microsoft über .NET Core 3 und veranschaulicht, wie ML.NET sich als Bestandteil in das Ökosystem einreiht.

Abbildung 2: ML.NET in .NET Core 3

Ziel von ML.NET ist es, Machine Learning für .NET-Entwickler so einfach wie möglich zu machen, ohne dabei das gewohnte Umfeld, also die Entwicklungsumgebung und die Programmiersprache, verlassen zu müssen. Microsoft möchte alles soweit abstrahieren, dass tiefgreifende Kenntnisse von Machine Learning nicht mehr notwendig sind. Das Beispiel zu Beginn des Artikels beweist ein Stück weit, dass dieser Vorsatz eingehalten wurde. Ob Web-, Desktop- oder IoT-Anwendung, Mobile Apps oder Spiele, als .NET-Entwickler können wir nun also KI/ML in jede Art von Anwendung integrieren – ohne ML-Vorkenntnisse.

Wir haben gesehen, dass mit ML.NET und dem dazugehörigen Tooling eigene ML Models auf einfache Art und Weise gebaut, trainiert, verteilt und genutzt werden können. Gehen die eigenen Bedürfnisse über das hinaus was ML.NET out of the box bietet (z. B. Optimierung von Hyperparametern etc.), steht es dem Entwickler frei, auf andere Tools (z. B. Infer.NET, TensorFlow, ONNX) zurückzugreifen. Ermöglicht wird das durch die Erweiterbarkeit von ML.NET, die von Beginn an Teil des Konzeptes und der Umsetzung ist.

Schließlich noch ein Wort zur Performance von ML.NET. Basierend auf einem 9 GB großem Dataset von Amazon, das Produktbewertungen enthält, hat Microsoft ein ML Model trainiert, dass zu 93 Prozent zuverlässige Vorhersagen treffen kann (Accuracy/Genauigkeit). Man muss dazu sagen, dass lediglich 10 Prozent der Daten aus dem Set zum Trainieren verwendet wurden. Der Grund dafür war, dass andere ML-Frameworks, die zum Vergleich herangezogen wurden, wegen Speicherproblemen nicht mit mehr Daten zurechtkamen. Im Ergebnis des Benchmarks erzielte ML.NET die höchste Genauigkeit und die beste Geschwindigkeit, wie in Abbildung 3 gezeigt wird. Die Details zu dieser Untersuchung können im Paper nachgelesen werden.

Abbildung 3: Benchmarkergebnisse von ML.NET und anderen Machine Learning Frameworks

Das soll für den schnellen Überblick über ML.NET an dieser Stelle genügen. Werfen wir nun einen Blick auf die Einsatzgebiete von ML.NET und welche Algorithmen das Framework dafür mitbringt.

Einsatzszenarien

Wirft man einen Blick in den Namespace Microsoft.ML.Trainers, der aus der DLL Microsoft.ML.StandardTrainers stammt, die wiederum mit dem NuGet-Package Microsoft.ML kommt, erhält man einen ersten Eindruck von der Vielzahl der von Microsoft implementierten Algorithmen. Abbildung 4 zeigt einen Ausschnitt.

Abbildung 4: Trainer-Klassen aus dem Namespace „Microsoft.ML.StandardTrainers“

Da eine Auflistung aller Algorithmen nicht zielführend wäre, und sowieso den Rahmen dieses Artikels sprengen würde, beschränken wir uns für die Übersicht auf die Klassen/Arten der unterstützten Algorithmen und deren Einsatzszenarien.

Möchte man beispielsweise Gefühle oder Stimmungen erkennen, wie im Beispiel der Sentiment-Analyse oben, kann man sich der binären Klassifikation bedienen. Binär bedeutet in diesem Fall, dass sich sämtliche Ergebnisse der Vorhersagen in zwei Ergebnismengen aufteilen. Eine Vorhersage kann entsprechend nur das eine oder das andere sein. In der Sentiment-Analyse entspricht das z. B. einer Vorhersage, dass eine bestimmte Aussage negativ oder positiv gemeint ist. Diese Art von ML-Algorithmen wird auch für die Implementierung von Spamfiltern, für die Betrugserkennung und die Vorhersage von Krankheiten eingesetzt.

Die Multiklassenklassifikation hingegen wird verwendet, wenn das vorhergesagte Ergebnis aus mehr als zwei Ergebnismengen stammen kann. So wird diese Art der
Algorithmen z. B. dazu verwendet, um Handschriften zu erkennen oder Pflanzen zu bestimmen.

Mit ML.NET können auch Models für Empfehlungen erstellt werden. Vorstellbar ist es z. B., dem Benutzer bestimmte Produkte oder Filme auf Grund seines (Konsum-)Verhaltens oder dem Kaufverhalten anderer Kunden zu empfehlen. Das ist hinreichend von E-Commerce-Shops bekannt. Zum Einsatz kann hier z. B. Matrixfaktorisierung kommen.

Mittels Regressionsalgorithmen lassen sich numerische Werte vorhersagen. Regression wird oftmals für die Vorhersage von Nachfrage, Preis und Verkaufszahlen für ein Produkt eingesetzt.

Mit Clustering werden Gruppierungen innerhalb von Daten gefunden und vorhergesagt, z. B. für die Unterteilung von Kunden und Märkten in bestimmte Segmente. Auch für die Einordnung von Pflanzen wird Clustering eingesetzt.

Anomaly Detection Models dienen der Anomalieerkennung. Anomalien möchte man z. B. in Strom- und Kommunikationsnetzen finden, um beispielsweise einen Cyberangriff aufzudecken. Auch die Vorhersage von Verkaufsspitzen fällt in diese Kategorie.

Zuletzt sei noch Computer Vision genannt. Computer Vision wird in der Bilderkennung und -Klassifikation eingesetzt. So möchte man z. B. Objekte und Szenen innerhalb einer visuellen Darstellung erkennen und beschreiben. Hier kommt das sogenannte Deep Learning zum Einsatz. ML.NET bringt dafür nicht direkt Algorithmen mit. In solchen Szenarien benötigt man z. B. ein ONNX oder TensorFlow Model. ML.NET versteht diese Models und bietet somit die Möglichkeit für Erweiterungen um beliebige Szenarien.

Für all die genannten Einsatzszenarien und Arten von ML ist ML.NET gedacht und bringt entsprechende Algorithmen mit, bzw. kann externe Models einbeziehen. Letztlich stehen damit sämtliche Türen des ML offen. Schwierig wird es, wenn es um das Finden des richtigen Ansatzes für das eigene jeweilige Problem geht. Hier muss sorgsam überlegt werden, was für ein Problem genau vorliegt, welche Daten zur Verfügung stehen und wie das Problem optimal gelöst werden kann. Der beste und schnellste Algorithmus nützt nichts, wenn er für das vorliegende Problem der falsche ist.

Eine Auflistung und Dokumentation aller Algorithmen in ML.NET findet sich hier. Um die Auswahl eines geeigneten Algorithmus bzw. Models zu erleichtern, pflegt Microsoft auf GitHub diverse praktische Beispiele für den Einstieg in ML. Die Community stellt ebenfalls eine Sammlung von Beispielen bereit.

Command Line Interface

Kehren wir nun zurück zur Praxis und schauen uns noch einmal das Tooling an. Wie zuvor erwähnt, benutzt die Model Builder Extension für Visual Studio unter der Haube das ML.NET CLI, um Models zu trainieren etc. Schauen wir uns also an, was dieses Tooling uns bietet und wie es funktioniert.

Das CLI ist ein .NET Core Global Tool und kann via Powershell, im Mac-Terminal oder in der Linux Bash mit dem Befehl dotnet tool install -g mlnet installiert werden. Voraussetzung dafür ist die Installation des .NET Core 2.2 SDKs. Nach der Installation kann das Tool mit mlnet –version aufgerufen werden. Der Parameter –version bewirkt, dass das CLI die aktuelle Version auf der Konsole ausgibt.

Um mit dem CLI ein ML Model zu trainieren, kann der folgende Befehl abgesetzt werden:

mlnet auto-train -d .\MyDataSet.csv --label-column-name ColumnToPredict --has-header --task regression.

Zuvor sollte man jedoch in ein leeres Verzeichnis bzw. in das Zielverzeichnis wechseln. Gegebenenfalls können die Trainingsdaten ebenfalls in das Zielverzeichnis kopiert werden. Die Trainingsdatendatei wird im obigen Aufruf nach dem Schalter -d angegeben. Weitere Parameter geben die vorherzusagende Spalte in den Trainingsdaten an, ob die Inputdatei einen Header besitzt, und welche ML-Art angewendet werden soll. In diesem Fall wurde die Regression gewählt. Mit dem Aufruf mlnet auto-train –help lassen sich alle Optionen für die Operation auto-train anzeigen.

Abbildung 5: AutoML mit der ML.NET CLI

Abbildung 5 zeigt die Ausgabe der Ergebnisse eines Trainingsvorgangs. Während der Prozedur wendet das CLI eine AutoML-Strategie an, um einen Algorithmus / ein Model zu finden, das die besten Ergebnisse in Bezug auf die Vorhersagegenauigkeit für die angegebene Spalte liefert (Kasten: „AutoML“). Das Beispiel in Abbildung 5 zeigt, dass der FastTreeRegression-Algorithmus die zuverlässigsten Ergebnisse mit einer Genauigkeit von 0.9317 (ca. 93 Prozent) liefert. Die Trainingszeit betrug insgesamt 30 Minuten. Evaluiert wurden verschiedene Models. Der Abbildung ist zu entnehmen, dass die FastTreeRegression jeden Platz unter den Top 5 der evaluierten Models einnimmt.

Am Ende des Trainingsvorgangs generiert das CLI Code. Um genauer zu sein, zwei Projekte. Das erste Projekt enthält das generierte binäre Model verpackt in einer ZIP-Datei, sowie zwei Model-Klassen. Eine Klasse repräsentiert die Struktur der Trainingsdaten, die wir hineingeben, und dient als Input-Model für Vorhersagen. Die andere Klasse repräsentiert die Ausgabe der Vorhersage des Models für einen bestimmten Input. Das Model-Projekt ist die Komponente, die wir dann in unseren eigenen Anwendungen verwenden können, um Vorhersagen auf Basis des erzeugten Models zu treffen.

Das zweite Projekt, dass durch das CLI generiert wird, ist eine Konsolenanwendung und zeigt beispielhaft, wie das Model verwendet werden kann. Das Projekt enthält ebenfalls eine Klasse namens ModelBuilder. Der ModelBuilder implementiert Methoden zum Trainieren des Models. Diese Klasse kann später im eigenen Code verwendet werden, um das vorhandene Model erneut zu trainieren (z. B. mit neuen, aktuellen Trainingsdaten). Dazu wird dann einfach die statische Methode ModelBuilder.CreateModel aufgerufen (Listing 2).

public static void CreateModel()
{
  // Load Data
  IDataView trainingDataView = mlContext.Data.LoadFromTextFile<ModelInput>(
                               path: TRAIN_DATA_FILEPATH,
                               hasHeader: true,
                               separatorChar: '\t',
                               allowQuoting: true,
                               allowSparse: false);

  // Build training pipeline
  IEstimator<ITransformer> trainingPipeline = BuildTrainingPipeline(mlContext);

  // Evaluate quality of Model
  Evaluate(mlContext, trainingDataView, trainingPipeline);

  // Train Model
  ITransformer mlModel = TrainModel(mlContext, trainingDataView, trainingPipeline);

  // Save model
  SaveModel(mlContext, mlModel, MODEL_FILEPATH, trainingDataView.Schema);
}

Die Methode lädt zuerst die Trainingsdaten über einen MLContext in einen sogenannten Data View. Die Klasse MLContext ist eine zentrale Komponente und Ausgangspunkt aller Operationen in ML.NET – ohne Kontext geht gar nichts. Ein Data View wird immer als IDataView dargestellt und repräsentiert die Sicht auf die Trainingsdaten für ML.NET.

Anschließend wird die Trainings-Pipeline erzeugt. Hier werden Algorithmen für die Datentransformation (z. B. zur Normalisierung von Spaltenwerten) und der Trainingsalgorithmus selbst in einer Pipeline aneinandergehängt. Nach der Evaluierung zur Bestimmung der Genauigkeit des Models mit den gegebenen Trainingsdaten, wird das Model dann trainiert. Das resultierende Model wird als ITransformer dargestellt. Der Name Transformer rührt daher, dass mit diesem Objekt Eingabedaten in eine Vorhersage transformiert werden können. Schließlich wird das Model dann in die Datei gespeichert, die in MODEL_FILEPATH angegeben ist.

AutoML

AutoML steht für Automated Machine Learning und beschreibt eine Ende-zu-Ende-Lösung zum Finden eines optimalen ML Models für ein gegebenes Problem innerhalb bestimmter Restriktionen (z. B. in Bezug auf Genauigkeit, Laufzeitverhalten, Speicherverbrauch etc.). AutoML ist Forschungsgegenstand. Es existieren aber bereits einige Implementierungen, so auch von Microsoft Research. Und genau diese Implementierung von Microsoft findet in ML.NET Anwendung.
Was bedeutet es, einen ML-Algorithmus zu finden? Was genau macht AutoML? Um ein ML Model zu kreieren, müssen zuerst einmal valide Trainingsdaten zur Verfügung gestellt werden. Diese Daten müssen aufbereitet werden. Dazu gehört u. a., die Daten zu bereinigen, unnötige und redundante Daten zu entfernen, Lücken in den Daten aufzufüllen und Werte zu normalisieren. Dann kommt das Domänenwissen ins Spiel. An Hand von Features, Eigenschaften der Trainingsdaten, lernt das ML Model die Domäne kennen und Vorhersagen für diese zu treffen. Features sind fundamental für ein ML Model und müssen entsprechend sorgfältig definiert werden. Anschließend müssen sie aus den Daten extrahiert und selektiert werden. Eine aufwendige Aufgabe, möchte man das von Hand erledigen. AutoML versucht automatisch, Features zu erlernen und zu selektieren. Die selektierten Features fließen dann in einen Algorithmus. Auch der muss sorgfältig ausgesucht werden. Auch das übernimmt AutoML für uns. Und schließlich folgt noch die Optimierung der Hyperparameter für das Model. Und auch die Optimierung wird durch AutoML automatisiert. Weitere Details können hier nachgelesen werden. Es passiert also eine Menge hinter der Bühne. AutoML reduziert die Aufwände für uns Entwickler signifikant und macht den allgemeinen Einsatz erst möglich.

Verwendung des Models

Wie kann das erzeugte Model nun aber in der eigenen Anwendung benutzt werden, um Vorhersagen zu treffen? Das ist relativ einfach. Zuerst einmal wird das durch das CLI generierte Model-Projekt dort referenziert, wo es eingesetzt werden soll. Das ist aber nicht zwingend notwendig, denn zur Verfügung stehen müssen die Klassen ModelInput und ModelOutput sowie die ZIP-Datei mit dem ML Model. Dafür können auch einfach die Klassendateien in das eigene Projekt kopiert werden. Zugriff auf das Model erfolgt zur Laufzeit durch die Pfadangabe zur ZIP-Datei. Man muss also sicherstellen, dass die ZIP-Datei zur Laufzeit zur Verfügung steht. Als letztes wird noch das NuGet-Package Microsoft.ML benötigt. Das kann einfach über den NuGet-Package-Manager oder die Kommandozeile installiert werden.

Ziehen wir noch einmal das Beispiel vom Anfang des Artikels heran, die Sentiment-Analyse; oder besser gesagt, das im Beispiel erzeugte Model. Die Verwendung könnte dann etwa so aussehen wie in Listing 3.

var context = new MLContext();

var model = context.Model.Load(GetAbsolutePath(MODEL_FILEPATH), out DataViewSchema inputSchema);

var engine = context.Model.CreatePredictionEngine<ModelInput, ModelOutput>(model);

var input = new ModelInput()
{
  Sentiment = false,
  SentimentText = "This is not correct and very stupid."
};

var output = engine.Predict(input);

var outputAsText = output.Prediction == true ? "negative" : "positive";

Console.WriteLine($"The sentence '{input.SentimentText}' has a {outputAsText} sentiment with a probability of {output.Score}.");

Zuerst wird eine Instanz von MLContext erzeugt. Wie gesagt, ist die Klasse MLContext Dreh- und Angelpunkt von ML.NET. Über die Eigenschaft Model des Contexts wird dann das zu verwendende ML Model in den Kontext geladen. Hier verwenden wir das vom CLI erzeugte Model zur Sentiment-Analyse. Es wird über den Pfad referenziert. Mit der Methode Model.CreatePredictionEngine instanziiert man dann zunächst die Komponente, die auf Basis des Models Vorhersagen treffen kann. Dazu wird das geladene Model als Parameter übergeben. Diese Schritte genügen zur Vorbereitung. Das ML Model ist einsatzbereit und wir können loslegen, Vorhersagen für Eingaben zu erzeugen. Jetzt kommen die generierten Model-Klassen zum Einsatz. Für Die Eingabe erstellen wir ein Objekt der Klasse ModelInput. Wir möchten herausfinden, ob der Satz „This is not correct and very stupid“ eine positive oder eine negative Aussage enthält. Der Satz wird für die Eigenschaft SentimentText der ModelInput-Instanz festgelegt. Nun wird die Eingabe an die Methode Predict der Vorhersage-Engine übergeben. Diese Methode schickt die Eingabe durch das Model und erzeugt eine Vorhersage in Form einer Instanz der Klasse ModelOutput. Über die Eigenschaft Prediction erfahren wir, ob der Satz eine negative oder positive Aussage enthält. Über die Eigenschaft Score erfahren wir darüber hinaus, wie wahrscheinlich die Vorhersage zutrifft. Beide Ergebnisse werden im obigen Beispiel in der Konsole ausgegeben. Wurde das Model mit denselben Daten trainiert wie in diesem Artikel, lautet die Ausgabe zum obigen Codebeispiel: The sentence ‚This is not correct and very stupid.‘ has a negative sentiment with a probability of 0.7026196. Der gegebene Satz enthält laut Vorhersage also mit einer 70-prozentigen Wahrscheinlichkeit eine negative Aussage.

Fazit

Wie wir sehen, kann mit ML.NET ein ML Model mit nur wenigen Zeilen Code direkt in der eigenen Anwendung benutzt werden. Es geht fast nicht einfacher. Durch das CLI von ML.NET ist es gleichermaßen einfach, ML Models zu erzeugen. Unter der Haube kümmert sich AutoML um die Vorbereitung der Trainingsdaten, das Identifizieren und Selektieren von Features und die Auswahl sowie Optimierung des eingesetzten Algorithmus. Die Model Builder Extension bietet zusätzlich einen entsprechenden UI-Aufsatz und eine Integration in Visual Studio an.

Mit ML.NET abstrahiert Microsoft Machine Learning soweit, dass es für jeden Entwickler möglich wird, die eigenen Anwendungen auch ohne ML-Kenntnisse mit intelligenten Funktionen zu erweitern. Wer mehr wissen möchte, sei auf die ausführliche Dokumentation verwiesen.

 

Ihr aktueller Zugang zur .NET- und Microsoft-Welt.
Der BASTA! Newsletter:

Behind the Tracks

.NET Framework & C#
Visual Studio, TFS, C# & mehr

Agile & DevOps
Best Practices & mehr

Web Development
Alle Wege führen ins Web

Data Access & Storage
Alles rund um´s Thema Data

HTML5 & JavaScript
Leichtegewichtig entwickeln

User Interface
Alles rund um UI- und UX-Aspekte

Microservices & APIs
Services, die sich über APIs via REST und JavaScript nutzen lassen

Security
Tools und Methoden für sicherere Applikationen

Cloud, Azure, Serverless
Cloud-basierte & Native Apps