Générer des images à partir de texte à l’aide de l’IA

Dans ce guide de démarrage rapide, vous utilisez la bibliothèque MEAI pour générer des images à partir de requêtes textuelles à l’aide d’un modèle IA. Les fonctionnalités de texte à image MEAI vous permettent de générer des images à partir d’invites en langage naturel ou d’images existantes à l’aide d’une surface d’API cohérente et extensible.

L’interface IImageGenerator fournit une API unifiée et extensible permettant d’utiliser différents services de génération d’images, ce qui facilite l’intégration de fonctionnalités de texte à image dans vos applications .NET. L’interface prend en charge les points suivants :

Génération de texte à image.
Composition du pipeline avec intergiciel (journalisation, télémétrie, mise en cache).
Options de configuration flexibles.
Prise en charge de plusieurs fournisseurs d’IA.

Note

L’interface IImageGenerator est actuellement indiquée comme expérimentale avec l’ID de diagnostic MEAI001. Vous devrez peut-être supprimer cet avertissement dans le fichier ou le code de votre projet.

Prerequisites

SDK .NET 8.0 ou version ultérieure - Installer le SDK .NET 8.
Un abonnement Azure : créez-en un gratuitement.
Azure Developer CLI (facultatif) : installer ou mettre à jour l’interface de ligne de commande du développeur Azure.

Configurer le service IA

Pour approvisionner un service et un modèle Azure OpenAI à l’aide du Portail Azure, suivez les étapes décrites dans l’article Créer et déployer une ressource Azure OpenAI Service. Dans l’étape « Déployer un modèle », sélectionnez le gpt-image-1 modèle.

Note

gpt-image-1 est un modèle plus récent qui offre plusieurs améliorations sur DALL-E 3. Il est disponible à partir d’OpenAI en quantité limitée ; postulez pour l’accès avec ce formulaire.

Créer l’application

Effectuez les étapes suivantes pour créer une application console .NET qui génère des images à partir d’invites de texte.

Créez une application console :
```
dotnet new console -o TextToImageAI
```

Accédez au répertoire TextToImageAI et ajoutez les packages nécessaires à votre application :

dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Exécutez les commandes suivantes pour ajouter des secrets d’application pour votre point de terminaison Azure OpenAI, le nom du modèle et la clé API :

dotnet user-secrets init
dotnet user-secrets set AZURE_OPENAI_ENDPOINT <your-Azure-OpenAI-endpoint>
dotnet user-secrets set AZURE_OPENAI_GPT_NAME gpt-image-1
dotnet user-secrets set AZURE_OPENAI_API_KEY <your-azure-openai-api-key>

Ouvrez la nouvelle application dans votre éditeur de choix (par exemple, Visual Studio).

Implémenter la génération d’images de base

Mettez à jour le fichier Program.cs avec le code suivant pour obtenir les données de configuration et créer le AzureOpenAIClient.

using Azure;
using Azure.AI.OpenAI;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;

IConfigurationRoot config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

string endpoint = config["AZURE_OPENAI_ENDPOINT"];
string apiKey = config["AZURE_OPENAI_API_KEY"];
string model = config["AZURE_OPENAI_GPT_NAME"];

// Create the Azure OpenAI client and convert to IImageGenerator.
AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(apiKey));

var imageClient = azureClient.GetImageClient(model);
#pragma warning disable MEAI001 // Type is for evaluation purposes only.
IImageGenerator generator = imageClient.AsIImageGenerator();

Code précédent :

Charge la configuration à partir des secrets utilisateur.
Crée un ImageClient de l'OpenAI SDK.
Convertit le ImageClient en un IImageGenerator à l'aide de la méthode d'extension AsIImageGenerator(ImageClient).

Ajoutez le code suivant pour implémenter la génération de texte à image de base :

// Generate an image from a text prompt
var options = new ImageGenerationOptions
{
    MediaType = "image/png"
};
string prompt = "A tennis court in a jungle";
var response = await generator.GenerateImagesAsync(prompt, options);

