TensorFlow .NET (Wie es für Entwickler funktioniert)

Maschinelles Lernen (ML) hat verschiedene Branchen revolutioniert, vom Gesundheitswesen bis zum Finanzwesen, indem es intelligente Entscheidungsfindung und Automatisierung ermöglicht. TensorFlow, Googles Open-Source-ML- und Deep-Learning-Framework, steht an der Spitze dieser Revolution. Mit "TensorFlow.NET" können .NET-Entwickler die Leistungsfähigkeit von TensorFlow innerhalb des C#-Ökosystems nutzen. In diesem Artikel werden wir TensorFlow.NET, seine Funktionen, Vorteile und praktischen Anwendungen in der C#-Entwicklung untersuchen. Außerdem lernen wir eine Bibliothek zur PDF-Erzeugung namens IronPDF von Iron Software anhand eines praktischen Beispiels kennen.

Verstehen von TensorFlow.NET

tensorFlow.NET" ist eine .NET-Anbindung für TensorFlow, die es Entwicklern ermöglicht, TensorFlow-Funktionalität direkt in C#- und .NET-Anwendungsschichten zu nutzen. Entwickelt von der Community und gepflegt von der SciSharp-Organisation, bietet "TensorFlow.NET" eine nahtlose Integration der Fähigkeiten von TensorFlow für maschinelles Lernen und neuronale Netze mit der Vielseitigkeit der .NET-Plattform. Es ermöglicht C#-Entwicklern, neuronale Netze zu erstellen, Modelle oder Trainingsbilder zu trainieren und ML-Modelle unter Verwendung der umfangreichen System-APIs und Werkzeuge von TensorFlow einzusetzen.

Hauptmerkmale von TensorFlow.NET

1. TensorFlow-Kompatibilität: tensorFlow.NET" bietet volle Kompatibilität mit den APIs und Operationen von TensorFlow, einschließlich Tensormanipulation oder -aktivierung, neuronale Netzwerkschichten, Verlustfunktionen, Optimierer und Dienstprogramme für die Datenvorverarbeitung und -auswertung.

2. Hohe Leistung: tensorFlow.NET nutzt TensorFlow's effiziente Graphenausführungs-Engine und optimierte Kernel, um hochleistungsfähige maschinelle Lerninferenzen und Training auf CPUs und GPUs zu liefern.

3. Einfache Integration: tensorFlow.NET" integriert sich nahtlos in bestehende .NET Anwendungen und Bibliotheken und ermöglicht es Entwicklern, die Fähigkeiten von TensorFlow zu nutzen, ohne die vertraute C# Entwicklungsumgebung zu verlassen.

4. Modell-Portabilität: tensorFlow.NET" ermöglicht Entwicklern den Import von vortrainierten TensorFlow-Modellen und den Export von trainierten Modellen für die Inferenz in anderen TensorFlow-basierten Umgebungen, wie Python oder mobilen Geräten.

5. Flexibilität und Erweiterbarkeit: tensorFlow.NET" bietet Flexibilität für die Anpassung und Erweiterung von Modellen für maschinelles Lernen unter Verwendung von C#-Sprachmerkmalen, wie LINQ (Sprache Integrierte Abfrage) für die Datenmanipulation und funktionale Programmierparadigmen für die Modellkomposition.

6. Gemeinschaftsunterstützung und Dokumentation: tensorFlow.NET" profitiert von einer aktiven Gemeinschaft von Mitwirkenden, die Dokumentation, Tutorials und Beispiele zur Verfügung stellen, um Entwicklern den Einstieg in das maschinelle Lernen in der C#-Welt mit TensorFlow zu erleichtern.

Praktische Beispiele mit TensorFlow.NET

Lassen Sie uns einige praktische Szenarien untersuchen, in denen TensorFlow.NET verwendet werden kann, um Modelle für maschinelles Lernen in C# zu erstellen und einzusetzen:

1. Laden und Verwenden von vortrainierten Modellen:

    // Load a pre-trained TensorFlow model
    var model = TensorFlowModel.LoadModel("model.pb");
    // Perform inference on input data
    var input = new float[,] { { 1.0f, 2.0f, 3.0f } };
    var output = model.Predict(input);

    // Load a pre-trained TensorFlow model
    var model = TensorFlowModel.LoadModel("model.pb");
    // Perform inference on input data
    var input = new float[,] { { 1.0f, 2.0f, 3.0f } };
    var output = model.Predict(input);

