Vom Python-Modell zur .NET-Anwendung

Künstliche Intelligenz entfaltet ihren Nutzen erst in konkreten Anwendungsszenarien. Anhand einer einfachen Sentiment-Analyse zeigen wir in diesem Beitrag, wie ein ML-Modell in Python entsteht und in einer .NET-Anwendung genutzt wird. Das Beispiel verbindet die Technologien, die im Artikel „Effizienter Brückenschlag“ aus der dotnetpro-Ausgabe 2/2026 [1] und in den weiteren hier in der Reihe „.NET, Python und KI“ erschienenen Beiträgen vorgestellt wurden, zu einem durchgängigen Praxis-Workflow.

Bisher beschrieben wurden die zentralen Bausteine für den Einsatz von Künstlicher Intelligenz in .NET-Anwendungen: die Integration von Python-Code mit Python.NET, der Austausch von Modellen über ONNX sowie die Nutzung nativer .NET-Technologien wie ML.NET, TensorFlow.NET und TorchSharp. Damit stehen Entwicklern verschiedene Wege offen, KI-Funktionalität in ihre Anwendungen zu integrieren.

Was bislang noch fehlt und nun gezeigt werden soll, ist die konkrete Verbindung dieser Ansätze in einem durchgängigen Anwendungsszenario. In der Praxis geht es nicht nur isoliert darum, ein Modell zu trainieren oder eine Bibliothek einzubinden, sondern darum, einen vollständigen Workflow abzubilden – vom Training eines Modells über dessen Bereitstellung bis hin zur Nutzung in einer produktiven .NET-Anwendung. Ein besonders anschauliches Beispiel hierfür ist die Sentiment-Analyse (Bild 1).

Die Sentiment-Analyse gehört zu den klassischen Aufgaben der Textklassifikation und wird in vielen Business-Anwendungen eingesetzt, etwa zur automatischen Auswertung von Kundenfeedback, Support-Anfragen oder Produktbewertungen. Ziel ist es, Texte anhand ihrer Stimmung zu klassifizieren, typischerweise in Kategorien wie positiv oder negativ. Die Sentiment-Analyse eignet sich ideal als Demonstrationsbeispiel, da sie mit überschaubarem Aufwand umgesetzt werden kann und gleichzeitig ein realistisches Anwendungsszenario darstellt. Im Folgenden wird daher ein einfacher, aber vollständiger Ansatz gezeigt: Ein Modell wird in Python trainiert, in ein interoperables Format überführt und anschließend in einer .NET-Anwendung für Vorhersagen genutzt.

Sentiment-Analyse mit Python und .NET

Konkret betrachten wir ein typisches Szenario aus der Praxis: Kunden hinterlassen Bewertungen zu einem Produkt, und eine Anwendung soll automatisch erkennen, ob diese positiv oder negativ sind. Ziel ist es, ein Modell zu erstellen, das kurze Texte klassifiziert und diese Information anschließend in einer .NET-Anwendung nutzbar macht.

Der Workflow orientiert sich dabei an einem in der Praxis häufig anzutreffenden Vorgehen: Das Training des Modells erfolgt in Python, da dort leistungsfähige Bibliotheken wie Scikit-Learn zur Verfügung stehen. Nach dem Training wird das Modell in ein standardisiertes Format überführt, sodass es unabhängig von der ursprünglichen Umgebung eingesetzt werden kann. Anschließend wird das Modell in eine .NET-Anwendung integriert und für Vorhersagen verwendet.

Im ersten Schritt werden Trainingsdaten definiert. Diese bestehen aus Texten und einer zugehörigen Bewertung, etwa „positiv“ oder „negativ“. Ein Beispiel könnte wie folgt aussehen:

"Dieses Produkt ist hervorragend"  ->  positiv
"Ich bin sehr unzufrieden"  ->  negativ

Diese Daten werden in Python mit Scikit-Learn verarbeitet. Zunächst erfolgt eine Transformation der Texte in numerische Features, beispielsweise mittels TF-IDF-Vektorisierung.

