La biblioteca PDF de C#
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
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.
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.
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.
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.
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#.
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.
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.
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.Exploremos algunos escenarios prácticos donde TensorFlow.NET puede ser utilizado para construir y desplegar modelos de aprendizaje automático en C#:
// 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); // 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); // 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");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);
}
}
}Ejemplo de salida de Hello TensorFlow
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.
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.
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#.
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.
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.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.
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:
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.
Soporte multiplataforma: IronPDF funciona en varias plataformas .NET, incluidas .NET Core, .NET Standard y .NET Framework. Es compatible con Windows, Linux y macOS.
Edición y firma: Puede establecer propiedades, añadir seguridad(contraseñas y permisos)e incluso aplicar firmas digitales a tus PDF.
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.
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");
}
}
}Desglosemos el fragmento de código:
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.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.
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.
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.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}");Ejemplo de salida:
- 5 + 6 = 11
- 5 - 6 = -1
- 5 * 6 = 30
- 5 / 6 = 0.8333333333333334Operaciones adicionales:
El código calcula la media y la suma de las constantes [a, b, c].
Generación de PDF:
ChromePdfRenderer y RenderHtmlAsPdf de IronPDF se utilizan para convertir la cadena HTML en un documento PDF.
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"
}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.
Install-Package IronPdf
No se necesita tarjeta de crédito
Su clave de prueba debería estar en el correo electrónico.
Si no es así, por favor contacte
support@ironsoftware.com
No se necesita tarjeta de crédito
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
No se necesita tarjeta de crédito ni crear una cuenta
Su clave de prueba debería estar en el correo electrónico.
Si no es así, por favor contacte con
support@ironsoftware.com
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
Licencias desde $749. ¿Tiene alguna pregunta? Póngase en contacto.
Reserve una demostración personal de 30 minutos.
Sin contrato, sin detalles de tarjeta, sin compromisos.
10 productos API de .NET para tus documentos de oficina
