Azure OpenAI: Um guia de introdução passo a passo

Configurando o Azure OpenAI

Nesta seção, mostrarei como configurar o Azure OpenAI. Presumo que você tenha alguma experiência com o uso do Azure. 

Observe que as interfaces de usuário mudam com frequência. Portanto, o layout e o texto de várias seções e títulos nas instruções e capturas de tela podem mudar com o tempo ou de região para região.

Etapa 1: Criar uma conta do Azure

Vá para a página inicial do Azure OpenAIe selecione Entrar em no canto superior direito. Faça login com sua conta da Microsoft. Se você não tiver uma conta da Microsoft, selecione a opção para criar uma nova conta na página de login e crie uma conta da Microsoft. 

Em seguida, crie uma conta do Azure seguindo as etapas abaixo:

1. Fazer login usando sua conta da Microsoft no Portal do Azure. Selecione a opção Iniciar com uma avaliação gratuita do Azure.

The Microsoft Azure Portal.

2. Na próxima página, selecione a opção para criar uma conta gratuita do conta gratuita do Azure com créditos gratuitos de US$ 200.

Escolha um tipo de conta do Azure.

3. Preencha suas informações pessoais no formulário.

Crie uma conta gratuita do Azure.

4. Verifique sua identidade usando um cartão de crédito ou débito. Observe que pode haver uma taxa de retenção temporária (geralmente alguns centavos ou equivalente) debitada de sua conta. 

Verifique sua conta do Azure (captura de tela do autor) 

5. Depois de verificar suas informações de pagamento, selecione Ir para o Portal do Azure. Ele redireciona você para o Quickstart Center.
6. Observe que os créditos gratuitos de US$ 200 não podem ser usados para os serviços do Azure OpenAI. Os modelos do Azure OpenAI só podem ser acessados com uma conta paga. Para atualizar sua conta para uma assinatura paga conforme o uso, volte ao portal do Azure e selecione Upgrade na barra superior .

Atualize sua conta do Azure.

7. Preencha os detalhes na página de upgrade e selecione Atualizar para pagar conforme você usa.

Depois de fazer upgrade para uma conta paga, você pode acessar os modelos da OpenAI. 

Etapa 2: Acesse o Azure OpenAI no portal do Azure

1. Volte para o portal do Azure, que mostra uma variedade de serviços, como serviços de IA, máquinas virtuais, contas de armazenamento e muito mais. 

Portal do Azure mostrando os serviços disponíveis.

2. Selecione os serviços de IA do Azure e vá para a página inicial dos serviços de IA. O Azure oferece vários serviços baseados em IA, como reconhecimento facial, detecção de anomalias, fala, visão computacional, OpenAI e muito mais. 

Serviços de IA do Azure.

3. Na conta do Conta do Azure OpenAI selecione a guia Exibir opção.
4. Isso leva à páginado Azure OpenAI , que mostra a lista de instâncias do OpenAI da sua conta. Selecione Create Azure OpenAI para criar uma nova instância. Você também pode selecionar Create na página anterior .
5. Digite os detalhes abaixo:
• Sob Assinaturaselecione o nome da sua assinatura paga.
• Em Grupo de recursosselecione Criar novo:
• Digite um nome para o novo grupo de recursos. 

Crie uma nova instância do Azure OpenAI.

• • • Em Region (Região), selecione a região mais próxima.
    • Sob Nomedigite um nome exclusivo.
    • Sob o Nível de preçosselecione Padrão S0.
    • Selecione Next para continuar.

6. Na seção Rede, selecione "Todas as redes, inclusive a Internet, podem acessar este recurso". Em seguida, passe para a próxima etapa.
7. Na seçãoTags, insira pares de nome-valor para categorizar essa instância. Isso ajuda no faturamento consolidado. Esta etapa é opcional. 
8. Na próxima seção, selecione Revisar + enviar, verifique novamente os valores e selecione Criar. Isso implementa uma nova instância do OpenAI. 
9. Após um breve período, você verá a mensagem "Your deployment is complete." Nessa página, selecione Go to resource (Ir para o recurso).
10. Na página do recurso, selecione o nome do recurso na seção Recursos guia.

Etapa 3: Configurar o acesso à API