TF-IDF (Term Frequency – Inverse Document Frequency)

Die Term Frequency (TF) beschreibt, wie häufig ein Wort in einem Dokument vorkommt. Je öfter ein Begriff erscheint, desto relevanter ist er für den Inhalt dieses Dokuments. Die Berechnung erfolgt als Anteil des Wortes an allen Wörtern im Dokument:

TF(t) = (Anzahl der Vorkommen von t im Dokument) / (Anzahl der Wörter im Dokument)

Die Inverse Document Frequency (IDF): bewertet, wie aussagekräftig ein Wort im gesamten Textkorpus ist. Wörter, die in vielen Dokumenten vorkommen (zum Beispiel „und“ oder „der“), erhalten eine geringere Gewichtung. Die Berechnung lautet:

IDF(t) = log(Anzahl aller Dokumente / Anzahl der Dokumente mit t)

Die TF-IDF-Wertung ergibt sich aus der Kombination beider Werte:

TF-IDF(t) = TF(t) × IDF(t)

Ein hoher TF-IDF-Wert zeigt an, dass ein Begriff für ein bestimmtes Dokument besonders charakteristisch ist.

Anschließend wird ein Klassifikationsmodell trainiert, etwa mit logistischer Regression. Das Modell lernt dabei, welche Wortmuster typischerweise mit positiven oder negativen Aussagen korrelieren. Nach dem Training wird das Modell exportiert (ONNX). Mithilfe von Tools wie skl2onnx lässt sich das trainierte Modell in das ONNX-Format konvertieren. Dadurch wird es unabhängig von Python und kann in anderen Umgebungen, zum Beispiel .NET, verwendet werden.

Integration des Modells in eine .NET-Anwendung

Nach dem Training und Export des Modells in das ONNX-Format kann dieses in einer .NET-Anwendung für Vorhersagen genutzt werden. Für die Integration nutzt man die ONNX Runtime als performante Inferenz-Engine direkt in .NET. Über das NuGet-Paket Microsoft.ML.OnnxRuntime lässt sich das Modell laden und ausführen. Der Ablauf besteht darin, eine InferenceSession zu erstellen, Eingabedaten bereitzustellen und die Vorhersage abzurufen. Hier ein einfaches Beispiel in C#:

using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // ONNX-Modell laden
        using var session = new InferenceSession("sentiment_model.onnx");
        // Beispieltext (vereinfachte Eingabe)
        var inputText = "Das Produkt ist wirklich gut";
        // Hinweis: In der Praxis muss der Text vorher
        // genauso vorverarbeitet werden wie beim Training (z.B. TF-IDF)
        // Dummy-Input (vereinfachtes Beispiel)
        var inputTensor = new DenseTensor<float>(new[] { 1, 10 });
        var inputs = new List<NamedOnnxValue>
        {
            NamedOnnxValue.CreateFromTensor("input", inputTensor)
        };
        // Vorhersage durchführen
        using var results = session.Run(inputs);
        // Ergebnis auslesen
        foreach (var result in results)
        {
            var prediction = result.AsEnumerable<float>();
            Console.WriteLine($"Vorhersage: {string.Join(", ", prediction)}");
        }
    }
}

Das Modell wird geladen, Eingabedaten werden übergeben und das Ergebnis wird ausgelesen. In einem realen Szenario ist insbesondere die Datenvorverarbeitung entscheidend. Der Eingabetext muss exakt so transformiert werden wie im Training, beispielsweise durch dieselbe TF-IDF-Vektorisierung. Häufig wird diese Vorverarbeitung entweder ebenfalls in das ONNX-Modell integriert oder separat in der .NET-Anwendung implementiert. Sobald das Modell eingebunden ist, kann es in unterschiedlichsten Szenarien eingesetzt werden: etwa in einem Web-API zur Analyse von Kundenfeedback, in einer Desktop-Anwendung zur Auswertung von Textdaten oder als Bestandteil eines größeren Verarbeitungssystems. Damit wird aus einem isolierten ML-Modell eine produktiv nutzbare KI-Funktion innerhalb einer .NET-Anwendung.