' Load a pre-trained TensorFlow model
	Dim model = TensorFlowModel.LoadModel("model.pb")
	' Perform inference on input data
	Dim input = New Single(, ) {
		{ 1.0F, 2.0F, 3.0F }
	}
	Dim output = model.Predict(input)

2. Schulung benutzerdefinierter Modelle:

    // Create a neural network model using TensorFlow.NET APIs and metrics
    var input = new Input(Shape.Scalar);
    var output = new Dense(1, Activation.ReLU).Forward(input);
    // Compile the model with loss function and optimizer algorithms
    var model = new Model(input, output);
    model.Compile(optimizer: new SGD(), loss: Losses.MeanSquaredError);
    // Train the model with training data just like Python
    model.Fit(x_train, y_train, epochs: 10, batchSize: 32);

    // Create a neural network model using TensorFlow.NET APIs and metrics
    var input = new Input(Shape.Scalar);
    var output = new Dense(1, Activation.ReLU).Forward(input);
    // Compile the model with loss function and optimizer algorithms
    var model = new Model(input, output);
    model.Compile(optimizer: new SGD(), loss: Losses.MeanSquaredError);
    // Train the model with training data just like Python
    model.Fit(x_train, y_train, epochs: 10, batchSize: 32);

IRON VB CONVERTER ERROR developers@ironsoftware.com

3. Evaluierung und Einsatz:

    // Evaluate the trained model on test data
    var evaluation = model.Evaluate(x_test, y_test);
    // Export the trained model for deployment
    model.SaveModel("trained_model.pb");

    // Evaluate the trained model on test data
    var evaluation = model.Evaluate(x_test, y_test);
    // Export the trained model for deployment
    model.SaveModel("trained_model.pb");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Weitere Beispiele für TensorFlow finden Sie auf der Seite mit den Beispielen.

// static Tensorflow
using static Tensorflow.Binding;
namespace IronPdfDemos
{
    public class TensorFlow
    {
        public static void Execute()
        {
            var hello = tf.constant("Hello, TensorFlow!");
            Console.WriteLine(hello);
        }
    }
}

// static Tensorflow
using static Tensorflow.Binding;
namespace IronPdfDemos
{
    public class TensorFlow
    {
        public static void Execute()
        {
            var hello = tf.constant("Hello, TensorFlow!");
            Console.WriteLine(hello);
        }
    }
}

' static Tensorflow
Imports Tensorflow.Binding
Namespace IronPdfDemos
	Public Class TensorFlow
		Public Shared Sub Execute()
			Dim hello = tf.constant("Hello, TensorFlow!")
			Console.WriteLine(hello)
		End Sub
	End Class
End Namespace

Beispiel Hello TensorFlow Ausgabe

Vorteile der Verwendung von TensorFlow.NET

1. Nahtlose Integration: tensorFlow.NET" bringt die Leistungsfähigkeit von TensorFlow in das .NET-Ökosystem und ermöglicht C#-Entwicklern, modernste maschinelle Lerntechniken und Algorithmen in ihren Anwendungen zu nutzen.

2. Leistung und Skalierbarkeit: tensorFlow.NET nutzt die optimierte Ausführungs-Engine von TensorFlow, um hochleistungsfähige maschinelle Lernberechnungen zu liefern, was es für die Handhabung großer Datensätze, Testbilder und komplexer oder dichter Modelle geeignet macht.

3. Vertraute Entwicklungsumgebung: die "TensorFlow.NET"-API ermöglicht es Entwicklern, Modelle für maschinelles Lernen mit vertrauten C#-Sprachmerkmalen und -Entwicklungswerkzeugen zu erstellen und einzusetzen, wodurch die Lernkurve für die Einführung von maschinellem Lernen in C#-Anwendungen reduziert wird.

4. Interoperabilität und Portabilität: tensorFlow.NET" erleichtert die Interoperabilität mit anderen TensorFlow-basierten Umgebungen und ermöglicht die nahtlose Integration von C#-basierten Machine-Learning-Modellen mit Python, TensorFlow Serving und TensorFlow Lite.

5. Gemeinschaftsgesteuerte Entwicklung: tensorFlow.NET" profitiert von einer aktiven Gemeinschaft von Mitwirkenden und Anwendern, die Unterstützung, Feedback und Beiträge zum Projekt liefern und so dessen kontinuierliches Wachstum und Verbesserung sicherstellen.

