Azure OpenAI e .NET

Natural Language Processing

O NLP, ou processamento de linguagem natural, é a capacidade da IA de compreender texto escrito e falado de forma natural. Além de compreender, o NLP também permite responder de forma natural, como se fosse realmente uma pessoa.

Quando você chama o Azure OpenAI no .NET, é essa capacidade que interpreta a pergunta do usuário.

Além disso, o NLP não se limita a texto. Ele também funciona para áudio, tanto na captação quanto na resposta.

O que é Generative AI

Generative AI, ou GenAI, é o segmento da IA capaz de produzir conteúdo original a partir de dados coletados. Esse conteúdo pode assumir diferentes formatos, como texto, imagens e vídeos.

Esses modelos se baseiam em redes neurais profundas (deep neural networks) que usam estatística para gerar dados. Existem várias famílias de modelos generativos, cada uma com seus pontos fortes, e o Azure OpenAI no .NET dá acesso a uma delas.

GAN, VAE, LSTM e Transformers

GAN (Generative Adversarial Networks) consiste em duas redes neurais que competem entre si: o gerador e o discriminador. O gerador cria amostras a partir de ruído aleatório, enquanto o discriminador tenta diferenciar as amostras geradas dos dados reais.

O treinamento funciona como um jogo de gato e rato, em que o gerador melhora continuamente para enganar o discriminador. Normalmente, você encontra GANs na criação de imagens realistas, na síntese de voz e na arte digital.

VAE (Variational Autoencoder) é um tipo de rede neural que aprende a codificar a entrada em um espaço latente compacto e depois reconstruí-la. Durante o treinamento, o modelo otimiza a distribuição desse espaço para facilitar a geração de novos dados parecidos com os originais.

Por isso, os VAEs aparecem na melhoria de imagens, na geração de novos conteúdos e na compressão de dados.

LSTM (Long Short-Term Memory) surgiu para tarefas de previsão e classificação em sequências, mas também gera texto ou música. Afinal, as LSTMs processam dados sequenciais e lembram informações por longos períodos, algo crucial quando a coerência importa.

Transformers usam mecanismos de atenção para modelar relações entre todas as partes de uma entrada ao mesmo tempo. Com isso, eles entendem o contexto em sequências longas e geram conteúdo a partir desse entendimento, como nos modelos GPT, na tradução automática e no conteúdo interativo.

GPT

GPT, ou Generative Pre-trained Transformer, é um tipo de modelo de IA criado pela OpenAI que usa a arquitetura Transformer para gerar texto em linguagem natural. Se você quiser se aprofundar, o artigo o que é um GPT e como sua arquitetura funciona detalha esse funcionamento.

Esses modelos passam primeiro por um pré-treinamento não supervisionado em enormes conjuntos de texto. Depois, recebem ajustes para tarefas específicas de linguagem, e são esses modelos que você consome com o Azure OpenAI no .NET.

Criando um resource group

Como sempre, o primeiro passo é criar um grupo de recursos para organizar os itens. O comando abaixo cria o grupo OAIResourceGroup na região East US.

az group create --name OAIResourceGroup --location eastus

Criando o recurso Azure OpenAI

Em seguida, o comando az cognitiveservices account create cria o recurso em si, alocado dentro do grupo criado anteriormente. Repare no parâmetro --kind OpenAI, que define o tipo do recurso.

az cognitiveservices account create --name MyOpenAIResource --resource-group OAIResourceGroup --location eastus --kind OpenAI --sku s0 --subscription <subscriptionID>

Obtendo a URL e a chave

Ao final da criação, a CLI exibe os dados de acesso, como a URL. Caso precise dessa informação depois, use o az cognitiveservices account show e filtre a propriedade properties.endpoint com o jq.

az cognitiveservices account show --name <myResourceName> --resource-group <myResourceGroupName> | jq -r .properties.endpoint

Além da URL, o acesso aos serviços exige uma chave. Você obtém essa chave com o az cognitiveservices account keys list, informando o nome do recurso e o grupo.

az cognitiveservices account keys list --name <myResourceName> --resource-group <myResourceGroupName> | jq -r .key1

Publicando e excluindo um modelo

Com o recurso pronto, o az cognitiveservices account deployment create publica um modelo. No exemplo, a implantação se chama MyModel e usa o modelo de embeddings text-embedding-ada-002.

az cognitiveservices account deployment create --name <myResourceName> --resource-group <myResourceGroupName> --deployment-name MyModel --model-name text-embedding-ada-002 --model-version "1" --model-format OpenAI --sku-capacity "1" --sku-name "Standard"

Um detalhe importante: no Azure OpenAI, o código chama o modelo pelo nome da implantação, e não pelo nome do modelo. Portanto, escolha esse nome com cuidado, porque ele vai aparecer no seu código C#.

Caso precise excluir o modelo, use o mesmo comando com a opção delete.

az cognitiveservices account deployment delete --name <myResourceName> --resource-group <myResourceGroupName> --deployment-name MyModel

