API do Modelo GPT

1. Fundamentos dos Modelos de Geração de Texto

O modelo de geração de texto da OpenAI, geralmente referido como Transformador Pré-Treinado Generativo (GPT), depende do mecanismo de autoatenção em aprendizado profundo para compreender e processar a linguagem natural. O treinamento do modelo GPT consiste em duas etapas: pré-treinamento e ajuste fino.

Pré-treinamento

Durante a etapa de pré-treinamento, o modelo passa por aprendizado não supervisionado usando um conjunto de dados de texto em grande escala. Nesse processo, o modelo é treinado prevendo a próxima palavra. Por exemplo, dada a frase "Eu tenho uma caneta", após ver as primeiras palavras, ele tenta prever a palavra "caneta". O objetivo principal do pré-treinamento é capacitar o modelo a entender a estrutura e a semântica da linguagem.

Ajuste Fino

A etapa de ajuste fino envolve aprendizado supervisionado em tarefas específicas. Nessa etapa, o modelo é ajustado para se adaptar a aplicações particulares, como sistemas de perguntas e respostas e sumarização de documentos. O ajuste fino envolve treinar ainda mais o modelo com conjuntos de dados anotados com base no modelo pré-treinado, possibilitando que ele se adapte melhor a tarefas específicas.

2. Cenários de Aplicação

O modelo de geração de texto da OpenAI pode ser aplicado a uma ampla variedade de cenários. Aqui estão algumas aplicações específicas:

• Redação de Documentos: Auxiliar os usuários na redação e edição rápida de documentos.
• Escrita de Código de Computador: Gerar trechos de código para auxiliar na programação.
• Responder Perguntas sobre uma Base de Conhecimento: Fornecer respostas com base no conhecimento armazenado.
• Análise de Texto: Extrair informações de texto, analisar sentimentos e muito mais.
• Fornecer Interface de Linguagem Natural para Software: Permitir que os usuários interajam com o software usando linguagem natural.
• Tutoria em Diversas Matérias: Fornecer orientação educacional em várias disciplinas.
• Tradução de Idiomas: Traduzir texto entre diferentes idiomas.
• Simulação de Personagens para Jogos: Gerar diálogos e histórias de fundo para jogos ou cenários de interpretação.

3. Introdução ao Modelo de Diálogo

Um modelo de diálogo é um tipo especial de modelo de geração de texto que compreende e gera conversas naturais por meio de pré-treinamento. Esse modelo pode simular uma conversa entre um usuário e um assistente virtual, adequado para aplicações interativas em tempo real.

O uso de um modelo de diálogo geralmente envolve conversas interativas de várias etapas. Por exemplo, quando um usuário faz uma pergunta, o modelo pode gerar respostas apropriadas com base em dados de treinamento anteriores. Além disso, o modelo de diálogo pode manter informações contextuais, considerando o conteúdo da conversa anterior para gerar respostas mais coerentes e naturais.

Cenários de aplicação do modelo de diálogo:

• Assistentes de Atendimento ao Cliente: Responder automaticamente a perguntas frequentes dos usuários, fornecer assistência e conselhos.
• Chatbots: Participar de interações conversacionais naturais com usuários.
• Assistentes Virtuais: Executar comandos de voz dos usuários, como agendar reuniões, definir lembretes e muito mais.
• Jogos de Interpretação de Personagens: Enriquecer a experiência de jogo dando a personagens de jogo diálogos e personalidades únicos.

4. API do Modelo de Diálogo

A API do Modelo de Diálogo permite que os desenvolvedores interajam com o modelo GPT usando requisições HTTP. Esta seção irá introduzir como usar o curl para construir requisições e analisar as respostas retornadas pelo modelo.

Construindo Requisições

Antes de começar, você precisa se registrar e obter uma chave API da OpenAI, que precisa ser autenticada por meio de cabeçalhos HTTP ao enviar requisições.

Aqui está um exemplo de uso do curl para enviar uma requisição para a API do Modelo de Diálogo:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {
        "role": "sistema",
        "conteúdo": "Você é um assistente prestativo."
      },
      {
        "role": "usuário",
        "conteúdo": "Qual equipe ganhou a Série Mundial de 2020?"
      }
    ]
  }'

