Trabalhe com os modelos GPT-3.5-Turbo, GPT-4 e GPT-4o

  • Artigo

Os modelos das séries GPT-3.5-Turbo, GPT-4 e GPT-4o são modelos de linguagem otimizados para interfaces de conversação. Os modelos comportam-se de forma diferente dos modelos GPT-3 mais antigos. Os modelos anteriores eram text-in e text-out, o que significa que eles aceitavam uma string de prompt e retornavam uma conclusão para anexar ao prompt. No entanto, os modelos mais recentes são o conversation-in e o message-out. Os modelos esperam entrada formatada em um formato de transcrição específico semelhante a um chat. Eles retornam uma conclusão que representa uma mensagem escrita por modelo no chat. Esse formato foi projetado especificamente para conversas de vários turnos, mas também pode funcionar bem para cenários sem bate-papo.

Este artigo orienta você sobre como começar a usar modelos de conclusão de bate-papo. Para obter os melhores resultados, utilize as técnicas aqui descritas. Não tente interagir com os modelos da mesma forma que fez com as séries de modelos mais antigos, porque os modelos são muitas vezes detalhados e fornecem respostas menos úteis.

Trabalhar com modelos de conclusão de chat

O trecho de código a seguir mostra a maneira mais básica de interagir com modelos que usam a API de conclusão de bate-papo. Se esta for a primeira vez que você usa esses modelos programaticamente, recomendamos que você comece com o início rápido de conclusão do chat.

Nota

Na documentação do Azure OpenAI, referimo-nos ao GPT-3.5-Turbo e ao GPT-35-Turbo de forma intercambiável. O nome oficial do modelo no OpenAI é gpt-3.5-turbo. Para o Azure OpenAI, devido a restrições de caracteres específicas do Azure, o nome do modelo subjacente é gpt-35-turbo.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
        {"role": "user", "content": "Who were the founders of Microsoft?"}
    ]
)

#print(response)
print(response.model_dump_json(indent=2))
print(response.choices[0].message.content)