A página de recursos mostra os detalhes da instância. 

A guiaDevelop (Desenvolver ) mostra as chaves da API e os URLs do endpoint da API para essa instância. As chaves foram geradas automaticamente para você. 

• Copie as chaves e o ponto final em um arquivo de texto.

Você recebe duas chaves de API. Isso permite que você use a segunda chave caso a primeira seja comprometida. Você também pode usar a segunda tecla enquanto regenera a primeira. Isso permite que você faça a rotação periódica das chaves sem sofrer nenhum tempo de inatividade. 

Chaves de API da instância do Azure OpenAI

• No Monitor verifique as métricas de uso dessa instância.
• Na seção Começar selecione Explorar o Azure AI Foundry portal para abrir o playground de IA em uma nova página.

Playground de bate-papo do Azure OpenAI.

• Selecione o Bate-papo playground no menu à esquerda.
• Em Implementaçãoselecione Criar novo dep.
• Selecione Dos modelos básicos na janela pop-up da nova implantação
• Isso mostra uma janela pop-up que permite que você selecione o modelo. 
• Na barra de pesquisa, digite "gpt-3". 
• Selecione gpt-35-turbo na lista. Esse é um modelo econômico que é otimizado para conclusões de bate-papo. Depois de obter uma configuração funcional, mude para um modelo mais avançado (e mais caro), se necessário.
• Selecione Confirmar.
• No modelo Implantar modelo selecione Personalizar.
• Reduza o limite de taxa de tokens por minuto para um valor baixo (por exemplo, 12 solicitações por minuto) para testes manuais. Aumente esse valor mais tarde, quando você colocar o modelo em produção. 
• Desativar a cota dinâmica. Você não precisará dele até que a implantação receba tráfego intenso. 
• Selecione Implantar.

Implemente um novo modelo no playground de bate-papo.

É isso aí! Na próxima seção, veremos como acessar essa implementação do modelo gpt-35-turbo da OpenAI. 

Regeneração de chaves de API

É recomendável que você gere novamente as chaves de acesso à API periodicamente. Isso garante que a conta não seja comprometida se chaves antigas forem vazadas inadvertidamente. As etapas a seguir descrevem como você pode regenerar as chaves:

• Em Resource Management, no menu à esquerda, selecione Keys and Endpoint.
• Regenere cada chave individualmente. 

Chaves de API da instância do Azure OpenAI.

Usando o Azure OpenAI em aplicativos

Depois de configurar o Azure OpenAI e implantar um modelo, veremos como acessá-lo programaticamente. 

Etapa 1: Configurando seu ambiente de desenvolvimento

Mostrarei como você pode usar o Python para se conectar ao Azure OpenAI. Instale as bibliotecas necessárias:

$ pip install openai

Se você estiver usando um notebook, execute o seguinte comando. Observação: Estou usando um notebook DataLab.

!pip install openai

Importe os pacotes necessários no shell do Python ou no notebook:

import os
from openai import AzureOpenAI

O módulo AzureOpenAI permite o acesso aos serviços da OpenAI no Azure. Isso é diferente do módulo OpenAI usado para acessar a API autônoma da OpenAI .

Antes de usar o Azure OpenAI, defina a chave de API e o ponto de extremidade em seu ambiente. A seção anterior mostrou como encontrar esses valores. Em princípio, você pode defini-las no ambiente de programação, mas recomendo que nunca faça isso. Nunca exponha chaves de API no programa. 

Definir chaves de API usando o terminal

Para executar o Python localmente, defina a variável de ambiente no arquivo de configuração do shell. Mostrarei a você como configurá-lo para o shell Bash. 

• Edite o arquivo .bashrc em um editor de texto .
• No final do arquivo, adicione estas duas linhas:
• export AZURE_OPENAI_API_KEY=MY_API_KEY'
• export AZURE_OPENAI_ENDPOINT=MY_ENDPOINT'
• Salve e feche o arquivo.
• Recarregue as alterações no terminal usando o comando source ~/.bashrc.
• Para outros shells, como sh ou zsh, o processo pode ser ligeiramente diferente .
• Abra (ou reabra) o shell Python na mesma sessão de terminal. 

