TensorFlow .NET (Cómo funciona para desarrolladores)

Aprendizaje automático(ML) ha revolucionado varios sectores, desde la sanidad a las finanzas, al permitir la toma de decisiones inteligente y la automatización. TensorFlow, el marco de aprendizaje profundo y ML de código abierto de Google, ha estado a la vanguardia de esta revolución. Con TensorFlow.NET, los desarrolladores .NET pueden aprovechar la potencia de TensorFlow dentro del ecosistema C#. En este artículo, exploraremos TensorFlow.NET, sus características, beneficios y aplicaciones prácticas en el desarrollo en C#. Además, conoceremos una biblioteca de generación de PDF llamada IronPDF de Iron Software con un ejemplo práctico.

Entendiendo TensorFlow.NET

TensorFlow.NET es un enlace .NET para TensorFlow, que permite a los desarrolladores utilizar la funcionalidad de TensorFlow directamente dentro de las capas de aplicación de C# y .NET. Desarrollado por la comunidad y mantenido por la organización SciSharp, TensorFlow.NET proporciona una integración perfecta de las capacidades de aprendizaje automático y redes neuronales de TensorFlow con la versatilidad de la plataforma .NET. Permite a los desarrolladores de C# crear redes neuronales, entrenar modelos o imágenes de entrenamiento e implantar modelos ML utilizando las amplias API y herramientas del sistema TensorFlow.

Características principales de TensorFlow.NET

1. Compatibilidad con TensorFlow: TensorFlow.NET proporciona total compatibilidad con las APIs y operaciones de TensorFlow, incluyendo la manipulación o activación de tensores, capas de redes neuronales, funciones de pérdida, optimizadores y utilidades para el preprocesamiento y evaluación de datos.

2. Alto rendimiento: TensorFlow.NET aprovecha el eficiente motor de ejecución de grafos computacionales de TensorFlow y los kernels optimizados para ofrecer inferencia y entrenamiento de aprendizaje automático de alto rendimiento en CPU y GPU.

3. Fácil integración: TensorFlow.NET se integra perfectamente con las aplicaciones y librerías .NET existentes, permitiendo a los desarrolladores aprovechar las capacidades de TensorFlow sin abandonar el entorno de desarrollo familiar de C#.

4. Portabilidad de modelos: TensorFlow.NET permite a los desarrolladores importar modelos TensorFlow preentrenados y exportar modelos entrenados para su inferencia en otros entornos basados en TensorFlow, como Python o dispositivos móviles.

5. Flexibilidad y extensibilidad: TensorFlow.NET proporciona flexibilidad para personalizar y ampliar los modelos de aprendizaje automático utilizando características del lenguaje C#, como LINQ(Idioma Consulta integrada) para la manipulación de datos y paradigmas de programación funcional para la composición de modelos.

6. Soporte y documentación de la comunidad: TensorFlow.NET se beneficia de una activa comunidad de colaboradores que proporcionan documentación, tutoriales y ejemplos para ayudar a los desarrolladores a iniciarse en el aprendizaje automático en el mundo C# utilizando TensorFlow.

Ejemplos prácticos con TensorFlow.NET

Exploremos algunos escenarios prácticos donde TensorFlow.NET puede ser utilizado para construir y desplegar modelos de aprendizaje automático en C#:

1. Carga y uso de modelos preformados:

    // 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. Formación de modelos personalizados:

    // 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. Evaluación y despliegue:

    // 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

Se pueden encontrar más ejemplos de TensorFlow en la página webEjemplos de TensorFlow.NET página.

// 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

Ejemplo de salida de Hello TensorFlow

Ventajas del uso de TensorFlow.NET

1. Integración sin fisuras: TensorFlow.NET lleva la potencia de TensorFlow al ecosistema .NET, permitiendo a los desarrolladores de C# aprovechar las técnicas y algoritmos de aprendizaje automático más avanzados en sus aplicaciones.

2. Rendimiento y escalabilidad: TensorFlow.NET aprovecha el motor de ejecución optimizado de TensorFlow para ofrecer cálculos de aprendizaje automático de alto rendimiento, lo que lo hace adecuado para manejar conjuntos de datos a gran escala, imágenes de prueba y modelos complejos o densos.

3. Entorno de desarrollo familiar: la API TensorFlow.NET permite a los desarrolladores construir e implantar modelos de aprendizaje automático utilizando características y herramientas de desarrollo del lenguaje C# que les resultan familiares, lo que reduce la curva de aprendizaje para adoptar el aprendizaje automático en aplicaciones C#.