{
  "id": "chatcmpl-8GHoQAJ3zN2DJYqOFiVysrMQJfe1P",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.",
        "role": "assistant",
        "function_call": null
      },
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ],
  "created": 1698892410,
  "model": "gpt-35-turbo",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 73,
    "prompt_tokens": 29,
    "total_tokens": 102
  },
  "prompt_filter_results": [
    {
      "prompt_index": 0,
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}
Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.

Nota

Os seguintes parâmetros não estão disponíveis com os novos modelos GPT-35-Turbo e GPT-4: logprobs, best_ofe echo. Se você definir qualquer um desses parâmetros, receberá um erro.

Todas as respostas incluem finish_reason. Os valores possíveis para finish_reason são:

  • stop: a API retornou a saída completa do modelo.
  • comprimento: saída de modelo incompleta devido ao max_tokens parâmetro ou ao limite de token.
  • content_filter: Conteúdo omitido devido a um sinalizador dos nossos filtros de conteúdo.
  • null: resposta da API ainda em andamento ou incompleta.

Considere definir max_tokens para um valor um pouco mais alto do que o normal, como 300 ou 500. Um valor mais alto garante que o modelo não pare de gerar texto antes de chegar ao final da mensagem.

Controlo de versões de modelos

Nota

A versão gpt-35-turbo é equivalente ao gpt-3.5-turbo modelo da OpenAI.

Ao contrário dos modelos GPT-3 e GPT-3.5 anteriores, o gpt-35-turbo modelo e os gpt-4 modelos e gpt-4-32k continuarão a ser atualizados. Ao criar uma implantação desses modelos, você também precisa especificar uma versão do modelo.

Você pode encontrar as datas de aposentadoria do modelo para esses modelos na página de modelos .

Trabalhar com a API de conclusão de bate-papo

A OpenAI treinou os modelos GPT-35-Turbo e GPT-4 para aceitar entradas formatadas como uma conversa. O parâmetro messages usa uma matriz de objetos de mensagem com uma conversa organizada por função. Quando você usa a API do Python, uma lista de dicionários é usada.

O formato de uma conclusão de chat básica é:

{"role": "system", "content": "Provide some context and/or instructions to the model"},
{"role": "user", "content": "The users messages goes here"}

Uma conversa com um exemplo de resposta seguido de uma pergunta seria assim:

{"role": "system", "content": "Provide some context and/or instructions to the model."},
{"role": "user", "content": "Example question goes here."},
{"role": "assistant", "content": "Example answer goes here."},
{"role": "user", "content": "First question/message for the model to actually respond to."}

Função do sistema

A função do sistema, também conhecida como mensagem do sistema, é incluída no início da matriz. Esta mensagem fornece as instruções iniciais para o modelo. Você pode fornecer várias informações na função do sistema, como:

  • Breve descrição do assistente.
  • Traços de personalidade do assistente.
  • Instruções ou regras que você deseja que o assistente siga.
  • Dados ou informações necessários para o modelo, como perguntas relevantes de um FAQ.

Você pode personalizar a função do sistema para seu caso de uso ou incluir instruções básicas. A função/mensagem do sistema é opcional, mas recomendamos que você inclua pelo menos uma básica para obter os melhores resultados.

Mensagens

Após a função do sistema, você pode incluir uma série de mensagens entre o e o user assistant.

 {"role": "user", "content": "What is thermodynamics?"}

Para acionar uma resposta do modelo, termine com uma mensagem de usuário para indicar que é a vez do assistente responder. Você também pode incluir uma série de mensagens de exemplo entre o usuário e o assistente como uma maneira de fazer poucos aprendizados.

Exemplos de prompt de mensagem

A seção a seguir mostra exemplos de diferentes estilos de prompts que você pode usar com os modelos GPT-35-Turbo e GPT-4. Estes exemplos são apenas um ponto de partida. Você pode experimentar diferentes prompts para personalizar o comportamento para seus próprios casos de uso.

Exemplo básico

Se você quiser que o modelo GPT-35-Turbo se comporte de forma semelhante ao chat.openai.com, você pode usar uma mensagem básica do sistema como Assistant is a large language model trained by OpenAI.

{"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
{"role": "user", "content": "Who were the founders of Microsoft?"}

Exemplo com instruções

Para alguns cenários, talvez você queira dar mais instruções ao modelo para definir guarda-corpos para o que o modelo é capaz de fazer.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer their tax related questions.
Instructions: 
- Only answer questions related to taxes. 
- If you're unsure of an answer, you can say "I don't know" or "I'm not sure" and recommend users go to the IRS website for more information. "},
{"role": "user", "content": "When are my taxes due?"}

Usar dados para aterramento

Você também pode incluir dados ou informações relevantes na mensagem do sistema para dar ao modelo contexto extra para a conversa. Se você precisar incluir apenas uma pequena quantidade de informações, você pode codificá-las na mensagem do sistema. Se você tiver uma grande quantidade de dados que o modelo deve estar ciente, poderá usar incorporações ou um produto como o Azure AI Search para recuperar as informações mais relevantes no momento da consulta.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer technical questions about Azure OpenAI Serivce. Only answer questions using the context below and if you're not sure of an answer, you can say 'I don't know'.

Context:
- Azure OpenAI Service provides REST API access to OpenAI's powerful language models including the GPT-3, Codex and Embeddings model series.
- Azure OpenAI Service gives customers advanced language AI with OpenAI GPT-3, Codex, and DALL-E models with the security and enterprise promise of Azure. Azure OpenAI co-develops the APIs with OpenAI, ensuring compatibility and a smooth transition from one to the other.
- At Microsoft, we're committed to the advancement of AI driven by principles that put people first. Microsoft has made significant investments to help guard against abuse and unintended harm, which includes requiring applicants to show well-defined use cases, incorporating Microsoft’s principles for responsible AI use."
},
{"role": "user", "content": "What is Azure OpenAI Service?"}

Aprendizagem de poucas imagens com a conclusão do chat

Você também pode dar poucos exemplos para o modelo. A abordagem para a aprendizagem de poucos tiros mudou ligeiramente por causa do novo formato de prompt. Agora você pode incluir uma série de mensagens entre o usuário e o assistente no prompt como exemplos de poucas fotos. Usando esses exemplos, você pode semear respostas para perguntas comuns para preparar o modelo ou ensinar comportamentos específicos ao modelo.

Este exemplo mostra como você pode usar o aprendizado de poucas imagens com GPT-35-Turbo e GPT-4. Você pode experimentar diferentes abordagens para ver o que funciona melhor para seu caso de uso.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer their tax related questions. "},
{"role": "user", "content": "When do I need to file my taxes by?"},
{"role": "assistant", "content": "In 2023, you will need to file your taxes by April 18th. The date falls after the usual April 15th deadline because April 15th falls on a Saturday in 2023. For more details, see https://www.irs.gov/filing/individuals/when-to-file."},
{"role": "user", "content": "How can I check the status of my tax refund?"},
{"role": "assistant", "content": "You can check the status of your tax refund by visiting https://www.irs.gov/refunds"}

Usar a conclusão do bate-papo para cenários que não sejam de bate-papo

A API de conclusão de bate-papo foi projetada para trabalhar com conversas de vários turnos, mas também funciona bem para cenários sem bate-papo.

Por exemplo, para um cenário de extração de entidade, você pode usar o seguinte prompt:

{"role": "system", "content": "You are an assistant designed to extract entities from text. Users will paste in a string of text and you will respond with entities you've extracted from the text as a JSON object. Here's an example of your output format:
{
   "name": "",
   "company": "",
   "phone_number": ""
}"},
{"role": "user", "content": "Hello. My name is Robert Smith. I'm calling from Contoso Insurance, Delaware. My colleague mentioned that you are interested in learning about our comprehensive benefits policy. Could you give me a call back at (555) 346-9322 when you get a chance so we can go over the benefits?"}

Criar um ciclo de conversação básico

Os exemplos até agora mostram a mecânica básica de interação com a API de conclusão de bate-papo. Este exemplo mostra como criar um loop de conversa que executa as seguintes ações:

  • Recebe continuamente a entrada do console e a formata corretamente como parte da lista de mensagens como conteúdo da função do usuário.
  • Produz respostas que são impressas no console e formatadas e adicionadas à lista de mensagens como conteúdo da função de assistente.

Toda vez que uma nova pergunta é feita, uma transcrição da conversa até agora é enviada junto com a última pergunta. Como o modelo não tem memória, você precisa enviar uma transcrição atualizada a cada nova pergunta ou o modelo perderá o contexto das perguntas e respostas anteriores.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")  # Your Azure OpenAI resource's endpoint value.
)

conversation=[{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user_input = input("Q:")      
    conversation.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="gpt-35-turbo", # model = "deployment_name".
        messages=conversation
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

Quando você executa o código anterior, você obtém uma janela de console em branco. Introduza a sua primeira pergunta na janela e, em seguida, selecione a Enter chave. Depois que a resposta for retornada, você pode repetir o processo e continuar fazendo perguntas.

Gerenciar conversas

O exemplo anterior é executado até que você atinja o limite de token do modelo. A cada pergunta feita e resposta recebida, a messages lista cresce em tamanho. O limite de tokens é de gpt-35-turbo 4.096 tokens. Os limites de token para gpt-4 e gpt-4-32k são 8.192 e 32.768, respectivamente. Esses limites incluem a contagem de tokens da lista de mensagens enviadas e da resposta do modelo. O número de tokens na lista de mensagens combinado com o valor do parâmetro deve permanecer abaixo desses max_tokens limites ou você recebe um erro.

É sua responsabilidade garantir que o prompt e a conclusão estejam dentro do limite do token. Para conversas mais longas, você precisa acompanhar a contagem de tokens e enviar ao modelo apenas um prompt que esteja dentro do limite.

Nota

É altamente recomendável que você permaneça dentro do limite de token de entrada documentado para todos os modelos, mesmo se descobrir que pode exceder esse limite.

O exemplo de código a seguir mostra um exemplo de loop de bate-papo simples com uma técnica para lidar com uma contagem de 4.096 tokens usando a biblioteca tiktoken do OpenAI.

O código usa tiktoken 0.5.1. Se você tiver uma versão mais antiga, execute pip install tiktoken --upgrade.

import tiktoken
import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")  # Your Azure OpenAI resource's endpoint value.
)

system_message = {"role": "system", "content": "You are a helpful assistant."}
max_response_tokens = 250
token_limit = 4096
conversation = []
conversation.append(system_message)

def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613"):
    """Return the number of tokens used by a list of messages."""
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        print("Warning: model not found. Using cl100k_base encoding.")
        encoding = tiktoken.get_encoding("cl100k_base")
    if model in {
        "gpt-3.5-turbo-0613",
        "gpt-3.5-turbo-16k-0613",
        "gpt-4-0314",
        "gpt-4-32k-0314",
        "gpt-4-0613",
        "gpt-4-32k-0613",
        }:
        tokens_per_message = 3
        tokens_per_name = 1
    elif model == "gpt-3.5-turbo-0301":
        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
        tokens_per_name = -1  # if there's a name, the role is omitted
    elif "gpt-3.5-turbo" in model:
        print("Warning: gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.")
        return num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613")
    elif "gpt-4" in model:
        print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
        return num_tokens_from_messages(messages, model="gpt-4-0613")
    else:
        raise NotImplementedError(
            f"""num_tokens_from_messages() is not implemented for model {model}."""
        )
    num_tokens = 0
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
    return num_tokens
while True:
    user_input = input("Q:")      
    conversation.append({"role": "user", "content": user_input})
    conv_history_tokens = num_tokens_from_messages(conversation)

    while conv_history_tokens + max_response_tokens >= token_limit:
        del conversation[1] 
        conv_history_tokens = num_tokens_from_messages(conversation)

    response = client.chat.completions.create(
        model="gpt-35-turbo", # model = "deployment_name".
        messages=conversation,
        temperature=0.7,
        max_tokens=max_response_tokens
    )


    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

Neste exemplo, depois que a contagem de tokens é atingida, as mensagens mais antigas na transcrição da conversa são removidas. Para eficiência, del é usado em vez de pop(). Começamos no índice 1 para sempre preservar a mensagem do sistema e remover apenas as mensagens do usuário ou assistente. Com o tempo, esse método de gerenciar a conversa pode fazer com que a qualidade da conversa se degrade à medida que o modelo perde gradualmente o contexto das partes anteriores da conversa.

Uma abordagem alternativa é limitar a duração da conversa ao comprimento máximo do token ou a um número específico de voltas. Depois que o limite máximo de token for atingido, o modelo perderia o contexto se você permitisse que a conversa continuasse. Você pode solicitar que o usuário inicie uma nova conversa e limpe a lista de mensagens para iniciar uma nova conversa com o limite total de token disponível.

A parte de contagem de tokens do código demonstrada anteriormente é uma versão simplificada de um dos exemplos de livros de receitas da OpenAI.

Resolução de Problemas

Aqui está uma dica de solução de problemas.

Não use sintaxe ChatML ou tokens especiais com o ponto de extremidade de conclusão de bate-papo

Alguns clientes tentam usar a sintaxe herdada do ChatML com os pontos de extremidade de conclusão de bate-papo e modelos mais recentes. O ChatML era um recurso de visualização que só funcionava com o ponto de extremidade de conclusão herdado com o modelo da gpt-35-turbo versão 0301. Este modelo está previsto para a reforma. Se você tentar usar a sintaxe ChatML com modelos mais recentes e o ponto de extremidade de conclusão do chat, isso poderá resultar em erros e comportamento inesperado de resposta do modelo. Não recomendamos este uso. Esse mesmo problema pode ocorrer ao usar tokens especiais comuns.

Código de Erro Mensagem de Erro Solução
400 400 - "Falha ao gerar saída devido a tokens especiais na entrada." Seu prompt contém tokens especiais ou tokens ChatML herdados não reconhecidos ou suportados pelo modelo/endpoint. Certifique-se de que sua matriz de prompt/mensagens não contenha nenhum token ChatML herdado/token especial. Se você estiver atualizando de um modelo herdado, exclua todos os tokens especiais antes de enviar uma solicitação de API para o modelo.

Falha ao criar a conclusão, pois o modelo gerou saída Unicode inválida

Código de Erro Mensagem de Erro Solução
500 500 - InternalServerError: Código de erro: 500 - {'error': {'message': 'Falha ao criar conclusão como o modelo gerou saída Unicode inválida}}. Você pode minimizar a ocorrência desses erros reduzindo a temperatura dos prompts para menos de 1 e garantindo que está usando um cliente com lógica de repetição. Repetir a solicitação geralmente resulta em uma resposta bem-sucedida.

Próximos passos