1. Introdução à Chamada de Função
No modelo GPT, a Chamada de Função refere-se à disponibilização de funções descritivas ao modelo por meio de uma API, permitindo-lhe selecionar e produzir inteligentemente um objeto JSON contendo parâmetros para chamar uma ou mais funções. É importante notar que a API de Completude de Bate-Papo não executa diretamente chamadas de função, mas gera JSON que pode ser utilizado para executar funções no código.
Em termos simples, a funcionalidade de Chamada de Função envolve fornecer um conjunto de definições de função (incluindo descrições de função e parâmetros) ao modelo GPT. O modelo então decide qual função chamar com base na consulta do usuário. Como o modelo não pode executar funções externas, ele somente responde com uma solicitação para qual função chamar (incluindo parâmetros da chamada da função). Após receber o resultado da solicitação do modelo, nosso programa executa a chamada da função localmente. O resultado da chamada da função é então concatenado com o prompt e enviado de volta ao modelo para processamento adicional antes de retornar o resultado final ao usuário.
2. Cenários de Aplicação da Chamada de Função
Aqui estão alguns exemplos de suas aplicações práticas:
- Criar um assistente para responder perguntas chamando APIs externas, como definir funções como
send_email(para: string, corpo: string)ouget_current_weather(localização: string, unidade: 'celsius' | 'fahrenheit'). - Converter linguagem natural em chamadas de API, por exemplo, traduzir "Quem são meus melhores clientes?" em
get_customers(receita_mínima: int, criado_antes: string, limite: int)e depois fazer uma chamada de API interna. - Extrair dados estruturados de texto, por exemplo, definindo funções como
extract_data(nome: string, aniversário: string)ousql_query(consulta: string).
Ao utilizar a funcionalidade de Chamada de Função, podemos implementar agentes de IA que interagem com nossos sistemas e bases de dados locais, como ter a IA consultar o clima mais recente, verificar os preços das ações, pedir comida para viagem ou reservar voos.
3. Modelos que Suportam Chamada de Função
Nem todas as versões do modelo foram treinadas com dados de chamada de função. Atualmente, os modelos que suportam chamada de função são: gpt-4, gpt-4-turbo-preview, gpt-4-0125-preview, gpt-4-1106-preview, gpt-4-0613, gpt-3.5-turbo, gpt-3.5-turbo-1106 e gpt-3.5-turbo-0613.
Além disso, os modelos gpt-4-turbo-preview, gpt-4-0125-preview, gpt-4-1106-preview e gpt-3.5-turbo-1106 suportam chamada de função paralela, permitindo executar múltiplas chamadas de função de uma vez e lidar com essas chamadas de função de forma simultânea para produzir resultados eficazes e eficientes.
Nota: O risco potencial associado à funcionalidade de Chamada de Função é que ela pode levar o modelo a produzir parâmetros errôneos (ou seja, parâmetros fantasmas). Portanto, antes de tomar qualquer ação que impacte o mundo real (como enviar e-mails, publicar online, fazer compras, etc.), é aconselhável incorporar um processo de confirmação do usuário ao nível do produto, garantindo que as funções sejam executadas somente após a confirmação do usuário.
4. Exemplos de Chamada de Função
4.1 Exemplo em Python
Implementar a Chamada de Função na plataforma OpenAI geralmente segue os passos básicos descritos abaixo. O seguinte detalhará o processo inteiro usando um exemplo de código Python, focando na consulta do clima.
Passo 1: Preparar funções chamáveis e definições de função para o modelo
Primeiramente, precisamos definir uma função que possa ser chamada pelo modelo GPT. Isso geralmente significa preparar nossa própria função que pode realizar determinadas operações com base nos parâmetros de entrada, como comunicar-se com uma API de terceiros.
import json
def get_current_weather(localizacao, unidade="fahrenheit"):
return json.dumps({
"localizacao": localizacao,
"temperatura": "18",
"unidade": unidade
})
Passo 2: Chamar o modelo com base no parâmetro de consulta e ferramentas
A seguir, precisamos chamar o modelo GPT através da API de conclusão de bate-papo e passar a consulta do usuário (por exemplo, "Qual é o clima atual") bem como o parâmetro tools, que inclui a descrição da função get_current_weather que acabamos de definir.
from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obter o clima atual para uma determinada localização",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "Nome da cidade, por exemplo: 'São Francisco, CA'"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
}
}
}]
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Qual é o clima atual em São Francisco?"}],
tools=tools
)
Passo 3: Executar a função localmente
O resultado retornado pelo modelo incluirá informações sobre a função que o modelo deseja chamar, normalmente contidas no parâmetro de resposta tool_calls. Podemos então executar a chamada de função correspondente localmente com base nas informações de chamada de função descritas no parâmetro tool_calls.
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
arguments = json.loads(tool_calls[0].function.arguments)
info_clima = get_current_weather(**arguments)
print(info_clima) # Aqui podemos ver as informações climáticas consultadas pela chamada da função
Passo 4: Chamar o modelo novamente com o resultado da função de retorno
Agora, podemos enviar o resultado de retorno da função como uma nova mensagem para o modelo, para que o modelo possa processar esses resultados e gerar uma resposta sob medida para o usuário.
follow_up_response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": "Qual é o clima atual em São Francisco?"},
{"role": "function", "name": "get_current_weather", "content": info_clima}
],
tools=tools
)
Explicação: No exemplo acima, o conteúdo de retorno da função é enviado para o modelo GPT através da mensagem da função da seguinte forma:
{"role": "function", "name": "get_current_weather", "content": info_clima}
Na prática, você também pode simplesmente colocar o conteúdo de retorno da função como conteúdo de referência na mensagem do sistema para que a AI se refira ao responder às perguntas.
Passo 5: Obter a resposta final do modelo
Finalmente, podemos recuperar a resposta final do modelo e fornecê-la ao usuário. Nesta etapa, o modelo produzirá uma resposta amigável com base nas informações climáticas que fornecemos.
saida_final = follow_up_response.choices[0].message.content
print(saida_final) # Esta saída é a informação climática que queremos mostrar ao usuário
Seguindo os passos acima, completamos um exemplo completo de consulta do clima usando o modelo GPT e chamadas de função.
4.2. Explicação da definição da função de chamada da função
4.2.1 Significado dos Campos do Parâmetro 'Tools'
Ao fazer uma chamada de função, é necessário definir as informações relevantes da função no parâmetro tools. O parâmetro tools é um array contendo várias definições de função, e cada definição de função inclui os seguintes campos:
-
type: Este campo representa o tipo da ferramenta. Em uma chamada de função, este campo deve ser definido como"function". -
function: Este campo contém informações detalhadas sobre a função e é um objeto com os seguintes campos específicos:-
name: O nome da função, que é uma string. -
description: Uma descrição do propósito da função, que pode ajudar o modelo a gerar parâmetros que atendam às expectativas do usuário. -
parameters: Descreve as definições de parâmetros da função e é um objeto que contém os seguintes subcampos:-
type: Define o tipo do parâmetro, que deve ser principalmente definido como"object". -
properties: As definições específicas de cada parâmetro da função, onde cada definição de parâmetro é um objeto que normalmente contém os seguintes subcampos:-
type: O tipo de dados do parâmetro (como"string","integer","boolean", etc.). -
description: A descrição do parâmetro para ajudar o modelo a entender seu propósito. -
enum(opcional): Quandotypeé"string", o campoenumpode especificar um array de strings representando o conjunto de valores válidos.
-
-
required: Um array de strings contendo os nomes dos parâmetros obrigatórios.
-
-
4.2.2 Exemplos de Definição de Ferramentas
Agora vamos fornecer alguns exemplos de definições de tools para ajudar a entender como cada campo é usado.
Exemplo 1: Obter Informações Meteorológicas Atuais
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obter informações meteorológicas atuais para a localidade especificada",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "A cidade para a qual o clima precisa ser consultado, por exemplo, 'São Francisco, CA'"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Unidade de temperatura, 'celsius' para Celsius, 'fahrenheit' para Fahrenheit"
}
},
"required": ["location", "unit"]
}
}
}
No exemplo acima, definimos uma função chamada get_current_weather para obter o clima atual de uma localidade especificada. Os parâmetros incluem location e unit, onde unit possui dois valores válidos: "celsius" (Celsius) e "fahrenheit" (Fahrenheit).
Exemplo 2: Encontrar Álbuns de um Artista Específico
{
"type": "function",
"function": {
"name": "find_artist_albums",
"description": "Encontrar todos os álbuns de um artista específico",
"parameters": {
"type": "object",
"properties": {
"artist_name": {
"type": "string",
"description": "O nome do artista"
}
},
"required": ["artist_name"]
}
}
}
Neste exemplo, criamos uma função chamada find_artist_albums para encontrar todos os álbuns de um artista específico. Esta função requer apenas um parâmetro: artist_name (o nome do artista).
4.3. Exemplo de Chamada de Função de Requisição HTTP
A OpenAI fornece uma API acessível por meio do protocolo HTTP. Abaixo, explicaremos como utilizar a funcionalidade de chamada de função por meio da API HTTP. Desenvolvedores de outras linguagens de programação podem se referir a este exemplo.
4.3.1. Passo 1: Chamar o Modelo com a Consulta do Usuário e Declaração da Função
Primeiro, precisamos enviar a consulta do usuário e a lista de funções que suportamos para o modelo GPT, para que o modelo possa analisar automaticamente qual função chamar para responder à consulta do usuário com base na pergunta do usuário.
No exemplo a seguir, informamos ao GPT que temos uma função get_current_weather que pode ser usada para consultar informações sobre o clima de uma cidade específica.
curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {OPENAI_KEY}' \
--data '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Como está o clima em Shanghai hoje?"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obter informações meteorológicas atuais para a localização especificada",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "A cidade para a qual o clima precisa ser consultado, por exemplo 'São Paulo, SP'"
},
"unit": {
"type": "string",
"enum": [
"celsius",
"fahrenheit"
],
"description": "Unidade de temperatura, 'celsius' para Celsius, 'fahrenheit' para Fahrenheit"
}
},
"required": [
"location",
"unit"
]
}
}
}
]
}'
Explicação dos parâmetros da solicitação:
{
"model": "gpt-3.5-turbo", // O modelo GPT a ser chamado
"messages": [ // Esta é a lista de mensagens para o GPT, incluindo a consulta do usuário
{
"role": "user",
"content": "Como está o clima em Shanghai hoje?"
}
],
"tools": [
// Esta é a definição da sua função, informando ao GPT as funções disponíveis
]
}
Consulte a seção 4.2.2 para a definição do parâmetro tools.
Durante o processamento normal pelo modelo GPT, você receberá uma resposta da API semelhante ao seguinte:
{
"model": "gpt-3.5-turbo-0613",
"object": "chat.completion",
"usage": {
"prompt_tokens": 122,
"completion_tokens": 27,
"total_tokens": 149
},
"id": "chatcmpl-8mL4hS4zNMocyR2ajKyAvSTcbNaao",
"created": 1706531447,
"choices": [
{
"index": 0,
"delta": null,
"message": {
"role": "assistant",
"tool_calls": [ // O parâmetro tool_calls representa a lista de funções que o GPT deseja chamar
{
"id": "call_1iF09ttX1R9ESR18Ul2nLe1R",
"type": "function",
"function": {
"name": "get_current_weather", // Indica que o GPT deseja responder à consulta do usuário chamando a função get_current_weather
"arguments": "{\n \"location\": \"Shanghai, China\",\n \"unit\": \"celsius\"\n}" // Estes são os parâmetros de entrada para chamar a função get_current_weather
}
}
]
},
"finish_reason": "tool_calls"
}
]
}
4.3.2. Passo 2: Execução Local da Chamada da Função
Uma vez que o modelo GPT em si não pode executar chamadas de função específicas e apenas nos informa qual função deseja chamar, nosso programa local precisa executar a chamada específica da função com base no parâmetro tool_calls retornado pelo modelo. A forma de executar funções locais varia em diferentes linguagens de programação. Por exemplo, em Python, você pode se referir à seção anterior.
4.3.3. Passo 3: Chamar Novamente o Modelo com o Resultado do Retorno da Função
Porque a chamada da função é executada localmente, precisamos passar o resultado da execução da função e a pergunta do usuário de volta para o modelo GPT para obter a resposta final.
curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer sk-Roc5MX1zEuVxiuaMaETV6wZ2jXcCehjUCzwP9AcNErUiwppQ' \
--data '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Como está o tempo em Shanghai hoje?"
},
{
"role": "function",
"name": "get_current_weather",
"content": "{\"city\":\"Shanghai\", \"temperature\":\"25 graus Celsius\"}"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obter informações meteorológicas atuais para a localização especificada",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "A cidade para a qual consultar o clima, ex.: 'São Paulo, SP'"
},
"unit": {
"type": "string",
"enum": [
"celsius",
"fahrenheit"
],
"description": "A unidade de temperatura, sendo 'celsius' para Celsius e 'fahrenheit' para Fahrenheit"
}
},
"required": [
"location",
"unit"
]
}
}
}
]
}'
Observação: A solicitação acima inclui uma mensagem adicional de função para informar o modelo GPT sobre o valor de retorno da função. O GPT responderá diretamente à pergunta do usuário com base nas informações de retorno da função e não chamará a função novamente.
A mensagem de função representa o valor de retorno da função e segue o formato abaixo:
{
"role": "function", // Tipo de mensagem é função, indicando o valor de retorno da função
"name": "get_current_weather", // Informa ao GPT que a mensagem atual é o valor de retorno da função get_current_weather
"content": "{\"city\":\"Shanghai\", \"temperature\":\"25 graus Celsius\"}" // Conteúdo de retorno da função, pode estar no formato JSON ou outro conteúdo de texto.
}
Aqui está a resposta final gerada pelo GPT:
{
"model": "gpt-3.5-turbo-0613",
"object": "chat.completion",
"usage": {
"prompt_tokens": 144,
"completion_tokens": 17,
"total_tokens": 161
},
"id": "chatcmpl-8mLmvvKAjSql7rGF8fvQeddKhWYvr",
"created": 1706534189,
"choices": [
{
"index": 0,
"delta": null,
"message": {
"role": "assistant",
"content": "O tempo em Shanghai hoje está 25 graus Celsius."
},
"finish_reason": "stop"
}
]
}