// Save the image to a file.
var dataContent = response.Contents.OfType<DataContent>().First();
string fileName = SaveImage(dataContent, "jungle-tennis.png");
Console.WriteLine($"Image saved to file: {fileName}");

static string SaveImage(DataContent content, string fileName)
{
    string userDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
    var path = Path.Combine(userDirectory, fileName);
    File.WriteAllBytes(path, content.Data.ToArray());
    return Path.GetFullPath(path);
}

Code précédent :

Définit le type de fichier image demandé en définissant ImageGenerationOptions.MediaType.
Génère une image à l’aide de la GenerateImagesAsync(IImageGenerator, String, ImageGenerationOptions, CancellationToken) méthode avec une invite de texte.
Enregistre l’image générée dans un fichier dans le répertoire utilisateur local.

Exécutez l'application, soit dans l'IDE, soit à l'aide de dotnet run.

L’application génère une image et génère le chemin d’accès du fichier à l’image. Ouvrez le fichier pour afficher l’image générée. L’image suivante montre un exemple d’image générée.

Configurer les options de génération d’images

Vous pouvez personnaliser la génération d’images en fournissant d’autres options telles que la taille, le format de réponse et le nombre d’images à générer. La ImageGenerationOptions classe vous permet de spécifier :

AdditionalProperties: options spécifiques au fournisseur.
Count: nombre d’images à générer.
ImageSize: dimensions de l’image générée en tant que System.Drawing.Size. Pour connaître les tailles prises en charge, consultez la référence de l’API OpenAI.
MediaType: type de média (type MIME) de l’image générée.
ModelId: ID de modèle.
RawRepresentationFactory: rappel qui crée la représentation brute des options de génération d’image à partir d’une implémentation sous-jacente.
ResponseFormat: les options sont Uri, Dataet Hosted.

Utiliser l’intégration de l’hébergement

Lorsque vous créez des applications web ou des services hébergés, vous pouvez intégrer la génération d’images à l’aide des modèles d’injection de dépendances et d’hébergement. Cette approche offre une meilleure gestion du cycle de vie, l’intégration de la configuration et la testabilité.

Configurer les services d’hébergement

Le Aspire.Azure.AI.OpenAI package fournit des méthodes d’extension pour inscrire des services Azure OpenAI avec le conteneur d’injection de dépendances de votre application :

Ajoutez les packages nécessaires à votre application web :

dotnet add package Aspire.Azure.AI.OpenAI --prerelease
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease

Configurez le client Azure OpenAI et le générateur d’images dans votre Program.cs fichier :
```
using Aspire.Azure.AI.OpenAI;
using Microsoft.Extensions.AI;
using OpenAI;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

// Add the Azure OpenAI client using hosting integration.
AspireAzureOpenAIClientBuilder openai = builder.AddAzureOpenAIClient("openai");
```
La méthode AddAzureOpenAIClient(IHostApplicationBuilder, String, Action<AzureOpenAISettings>, Action<IAzureClientBuilder<AzureOpenAIClient,AzureOpenAIClientOptions>>) enregistre le client Azure OpenAI via l'injection de dépendances. La chaîne de connexion (nommée "openai") est récupérée à partir de la configuration, généralement à partir de appsettings.json ou des variables d’environnement.
```
{
  "ConnectionStrings": {
    "openai": "Endpoint=https://your-resource-name.openai.azure.com/;Key=your-api-key"
  }
}
```

Inscrivez le service à l'aide de l'injection de dépendances IImageGenerator :

// Register the image generator with dependency injection.
ImageGeneratorBuilder imageBuilder = builder.Services.AddImageGenerator(services =>
{
    OpenAIClient openAiClient = services.GetRequiredService<OpenAIClient>();
    OpenAI.Images.ImageClient imageClient = openAiClient.GetImageClient("gpt-image-1");
    #pragma warning disable MEAI001 // Type is for evaluation purposes only.
    return imageClient.AsIImageGenerator();
    #pragma warning restore MEAI001
});

