Deep Learning in .NET – TensorFlow.NET und TorchSharp

Der Artikel „Effizienter Brückenschlag“ aus der dotnetpro-Ausgabe 2/2026 [1] hat bereits im Überblick dargestellt, wie KI-Modelle und Python-Code in .NET-Anwendungen integriert werden können. In diesem Beitrag befassen wir uns vertieft mit Deep Learning, das klassische Machine-Learning-Ansätze um leistungsfähige neuronale Netze erweitert, welche besonders bei Bild-, Sprach- und Textverarbeitung überzeugen. Während diese Technologien lange eng mit Python verknüpft waren, stehen inzwischen leistungsfähige .NET-Bindings zur Verfügung. Mit TensorFlow.NET und TorchSharp lassen sich moderne Deep-Learning-Modelle direkt in C# entwickeln.

Während klassische Machine-Learning-Verfahren häufig auf statistischen Modellen und vergleichsweise einfachen Feature-Transformationen basieren, geht Deep Learning einen Schritt weiter. Hier kommen künstliche neuronale Netze mit vielen Schichten (Deep Neural Networks) zum Einsatz, die in der Lage sind, komplexe Muster direkt aus großen Datenmengen zu lernen. Besonders in Bereichen wie Bildverarbeitung, Sprachverarbeitung oder bei generativen KI-Systemen ist Deep Learning heute der dominierende Ansatz. Im Unterschied zu klassischen ML-Modellen entfällt die manuelle Feature-Extraktion, da das Modell relevante Merkmale selbstständig aus den Rohdaten lernt.

Im Kontext von .NET stellt sich die Frage, wie sich diese Modelle integrieren lassen. In [1] wurden bereits verschiedene Ansätze beleuchtet: die direkte Nutzung von Python über Python.NET sowie der Austausch trainierter Modelle über ONNX. Beide Strategien bleiben auch im Deep-Learning-Kontext relevant, stoßen jedoch bei komplexen Modellen oder spezifischen Trainingsanforderungen teilweise an Grenzen – etwa hinsichtlich Performance, Flexibilität oder Wartbarkeit.

Mit TensorFlow.NET und TorchSharp stehen zwei leistungsfähige Bibliotheken zur Verfügung, die die Funktionalität von TensorFlow beziehungsweise PyTorch in die .NET-Welt übertragen. Dadurch können Entwickler neuronale Netze direkt in C# definieren, trainieren und ausführen, ohne zwingend auf Python angewiesen zu sein. Gleichzeitig bleibt die Nähe zu den Original-Frameworks erhalten, sodass bestehende Konzepte, Modelle und Workflows weitgehend übernommen werden können.

TensorFlow.NET – Deep Learning mit TensorFlow in C#

Mit TensorFlow.NET werden große Teile des TensorFlow-API in C# nutzbar gemacht. Intern werden die TensorFlow-Operationen weiterhin in nativen Bibliotheken ausgeführt, während C# als Steuerungsschicht dient. Das bedeutet: Entwickler definieren Modelle, Trainingslogik und Datenflüsse in C#, während die eigentliche Berechnung (zum Beispiel Matrixmultiplikationen auf GPU/CPU) in optimiertem nativem Code erfolgt. Dadurch bleibt die Performance auf einem vergleichbaren Niveau wie in Python-basierten Lösungen. Ein zentraler Bestandteil ist – wie in TensorFlow üblich – die Arbeit mit Tensors und Computational Graphs. Modelle können entweder auf niedriger Ebene (Operationen und Graphen) oder über höhere Abstraktionen wie Keras definiert werden.

Die Integration in .NET erfolgt über NuGet-Pakete:

dotnet add package TensorFlow.NET
dotnet add package SciSharp.TensorFlow.Redist

Das Paket SciSharp.TensorFlow.Redist enthält die nativen TensorFlow-Bibliotheken, die zur Ausführung notwendig sind.

Im folgenden Beispiel erstellen wir ein einfaches neuronales Netz zur binären Klassifikation. Ziel ist es, anhand numerischer Eingabewerte eine Entscheidung (0 oder 1) zu treffen.

Hinweis: Das XOR-Beispiel ist eine stark vereinfachte Mini-Version eines echten Problems. Beim XOR hängen die richtigen Ausgaben nicht „einfach“ von den Eingaben ab – es gibt keine gerade Linie, die die Klassen sauber trennt. Genau das passiert auch in der Realität: Viele Daten haben komplexe, nichtlineare Zusammenhänge, die man nicht mit einfachen Regeln beschreiben kann. Das neuronale Netz lernt beim XOR, diese komplexe Struktur zu erkennen. Und genau das gleiche Prinzip wird in echten Anwendungen genutzt – nur mit viel mehr Daten und deutlich komplexeren Mustern.