Importe a chave da API e os valores do ponto de extremidade no terminal Python:

azure_openai_api_key = os.getenv["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.getenv["AZURE_OPENAI_ENDPOINT"]

Definir chaves de API usando notebooks on-line (DataLab)

O DataLab permite que você defina diretamente as variáveis de ambiente para um notebook.

• Na barra de menus superior, selecione Environment (Ambiente) e selecione Environment variables (Variáveis de ambiente) no menu suspenso. 
• Selecione a opção para adicionar variáveis de ambiente. 
• Adicione duas variáveis, AZURE_OPENAI_API_KEY e AZURE_OPENAI_ENDPOINT, e seus respectivos valores .
• Dê um nome a esse conjunto de valores de ambiente e salve as alterações. 

No bloco de notas, extraia esses valores conforme mostrado abaixo:

azure_openai_api_key = os.environ["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]

Etapa 2: Faça sua primeira chamada de API para o Azure OpenAI

Agora você pode usar a função AzureOpenAI() para criar um objeto client para aceitar solicitações. Essa função usa os seguintes parâmetros:

• api_version: A versão da API do Azure OpenAI. Verifique a versão mais recente na documentação do Azure. 
• api_key: a chave da API do Azure OpenAI. Obtenha isso das variáveis de ambiente que você definiu anteriormente. Não defina isso manualmente aqui. 
• azure_endpointURL do ponto de extremidade da API do Azure OpenAI (obtenha esse valor no ambiente). 

client = AzureOpenAI(
    api_version="2024-06-01",
    api_key=azure_openai_api_key,
    azure_endpoint=azure_openai_endpoint
)

Use esse objeto client para tarefas como o preenchimento de bate-papo usando a função .chat.completions.create(). Essa função aceita os seguintes parâmetros:

• model: O nome do modelo. Em versões mais antigas da API da OpenAI, esse costumava ser o parâmetro engine. Observe que o parâmetro model deve corresponder ao modelo especificado durante a implantação (no portal do Azure AI Foundry). Se você tentar usar um modelo diferente do implantado, ocorrerá um erro, conforme mostrado abaixo: 

NotFoundError: Error code: 404 - {'error': {'code': 'DeploymentNotFound', 'message': 'The API deployment for this resource does not exist. If you created the deployment within the last 5 minutes, please wait a moment and try again.'}}

• messages: Esse parâmetro especifica a conversa entre o usuário e o modelo. Ele consiste em um conjunto de objetos de mensagem. Cada objeto de mensagem tem um par de valores chave denotado por role ( system, user ou assistant) e content(o texto da mensagem). Esses objetos de mensagem fornecem contexto para a interação e orientam as respostas do modelo. 

Abaixo, dou exemplos de pares chave-valor (role, content ) para diferentes valores de role:

• user: o prompt inserido pelo usuário final. 

Exemplo: {“role”: “user”, “content”: “explain the difference between rational and irrational numbers”}

• systemDescrição da função que se espera que a OpenAI desempenhe na interação. 

Exemplo: {“role”: “system”, “content”: “you are a helpful teacher to guide elementary mathematics students”}

• assistantVocê pode encontrar no site: a resposta esperada da OpenAI. 

Exemplo: {“role”: “assistant”, “content”: “the difference between rational and irrational numbers is … an example explanation …”}

A função assistant é necessária somente quando os dados de treinamento são fornecidos para ajustar o modelo. Ao usar o client para tarefas como conclusão de bate-papo, apenas as funções user e system são suficientes. Para muitas tarefas simples, apenas a função user é suficiente .

• max_tokensNúmero máximo de tokens: esse parâmetro determina o número máximo de tokens que podem ser usados para processar (tanto a entrada quanto a saída) a chamada de API. Você será cobrado diretamente pelos tokens que usar. O valor padrão é 16. Esse valor é suficiente para casos de uso simples; portanto, esse parâmetro pode ser omitido. 

simple_completion = client.chat.completions.create(
    model="gpt-35-turbo",  
    messages=[
        {
            "role": "user",
            "content": "Explain the difference between OpenAI and Azure OpenAI in 20 words",
        },
    ],
)

Imprima a saída da tarefa de conclusão do bate-papo:

print(simple_completion.to_json())

A saída é um objeto JSON com vários pares de valores-chave. Ele inclui a saída do modelo, conforme mostrado no exemplo abaixo. Observe que assistant é a função padrão atribuída ao modelo .

"message": {
   "content": "OpenAI is a research organization focused on advancing AI, while Azure OpenAI is a collaboration between Microsoft and OpenAI.",
   "role": "assistant"
},

Etapa 3: Usando modelos da OpenAI para diferentes tarefas

Para acessar qualquer modelo com o Azure OpenAI, você deve primeiro implantar o modelo. Na seção anterior, você implementou o modelo gpt-35-turbo. Para usar um modelo diferente:

• Volte para o Azure AI Foundry e implante um modelo diferente, conforme explicado na seção anterior. Você pode escolher entre vários modelos, como GPT-3,5, GPT-4o, o1 e o1-mini, o3 e o3-mini, entre outros .
• Reescreva os prompts acima (na função chat.completions.create() ) usando o nome do novo modelo .

Em versões mais antigas do OpenAI, era comum usar modelos diferentes para tarefas diferentes. Havia modelos dedicados para geração de código, PNL e muito mais. Modelos modernos, como o GPT-3.5 e o GPT-4, podem executar todas as tarefas generativas baseadas em texto. Assim, muitos dos modelos antigos específicos de tarefas (como os modelos davinci para geração de código) foram eliminados .

Agora vamos examinar como usar a API para várias tarefas simples, como resposta a perguntas e resumo de texto. Nas tarefas de exemplo abaixo, usamos o mesmo modelo - GPT-3.5. Você também pode escolher um dos modelos GPT-4. 

Como essas duas tarefas são baseadas em texto, vamos primeiro declarar um bloco de texto para você trabalhar. Copiei arbitrariamente uma avaliação de um par de botas de um site de comércio eletrônico. Atribua o texto desta revisão a uma variável text. Certifique-se de que você evite qualquer caractere de aspas simples ou duplas no texto. 

text = 'Comfort and Quality wise the boots are absolutely excellent. A 10 miles hike along the city Streets and the alps nearby felt like a smooth sail. The most plus it was quite well ventilated cause of the heavy duty Gore-tex material. After 12 hours when I removed it, there was just very little bit of perspiration (My foot sweats a lot) and absolutely no foul smell. Speaking of the Gore-Tex I would say, I sported this on a heavy rainy day after buying it in India, I was fearing the boot, though not very much like normal boots, would still be drenching with water, instead it was very little soaked. And some 5-6 hours later it was completely dry (Kept inside a closed room in the night). The only disadvantage I think is, that it fits my foot perfectly according to the size I chose, and there is no slight pain from 7 AM till 8 PM due to the shoe weight (of course its 1.2 KG, even though it doesn\'t feel like)' 

Resumo de texto 

Para resumir o texto acima:

• Use o objeto client criado anteriormente .
• Passe as funções apropriadas no parâmetro messages, conforme mostrado no exemplo abaixo :

summary_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {
         "role": "system",
         "content": "You are a helpful assistant for summarizing text"
        },
        {
            "role": "user",
            "content": f"Summarize this text in 10 words: {text}",
        },
    ],
)