Significado dos Parâmetros do Modelo de Diálogo

Ao usar a API do Modelo de Diálogo da OpenAI, os principais parâmetros incluem "model" e "messages", cada um carregando significados específicos e influenciando os resultados produzidos.

Parâmetros do Modelo

O parâmetro do modelo é usado para especificar a versão do modelo a ser utilizada. Por exemplo, "model": "gpt-3.5-turbo" indica que você está solicitando o modelo GPT-3.5-Turbo. A versão do modelo selecionada aqui responderá à entrada do usuário com base em suas capacidades, dados de treinamento e recursos de interface.

Aqui estão os modelos atualmente suportados:

Parâmetro de Mensagens

O parâmetro de mensagens é uma matriz, onde cada elemento representa uma mensagem na conversa. Cada mensagem é um objeto contendo duas propriedades: role (o papel do remetente) e content (o conteúdo específico da mensagem).

• role: Especifica o papel do remetente para a mensagem. Os valores opcionais incluem "sistema", "usuário" e "assistente".
• content: O conteúdo específico da mensagem.

Tipos e Funções do Papel

O valor do parâmetro de papel define o tipo e a função da mensagem. A API de Diálogo irá alterar a resposta do modelo com base em diferentes papéis.

Função 'sistema'

As mensagens do sistema são utilizadas para indicar globalmente o comportamento do modelo. Por exemplo, elas podem especificar explicitamente a função desempenhada pelo modelo (como assistente, tradutor, etc.) ou fornecer instruções específicas a serem seguidas na conversa. As mensagens do sistema têm um impacto de longo prazo no comportamento do modelo ao longo da conversa, mas geralmente são opcionais.

Por exemplo, se desejar que o modelo participe da conversa como um assistente de atendimento ao cliente, você pode especificar na mensagem do sistema:

{
  "role": "sistema",
  "conteúdo": "Você é um assistente de atendimento ao cliente."
}

Função 'usuário'

As mensagens do usuário representam as perguntas inseridas pelo usuário. O modelo responde a essas mensagens e fornece informações, respostas ou outras formas de saída. Essas mensagens são uma parte crucial do fluxo de trabalho da API de Diálogo e geralmente correspondem a consultas reais do usuário na aplicação.

Por exemplo, na solicitação do usuário no exemplo curl acima:

{
  "role": "usuário",
  "conteúdo": "Qual time ganhou a Série Mundial de 2020?"
}

Função 'assistente'

As mensagens do assistente normalmente se referem às respostas geradas pelo modelo e também podem ser parte das mensagens de histórico de conversa fornecidas pelo desenvolvedor, usadas para simular o formato das mensagens de retorno de IA. Nas solicitações da API, as mensagens do papel de assistente normalmente não são fornecidas, a menos que seja necessário pré-definir o formato em que o modelo responde a perguntas no histórico da conversa para fornecer exemplos de saída para o modelo.

Analisando a Resposta

A resposta do modelo é retornada no formato JSON. Aqui está um exemplo de como analisar a resposta:

{
  "escolhas": [
    {
      "motivo_finalização": "parar",
      "índice": 0,
      "mensagem": {
        "conteúdo": "O campeão da Série Mundial de 2020 é o Los Angeles Dodgers.",
        "função": "assistente"
      },
      "registros_probabilidades": null
    }
  ],
  "criado": 1677664795,
  "id": "chatcmpl-7QyqpwdfhqwajicIEznoc6Q47XAyW",
  "modelo": "gpt-3.5-turbo-0613",
  "objeto": "completude.conversa",
  "uso": {
    "tokens_completos": 17,
    "tokens_prompt": 57,
    "total_tokens": 74
  }
}

Na resposta acima, você pode obter a resposta do modelo a partir de escolhas [0] .mensagem.conteúdo.

Como Implementar a Função de Memória em um Modelo de Diálogo

Abaixo está um exemplo de uso da API de Completions de Chat da OpenAI para implementar a função de memória do modelo GPT, que demonstra como salvar o contexto da conversa histórica (ou seja, o conteúdo da memória) em uma nova solicitação de API para alcançar um diálogo contínuo.

