Generare immagini dal testo usando l'intelligenza artificiale

In questa guida introduttiva si usa la libreria Microsoft.Extensions.AI (MEAI) per generare immagini tramite prompt di testo usando un modello di intelligenza artificiale. Le funzionalità da testo a immagine MEAI consentono di generare immagini da richieste di linguaggio naturale o immagini esistenti usando una superficie API coerente ed estendibile.

L'interfaccia IImageGenerator fornisce un'API unificata ed estendibile per l'uso di vari servizi di generazione di immagini, semplificando l'integrazione delle funzionalità di sintesi testuale nelle app .NET. L'interfaccia supporta:

Generazione da testo a immagine.
Composizione della pipeline con middleware (registrazione, telemetria, memorizzazione nella cache).
Opzioni di configurazione flessibili.
Supporto per più provider di intelligenza artificiale.

Annotazioni

L'interfaccia IImageGenerator è attualmente contrassegnata come sperimentale con l'ID MEAI001 di diagnostica. Potrebbe essere necessario eliminare questo avviso nel file di progetto o nel codice.

Prerequisiti

.NET 8.0 SDK o versione successiva: Installare il .NET 8 SDK.
Una sottoscrizione di Azure: crearne una gratuitamente.
Interfaccia della riga di comando per sviluppatori di Azure (facoltativa): installare o aggiornare l'interfaccia della riga di comando per sviluppatori di Azure.

Configurare il servizio di intelligenza artificiale

Per effettuare il provisioning di un servizio e un modello OpenAI di Azure usando il portale di Azure, completare la procedura descritta nell'articolo creare e distribuire una risorsa del servizio OpenAI di Azure. Nel passaggio "Distribuisci un modello" selezionare il modello di gpt-image-1.

Annotazioni

gpt-image-1 è un modello più recente che offre diversi miglioramenti rispetto a DALL-E 3. È disponibile da OpenAI su base limitata; richiedere l'accesso con questo modulo.

Creare l'applicazione

Completare la procedura seguente per creare un'applicazione console .NET che genera immagini da richieste di testo.

Creare una nuova applicazione console:
```
dotnet new console -o TextToImageAI
```

Passare alla directory TextToImageAI e aggiungere i pacchetti necessari all'app:

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

Eseguire i comandi seguenti per aggiungere segreti dell'app per l'endpoint Azure OpenAI, il nome del modello e la chiave 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>

Aprire la nuova app nell'editor preferito, ad esempio Visual Studio.

Implementare la generazione di immagini di base

Aggiornare il Program.cs file con il codice seguente per ottenere i dati di configurazione e creare 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();

Il codice precedente:

Carica la configurazione dai segreti utente.
Crea un oggetto ImageClient da OpenAI SDK.
Converte il ImageClient in un IImageGenerator utilizzando il metodo di estensione AsIImageGenerator(ImageClient).

Aggiungere il codice seguente per implementare la generazione di testo a immagine di 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);
}

Il codice precedente:

Imposta il tipo di file di immagine richiesto impostando ImageGenerationOptions.MediaType.
Genera un'immagine usando il GenerateImagesAsync(IImageGenerator, String, ImageGenerationOptions, CancellationToken) metodo con una richiesta di testo.
Salva l'immagine generata in un file nella directory utente locale.

Eseguire l'applicazione tramite l'IDE o usando dotnet run.

L'applicazione genera un'immagine e restituisce il percorso del file all'immagine. Aprire il file per visualizzare l'immagine generata. L'immagine seguente mostra un esempio di immagine generata.

Configurare le opzioni di generazione di immagini

È possibile personalizzare la generazione di immagini fornendo altre opzioni, ad esempio dimensioni, formato di risposta e numero di immagini da generare. La ImageGenerationOptions classe consente di specificare:

AdditionalProperties: opzioni specifiche del provider.
Count: numero di immagini da generare.
ImageSize: Le dimensioni dell'immagine generata come un System.Drawing.Size. Per le dimensioni supportate, vedere le informazioni di riferimento sull'API OpenAI.
MediaType: tipo di supporto (tipo MIME) dell'immagine generata.
ModelId: ID del modello.
RawRepresentationFactory: callback che crea la rappresentazione non elaborata delle opzioni di generazione dell'immagine da un'implementazione sottostante.
ResponseFormat: le opzioni sono Uri, Datae Hosted.

Usare l'integrazione dell'hosting

Quando si creano app Web o servizi ospitati, è possibile integrare la generazione di immagini usando l'inserimento delle dipendenze e i modelli di hosting. Questo approccio offre una migliore gestione del ciclo di vita, integrazione della configurazione e testability.