TensorFlow.NET Lizenz

Es ist ein Open-Source-Paket mit Apache-Lizenz, das frei verwendet werden kann. Mehr über die Lizenz können Sie auf der Lizenzseite lesen.

Einführung in IronPDF

ironPDF" ist eine leistungsstarke C# PDF-Bibliothek, die es Entwicklern ermöglicht, PDFs direkt aus HTML-, CSS-, Bild- und JavaScript-Eingaben zu erstellen, zu bearbeiten und zu signieren. Es handelt sich um eine kommerzielle Lösung mit hoher Leistung und geringem Speicherbedarf. Hier sind einige der wichtigsten Merkmale:

1. HTML zu PDF Konvertierung: ironPDF" kann HTML-Dateien, HTML-Strings und URLs in PDFs umwandeln. So können Sie beispielsweise eine Webseite mit dem Chrome PDF-Renderer als PDF wiedergeben.

2. Plattformübergreifende Unterstützung: ironPDF" funktioniert auf verschiedenen .NET-Plattformen, einschließlich .NET Core, .NET-Standard und .NET-Framework. Es ist kompatibel mit Windows, Linux und macOS.

3. Bearbeiten und Signieren: Sie können Eigenschaften festlegen, Sicherheit hinzufügen (passwörter und Berechtigungen)und sogar digitale Signaturen auf Ihre PDFs anwenden.

4. Seitenvorlagen und Einstellungen: Passen Sie Ihre PDFs an, indem Sie Kopf- und Fußzeilen sowie Seitenzahlen hinzufügen und die Ränder anpassen. ironPDF" unterstützt auch responsive Layouts und benutzerdefinierte Papierformate.

5. Einhaltung von Standards: ironPDF" hält sich an PDF-Standards wie PDF/A und PDF/UA. Es unterstützt die UTF-8-Zeichenkodierung und verarbeitet Assets wie Bilder, CSS und Schriftarten.

Erzeugen von PDF-Dokumenten mit TensorFlow.NET und IronPDF

Erstellen Sie zunächst ein Visual Studio-Projekt und wählen Sie die unten stehende Konsolenanwendungsvorlage aus.

Geben Sie den Projektnamen und den Standort an.

Wählen Sie im nächsten Schritt die gewünschte .NET-Version aus und klicken Sie auf die Schaltfläche Erstellen.

Installieren Sie "IronPDF" aus dem NuGet-Paket des Visual Studio Package Manager.

Installieren Sie die Pakete "TensorFlow.NET" und "TensorFlow.Keras", ein unabhängiges Paket, das zur Ausführung von Modellen verwendet wird.

using IronPdf;
using static Tensorflow.Binding;

namespace IronPdfDemos
{
    public class Program
    {
        public static void Main()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();

            // Prepare HTML
            var content = "<h1>Demonstrate TensorFlow with IronPDF</h1>";
            content += $"<p></p>";
            content += $"<h2></h2>";

            // Eager mode
            content += $"<h2>Enable Eager Execution</h2>";
            content += $"<p>tf.enable_eager_execution();</p>";

            // tf is a static TensorFlow instance
            tf.enable_eager_execution(); // Enable eager mode

            content += $"<h2>Define tensor constants.</h2>";
            // Introduce tensor constants
            var a = tf.constant(5);
            var b = tf.constant(6);
            var c = tf.constant(7);

            content += $"<p></p>";
            content += $"<p></p>";
            content += $"<p></p>";

            content += $"<h2>Various tensor operations.</h2>";
            // Various tensor operations usage
            // Note: Tensors also support operators (+, *, ...)
            var add = tf.add(a, b);
            var sub = tf.subtract(a, b);
            var mul = tf.multiply(a, b);
            var div = tf.divide(a, b);

            content += $"<p>var add = tf.add(a, b);</p>";
            content += $"<p>var sub = tf.subtract(a, b);</p>";
            content += $"<p>var mul = tf.multiply(a, b);</p>";
            content += $"<p>var div = tf.divide(a, b);</p>";

            content += $"<h2>Access tensors value.</h2>";
            // Tensors value
            print($"{(int)a} + {(int)b} = {(int)add}");
            print($"{(int)a} - {(int)b} = {(int)sub}");
            print($"{(int)a} * {(int)b} = {(int)mul}");
            print($"{(int)a} / {(int)b} = {(double)div}");

