Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Ajuste fino para chamada de funções

Aula 9 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Por que fazer ajuste fino para chamada de funções
  2. Formato de dados para chamada de funções
  3. Casos de uso comuns
  4. Script de preparação de dados
  5. Lançamento da tarefa de ajuste fino
  6. Boas práticas
  7. Pontos-chave

Atualização de 2 de novembro de 2026 — Disponibilidade do ajuste fino. O serviço de ajuste fino self-service da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca o utilizaram já não podem criar tarefas; desde 2 de julho, é necessário ter utilizado um modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novas tarefas. Os modelos já treinados permanecem utilizáveis até que o seu modelo base seja desativado. Este curso mantém a sua utilidade para compreender e aproveitar um modelo existente; para novos projetos, priorize a engenharia de prompts, a RAG e as avaliações.

Por que fazer ajuste fino para chamada de funções

A chamada de funções permite ao modelo decidir quando e como invocar funções externas. Neste contexto, o ajuste fino não serve para afinar o estilo de escrita: serve para robustecer um mecanismo de tomada de decisões. Um modelo treinado com as suas próprias chamadas aprende primeiro a selecionar a função correta entre várias opções disponíveis. Se a sua aplicação expõe tanto a consulta de horários como a criação de marcações, a frase “gostaria de ver o que está livre na quinta-feira” nunca deve acionar uma reserva.

Em seguida, o modelo aprende a extrair os parâmetros corretos do pedido do utilizador, ou seja, a converter formulações naturais em valores que respeitem o esquema: “amanhã às 14h” torna-se uma data e hora normalizadas. O mesmo mecanismo ensina reflexos menos vistosos, mas igualmente críticos. Saber quando NÃO chamar uma função evita a armadilha de um modelo que aciona uma ferramenta perante um simples “olá”. E encadear várias chamadas de função de forma lógica — listar disponibilidades e, depois, reservar o horário escolhido — exige que o modelo tenha visto sequências completas durante o treino, e não chamadas isoladas.

Formato de dados para chamada de funções

Os exemplos de treino incluem as definições das funções (ferramentas) e as chamadas correspondentes. A mensagem do assistente deixa de conter texto para passar a incluir um array tool_calls; o resultado devolvido pelo seu sistema surge numa mensagem com a função tool, ligada à chamada através do tool_call_id; o assistente fala novamente para formular a resposta destinada ao utilizador. É todo este ciclo, e não apenas a chamada, que o modelo deve aprender a reproduzir.

{
  "messages": [
    {
      "role": "system",
      "content": "You are an assistant that helps manage appointments."
    },
    {
      "role": "user",
      "content": "Book me a slot tomorrow at 2 PM with Dr. Martin."
    },
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_001",
          "type": "function",
          "function": {
            "name": "create_appointment",
            "arguments": "{\"date\": \"2026-04-03\", \"time\": \"14:00\", \"practitioner\": \"Dr. Martin\"}"
          }
        }
      ]
    },
    {
      "role": "tool",
      "tool_call_id": "call_001",
      "content": "{\"status\": \"confirmed\", \"id\": \"appt_42\"}"
    },
    {
      "role": "assistant",
      "content": "Your appointment with Dr. Martin is confirmed for tomorrow at 2 PM. Reference: APPT-42."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "create_appointment",
        "description": "Creates a new medical appointment",
        "parameters": {
          "type": "object",
          "properties": {
            "date": {
              "type": "string",
              "description": "Date in YYYY-MM-DD format"
            },
            "time": {
              "type": "string",
              "description": "Time in HH:MM format"
            },
            "practitioner": {
              "type": "string",
              "description": "Name of the practitioner"
            }
          },
          "required": ["date", "time", "practitioner"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "list_slots",
        "description": "Lists available slots for a practitioner",
        "parameters": {
          "type": "object",
          "properties": {
            "practitioner": {"type": "string"},
            "date": {"type": "string"}
          },
          "required": ["practitioner"]
        }
      }
    }
  ]
}

Casos de uso comuns

Selecionar a função correta

Treine o modelo para distinguir qual a função a chamar consoante o contexto. No exemplo abaixo, o pedido refere-se à verificação de disponibilidades, e não à realização de uma reserva: o exemplo reforça que uma pergunta aberta deve acionar list_slots, e nada mais.

{
  "messages": [
    {"role": "user", "content": "What slots are free on Thursday with Dr. Martin?"},
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_002",
          "type": "function",
          "function": {
            "name": "list_slots",
            "arguments": "{\"practitioner\": \"Dr. Martin\", \"date\": \"2026-04-04\"}"
          }
        }
      ]
    }
  ],
  "tools": ["... same tools as above ..."]
}

NÃO chamar uma função