Observe como passamos o texto como uma variável no prompt no snippet acima.

print(summary_completion.to_json())

O resultado contém o resumo do assistente do texto longo, conforme mostrado neste trecho: 

"message": {
   "content": "Excellent comfort and quality, well-ventilated, quick-drying, lightweight boots, minimal perspiration, no foul smell.",
   "role": "assistant"
},

Perguntas respondidas

Para responder a perguntas (com base no texto de entrada acima), modificamos o prompt para passar a pergunta como uma variável de cadeia de caracteres. Como antes, o prompt também inclui o texto como uma variável. O modelo responde à pergunta com base no texto fornecido. 

question = 'Are these shoes heavy?'

qna_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for answering questions"
        },
        {
            "role": "user",
            "content": f"Answer this question: {question} in 10 words based on this text: {text}",
        },
    ],
)

Converta a saída em JSON e a imprima:

print(qna_completion.to_json())

A saída inclui a resposta do assistente à pergunta:

"message": {
   "content": "Lightweight. Not heavy. Comfortable for long hikes. Well-ventilated Gore-tex material.",
   "role": "assistant"
},

Casos de uso do Azure OpenAI

Agora, vamos dar uma olhada nos diferentes casos de uso do serviço Azure OpenAI.

Processamento de linguagem natural (NLP)