La AddImageGenerator méthode inscrit le générateur d’images en tant que service singleton qui peut être injecté dans des contrôleurs, des services ou des points de terminaison d’API minimes.

Ajouter des options et une journalisation ::
```
imageBuilder.ConfigureOptions(options =>
{
    options.MediaType = "image/png";
}).UseLogging();
```
Code précédent :
- Configure les options en appelant la méthode d’extension ConfigureOptions(ImageGeneratorBuilder, Action<ImageGenerationOptions>) sur le ImageGeneratorBuilder. Cette méthode configure le ImageGenerationOptions pour qu'il soit passé au générateur suivant dans le pipeline.
- Ajoute la journalisation au pipeline du générateur d’images en appelant la méthode d’extension UseLogging(ImageGeneratorBuilder, ILoggerFactory, Action<LoggingImageGenerator>) .

Utiliser le générateur d’images dans les points de terminaison

Une fois inscrit, vous pouvez injecter IImageGenerator dans vos points de terminaison ou services :

// Use the image generator in an endpoint.
app.MapPost("/generate-image", async (IImageGenerator generator, string prompt) =>
{
    ImageGenerationResponse response = await generator.GenerateImagesAsync(prompt);
    DataContent dataContent = response.Contents.OfType<DataContent>().First();

    return Results.File(dataContent.Data.ToArray(), dataContent.MediaType);
});

Cette approche d’hébergement offre plusieurs avantages :

Gestion de la configuration : les chaînes de connexion et les paramètres sont gérés via le système de configuration .NET.
Injection de dépendances : le générateur d’images est disponible dans l’ensemble de votre application par le biais d’une DI.
Gestion du cycle de vie : les services sont correctement initialisés et supprimés par l’infrastructure d’hébergement.
Testabilité : les implémentations fictifs peuvent être facilement remplacées par des tests.
Intégration à .NET Aspire : lors de l’utilisation de .NET Aspire, la méthode s’intègre à la AddAzureOpenAIClient découverte de service et à la télémétrie.

Meilleures pratiques

Lors de l’implémentation de la génération de texte à image dans vos applications, tenez compte des meilleures pratiques suivantes :

Ingénierie des prompts : écrivez des prompts clairs et détaillés qui décrivent l’image souhaitée. Incluez des détails spécifiques sur le style, la composition, les couleurs et les éléments.
Gestion des coûts : la génération d’images peut être coûteuse. Mettez en cache les résultats lorsque c’est possible et implémentez la limitation du taux pour contrôler les coûts.
Sécurité du contenu : passez toujours en revue les images générées pour le contenu approprié, en particulier dans les applications de production. Envisagez d’implémenter le filtrage et la modération du contenu.
Expérience utilisateur : la génération d’images peut prendre plusieurs secondes. Fournissez des indicateurs de progression et gérez les délais d'expiration avec souplesse.
Considérations juridiques : Tenez compte des droits de licence et d’utilisation des images générées. Passez en revue les conditions d’utilisation de votre fournisseur IA.

Nettoyer les ressources

Lorsque vous n’avez plus besoin de la ressource Azure OpenAI, supprimez-la pour éviter les frais encourus :

Dans le portail Azure, accédez à votre ressource Azure OpenAI.
Sélectionnez la ressource, puis sélectionnez Supprimer.

Étapes suivantes

Vous avez généré diverses images à l’aide de l’interface IImageGenerator dans Microsoft.Extensions.AI. Vous pouvez ensuite explorer certaines des fonctionnalités supplémentaires, notamment :

Affinement de l’image générée de manière itérative.
Modification d’une image existante.
Personnalisation d’une image, d’un diagramme ou d’un thème.

Voir aussi

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-11-21