            content += $"<p>{(int)a} + {(int)b} = {(int)add}</p>";
            content += $"<p>{(int)a} - {(int)b} = {(int)sub}</p>";
            content += $"<p>{(int)a} * {(int)b} = {(int)mul}</p>";
            content += $"<p>{(int)a} / {(int)b} = {(double)div}</p>";

            // Some more operations
            var mean = tf.reduce_mean(tf.constant(new[] { a, b, c }));
            var sum = tf.reduce_sum(tf.constant(new[] { a, b, c }));

            content += $"<h2>Access tensors value.</h2>";
            // Access tensors value
            print("mean =", mean.numpy());
            print("sum =", sum.numpy());

            content += $"<p>mean = {mean.numpy()}</p>";
            content += $"<p>sum = {sum.numpy()}</p>";

            content += $"<h2>Matrix multiplications.</h2>";
            // Matrix multiplications with a single row
            var matrix1 = tf.constant(new float[,] { { 1, 2 }, { 3, 4 } });
            var matrix2 = tf.constant(new float[,] { { 5, 6 }, { 7, 8 } });
            var product = tf.matmul(matrix1, matrix2);

            content += "<p>matrix1 = tf.constant(new float[,] { { { 1, 2 }}, { { 3, 4 }} })</p>";
            content += "<p>matrix2 = tf.constant(new float[,] { { { 5, 6 }}, { { 7, 8 }} })</p>";
            content += "<p>product = tf.matmul(matrix1, matrix2)</p>";

            content += $"<h2>Convert Tensor to Numpy.</h2>";
            // Convert Tensor to Numpy
            print("product =", product.numpy());

            content += $"<p>product = {product.numpy()}</p>";

            // Create a PDF from an HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("tensorflow.pdf");
        }
    }
}

using IronPdf;
using static Tensorflow.Binding;

namespace IronPdfDemos
{
    public class Program
    {
        public static void Main()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();

            // Prepare HTML
            var content = "<h1>Demonstrate TensorFlow with IronPDF</h1>";
            content += $"<p></p>";
            content += $"<h2></h2>";

            // Eager mode
            content += $"<h2>Enable Eager Execution</h2>";
            content += $"<p>tf.enable_eager_execution();</p>";

            // tf is a static TensorFlow instance
            tf.enable_eager_execution(); // Enable eager mode

            content += $"<h2>Define tensor constants.</h2>";
            // Introduce tensor constants
            var a = tf.constant(5);
            var b = tf.constant(6);
            var c = tf.constant(7);

            content += $"<p></p>";
            content += $"<p></p>";
            content += $"<p></p>";

            content += $"<h2>Various tensor operations.</h2>";
            // Various tensor operations usage
            // Note: Tensors also support operators (+, *, ...)
            var add = tf.add(a, b);
            var sub = tf.subtract(a, b);
            var mul = tf.multiply(a, b);
            var div = tf.divide(a, b);

            content += $"<p>var add = tf.add(a, b);</p>";
            content += $"<p>var sub = tf.subtract(a, b);</p>";
            content += $"<p>var mul = tf.multiply(a, b);</p>";
            content += $"<p>var div = tf.divide(a, b);</p>";

            content += $"<h2>Access tensors value.</h2>";
            // Tensors value
            print($"{(int)a} + {(int)b} = {(int)add}");
            print($"{(int)a} - {(int)b} = {(int)sub}");
            print($"{(int)a} * {(int)b} = {(int)mul}");
            print($"{(int)a} / {(int)b} = {(double)div}");

            content += $"<p>{(int)a} + {(int)b} = {(int)add}</p>";
            content += $"<p>{(int)a} - {(int)b} = {(int)sub}</p>";
            content += $"<p>{(int)a} * {(int)b} = {(int)mul}</p>";
            content += $"<p>{(int)a} / {(int)b} = {(double)div}</p>";

            // Some more operations
            var mean = tf.reduce_mean(tf.constant(new[] { a, b, c }));
            var sum = tf.reduce_sum(tf.constant(new[] { a, b, c }));

            content += $"<h2>Access tensors value.</h2>";
            // Access tensors value
            print("mean =", mean.numpy());
            print("sum =", sum.numpy());

            content += $"<p>mean = {mean.numpy()}</p>";
            content += $"<p>sum = {sum.numpy()}</p>";