Por ser um modelo de linguagem em sua essência, os modelos de uso geral da OpenAI, como o GPT-3 e o GPT-4, são excelentes em tarefas de PNL, como:

• Resumo de texto: Forneça à API um grande trecho de texto como entrada e peça que ela o resuma de acordo com suas necessidades. No exemplo anterior, resumimos a longa avaliação do cliente em um resumo de 10 palavras.
• Classificação de texto: Dado um documento (ou um conjunto de documentos) e um conjunto de rótulos predefinidos, o OpenAI pode classificar o(s) documento(s) com o rótulo mais adequado. 
• Análise de sentimento: A API pode analisar uma parte do texto de entrada para avaliar seu sentimento. Por exemplo, ele pode classificar uma avaliação de cliente como positiva, negativa ou neutra.

No exemplo a seguir, realizamos uma análise de sentimento para classificar o texto da avaliação do cliente (definido anteriormente).

sentiment_classification = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for classifying customer reviews into one of the following categories: very positive, positive, neutral, negative, very negative"
        },
        {
            "role": "user",
            "content": f"Classify this review: {text}",
        },
    ],
    #max_tokens=16
)

print(sentiment_classification.to_json())

O resultado contém um trecho parecido com o trecho abaixo. Ele contém a classificação da revisão feita pelo assistente:

"message": {
   "content": "This review can be classified as very positive.",
   "role": "assistant"
},

Geração de código

Os modelos OpenAI podem gerar código em várias linguagens de programação. As versões anteriores do OpenAI tinham modelos específicos de código, como Codex e code-davinci, que foram ajustados para a geração de código .

No entanto, as versões mais recentes do OpenAI, como GPT-3.5 e GPT-4, geram código sem ajuste fino. Os modelos básicos são pré-treinados em conjuntos de dados baseados em codificação. Assim, o Codex, o code-davinci e muitos outros modelos legados foram descontinuados e não estão mais disponíveis para novas implementações. 

Os modelos da OpenAI podem ajudar você a escrever códigos em várias linguagens de programação comuns. Interagir com o modelo em linguagem natural para dar instruções para tarefas de programação como: 

• Gerar código: Com um prompt de texto ou um comentário, o modelo pode gerar um trecho de código. O programador pode combinar vários desses trechos em um programa funcional adequado. Isso ajuda a automatizar tarefas repetitivas, como escrever código padrão. 
• Debug: O modelo pode analisar erros e mensagens de advertência para explicar o problema em linguagem natural e fazer sugestões sobre como corrigi-lo. Você pode usar o modelo para analisar erros e mensagens de advertência para explicar o problema em linguagem natural e fazer sugestões sobre como corrigi-lo. 
• Otimize: Os modelos da OpenAI podem ajudar a refatorar o código em estruturas mais limpas e usar algoritmos mais eficientes para tarefas comuns, como classificação. 
• Explique: Os modelos da OpenAI também podem explicar os trechos de código que geram. Essas explicações ajudam a personalizar o código gerado para atender às necessidades do desenvolvedor. Eles também podem ajudar os novos programadores a entender os conceitos de programação. 

Considere um exemplo simples de como escrever uma função Python para abrir e ler um arquivo. Essa é uma tarefa bastante comum que pode ser facilmente automatizada. Pedimos à OpenAI que gere e explique o código. Use o objeto client criado anteriormente .

code_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for generating programming code"
        },
        {
            "role": "user",
            "content": "Write and explain a Python function to open and read a file",
        },
    ],
)

Imprima a saída: 

print(code_completion.to_json())

Observe que o objeto JSON de saída contém a saída do assistente semelhante ao trecho de amostra abaixo: 

"content": "Below is a Python function that opens a file, reads its contents, and returns the content as a string:\n\n```python\ndef read_file(file_path):\n    try:\n        with open(file_path, 'r') as file:\n …

Geração de imagens com DALL-E