Por fim, para excluir o recurso inteiro, aplique o delete diretamente no account. Atenção, porque esse processo é irreversível.

az cognitiveservices account delete --name <myResourceName> --resource-group <myResourceGroupName>

Instalando os pacotes do Azure OpenAI no .NET

O pacote para consumir o Azure OpenAI no .NET é o Azure.AI.OpenAI, que neste exemplo está na versão 1.0.0-beta.16. Como ele é um prerelease, a instalação exige a flag --prerelease.

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity

Note que também instalamos o Azure.Identity, responsável pela autenticação e pelo acesso aos serviços do Azure. Ele entra em cena quando você usar o Microsoft Entra ID em vez de chaves.

Criando o OpenAIClient do Azure OpenAI no .NET

O primeiro passo no código é criar a conexão, e isso acontece pelo OpenAIClient. Para o Azure, ele recebe dois parâmetros: a URL do recurso, como um Uri, e a chave de acesso, como um AzureKeyCredential.

using Azure;
using Azure.AI.OpenAI;

var useAzureOpenAI = true;

OpenAIClient client = useAzureOpenAI
    ? new OpenAIClient(
        new Uri("https://your-azure-openai-resource.com/"),
        new AzureKeyCredential("your-azure-openai-resource-api-key"))
    : new OpenAIClient("your-api-key-from-platform.openai.com");

Repare que o mesmo cliente também aceita uma chave da plataforma da OpenAI, sem passar pelo Azure. Nesse caso, você informa apenas a API Key no construtor.

As informações de acesso vêm dos comandos account show e keys list que executamos antes.

Autenticação com Microsoft Entra ID no Azure OpenAI para .NET

Caso precise se autenticar com o Microsoft Entra ID, antigo Azure Active Directory, informe um DefaultAzureCredential como credencial. Dessa forma, nenhuma chave fica gravada no código ou na configuração.

using Azure.AI.OpenAI;
using Azure.Identity;

var endpoint = "https://myaccount.openai.azure.com/";
var client = new OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());

O DefaultAzureCredential percorre várias fontes de credencial, como identidade gerenciada e o login da CLI do Azure. Assim, o mesmo código funciona na sua máquina e no ambiente hospedado.

Configurando o chat do Azure OpenAI no .NET

Chegou o grande momento de usar o modelo na aplicação. Partindo do ponto em que você já criou o recurso e instalou os pacotes, inicialize o cliente lendo a chave de uma variável de ambiente.

Uri azureOpenAIResourceUri = new("https://my-resource.openai.azure.com/");
AzureKeyCredential azureOpenAIApiKey = new(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY"));
OpenAIClient client = new(azureOpenAIResourceUri, azureOpenAIApiKey);

Agora, o recurso de chat completions gera respostas para as entradas da aplicação. Para isso, comece criando um ChatCompletionsOptions, que concentra as opções da conversa.

O primeiro parâmetro é o DeploymentName, que indica o modelo, como gpt-3.5-turbo. Caso use um modelo publicado por você, informe o nome da implantação criada no passo az cognitiveservices account deployment create.

O segundo parâmetro é a lista Messages, que representa o histórico da conversa. Cada mensagem tem um papel: a de sistema define o comportamento do assistente, a de usuário traz a pergunta e a de assistente traz uma resposta anterior.

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    // Use DeploymentName como "model" em clientes fora do Azure
    DeploymentName = "gpt-3.5-turbo",
    Messages =
    {
        // Como o assistente deve se comportar
        new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."),
        // Mensagem inicial do usuário
        new ChatRequestUserMessage("Can you help me?"),
        // Resposta inicial do assistente
        new ChatRequestAssistantMessage("Arrrr! Of course, me hearty! What can I do for ye?"),
        new ChatRequestUserMessage("What's the best way to train a parrot?"),
    }
};

Nesse exemplo, a mensagem de sistema pede que o assistente fale como um pirata. Em seguida, o histórico simula uma troca inicial antes da pergunta real sobre como treinar um papagaio.

Interagindo com o GPT pelo Azure OpenAI no .NET

Com as opções prontas, o método GetChatCompletionsAsync envia a conversa para o modelo. Ele devolve um Response<ChatCompletions>, e a resposta do assistente fica em Choices[0].Message.

Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
ChatResponseMessage responseMessage = response.Value.Choices[0].Message;

// Exibe o papel (assistant) e o conteúdo da resposta
Console.WriteLine($"[{responseMessage.Role.ToString().ToUpperInvariant()}]: {responseMessage.Content}");

Para continuar a conversa, basta adicionar a resposta recebida e a próxima pergunta à lista Messages e chamar o método de novo. Afinal, o modelo não guarda estado entre chamadas, e o histórico precisa viajar em cada requisição.

Esse é o ciclo básico do Azure OpenAI no .NET: configurar o cliente, montar as mensagens e ler a resposta. Para uma visão mais ampla da IA generativa na plataforma, o artigo IA generativa no .NET e C# complementa este conteúdo.