Configurare i servizi di hosting

Il Aspire.Azure.AI.OpenAI pacchetto fornisce metodi di estensione per registrare i servizi OpenAI di Azure con il contenitore di inserimento delle dipendenze dell'applicazione:

Aggiungere i pacchetti necessari all'applicazione Web:

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

Configurare il client e il generatore di immagini OpenAI di Azure nel Program.cs file:
```
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");
```
Il AddAzureOpenAIClient(IHostApplicationBuilder, String, Action<AzureOpenAISettings>, Action<IAzureClientBuilder<AzureOpenAIClient,AzureOpenAIClientOptions>>) metodo registra il client OpenAI di Azure con inserimento delle dipendenze. La stringa di connessione (denominata "openai") viene recuperata dalla configurazione, in genere dalle appsettings.json variabili di ambiente o :
```
{
  "ConnectionStrings": {
    "openai": "Endpoint=https://your-resource-name.openai.azure.com/;Key=your-api-key"
  }
}
```

Registrazione del servizio IImageGenerator con iniezione delle dipendenze:

// 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
});

Il AddImageGenerator metodo registra il generatore di immagini come servizio singleton che può essere inserito in controller, servizi o endpoint API minimi.

Aggiungere opzioni e registrazione:
```
imageBuilder.ConfigureOptions(options =>
{
    options.MediaType = "image/png";
}).UseLogging();
```
Il codice precedente:
- Configura le opzioni chiamando il ConfigureOptions(ImageGeneratorBuilder, Action<ImageGenerationOptions>) metodo di estensione in ImageGeneratorBuilder. Questo metodo configura l'oggetto ImageGenerationOptions da passare al generatore successivo nella pipeline.
- Aggiunge la registrazione alla pipeline del generatore di immagini chiamando il UseLogging(ImageGeneratorBuilder, ILoggerFactory, Action<LoggingImageGenerator>) metodo di estensione.

Usare il generatore di immagini negli endpoint

Una volta registrato, puoi eseguire l'inserimento di IImageGenerator nei tuoi endpoint o servizi.

// 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);
});

Questo approccio di hosting offre diversi vantaggi:

Gestione della configurazione: le stringhe di connessione e le impostazioni vengono gestite tramite il sistema di configurazione .NET.
Dependency Injection: il generatore di immagini è disponibile in tutta l'applicazione tramite DI.
Gestione del ciclo di vita: i servizi vengono inizializzati e eliminati correttamente dall'infrastruttura di hosting.
Verificabilità: le implementazioni fittizie possono essere sostituite facilmente per i test.
Integrazione con .NET Aspire: quando si usa .NET Aspire, il AddAzureOpenAIClient metodo si integra con l'individuazione dei servizi e i dati di telemetria.

Procedure consigliate

Quando si implementa la generazione da testo a immagine nelle applicazioni, prendere in considerazione queste procedure consigliate:

Progettazione prompt: Scrivere istruzioni chiare e dettagliate che descrivono l'immagine desiderata. Includere dettagli specifici sullo stile, la composizione, i colori e gli elementi.
Gestione dei costi: la generazione di immagini può essere costosa. Memorizzare nella cache i risultati quando possibile e implementare la limitazione della frequenza per controllare i costi.
Sicurezza del contenuto: esaminare sempre le immagini generate per il contenuto appropriato, in particolare nelle applicazioni di produzione. Valutare la possibilità di implementare filtri e moderazione del contenuto.
Esperienza utente: la generazione di immagini può richiedere alcuni secondi. Fornire indicatori di stato e gestire correttamente i timeout.
Considerazioni legali: tenere conto delle licenze e dei diritti di utilizzo per le immagini generate. Esamina le condizioni di servizio del tuo provider di intelligenza artificiale.

Pulire le risorse

Quando la risorsa OpenAI di Azure non è più necessaria, eliminarla per evitare di incorrere in addebiti:

Nel portale di Azure passare alla risorsa OpenAI di Azure.
Selezionare la risorsa e quindi selezionare Elimina.

Passaggi successivi

Hai generato con successo alcune immagini diverse usando l'interfaccia IImageGenerator in Microsoft.Extensions.AI. Successivamente, è possibile esplorare alcune delle funzionalità aggiuntive, tra cui:

Ridefinizione dell'immagine generata in modo iterativo.
Modifica di un'immagine esistente.
Personalizzazione di un'immagine, di un diagramma o di un tema.

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-11-21