            content += $"<h2>Matrix multiplications.</h2>";
            // Matrix multiplications with a single row
            var matrix1 = tf.constant(new float[,] { { 1, 2 }, { 3, 4 } });
            var matrix2 = tf.constant(new float[,] { { 5, 6 }, { 7, 8 } });
            var product = tf.matmul(matrix1, matrix2);

            content += "<p>matrix1 = tf.constant(new float[,] { { { 1, 2 }}, { { 3, 4 }} })</p>";
            content += "<p>matrix2 = tf.constant(new float[,] { { { 5, 6 }}, { { 7, 8 }} })</p>";
            content += "<p>product = tf.matmul(matrix1, matrix2)</p>";

            content += $"<h2>Convert Tensor to Numpy.</h2>";
            // Convert Tensor to Numpy
            print("product =", product.numpy());

            content += $"<p>product = {product.numpy()}</p>";

            // Create a PDF from an HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("tensorflow.pdf");
        }
    }
}

Imports IronPdf
Imports Tensorflow.Binding

Namespace IronPdfDemos
	Public Class Program
		Public Shared Sub Main()
			' Instantiate Cache and ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()

			' Prepare HTML
			Dim content = "<h1>Demonstrate TensorFlow with IronPDF</h1>"
			content &= $"<p></p>"
			content &= $"<h2></h2>"

			' Eager mode
			content &= $"<h2>Enable Eager Execution</h2>"
			content &= $"<p>tf.enable_eager_execution();</p>"

			' tf is a static TensorFlow instance
			tf.enable_eager_execution() ' Enable eager mode

			content &= $"<h2>Define tensor constants.</h2>"
			' Introduce tensor constants
			Dim a = tf.constant(5)
			Dim b = tf.constant(6)
			Dim c = tf.constant(7)

			content &= $"<p></p>"
			content &= $"<p></p>"
			content &= $"<p></p>"

			content &= $"<h2>Various tensor operations.</h2>"
			' Various tensor operations usage
			' Note: Tensors also support operators (+, *, ...)
			Dim add = tf.add(a, b)
			Dim [sub] = tf.subtract(a, b)
			Dim mul = tf.multiply(a, b)
			Dim div = tf.divide(a, b)

			content &= $"<p>var add = tf.add(a, b);</p>"
			content &= $"<p>var sub = tf.subtract(a, b);</p>"
			content &= $"<p>var mul = tf.multiply(a, b);</p>"
			content &= $"<p>var div = tf.divide(a, b);</p>"

			content &= $"<h2>Access tensors value.</h2>"
			' Tensors value
			print($"{CInt(a)} + {CInt(b)} = {CInt(add)}")
			print($"{CInt(a)} - {CInt(b)} = {CInt([sub])}")
			print($"{CInt(a)} * {CInt(b)} = {CInt(mul)}")
			print($"{CInt(a)} / {CInt(b)} = {CDbl(div)}")

			content &= $"<p>{CInt(a)} + {CInt(b)} = {CInt(add)}</p>"
			content &= $"<p>{CInt(a)} - {CInt(b)} = {CInt([sub])}</p>"
			content &= $"<p>{CInt(a)} * {CInt(b)} = {CInt(mul)}</p>"
			content &= $"<p>{CInt(a)} / {CInt(b)} = {CDbl(div)}</p>"

			' Some more operations
			Dim mean = tf.reduce_mean(tf.constant( { a, b, c }))
			Dim sum = tf.reduce_sum(tf.constant( { a, b, c }))

			content &= $"<h2>Access tensors value.</h2>"
			' Access tensors value
			print("mean =", mean.numpy())
			print("sum =", sum.numpy())

			content &= $"<p>mean = {mean.numpy()}</p>"
			content &= $"<p>sum = {sum.numpy()}</p>"

			content &= $"<h2>Matrix multiplications.</h2>"
			' Matrix multiplications with a single row
			Dim matrix1 = tf.constant(New Single(, ) {
				{ 1, 2 },
				{ 3, 4 }
			})
			Dim matrix2 = tf.constant(New Single(, ) {
				{ 5, 6 },
				{ 7, 8 }
			})
			Dim product = tf.matmul(matrix1, matrix2)

			content &= "<p>matrix1 = tf.constant(new float[,] { { { 1, 2 }}, { { 3, 4 }} })</p>"
			content &= "<p>matrix2 = tf.constant(new float[,] { { { 5, 6 }}, { { 7, 8 }} })</p>"
			content &= "<p>product = tf.matmul(matrix1, matrix2)</p>"

			content &= $"<h2>Convert Tensor to Numpy.</h2>"
			' Convert Tensor to Numpy
			print("product =", product.numpy())

			content &= $"<p>product = {product.numpy()}</p>"

			' Create a PDF from an HTML string using C#
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			pdf.SaveAs("tensorflow.pdf")
		End Sub
	End Class
