Gerar imagens de texto usando IA

Neste início rápido, você usa a Microsoft.Extensions.AI biblioteca (MEAI) para gerar imagens de prompts de texto usando um modelo de IA. As capacidades de texto para imagem do MEAI permitem que você gere imagens a partir de prompts de linguagem natural ou imagens existentes usando uma interface de API consistente e extensível.

A IImageGenerator interface fornece uma API unificada e extensível para trabalhar com vários serviços de geração de imagem, facilitando a integração de recursos de texto em imagem aos seus aplicativos .NET. A interface dá suporte a:

• Geração de texto para imagem.
• Composição de pipeline com middleware (registro, telemetria, cache).
• Opções de configuração flexíveis.
• Suporte para vários provedores de IA.

Pré-requisitos

• SDK do .NET 8.0 ou superior – Instalar o SDK do .NET 8.
• Uma assinatura do Azure – Crie uma gratuitamente.
• CLI do Desenvolvedor do Azure (opcional) – Instalar ou atualizar a CLI do Desenvolvedor do Azure.

Configurar o serviço de IA

Para provisionar um serviço e um modelo do OpenAI do Azure usando o portal do Azure, conclua as etapas no artigo Criar e implantar um recurso do Serviço OpenAI do Azure. Na etapa "Implantar um modelo", selecione o gpt-image-1 modelo.

Criar o aplicativo

Conclua as etapas a seguir para criar um aplicativo de console do .NET que gera imagens de prompts de texto.

1. Crie um novo aplicativo de console:

   dotnet new console -o TextToImageAI
   

2. Navegue até o TextToImageAI diretório e adicione os pacotes necessários ao seu aplicativo:

   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
   

3. Execute os seguintes comandos para adicionar segredos do aplicativo ao ponto de extremidade do Azure OpenAI, ao nome do modelo e à chave de 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>
   

4. Abra o novo aplicativo em seu editor de escolha (por exemplo, Visual Studio).

Implementar a geração básica de imagem

1. Atualize o Program.cs arquivo com o seguinte código para obter os dados de configuração e criar: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();
   

   O código anterior:

   • Carrega a configuração de segredos do usuário.
   • Cria um elemento a partir do SDK da OpenAI.
   • Converte o ImageClient em um IImageGenerator usando o método de extensão AsIImageGenerator(ImageClient).

2. Adicione o seguinte código para implementar a geração básica de texto para imagem:

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

   O código anterior:

   • Define o tipo de arquivo de imagem solicitado definindo ImageGenerationOptions.MediaType.
   • Gera uma imagem usando o GenerateImagesAsync(IImageGenerator, String, ImageGenerationOptions, CancellationToken) método com um prompt de texto.
   • Salva a imagem gerada em um arquivo no diretório de usuário local.

3. Execute o aplicativo por meio do IDE ou usando dotnet run.

   O aplicativo gera uma imagem e fornece o caminho do arquivo para a imagem. Abra o arquivo para exibir a imagem gerada. A imagem a seguir mostra um exemplo de uma imagem gerada.

   

Configurar opções de geração de imagem

Você pode personalizar a geração de imagens fornecendo outras opções, como tamanho, formato de resposta e número de imagens a serem geradas. A ImageGenerationOptions classe permite que você especifique:

• AdditionalProperties: opções específicas do provedor.
• Count: o número de imagens a serem geradas.
• ImageSize: as dimensões da imagem gerada como System.Drawing.Size. Para obter tamanhos com suporte, consulte a referência da API OpenAI.
• MediaType: o tipo de mídia (tipo MIME) da imagem gerada.
• ModelId: a ID do modelo.
• RawRepresentationFactory: a função de callback que cria a representação em bruto das opções de geração de imagem a partir de uma implementação subjacente.
• ResponseFormat: opções são Uri, Datae Hosted.

Usar a integração de hospedagem

Ao criar aplicativos Web ou serviços hospedados, você pode integrar a geração de imagens usando a injeção de dependência e padrões de hospedagem. Essa abordagem fornece melhor gerenciamento do ciclo de vida, integração de configuração e testabilidade.

Configurar serviços de hospedagem

O pacote Aspire.Azure.AI.OpenAI fornece métodos de extensão para registrar serviços do Azure OpenAI no contêiner de injeção de dependência do seu aplicativo.