4. Interoperabilidad y portabilidad: TensorFlow.NET facilita la interoperabilidad con otros entornos basados en TensorFlow, permitiendo una integración perfecta de modelos de aprendizaje automático basados en C# con Python, TensorFlow Serving y TensorFlow Lite.

5. Desarrollo impulsado por la comunidad: TensorFlow.NET se beneficia de una comunidad activa de colaboradores y usuarios que proporcionan apoyo, comentarios y contribuciones al proyecto, asegurando su continuo crecimiento y mejora.

Licencia de TensorFlow.NET

Se trata de un paquete de código abierto con licencia Apache que puede utilizarse libremente. Más información sobre la licencia enLicencia de TensorFlow.NET página.

Presentación de IronPDF

ironPDF es una potente biblioteca PDF en C# que permite a los desarrolladores crear, editar y firmar archivos PDF directamente a partir de entradas HTML, CSS, imágenes y JavaScript. Es una solución comercial de alto rendimiento y bajo consumo de memoria. Estas son algunas de sus principales características:

1. Conversión de HTML a PDF: IronPDF puede convertir archivos HTML, cadenas HTML y URLs a PDFs. Por ejemplo, puedes renderizar una página web como PDF utilizando el renderizador de PDF de Chrome.

2. Soporte multiplataforma: IronPDF funciona en varias plataformas .NET, incluidas .NET Core, .NET Standard y .NET Framework. Es compatible con Windows, Linux y macOS.

3. Edición y firma: Puede establecer propiedades, añadir seguridad(contraseñas y permisos)e incluso aplicar firmas digitales a tus PDF.

4. Plantillas de página y configuración: Personaliza tus PDF añadiendo encabezados, pies de página y números de página, y ajustando los márgenes. ironPDF también admite diseños adaptables y tamaños de papel personalizados.

5. Cumplimiento de estándares: ironPDF cumple estándares PDF como PDF/A y PDF/UA. Admite la codificación de caracteres UTF-8 y gestiona activos como imágenes, CSS y fuentes.

Generar documentos PDF usando TensorFlow.NET y IronPDF

En primer lugar, cree un proyecto de Visual Studio y seleccione la siguiente plantilla de aplicación de consola.

Indique el nombre y la ubicación del proyecto.

Seleccione la versión .NET necesaria en el siguiente paso y haga clic en el botón Crear.

Instale IronPDF desde el paquete NuGet del gestor de paquetes de Visual Studio.

Instala los paquetes TensorFlow.NET y TensorFlow.Keras, un paquete independiente utilizado para ejecutar modelos.

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

Código Explicación

Desglosemos el fragmento de código:

1. Declaraciones de importación:

   El código comienza importando las bibliotecas necesarias. Específicamente:

    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. Ejecución ansiosa:

   La línea `tf.enable_eager_execution()activa el modo de ejecución eager de TensorFlow. En la ejecución ansiosa, las operaciones se evalúan inmediatamente, lo que facilita la depuración y la interacción con los tensores.

3. Definir Constantes de Tensor:

   El código define tres constantes tensoriales: a, b y c. Se inicializan con los valores 5, 6 y 7, respectivamente.

4. Varias operaciones tensoriales:

   Se realizan las siguientes operaciones tensoriales:

    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. Acceder a los valores del tensor:

   Los resultados de las operaciones tensoriales se imprimen utilizando la función print:

    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

Ejemplo de salida:

- 5 + 6 = 11

- 5 - 6 = -1

- 5 * 6 = 30

- 5 / 6 = 0.8333333333333334

6. Operaciones adicionales:

   El código calcula la media y la suma de las constantes [a, b, c].

7. Generación de PDF:

   ChromePdfRenderer y RenderHtmlAsPdf de IronPDF se utilizan para convertir la cadena HTML en un documento PDF.

Salida

Licencia IronPDF

ironPDFnecesita una licencia para funcionar. Encontrará más información sobre licencias en[Licencias IronPDF](/licensing/) página. Coloque la clave en el archivoappSettings.json` como se muestra a continuación.

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

Conclusión

En conclusión, TensorFlow.NET permite a los desarrolladores de C# explorar el mundo del aprendizaje automático y la inteligencia artificial con la versatilidad y productividad del ecosistema .NET. Tanto si está creando aplicaciones inteligentes, herramientas de análisis predictivo o sistemas automatizados de toma de decisiones, TensorFlow.NET proporciona un marco potente y flexible para liberar el potencial del aprendizaje automático en C#. Junto con la biblioteca IronPDF de Iron Software, los desarrolladores pueden adquirir conocimientos avanzados para desarrollar aplicaciones modernas.