Os exemplos anteriores foram todos baseados em texto. Eles usaram o OpenAI como um modelo de linguagem grande (LLM), que normalmente é criado usando a arquitetura do transformador. Além dos LLMs, o OpenAI inclui modelos baseados em difusores, como o DALL-E, que geram imagens a partir de um prompt de entrada. 

Para usar o DALL-E, forneça um prompt baseado em texto com uma descrição detalhada da imagem que você deseja ver. Com base nessa descrição, o DALL-E gera uma imagem de alta qualidade. Isso é útil para tarefas como criar ilustrações, projetar conceitos de produtos, fazer esboços para campanhas de marketing e muito mais. 

DALL-E não está disponível em todas as regiões geográficas. Se ele estiver disponível em sua região, crie uma nova implantação (conforme explicado anteriormente neste tutorial), mas usando o modelo DALL-E-3 em vez de GPT-3. Acesse o modelo DALL-E usando o mesmo objeto client descrito anteriormente. Use o método client.images.generate() para gerar uma imagem :

• Defina o nome do modelo como dalle3 usando o parâmetro model .
• Descreva a imagem desejada com o parâmetro prompt .
• Você também pode especificar um valor para n, que é o número de imagens a serem geradas .

result = client.images.generate(
    model="dalle3", 
    prompt="An owl wearing a Christmas hat",
    n=1
)

Extraia o objeto de resposta JSON da resposta do modelo: 

import json
json_response = json.loads(result.model_dump_json())

Declare o diretório da imagem. Observe que o diretório images deve existir no diretório de trabalho atual (no qual você iniciou o shell do Python) .

image_dir = os.path.join(os.curdir, 'images')

Especifique o caminho da imagem nesse diretório:

image_path = os.path.join(image_dir, 'generated_image.png')

Extraia o URL da imagem gerada do objeto de resposta JSON, faça o download da imagem (como um fluxo) e grave-a no arquivo de imagem:

image_url = json_response["data"][0]["url"]  
generated_image = requests.get(image_url).content  
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

Exibir a imagem:

from PIL import Image

image = Image.open(image_path)
image.show()

Práticas recomendadas para usar o Azure OpenAI

O uso do serviço Azure OpenAI é simples, mas, como acontece com todas as tecnologias, há algumas práticas recomendadas a serem seguidas para que você possa tirar o máximo proveito delas. Vamos analisá-las nesta seção.

Monitoramento e gerenciamento do uso da API

O Azure OpenAI é um dos serviços mais caros do Azure. Mesmo os créditos gratuitos disponíveis para novas contas não podem ser usados para a API da OpenAI. Portanto, é essencial rastrear o uso, mesmo para novos usuários. O uso não verificado da API pode levar a contas inesperadamente grandes.

As cobranças da OpenAI são baseadas no uso e no consumo de tokens. Os tokens representam unidades de texto processadas pelo modelo, tanto para entrada quanto para saída. O processamento de um documento de texto grande consome mais tokens do que a geração de uma resposta mais longa. Quanto mais tokens você usar, mais você pagará. Portanto, seja econômico com as informações que você fornece ao modelo ou pede que ele gere. 

Use o parâmetro max_tokens para limitar o número de tokens consumidos nessa solicitação. Para modelos de produção, faça experiências para determinar quantos tokens suas solicitações ou usuários normalmente precisam e limite o uso de acordo. Aumente o limite de acordo com cada caso. 

Para monitorar as métricas básicas:

• Do site Serviços de IA do Azure | Azure OpenAI selecione o recurso a ser monitorado.
• Na página de recursos, selecione a opção Monitor para exibir várias métricas, como o número de solicitações HTTP e o número de tokens processados por modelo e por implantação.

Painel de métricas do Azure OpenAI.

Você também pode visualizar métricas mais detalhadas:

• Na seção Monitoramento no menu esquerdo, selecione Métricas.

Métricas detalhadas do Azure OpenAI.

• Na seção Selecionar um escopo selecione a instância do OpenAI (marque a caixa de seleção)
• Selecione Aplicar.

Sobre as Métricas página:

• Selecione a janela de tempo no canto superior direito. 
• Na barra de menus na parte superior do gráfico (inicialmente vazio), selecione a métrica apropriada no menu suspensoMétrica. Você pode escolher entre várias métricas, como:
• Solicitações do Azure OpenAI, 
• Estatísticas sobre o uso de tokens (tokens ativos, tokens gerados, etc.)
• Desempenho das chamadas de API (tempo para o primeiro byte, etc.) e muito mais. 

Exemplo de monitoramento do Azure OpenAI.

Por fim, sempre defina limites de orçamento nas contas de API e configure as definições para receber alertas por e-mail quando você ultrapassar um limite de orçamento. 

Modelos de ajuste fino

Os modelos básicos da OpenAI são treinados em enormes conjuntos de dados que abrangem muitos domínios diferentes. Em linhas gerais, há três maneiras diferentes de obter o resultado desejado dos modelos LLM: 

• Engenharia imediata: Para a maioria dos casos de uso, adicionar instruções específicas ao prompt é suficiente. Isso é chamado de engenharia imediata. 
• Aprendizagem com poucos disparos: Nos casos em que a engenharia do prompt é insuficiente, umadiciona alguns exemplos ao prompt para ajudar o modelo a entender as respostas desejadas pelo usuário. Isso é chamado de aprendizado de poucas tentativas, no qual o modelo aprende com base em um pequeno número de exemplos. 
• Ajuste fino: Às vezes, você quer conversar com o modelo sobre um domínio muito específico, por exemplo, com base em um manual para conserto de equipamentos especializados. A geração de texto sobre esse tópico envolve o uso de jargões e padrões de linguagem específicos do domínio, que provavelmente não fazem parte de conjuntos de dados públicos (nos quais os modelos básicos foram treinados). 

Você pode fazer o ajuste fino de um modelo básico se o aprendizado com poucos disparos e a engenharia imediata não ajudarem a obter as respostas certas. 

O ajuste fino refere-se ao retreinamento de um modelo básico pré-treinado em um conjunto de dados especializado. Na prática, apenas algumas camadas do modelo básico (não o modelo inteiro) são treinadas novamente com os novos dados. O tutorial de ajuste fino do Azure explica as etapas de ajuste fino de um modelo popular da OpenAI. 

Lembre-se de que, para ajustar com sucesso um modelo básico, você precisa de grandes volumes de dados relevantes e de alta qualidade com milhares de exemplos de treinamento. Além disso, o ajuste fino invariavelmente envolve grandes custos iniciais para treinar o modelo. Além disso, o modelo ajustado precisa ser hospedado às suas custas antes da implementação. 

Protegendo suas chaves de API

As chaves de API expostas publicamente podem ser usadas indevidamente para acessar informações confidenciais, executar tarefas inseguras e/ou ilegais ou fazer solicitações não autorizadas, resultando em uma grande conta para o proprietário da conta. Portanto, é fundamental gerenciar com segurança as chaves de API em vez de codificá-las no código-fonte. Você pode adotar várias abordagens para fazer isso: 

• Para serviços em nuvem, use ferramentas de gerenciamento de chaves, como o AWS Secrets Manager e o Azure Key Vault.
• Use os arquivos .env para armazenar chaves no formato de valor-chave. Adicione esse arquivo à lista .gitignore para garantir que ele não seja confirmado no repositório de código .
• Para serviços baseados no notebook Jupyter, use a opção para armazenar chaves como parte do ambiente. Esse método foi descrito anteriormente neste tutorial. 

Aconselho que você restrinja as permissões para quais tarefas as chaves podem ser usadas. Também é útil girar ou regenerar as chaves periodicamente para que as chaves antigas não possam ser usadas indevidamente em caso de vazamento.

Conclusão 

Neste tutorial, discutimos como começar com uma conta do Azure, configurar os serviços do OpenAI, criar uma nova instância do OpenAI e implantar um modelo. Em seguida, vimos exemplos de uso dos modelos da OpenAI em tarefas práticas. Também abordamos como monitorar o uso e o desempenho dos recursos do Azure OpenAI. 

Para obter uma compreensão mais profunda do Microsoft Azure, siga o curso DataCamp Azure Fundamentals. Para saber mais sobre os principais conceitos da OpenAI, siga a trilha DataCamp OpenAI Fundamentals.