End Namespace

Code Erläuterung

Schauen wir uns das Codeschnipsel genauer an:

1. Import-Anweisungen:

    Der Code beginnt mit dem Importieren der erforderlichen Bibliotheken. Konkret:

    using IronPdf; // This imports the IronPDF package, which is used for working with PDF files.
    using static Tensorflow.Binding; // This imports the TensorFlow library, specifically the .NET standard binding.

    using IronPdf; // This imports the IronPDF package, which is used for working with PDF files.
    using static Tensorflow.Binding; // This imports the TensorFlow library, specifically the .NET standard binding.

IRON VB CONVERTER ERROR developers@ironsoftware.com

2. Eifrige Ausführung:

    Die Zeile `tf.enable_eager_execution();` aktiviert den eifrigen Ausführungsmodus von TensorFlow. Bei der eifrigen Ausführung werden die Operationen sofort ausgewertet, was die Fehlersuche und die Interaktion mit Tensoren erleichtert.

3. Tensor-Konstanten definieren:

    Der Code definiert drei Tensorkonstanten: `a`, `b` und `c`. Diese werden mit den Werten 5, 6 bzw. 7 initialisiert.

4. Verschiedene Tensor-Operationen:

    Die folgenden Tensoroperationen werden durchgeführt:

    var add = tf.add(a, b); // Adds a and b.
    var sub = tf.subtract(a, b); // Subtracts b from a.
    var mul = tf.multiply(a, b); // Multiplies a and b.
    var div = tf.divide(a, b); // Divides a by b.

    var add = tf.add(a, b); // Adds a and b.
    var sub = tf.subtract(a, b); // Subtracts b from a.
    var mul = tf.multiply(a, b); // Multiplies a and b.
    var div = tf.divide(a, b); // Divides a by b.

IRON VB CONVERTER ERROR developers@ironsoftware.com

5. Zugriff auf Tensorwerte:

    Die Ergebnisse der Tensoroperationen werden mit der Funktion `print` ausgedruckt:

    print($"{(int)a} + {(int)b} = {(int)add}");
    print($"{(int)a} - {(int)b} = {(int)sub}");
    print($"{(int)a} * {(int)b} = {(int)mul}");
    print($"{(int)a} / {(int)b} = {(double)div}");

    print($"{(int)a} + {(int)b} = {(int)add}");
    print($"{(int)a} - {(int)b} = {(int)sub}");
    print($"{(int)a} * {(int)b} = {(int)mul}");
    print($"{(int)a} / {(int)b} = {(double)div}");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beispiel Ausgabe:

    - 5 + 6 = 11

    - 5 - 6 = -1

    - 5 * 6 = 30

    - 5 / 6 = 0.8333333333333334

6. Zusätzliche Operationen:

    Der Code berechnet den Mittelwert und die Summe der Konstanten `[a, b, c]`.

7. PDF-Erstellung:

    chromePdfRenderer" und "RenderHtmlAsPdf" von IronPDF werden verwendet, um den HTML-String in ein PDF-Dokument umzuwandeln.

Ausgabe

IronPDF-Lizenz

ironPDF" benötigt eine Lizenz, um zu laufen. Weitere Informationen zur Lizenzierung finden Sie auf der Seite Lizenzierung. Platzieren Sie den Schlüssel in der Datei "appSettings.json" wie unten gezeigt.

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass "TensorFlow.NET" C#-Entwickler in die Lage versetzt, die Welt des maschinellen Lernens und der künstlichen Intelligenz mit der Vielseitigkeit und Produktivität des .NET-Ökosystems zu erkunden. Ob Sie intelligente Anwendungen, prädiktive Analysetools oder automatisierte Entscheidungsfindungssysteme entwickeln, TensorFlow.NET bietet ein leistungsstarkes und flexibles Framework, um das Potenzial des maschinellen Lernens in C# zu entfesseln. Zusammen mit der IronPDF-Bibliothek von Iron Software zum Lesen und Erzeugen von PDF-Dokumenten können Entwickler fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen erwerben.