La bibliothèque 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
Apprentissage automatique(ML)a révolutionné diverses industries, de la santé à la finance, en permettant une prise de décision intelligente et l'automatisation. TensorFlow, le framework ML et d'apprentissage profond open-source de Google, a été à la pointe de cette révolution. Avec TensorFlow.NET, les développeurs .NET peuvent exploiter la puissance de TensorFlow dans l'écosystème C#. Dans cet article, nous allons explorer TensorFlow.NET, ses fonctionnalités, ses avantages et ses applications pratiques dans le développement en C#. De plus, nous allons découvrir une bibliothèque de génération de PDF appelée IronPDF de Iron Software avec un exemple pratique.
TensorFlow.NET est une liaison .NET pour TensorFlow, permettant aux développeurs d'utiliser directement les fonctionnalités de TensorFlow au sein des couches d'application C# et .NET. Développé par la communauté et maintenu par l'organisation SciSharp, TensorFlow.NET offre une intégration transparente des capacités d'apprentissage automatique et de réseaux neuronaux de TensorFlow avec la polyvalence de la plateforme .NET. Il permet aux développeurs C# de créer des réseaux neuronaux, d'entraîner des modèles ou des images d'entraînement, et de déployer des modèles d'apprentissage automatique en utilisant les API système et les outils étendus de TensorFlow.
Compatibilité avec TensorFlow : TensorFlow.NET offre une compatibilité totale avec les API et les opérations de TensorFlow, y compris la manipulation de tenseurs ou l'activation, les couches de réseaux neuronaux, les fonctions de perte, les optimisateurs et les utilitaires pour le prétraitement et l'évaluation des données.
Haute Performance : TensorFlow.NET utilise le moteur d'exécution de graphes computationnels efficace de TensorFlow et des noyaux optimisés pour offrir une inférence et un apprentissage automatique de haute performance sur les CPU et les GPU.
Intégration facile : TensorFlow.NET s'intègre parfaitement aux applications et bibliothèques .NET existantes, permettant ainsi aux développeurs de tirer parti des capacités de TensorFlow sans quitter l'environnement de développement C# familier.
Portabilité des modèles: TensorFlow.NET permet aux développeurs d'importer des modèles TensorFlow pré-entraînés et d'exporter des modèles entraînés pour l'inférence dans d'autres environnements basés sur TensorFlow, tels que Python ou les appareils mobiles.
Flexibilité et extensibilité : TensorFlow.NET offre la flexibilité de personnaliser et d'étendre les modèles d'apprentissage automatique en utilisant les fonctionnalités de langage C#, telles que LINQ(Langue Requête intégrée)pour la manipulation des données et les paradigmes de programmation fonctionnelle pour la composition de modèles.
TensorFlow.NET bénéficie d'une communauté active de contributeurs qui fournissent de la documentation, des tutoriels et des exemples pour aider les développeurs à démarrer avec l'apprentissage automatique dans le monde C# en utilisant TensorFlow.Explorons quelques scénarios pratiques où TensorFlow.NET peut être utilisé pour créer et déployer des modèles d'apprentissage automatique 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");D'autres exemples de TensorFlow peuvent être trouvés sur le site web duExemples de TensorFlow.NET page.
// 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);
}
}
}Exemple de sortie Hello TensorFlow
Intégration transparente : TensorFlow.NET apporte la puissance de TensorFlow à l'écosystème .NET, permettant aux développeurs C# d'exploiter les techniques et algorithmes d'apprentissage automatique de pointe dans leurs applications.
Performances et évolutivité : TensorFlow.NET exploite le moteur d'exécution optimisé de TensorFlow pour fournir des calculs d'apprentissage automatique de haute performance, ce qui le rend adapté à la manipulation d'ensembles de données à grande échelle, d'images de test et de modèles complexes ou denses.
Environnement de développement familier : l'API TensorFlow.NET permet aux développeurs de construire et de déployer des modèles d'apprentissage automatique en utilisant des fonctionnalités et des outils de développement familiers du langage C#, réduisant ainsi la courbe d'apprentissage pour l'adoption de l'apprentissage automatique dans les applications C#.
Interopérabilité et portabilité : TensorFlow.NET facilite l'interopérabilité avec d'autres environnements basés sur TensorFlow, permettant une intégration transparente des modèles d'apprentissage machine basés sur C# avec Python, TensorFlow Serving, et TensorFlow Lite.
TensorFlow.NET bénéficie d'une communauté active de contributeurs et d'utilisateurs qui apportent leur soutien, leurs commentaires et leurs contributions au projet, assurant ainsi sa croissance et son amélioration continues.Il s'agit d'un logiciel libre sous licence Apache qui peut être utilisé librement. Pour en savoir plus sur la licence, consultez le siteLicence TensorFlow.NET page.
ironPDF est une puissante bibliothèque PDF C# qui permet aux développeurs de créer, d'éditer et de signer des PDF directement à partir d'entrées HTML, CSS, d'images et de JavaScript. Il s'agit d'une solution commerciale très performante et peu gourmande en mémoire. En voici les principales caractéristiques :
Conversion HTML en PDF : ironPDF peut convertir des fichiers HTML, des chaînes HTML et des URL en PDF. Par exemple, vous pouvez rendre une page web sous forme de PDF à l'aide du moteur de rendu PDF de Chrome.
Prise en charge multiplateforme : IronPDF fonctionne sur diverses plateformes .NET, notamment .NET Core, .NET Standard et .NET Framework. Il est compatible avec Windows, Linux et macOS.
Édition et signature : Vous pouvez définir des propriétés, ajouter des(mots de passe et autorisations)et même d'appliquer des signatures numériques à vos PDF.
Modèles de page et paramètres : Personnalisez vos PDF en ajoutant des en-têtes, des pieds de page et des numéros de page, et en ajustant les marges. IronPDF prend également en charge les mises en page réactives et les formats de papier personnalisés.
Tout d'abord, créez un projet Visual Studio et sélectionnez le modèle Console App ci-dessous.
Indiquer le nom et la localisation du projet.
Sélectionnez la version .NET requise à l'étape suivante et cliquez sur le bouton Créer.
Installez IronPDF à partir de NuGet Package depuis le Visual Studio Package Manager.
Installer les paquets TensorFlow.NET et TensorFlow.Keras, un paquet indépendant utilisé pour exécuter des modèles.
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");
}
}
}Décortiquons l'extrait de code :
Déclarations d'importation :
Le code commence par importer les bibliothèques nécessaires. En particulier :
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.Exécution enthousiaste :
La ligne tf.enable_eager_execution(); active le mode d'exécution impatient de TensorFlow. Dans l'exécution impatiente, les opérations sont évaluées immédiatement, ce qui facilite le débogage et l'interaction avec les tenseurs.
Définir les constantes du tenseur :
Le code définit trois constantes tensorielles : a, b, et c. Ils sont initialisés avec les valeurs 5, 6 et 7, respectivement.
Diverses opérations de tenseur :
Les opérations tensorielles suivantes sont effectuées :
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.Accéder aux valeurs du tenseur :
Les résultats des opérations tensorielles sont imprimés à l'aide de la fonction 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}");Exemple de sortie :
- 5 + 6 = 11
- 5 - 6 = -1
- 5 * 6 = 30
- 5 / 6 = 0.8333333333333334Opérations supplémentaires :
Le code calcule la moyenne et la somme des constantes [a, b, c].
Génération de PDF :
ChromePdfRenderer et RenderHtmlAsPdf de IronPDF sont utilisés pour rendre la chaîne HTML en un document PDF.
IronPDF a besoin d'une licence pour fonctionner. Pour en savoir plus sur les licences, consultez le siteLicences d'IronPDF page. Placez la clé dans le fichier appSettings.json comme indiqué ci-dessous.
{
"IronPdf.License.LicenseKey": "The Key Here"
}En conclusion, TensorFlow.NET permet aux développeurs C# d'explorer le monde de l'apprentissage automatique et de l'intelligence artificielle avec la polyvalence et la productivité de l'écosystème .NET. Que vous construisiez des applications intelligentes, des outils d'analyse prédictive ou des systèmes de prise de décision automatisés, TensorFlow.NET fournit un cadre puissant et flexible pour libérer le potentiel de l'apprentissage automatique en C#. Avec la bibliothèque IronPDF de Iron Software, les développeurs peuvent acquérir des compétences avancées pour développer des applications modernes.
Install-Package IronPdf
Aucune carte de crédit n'est requise
Votre clé d'essai devrait se trouver dans l'email.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Aucune carte de crédit n'est requise
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Aucune carte de crédit ou création de compte n'est nécessaire
Votre clé d'essai devrait être dans l'e-mail.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Licences à partir de 749 $. Vous avez une question ? Contactez-nous.
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
10 produits .NET API pour vos documents de bureau