Alternative Integrationsansätze im Vergleich

Das gezeigte Beispiel nutzt ONNX als Brücke zwischen Python und .NET. Dieser Weg eignet sich besonders gut, wenn ein trainiertes Modell stabil bereitgestellt und performant in einer .NET-Anwendung ausgeführt werden soll. ONNX trennt Training und Inferenz sauber voneinander: Das Modell entsteht in Python, wird exportiert und anschließend unabhängig von der Python-Laufzeitumgebung in .NET genutzt.

Daneben gibt es weitere Möglichkeiten, eine Sentiment-Analyse in .NET-Anwendungen zu integrieren. Eine direkte Variante ist Python.NET. Dabei würde die .NET-Anwendung das Python-Skript unmittelbar aufrufen und die Klassifikation direkt in der Python-Umgebung ausführen. Das ist besonders praktisch für Prototypen oder interne Werkzeuge, da bestehender Python-Code nahezu unverändert weiterverwendet werden kann. Der Nachteil liegt jedoch in der Laufzeitabhängigkeit: Auf dem Zielsystem müssen Python und alle benötigten Bibliotheken korrekt installiert sein.

Eine zweite Alternative ist ein REST-Service. Hier läuft das Python-Modell in einem separaten Dienst. Die .NET-Anwendung sendet den zu analysierenden Text per HTTP an den Service und erhält die Klassifikation als JSON-Antwort zurück. Dieser Ansatz ist sehr flexibel und passt gut zu Microservice-Architekturen. Gleichzeitig entstehen allerdings zusätzlicher Betriebsaufwand, Netzwerk-Latenz und Anforderungen an Monitoring, Skalierung und Sicherheit.

Eine dritte Möglichkeit besteht darin, die Sentiment-Analyse vollständig mit ML.NET umzusetzen. In diesem Fall bleibt der gesamte Workflow in C#: Daten laden, Text vektorisieren, Modell trainieren und Vorhersagen durchführen. Das vereinfacht Deployment und Wartung, da keine Python-Komponenten notwendig sind. Allerdings ist das Python-Ökosystem bei vielen spezialisierten ML- und NLP-Verfahren weiterhin breiter aufgestellt.

Welcher Ansatz am besten geeignet ist, hängt daher vom konkreten Projekt ab. Für produktionsnahe Szenarien mit klar getrenntem Training und Deployment ist ONNX meist die robusteste Wahl. Für schnelle Experimente bietet Python.NET viel Flexibilität. Für verteilte Architekturen ist ein REST-Service attraktiv. Und wenn eine möglichst reine .NET-Lösung gewünscht ist, ist ML.NET der naheliegende Weg.

Fazit und Ausblick: KI in realen .NET-Anwendungen

Das gezeigte Beispiel der Sentiment-Analyse verdeutlicht, wie sich die bislang zum Thema „.NET, Python und KI“ vorgestellten Technologien zu einem Workflow verbinden lassen. Ein Modell wird in Python trainiert, in ein interoperables Format überführt und anschließend in einer .NET-Anwendung produktiv genutzt. Damit wird aus einem isolierten Data-Science-Ergebnis eine konkrete Funktion innerhalb einer Business-Anwendung.

Künstliche Intelligenz ist kein isoliertes Spezialgebiet mehr, sondern ein integraler Bestandteil moderner Anwendungen. Wer die grundlegenden Integrationsmuster verstanden hat, kann unterschiedlichste Anwendungsfälle umsetzen – von Textanalyse über Prognosen bis hin zu komplexen Deep-Learning-Szenarien.

[1] Veikko Krypczyk, Effizienter Brückenschlag, dotnetpro 2/2026, Seite 40 ff.