Reserve parte do seu conjunto de dados para trocas em que o modelo não deve utilizar nenhuma função. Um modelo treinado exclusivamente com chamadas adquire o hábito de produzir uma a cada passo, mesmo para uma saudação ou uma pergunta geral — um comportamento que irrita os utilizadores e onera o seu backend. O contraexemplo abaixo ocupa apenas algumas linhas e elimina toda uma classe de erros.

{
  "messages": [
    {"role": "user", "content": "Hello, how are you?"},
    {
      "role": "assistant",
      "content": "Hello! I'm doing well, thanks. How can I help you with your appointments today?"
    }
  ],
  "tools": ["... same tools ..."]
}

Extrair parâmetros complexos

Os pedidos reais raramente são estruturados. “Na próxima segunda-feira de manhã” e “o cardiologista” devem transformar-se numa data absoluta, num período de tempo e numa especialidade. É precisamente aqui que o modelo base mais falha, pelo que é onde o ajuste fino oferece o ganho mais visível: multiplique este tipo de exemplos em vez de casos que já estejam limpos.

{
  "messages": [
    {"role": "user", "content": "Cancel my appointment next Monday morning with the cardiologist"},
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_003",
          "type": "function",
          "function": {
            "name": "cancel_appointment",
            "arguments": "{\"date\": \"2026-04-06\", \"period\": \"morning\", \"specialty\": \"cardiology\"}"
          }
        }
      ]
    }
  ],
  "tools": ["..."]
}

Script de preparação de dados

A construção do ficheiro permanece mecânica: uma função de montagem, uma definição de ferramenta partilhada por todos os exemplos, uma lista de casos e, depois, a escrita linha a linha no formato JSONL. Note o uso de json.dumps para o campo arguments, que deve ser uma string e não um objeto.

import json

def create_function_calling_example(
    messages: list[dict],
    tools: list[dict]
) -> dict:
    """Creates a training example for function calling."""
    return {
        "messages": messages,
        "tools": tools
    }

# Tool definitions
tools = [
    {
      "type": "function",
      "function": {
        "name": "search_product",
        "description": "Searches for a product in the catalog",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {"type": "string", "description": "Search terms"},
            "category": {"type": "string", "enum": ["electronics", "clothing", "home"]},
            "max_price": {"type": "number", "description": "Maximum price in euros"}
          },
          "required": ["query"]
        }
      }
    }
]

# Training examples
examples = [
    create_function_calling_example(
        messages=[
            {"role": "user", "content": "I'm looking for headphones under 100 euros"},
            {
                "role": "assistant",
                "tool_calls": [{
                    "id": "call_1",
                    "type": "function",
                    "function": {
                        "name": "search_product",
                        "arguments": json.dumps({
                            "query": "headphones",
                            "category": "electronics",
                            "max_price": 100
                        })
                    }
                }]
            }
        ],
        tools=tools
    )
]

# Save
with open("function_calling_train.jsonl", "w", encoding="utf-8") as f:
    for ex in examples:
        f.write(json.dumps(ex, ensure_ascii=False) + "\n")

Lançamento da tarefa de ajuste fino

A tarefa é criada exatamente como para o ajuste fino conversacional: o formato enriquecido é reconhecido a partir do conteúdo do ficheiro, sem parâmetros adicionais.

from openai import OpenAI

client = OpenAI()

file = client.files.create(
    file=open("function_calling_train.jsonl", "rb"),
    purpose="fine-tune"
)

job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-5.6-luna",
    suffix="function-calling-v1"
)

Boas práticas

O resultado depende, em primeiro lugar, da diversidade do seu conjunto de dados. Cada função deve aparecer várias vezes, as formulações dos utilizadores devem variar para a mesma intenção e beneficia de incluir casos ambíguos acompanhados da resolução que considera correta, sem esquecer as conversas normais que não acionam nenhuma função.

Em seguida, vem o realismo dos parâmetros. Os arguments devem corresponder exatamente ao esquema definido em tools, com valores plausíveis em vez de marcadores como “xxx” — um modelo treinado com valores falsos irá produzi-los. Teste sistematicamente se cada campo arguments é um JSON válido: falta de uma chave ou de uma aspa basta para tornar o exemplo inutilizável.

Por fim, coloca-se a questão das proporções. Para um conjunto de dados de 100 exemplos que abrange 3 funções, a distribuição abaixo oferece um equilíbrio saudável entre cobertura funcional e moderação.

Tipo de exemploQuantidade
Por função25-30
Sem chamada de função10-15
Chamadas encadeadas (várias etapas)5-10

Pontos-chave

  • O formato inclui tools para além de messages
  • As chamadas de função utilizam tool_calls na mensagem do assistente
  • Inclua exemplos em que o modelo NÃO deve chamar uma função
  • Varie as formulações para a mesma intenção
  • Verifique se todos os arguments são JSON válidos e conformes ao esquema