using System;
using Tensorflow;
using static Tensorflow.Binding;
using Tensorflow.Keras;
using Tensorflow.Keras.Layers;
using Tensorflow.NumPy;
class Program
{
    static void Main(string[] args)
    {
        // TensorFlow initialisieren
        tf.enable_eager_execution();
        // Trainingsdaten (vereinfachtes Beispiel)
        var x_train = np.array(new float[,]
        {
            {0, 0},
            {0, 1},
            {1, 0},
            {1, 1}
        });
        var y_train = np.array(new float[]
        {
            0, 1, 1, 0   // XOR-Problem
        });
        // Modell definieren (Keras API)
        var model = keras.Sequential();
        model.add(new Dense(8, activation: "relu", input_shape: 2));
        model.add(new Dense(4, activation: "relu"));
        model.add(new Dense(1, activation: "sigmoid"));
        // Kompilieren des Modells
        model.compile(
            optimizer: keras.optimizers.Adam(),
            loss: "binary_crossentropy",
            metrics: new[] { "accuracy" }
        );
        // Training
        model.fit(x_train, y_train, epochs: 200, verbose: 1);
        // Vorhersage
        var prediction = model.predict(x_train);
        Console.WriteLine("Vorhersagen:");
        Console.WriteLine(prediction);
    }
}

Das Beispiel zeigt einen Deep-Learning-Workflow:

• Datenbereitstellung: Trainingsdaten werden als NumPy-Arrays (über Tensorflow.NumPy) definiert.
• Modellaufbau: Ein sequenzielles Modell mit mehreren Dense-Schichten wird erstellt.
• Kompilierung: Verlustfunktion, Optimierer und Metriken werden festgelegt.
• Training: Das Modell wird über mehrere Epochen trainiert.
• Inferenz: Nach dem Training werden Vorhersagen berechnet.

TorchSharp – PyTorch für .NET

Neben TensorFlow hat sich PyTorch in den letzten Jahren als eines der führenden Frameworks für Deep Learning etabliert. Es zeichnet sich insbesondere durch seine flexible, imperative Programmierweise aus, die es erlaubt, Modelle dynamisch zur Laufzeit zu definieren. TorchSharp ermöglicht den Zugriff auf die PyTorch-Engine direkt aus C#. Zentrale Konzepte in TorchSharp sind:

• Tensoren als grundlegende Datenstruktur,
• Module zur Definition von Modellen,
• Optimierer zur Anpassung der Gewichte,
• Loss-Funktionen zur Bewertung der Modellgüte.

Die Integration erfolgt ebenfalls über NuGet:

dotnet add package TorchSharp

Es folgt ein Beispiel für ein einfaches neuronales Netz: konkret wieder ein XOR-Problem, analog zum TensorFlow.NET-Beispiel, jedoch im TorchSharp-Stil:

using System;
using TorchSharp;
using static TorchSharp.torch;
using static TorchSharp.torch.nn;
class Program
{
    static void Main(string[] args)
    {
        // Gerät wählen (CPU)
        var device = CPU;
        // Trainingsdaten (XOR)
        var x = tensor(new float[,] {
            {0, 0},
            {0, 1},
            {1, 0},
            {1, 1}
        }).to(device);
        var y = tensor(new float[,] {
            {0},
            {1},
            {1},
            {0}
        }).to(device);
        // Modell definieren
        var model = Sequential(
            ("layer1", Linear(2, 8)),
            ("relu1", ReLU()),
            ("layer2", Linear(8, 4)),
            ("relu2", ReLU()),
            ("output", Linear(4, 1)),
            ("sigmoid", Sigmoid())
        ).to(device);
        // Verlustfunktion und Optimierer
        var lossFn = BCELoss();
        var optimizer = optim.Adam(model.parameters(), lr: 0.01);
        // Training
        for (int epoch = 0; epoch < 2000; epoch++)
        {
            model.train();
            var prediction = model.forward(x);
            var loss = lossFn.call(prediction, y);
            optimizer.zero_grad();
            loss.backward();
            optimizer.step();
            if (epoch % 200 == 0)
            {
                Console.WriteLine($"Epoch {epoch}, Loss: {loss.ToSingle()}");
            }
        }
        // Inferenz
        model.eval();
        var output = model.forward(x);
        Console.WriteLine("Vorhersagen:");
        Console.WriteLine(output);
    }
}

Das Beispiel folgt dem typischen PyTorch-/TorchSharp-Workflow:

• Daten als Tensoren: Eingaben und Zielwerte werden direkt als Tensoren definiert.
• Modellstruktur: Das Netzwerk wird als Sequenz von Layern aufgebaut.
• Training Loop: Anders als bei Keras erfolgt das Training explizit über eine Schleife, inklusive Forward Pass, Loss-Berechnung, Backpropagation und Optimierung.
• Inferenz: Nach dem Training werden Vorhersagen berechnet.

Fazit

TensorFlow.NET orientiert sich am Keras-API und bietet einen hohen Abstraktionsgrad: Modelle lassen sich deklarativ definieren, Trainingsprozesse sind weitgehend gekapselt. Das erleichtert den Einstieg und eignet sich besonders für standardisierte, produktionsnahe Szenarien. TorchSharp hingegen folgt dem PyTorch-Paradigma und setzt auf eine imperative Programmierung. Trainingsschleifen werden explizit implementiert, was eine größere Kontrolle ermöglicht und sich insbesondere für komplexe oder experimentelle Modelle eignet (Bild 1).