import requests

api_url = "https://api.openai.com/v1/chat/completions"
api_key = "Sua Chave de API da OpenAI"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

data = {
    "model": "gpt-3.5-turbo",  # Pode ser substituído por gpt-4 ou outros modelos disponíveis
    "messages": [
      {
        "role": "system",  # Mensagem do sistema, usada para definir o comportamento do modelo de diálogo
        "content": "Você é um assistente de ajuda."
      },
      {
        "role": "user",  # Mensagem do usuário, o modelo irá responder a isso
        "content": "Você pode me dizer as principais razões para as mudanças climáticas?"
      },
      {
        "role": "assistant",  # Resposta do modelo
        "content": "As principais razões para as mudanças climáticas incluem emissões de gases de efeito estufa, combustão de combustíveis fósseis e desmatamento, etc."
      },
      {
        "role": "user",  # Nova pergunta baseada na resposta do modelo
        "content": "Como podemos reduzir as emissões de gases de efeito estufa?"
      }
    ]
}

response = requests.post(api_url, headers=headers, json=data)

if response.status_code == 200:
    reply_content = response.json()['choices'][0]['message']['content']
    print(f"Resposta do Modelo => {reply_content}")
else:
    print(f"Erro na solicitação: {response.status_code}")

Neste exemplo, simulamos um usuário perguntando primeiro sobre as principais razões para as mudanças climáticas e depois fazendo outra pergunta com base na explicação do modelo. Em solicitações posteriores, mantemos o conteúdo da conversa anterior para garantir que o modelo possa lembrar a história da conversa anterior e gerar uma resposta com base nela. Este método alcança a transmissão e memória do estado do diálogo usando a entrada e saída da rodada de conversa anterior como as mensagens de histórico da nova solicitação.

Dica: Para implementar a função de memória do diálogo, devido ao limite máximo de tokens do modelo, não é viável inserir todas as mensagens de conversa históricas para cada solicitação. Tipicamente, mensagens relevantes relacionadas às perguntas atuais são inseridas como mensagens históricas no modelo, e as seções subsequentes apresentarão como o recurso de Embeddings alcança a pesquisa de similaridade de texto.

5. Esquema JSON

O Esquema JSON é um recurso da API de modelo de diálogo que permite aos usuários instruir o modelo a sempre retornar um objeto JSON, adequado para cenários que exigem receber respostas no formato JSON.

Usando o Esquema JSON

Para usar o Esquema JSON, é necessário definir o campo response_format para { "type": "json_object" } no corpo da solicitação HTTP e garantir que a mensagem do sistema indique que a saída do modelo está em formato JSON. Abaixo está um exemplo de solicitação curl para habilitar o Esquema JSON:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo-1106",
    "response_format": { "type": "json_object" },
    "messages": [
      {
        "role": "system",
        "content": "Você é um assistente útil projetado para produzir JSON."
      },
      {
        "role": "user",
        "content": "Qual time venceu a Série Mundial de 2020?"
      }
    ]
  }'

Análise da Resposta do Esquema JSON

No modo de Esquema JSON, a resposta conterá um objeto JSON completo e perfeitamente analisado. Este modo garante que a saída do modelo seja um objeto JSON válido que pode ser diretamente analisado e utilizado. Abaixo está um exemplo de uma resposta que poderia ser retornada usando o Esquema JSON:

{
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "content": "{\"winner\": \"Los Angeles Dodgers\"}"
      }
    }
  ]
}

Em Python, você pode usar o seguinte código para extrair o conteúdo da resposta:

import json

response = {
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "content": "{\"winner\": \"Los Angeles Dodgers\"}"
      }
    }
  ]
}

conteudo_resposta = json.loads(response['choices'][0]['message']['content'])

print(conteudo_resposta)

A saída será:

{'winner': 'Los Angeles Dodgers'}

O Esquema JSON fornece um método confiável para garantir a formatação correta das respostas para casos de uso específicos. Portanto, é recomendável habilitar o Esquema JSON em cenários onde existem requisitos específicos para o formato da resposta da API.