1. Adicione os pacotes necessários ao seu aplicativo Web:

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

2. Configure o cliente do Azure OpenAI e o gerador de imagens em seu Program.cs arquivo:

   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");
   

   O AddAzureOpenAIClient(IHostApplicationBuilder, String, Action<AzureOpenAISettings>, Action<IAzureClientBuilder<AzureOpenAIClient,AzureOpenAIClientOptions>>) método registra o cliente do Azure OpenAI com injeção de dependência. A cadeia de conexão (nomeada "openai") é recuperada da configuração, normalmente de appsettings.json ou de variáveis de ambiente.

   {
     "ConnectionStrings": {
       "openai": "Endpoint=https://your-resource-name.openai.azure.com/;Key=your-api-key"
     }
   }
   

3. Registre o IImageGenerator serviço com injeção de dependência:

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

   O AddImageGenerator método registra o gerador de imagem como um serviço singleton que pode ser injetado em controladores, serviços ou endpoints mínimos de API.

4. Adicionar opções e registro de logs::

   imageBuilder.ConfigureOptions(options =>
   {
       options.MediaType = "image/png";
   }).UseLogging();
   

   O código anterior:

   • Configura opções chamando o método de extensão ConfigureOptions(ImageGeneratorBuilder, Action<ImageGenerationOptions>) no ImageGeneratorBuilder. Esse método configura o ImageGenerationOptions que será passado para o próximo gerador no pipeline.
   • Adiciona registro em log ao pipeline do gerador de imagens ao chamar o método de extensão UseLogging(ImageGeneratorBuilder, ILoggerFactory, Action<LoggingImageGenerator>).

Usar o gerador de imagem em endpoints

Depois de cadastrado, você pode injetar IImageGenerator em suas APIs ou serviços.

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

Essa abordagem de hospedagem oferece vários benefícios:

• Gerenciamento de configuração: as cadeias de conexão e as configurações são gerenciadas por meio do sistema de configuração do .NET.
• Injeção de dependência: o gerador de imagem está disponível em todo o aplicativo por meio de DI.
• Gerenciamento do ciclo de vida: os serviços são inicializados e descartados corretamente pela infraestrutura de hospedagem.
• Testabilidade: implementações simuladas podem ser facilmente substituídas por testes.
• Integração com o .NET Aspire: ao usar o .NET Aspire, o AddAzureOpenAIClient método se integra à descoberta e telemetria do serviço.

Práticas recomendadas

Ao implementar a geração de texto em imagem em seus aplicativos, considere estas práticas recomendadas:

• Engenharia de prompt: escreva prompts claros e detalhados que descrevem a imagem desejada. Inclua detalhes específicos sobre estilo, composição, cores e elementos.
• Gerenciamento de custos: a geração de imagem pode ser cara. Cache resultados quando possível e implemente o controle de taxa para controlar os custos.
• Segurança de conteúdo: sempre examine as imagens geradas quanto ao conteúdo apropriado, especialmente em aplicativos de produção. Considere implementar a filtragem e a moderação de conteúdo.
• Experiência do usuário: a geração de imagem pode levar vários segundos. Forneça indicadores de progresso e lide com timeouts de maneira elegante.
• Considerações legais: esteja ciente dos direitos de licenciamento e uso para imagens geradas. Examine os termos de serviço do provedor de IA.

Limpar os recursos

Quando você não precisar mais do recurso do Azure OpenAI, exclua-o para evitar incorrer em encargos:

1. No Portal do Azure, navegue até o recurso do Azure OpenAI.
2. Selecione o recurso e selecione Excluir.

Próximas etapas

Você gerou com êxito algumas imagens diferentes usando a IImageGenerator interface em Microsoft.Extensions.AI. Em seguida, você pode explorar algumas das funcionalidades adicionais, incluindo:

• Refinando a imagem gerada iterativamente.
• Editando uma imagem existente.
• Personalizando uma imagem, um diagrama ou um tema.

Consulte também

• Explorar recursos de texto para imagem no .NET (postagem no blog)
• visão geral da biblioteca Microsoft.Extensions.AI
• Início Rápido: Criar um aplicativo de chat de IA com o .NET