Como Criar Dados para o Ajuste Fino de LLMs

A afinação de um grande modelo de linguagem (LLM) é tão boa quanto os dados com que é treinado. Conjuntos de dados de alta qualidade e bem estruturados determinam diretamente o quão bem o modelo segue instruções, responde a perguntas e se comporta em produção.

Este guia percorre a preparação de dados de ponta a ponta para o fine-tuning de LLM, desde o texto bruto até um conjunto de dados pronto para produção.

Principais Conclusões

• Dados de alta qualidade são mais importantes do que grandes quantidades ao ajustar LLMs. Conjuntos de dados limpos, bem estruturados e alinhados à tarefa superam consistentemente os dados ruidosos e excessivamente grandes.
• Comece com um objetivo claramente definido antes de recolher dados. Saber se está a ajustar para seguir instruções, especialização em determinado domínio ou comportamento conversacional orienta todas as decisões relativas aos dados.
• Pares de instrução-resposta são a base para um ajuste fino eficaz. Prompts bem elaborados com respostas precisas e concisas ajudam os modelos a aprender comportamentos desejados mais rapidamente.
• A formatação adequada dos dados é fundamental. Alinhar o seu conjunto de dados com o formato de destino (JSON, JSONL ou formato de chat) evita falhas no treino e melhora a eficiência da aprendizagem.
• A avaliação e iteração contínuas são necessárias. O ajuste fino é um processo iterativo: monitorizar os resultados, refinar os dados e treinar novamente para alcançar um desempenho ótimo.

Compreender os Requisitos de Dados para o Ajuste Fino de LLM

Os dados de ajustamento fino não são texto cru recolhido da internet. Ao contrário do pré-treinamento, onde os modelos aprendem padrões da língua a partir de um corpus massivo, o ajustamento fino ensina ao modelo como deve comportar-se. O objetivo é moldar as respostas para que o modelo siga instruções, responda a perguntas de forma precisa e adote uma persona consistente.

Na prática, isto significa transformar o conhecimento em exemplos estruturados que associam uma intenção do utilizador a uma resposta ideal. Cada ponto de dados mostra explicitamente ao modelo como é uma boa resposta para um determinado prompt. Com o tempo, o modelo internaliza estes padrões e começa a generalizá-los para entradas não vistas.

A maioria dos pipelines modernos de fine-tuning baseia-se em dados de estilo instrução ou de estilo chat. Conjuntos de dados de estilo instrução consistem numa instrução, uma entrada opcional e uma saída. Conjuntos de dados de estilo chat utilizam mensagens baseadas em funções, como sistema, utilizador e assistente. Ambas as abordagens têm o mesmo objetivo; a escolha depende normalmente do modelo alvo e do framework de treino.

Formatos de Dados para Ajuste Fino de LLM

Antes de criar ou exportar um conjunto de dados, é crucial compreender os diferentes formatos de dados utilizados para o ajuste fino de LLM. O formato que escolhemos afeta diretamente a forma como o modelo interpreta instruções, aprende o fluxo de conversação e se generaliza para o uso no mundo real. Embora a maioria das frameworks de treino modernas suporte múltiplos formatos, cada formato tem um propósito ligeiramente diferente e é adequado para diferentes objetivos de ajuste fino.

Aqui estão alguns dos formatos de dados mais usados para o ajuste fino de modelos.

Formato de Estilo de Conclusão

Os conjuntos de dados do tipo conclusão são a forma mais simples e tradicional de dados para fine-tuning. Neste formato, o modelo é apresentado com um prompt e treinado para prever a continuação. Este formato era frequentemente usado nos primeiros fine-tunings ao estilo GPT e ainda é suportado por muitas APIs.

Um exemplo de estilo de conclusão normalmente é assim:

{
"prompt": "What is a Linux-Console.net GPU Droplet?
Answer:",
"completion": " A GPU Droplet is a virtual machine on Linux-Console.net that includes NVIDIA GPUs for AI, machine learning, and high-performance computing workloads."
}

Neste formato, o modelo aprende a continuar a gerar texto após o prompt. Embora esta abordagem seja simples, tem limitações. Como a estrutura é implícita, o modelo pode ter dificuldades com instruções complexas ou conversas com múltiplas interações. O fine-tuning no estilo de conclusão é mais adequado para tarefas de âmbito limitado, como respostas curtas, classificação ou geração de texto controlada.

Formato de Estilo Instrução

A afinação fina ao estilo instrução torna o objetivo de aprendizagem explícito ao separar claramente a instrução do resultado esperado. Este formato tornou-se o padrão de facto para a adaptação de LLMs de código aberto porque melhora o comportamento de seguir instruções e reduz a ambiguidade.

Um exemplo no estilo de instrução geralmente contém três campos: uma instrução, uma entrada opcional e uma saída. A instrução descreve a tarefa, a entrada fornece contexto adicional se necessário, e a saída representa a resposta ideal.

{
"instruction": "Explain what a GPU Droplet is in Linux-Console.net",
"input": "",
"output": "A GPU Droplet is a virtual machine provided by Linux-Console.net that comes with NVIDIA GPUs and is designed for AI, machine learning, deep learning, and high-performance computing workloads."
}

Este formato é altamente legível e fácil de depurar. Isto permite misturar diferentes tipos de tarefas, como explicações, resumos e resolução de problemas, dentro do mesmo conjunto de dados. Dados no estilo de instrução são ideais quando o objetivo é ensinar um modelo a seguir comandos de forma consistente e produzir respostas consistentes e específicas de um domínio.

Formato de Estilo Chat

Conjuntos de dados em estilo de chat são concebidos para espelhar interações conversacionais reais. Cada exemplo de treino consiste numa sequência de mensagens, onde cada mensagem está associada a um papel, como sistema, utilizador ou assistente. Este formato está estreitamente alinhado com a forma como os LLMs baseados em chat são usados em produção.

Um exemplo em estilo de chat normalmente é assim:

{
"messages": [
{"role": "system", "content": "You are a helpful Linux-Console.net support assistant."},
{"role": "user", "content": "What is a GPU Droplet?"},
{"role": "assistant", "content": "A GPU Droplet is a virtual machine on Linux-Console.net equipped with NVIDIA GPUs, designed for AI, machine learning, and high-performance computing workloads."}
]
}

A mensagem do sistema define o comportamento e o tom do modelo, enquanto as mensagens do utilizador e do assistente ensinam o fluxo da conversação. Este formato é particularmente eficaz para chatbots, agentes de apoio ao cliente e assistentes de múltiplas interações.

No entanto, os conjuntos de dados em estilo de chat são mais verbosos e ligeiramente mais complexos de organizar. São mais adequados quando a aplicação final é conversacional e dependente do contexto.

Antes de decidir sobre o formato apropriado para o treino do modelo, devemos primeiro clarificar a tarefa específica que pretendemos realizar.

Se estivermos a adaptar um modelo para tarefas simples de prompt–resposta, dados no estilo de conclusão podem ser suficientes. Para a maioria dos casos de adaptação de domínio e de seguimento de instruções, conjuntos de dados no estilo de instrução oferecem o melhor equilíbrio entre clareza e flexibilidade. Ao construir agentes conversacionais ou assistentes que precisam de manter o contexto e a personalidade, conjuntos de dados no estilo de conversa são a escolha mais natural. O mais importante é a consistência. Um conjunto de dados bem estruturado e limpo, em qualquer um destes formatos, terá um desempenho melhor do que um maior mas mal concebido.

De onde vêm os dados de ajuste fino

Conjuntos de dados de alta qualidade para afinação fina são quase sempre derivados de fontes autorizadas. Estas incluem documentação de produtos, referências de API, tickets de suporte internos, artigos de centros de ajuda e explicações especializadas selecionadas. Em muitos sistemas do mundo real, as equipas também criam exemplos sintéticos para cobrir casos extremos ou consultas sub-representadas.

Há sempre a necessidade de identificar fontes confiáveis que reflitam o conhecimento e o comportamento que queremos que o modelo aprenda. Para o ajuste fino específico de domínio, isso frequentemente inclui documentação oficial, bases de conhecimento internas, bilhetes de apoio, perguntas frequentes e guias escritos por especialistas. Quanto mais próximos os dados estiverem das perguntas reais dos utilizadores e de respostas autorizadas, mais eficaz será o modelo ajustado. Por vezes, pode também haver a necessidade de realizar web scraping ético para gerar dados confiáveis para certos chatbots específicos de domínio.

Na prática, muitas equipas baseiam-se numa combinação de dados proprietários e conjuntos de dados abertos. Plataformas como a Hugging Face desempenham um papel central neste processo. A Hugging Face hospeda milhares de conjuntos de dados disponíveis publicamente, que abrangem ajuste de instruções, resposta a perguntas, sumarização e tarefas de conversação. Estes conjuntos de dados podem ser usados diretamente, adaptados a um novo domínio ou servir como modelos para criar dados personalizados. Os Conjuntos de Dados da Hugging Face também fornecem utilitários padronizados de carregamento, versionamento e streaming, que tornam a aquisição e pré-processamento de dados em grande escala significativamente mais fáceis.

Dados Gerados por LLM e Criação de Conjuntos de Dados Sintéticos

Uma das práticas modernas na afinação de LLM é gerar dados de treino usando um modelo de linguagem grande existente. Esta abordagem, frequentemente referida como geração de dados sintéticos ou dados gerados por LLM, tornou-se cada vez mais popular porque reduz significativamente o tempo e o custo necessários para construir conjuntos de dados de alta qualidade.

Neste fluxo de trabalho, um modelo base robusto é incentivado a gerar pares de instrução–resposta, exemplos de pergunta–resposta ou conversas de múltiplas interações com base num esquema pré-definido. Os resultados gerados são depois revistos, filtrados e refinados antes de serem adicionados ao conjunto de dados para fine-tuning. Quando realizado com cuidado, esta técnica pode produzir dados que refletem de perto as interações reais dos utilizadores.

Os dados gerados por LLM são particularmente úteis quando os exemplos escritos por humanos são escassos, ao cobrir casos extremos ou ao expandir um conjunto de dados existente para melhorar a cobertura e a diversidade. Por exemplo, uma vez que definamos um pequeno conjunto de factos confiáveis do Linux-Console.net, um LLM pode gerar dezenas de perguntas semanticamente variadas e respostas de alta qualidade, mantendo a consistência com o conhecimento original.

No entanto, os dados sintéticos devem ser usados com cautela. Os modelos tendem a reforçar os seus próprios preconceitos e padrões de fraseado, o que pode levar a overfitting ou à redução da diversidade linguística se o conjunto de dados for totalmente sintético. Por esta razão, os dados gerados por LLM funcionam melhor quando combinados com dados humanos curados ou de fontes autorizadas. A revisão humana, verificações de validação automáticas e a deduplicação são passos essenciais neste processo.

Nos fluxos de produção, as equipas seguem frequentemente uma abordagem híbrida. Os dados escritos por humanos estabelecem a correção e o tom, enquanto os dados gerados por LLMs aumentam a dimensão do conjunto de dados e preenchem lacunas. Este equilíbrio permite às equipas obter bons resultados de ajuste fino sem sacrificar a precisão ou a fiabilidade.

Preparar Conjuntos de Dados Hugging Face para Ajuste Fino de LLM

A Hugging Face possui agora um vasto número de conjuntos de dados open-source que podem ser usados para criar dados de fine-tuning de alta qualidade. Muitos destes conjuntos de dados já contêm pares de instrução–resposta, mas ainda precisam ser formatados numa estrutura de prompt consistente antes do treino.

Exemplo_1:

from datasets import load_dataset
from itertools import islice

# Load Dolly dataset (non-streaming; small enough)
dataset = load_dataset("databricks/databricks-dolly-15k", split="train")

# Take first 1000 samples
samples = list(islice(dataset, 1000))

print("Dolly sample structure:")
print(samples[0])

# Format for instruction fine-tuning
def format_dolly(example):
   instruction = example["instruction"]
   context = example.get("context", "")
   response = example["response"]

   prompt_parts = [
       f"### Instruction:\n{instruction}"
   ]

   if context.strip():
       prompt_parts.append(f"### Input:\n{context}")

   prompt_parts.append(f"### Response:\n{response}")

   return {"text": "\n".join(prompt_parts)}

# Apply formatting
formatted_samples = [format_dolly(sample) for sample in samples]

Dolly sample structure:
{'instruction': 'When did Virgin Australia start operating?', 'context': "Virgin Australia, the trading name of Virgin Australia Airlines Pty Ltd, is an Australian-based airline. It is the largest airline by fleet size to use the Virgin brand. It commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route. It suddenly found itself as a major airline in Australia's domestic market after the collapse of Ansett Australia in September 2001. The airline has since grown to directly serve 32 cities in Australia, from hubs in Brisbane, Melbourne and Sydney.", 'response': 'Virgin Australia commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route.', 'category': 'closed_qa'}

Exemplo_2:

from datasets import load_dataset
from itertools import islice

dataset = load_dataset(
   "Open-Orca/OpenOrca",
   split="train",
   streaming=True
)

samples = list(islice(dataset, 1000))

def format_openorca(example):
   system = example.get("system_prompt", "You are a helpful assistant.")
   question = example["question"]
   answer = example["response"]

   text = (
       f"### System:\n{system}\n"
       f"### Instruction:\n{question}\n"
       f"### Response:\n{answer}"
   )

   return {"text": text}

formatted_samples = [format_openorca(s) for s in samples]

{   'text': '### System:\n'
            '\n'
            '### Instruction:\n'
            'You will be given a definition of a task first, then some input '
            'of the task.\n'
            'This task is about using the specified sentence and converting '
            'the sentence to Resource Description Framework (RDF) triplets of '
            'the form (subject, predicate object). The RDF triplets generated '
            'must be such that the triplets accurately capture the structure '
            'and semantics of the input sentence. The input is a sentence and '
            'the output is a list of triplets of the form [subject, predicate, '
            'object] that capture the relationships present in the sentence. '
            'When a sentence has more than 1 RDF triplet possible, the output '
            'must contain all of them.\n'
            '\n'
            "AFC Ajax (amateurs)'s ground is Sportpark De Toekomst where Ajax "
            'Youth Academy also play.\n'
            'Output:\n'
            '### Response:\n'
            '[\n'
            '  ["AFC Ajax (amateurs)", "has ground", "Sportpark De '
            'Toekomst"],\n'
            '  ["Ajax Youth Academy", "plays at", "Sportpark De Toekomst"]\n'
            ']'}

• Garante uma estrutura de prompt consistente em todas as amostras,
• Lida de forma limpa com entradas opcionais,
• Produz um único campo "text" que funciona de forma perfeita com tokenizadores,
• Compatível com LoRA, QLoRA e com pipelines de ajuste fino completo.

Uma vez formatado, este conjunto de dados pode ser diretamente tokenizado e passado para um ciclo de treino usando Hugging Face Trainer, SFTTrainer ou código PyTorch personalizado. Dica:
Verifique sempre algumas amostras formatadas antes do treino. Pequenas inconsistências na formatação podem impactar significativamente o comportamento do modelo durante o fine-tuning.

Criando Dados para o Ajuste Fino de LLMs Específicos de Domínio

Afinar um grande modelo de linguagem para um domínio específico, como saúde, jurídico, financeiro ou educativo, requer a recolha de dados brutos.

Esta secção descreve uma abordagem estruturada para criar dados de afinação fina de alta qualidade e específicos de domínio. Definir o Âmbito do Domínio e as Tarefas-Alvo: Comece por definir claramente o que o modelo deve aprender e como será utilizado. A afinação fina específica de domínio é mais eficaz quando o âmbito é limitado e orientado a tarefas.

Perguntas chave a responder:

• Em que domínio de conhecimento é que o modelo deve especializar-se?
• Que tarefas os utilizadores irão realizar utilizando o modelo?
• Que nível de especialização devem refletir as respostas?

Exemplos:

• Saúde: resumo de notas clínicas, explicação de conceitos médicos
• Finanças: interpretação de métricas financeiras, análise de lucros
• DevOps: análise de logs, resolução de incidentes

Um escopo bem definido evita que dados ruidosos ou irrelevantes diminuam o desempenho do modelo. Recolher Dados de Domínio de Alta Qualidade: Os conjuntos de dados específicos de domínio devem ser obtidos a partir de materiais fiáveis e autorizados.

As fontes de dados comuns incluem:

• Documentação interna e bases de conhecimento
• Whitepapers da indústria e publicações de investigação
• Manuais técnicos e documentação de produtos
• Tickets de suporte, perguntas frequentes e interações com clientes
• Transcrições ou notas de especialistas na matéria

Assegure-se de que toda a recolha de dados cumpra os requisitos de privacidade, segurança e licenciamento.

Transformar Conteúdo Bruto em Pares de Instrução–Resposta: O texto bruto do domínio deve ser convertido em exemplos de aprendizagem supervisionada que ensinem o modelo a responder a consultas específicas do domínio.

Cada amostra deve representar uma tarefa realista que se espera que o modelo execute.

Exemplo (Finanças):

• Instrução: Explique o EBITDA e o seu papel na avaliação de uma empresa.
• Resposta: O EBITDA representa os lucros antes de juros, impostos, depreciação e amortização, e é comumente usado para avaliar o desempenho operacional de uma empresa.

Esta transformação pode ser feita manualmente, semi-automaticamente com a ajuda de LLM, ou totalmente de forma programática com validação. Use uma Estrutura de Prompt Consistente: A consistência na formatação é crucial para um ajuste fino estável. Um modelo de prompt padronizado ajuda o modelo a aprender os limites da tarefa e as expectativas de resposta.

Formato de ajuste de instruções recomendado:

### Instruction:
<Task description>

### Input:
<Optional domain context>

### Response:
<Expected output>

Esta estrutura é amplamente compatível com pipelines de ajuste fino ao estilo Alpaca, estilo Dolly e baseados em LLaMA.

Formatar Dados de Domínio Programaticamente: Uma vez que os pares de instrução–resposta estejam definidos, eles podem ser convertidos em amostras de texto prontas para treino.

def format_domain_example(example):
    instruction = example["instruction"]
    context = example.get("context", "")
    response = example["response"]

    sections = [f"### Instruction:\n{instruction}"]

    if context.strip():
        sections.append(f"### Input:\n{context}")

    sections.append(f"### Response:\n{response}")

    return {"text": "\n".join(sections)}

O campo de “texto” resultante pode ser diretamente tokenizado e passado para fluxos de trabalho de ajuste fino supervisionado. Valide a Qualidade dos Dados Antes do Ajuste Fino: Antes de iniciar o treino, reveja manualmente um subconjunto de exemplos para garantir que os dados são factualmente corretos, que as instruções são corretas e inequívocas, e que as respostas são de qualidade.

Dados de má qualidade, mesmo em pequenas quantidades, podem afetar significativamente o comportamento de um modelo após o ajustamento fino. Para mais informações sobre este tema, sinta-se à vontade para consultar o blog detalhado sobre Envenenamento de LLM.

Escolher uma Estratégia de Ajuste Fino Apropriada: Para a maioria dos casos de uso específicos de domínio:

• LoRA/QLoRA oferecem uma adaptação rápida e económica
• O ajuste fino completo oferece o máximo desempenho a um custo mais elevado

A maioria das equipas alcança resultados sólidos usando o ajuste fino supervisionado baseado em LoRA com dados bem selecionados. Já criámos um tutorial passo a passo mostrando como usar o LoRA para o ajuste fino de modelos com um conjunto de dados personalizado. Sinta-se à vontade para consultar a secção de recursos para mais informações.

Gerar Dados de Afinamento Específicos de Domínio através de Web Scraping

A extração de dados da web é uma forma prática de recolher conteúdo específico de determinado domínio a partir de documentação pública, blogs ou bases de conhecimento. Uma vez recolhido, este texto bruto pode ser transformado em pares de instrução–resposta para ajuste fino supervisionado.

Aviso: Certifique-se sempre de que o site permite scraping e que este é feito de forma ética.

Passo 1: Instalar Bibliotecas Necessárias

Use o pip para instalar as bibliotecas necessárias.

pip install requests beautifulsoup4

Passo 2: Extrair o Conteúdo Usando o Beautiful Soup

Neste exemplo, extraímos cabeçalhos e parágrafos de uma página de documentação técnica.

import requests
from bs4 import BeautifulSoup

def scrape_page(url):
    response = requests.get(url, timeout=10)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, "html.parser")

    title = soup.find("h1")
    paragraphs = soup.find_all("p")

    content = {
        "title": title.get_text(strip=True) if title else "",
        "paragraphs": [
            p.get_text(strip=True)
            for p in paragraphs
            if len(p.get_text(strip=True)) > 100
        ]
    }

    return content

Passo 3: Converter Conteúdos Raspados em Pares de Instrução–Resposta

Após a recolha de dados, convertemos o texto bruto em exemplos de treino adequados para o ajuste de instruções.

def create_instruction_data(scraped_content):
    instruction = (
        f"Explain the following topic in a clear and concise manner: "
        f"{scraped_content['title']}"
    )

    response = " ".join(scraped_content["paragraphs"])

    return {
        "instruction": instruction,
        "response": response
    }

Passo 4: Formatar Dados para o Ajuste Fino do LLM

Finalmente, formate os pares de instrução–resposta num único campo de prompt.

def format_for_finetuning(example):
    text = (
        f"### Instruction:\n{example['instruction']}\n\n"
        f"### Response:\n{example['response']}"
    )
    return {"text": text}

Passo 5: Exemplo Completo

url = "https://linux-console.net/community/tutorials/deploy-coreflux-mqtt-mongodb
"
scraped = scrape_page(url)

instruction_data = create_instruction_data(scraped)
formatted_sample = format_for_finetuning(instruction_data)

print(formatted_sample["text"][:500])

### Instruction:
Explain the following topic in a clear and concise manner: Deploy Coreflux MQTT Broker with MongoDB on Linux-Console.net

### Response:
MQTT brokersare essential for modernIoTinfrastructure andautomationsystems, where the need for a centralized, unified, and fast data hub is the key part for system interoperability and data exchange.Corefluxis a powerful,low codeMQTT broker that expands the traditional MQTT broker to a system that provides advanced features forreal-time dataprocessin

Gerar Dados Sintéticos Usando LLMs (Sem APIs Pagas)

Coletar e anotar manualmente dados específicos de um domínio é frequentemente caro e demorado. Uma alternativa prática é a geração de dados sintéticos usando LLMs, onde um LLM é utilizado para criar pares de instrução–resposta realistas em larga escala. Muitas vezes podemos usar uma chave de API GROQ ou outros serviços pagos para utilizar o LLM na geração de dados sintéticos, mas neste pipeline de dados, vamos demonstrar como gerar dados sintéticos de suporte ao cliente usando um LLM gratuito, a correr localmente da Hugging Face, sem necessidade de chaves de API ou serviços pagos.

Exemplo: Gerador de Dados Sintéticos para Suporte ao Cliente

O exemplo seguinte utiliza a biblioteca transformers da Hugging Face com um modelo open-source leve (flan-t5-base) para gerar pares instrução–resposta para cenários de suporte ao cliente.

Instalar Dependências

pip install transformers torch

Código Python: Gerar Dados Sintéticos Usando um LLM Local

import random
import json
from transformers import pipeline

class FreeSyntheticDataGenerator:
    def __init__(self):
        # Instruction-tuned model
        self.generator = pipeline(
            "text2text-generation",
            model="google/flan-t5-base"
        )

        self.templates = {
            "order_inquiry": [
                "Where is my order #{order_id}?",
                "Can you track order #{order_id}?",
                "What is the status of order #{order_id}?"
            ],
            "return_request": [
                "I want to return my {product}",
                "How do I get a refund for {product}?"
            ],
            "technical_support": [
                "My {device} is not turning on.",
                "I am facing error code {error_code} on {software}"
            ]
        }

        self.variables = {
            "order_id": ["12345", "67890", "ABC999"],
            "product": ["laptop", "phone", "headphones"],
            "device": ["laptop", "router", "tablet"],
            "software": ["Windows", "Android", "website"],
            "error_code": ["404", "E-001"]
        }

    def generate_examples(self, category, count=5):
        dataset = []

        for _ in range(count):
            instruction = random.choice(self.templates[category])

            for var, values in self.variables.items():
                instruction = instruction.replace(
                    f"{{{var}}}", random.choice(values)
                )

            prompt = f"""
You are a professional customer support agent.
Respond clearly and concisely.
Customer query: {instruction}
"""

            response = self.generator(
                prompt,
                max_length=150,
                do_sample=False
            )[0]["generated_text"]

            dataset.append({
                "instruction": instruction,
                "output": response.strip(),
                "category": category
            })

        return dataset


if __name__ == "__main__":
    generator = FreeSyntheticDataGenerator()
    samples = generator.generate_examples("order_inquiry", 3)
    print(json.dumps(samples, indent=2))

Formato de Saída para Ajuste Fino

Cada exemplo gerado segue um formato de ajuste por instruções, tornando-o adequado para ajuste fino supervisionado (SFT):

[
  {
    "instruction": "What is the status of order #12345?",
    "output": "Order #12345 has been placed.",
    "category": "order_inquiry"
  },
  {
    "instruction": "What is the status of order #12345?",
    "output": "Your order is currently being processed and is expected to be delivered within the estimated delivery timeline.",
    "category": "order_inquiry"
  },
  {
    "instruction": "Where is my order #12345?",
    "output": "Where is your order #12345?",
    "category": "order_inquiry"
  }
]

Sinta-se à vontade para explorar outras opções gratuitas também; no entanto, se estiver a utilizar opções de API pagas, pode utilizá-las para gerar dados sintéticos de qualidade (e muito mais). Aqui estão alguns exemplos:

No entanto, as APIs pagas são, por vezes, melhores para a geração de dados sintéticos porque utilizam modelos grandes, ajustados por instruções, que são especificamente treinados para seguir prompts com precisão e produzir respostas estruturadas e de alta qualidade.

Ao contrário dos modelos gratuitos ou básicos, as APIs pagas compreendem a intenção, as instruções de função e os requisitos de formatação, o que resulta em saídas que são coerentes, relevantes e consistentes em milhares de exemplos. Isso reduz significativamente alucinações, repetições e textos fora do tópico, o que significa que os dados gerados necessitam de muito menos limpeza manual antes de poderem ser utilizados para ajuste fino.

Além disso, as APIs pagas lidam automaticamente com escalabilidade, fiabilidade e desempenho, permitindo às equipas gerar rapidamente grandes volumes de dados sintéticos e tornando-as uma escolha mais eficiente e fácil para conjuntos de dados de qualidade de produção.

Porque a Qualidade dos Dados é Mais Importante do que o Volume de Dados

Um dos erros mais comuns no ajuste fino é priorizar o tamanho do conjunto de dados em detrimento da qualidade do conjunto de dados. Grandes volumes de exemplos ruidosos, repetitivos ou ambíguos podem prejudicar activamente o desempenho do modelo. Em contraste, um conjunto de dados menor, com instruções claras e respostas precisas, frequentemente produz resultados muito melhores.

Os dados de afinação de alta qualidade possuem algumas características definidoras. Cada exemplo foca numa única intenção, a resposta é completa mas concisa, o tom é consistente em todo o conjunto de dados, e não existem contradições ou factos inventados. Devem ser evitados exemplos duplicados ou quase duplicados, a menos que a repetição seja intencional para reforço.

Como regra geral, milhares de exemplos cuidadosamente selecionados são geralmente suficientes para adaptação ao domínio e modelagem de comportamento. Só precisamos de dezenas de milhares de amostras quando estamos a procurar uma especialização profunda ou a cobrir uma gama muito ampla de tarefas.

Perguntas Frequentes

Quanta informação é necessária para ajustar um LLM?

A quantidade de dados necessária depende do método de ajuste fino e da tarefa. Para métodos de ajuste fino eficientes em termos de parâmetros, como LoRA ou QLoRA, muitas vezes é possível obter resultados de alta qualidade com apenas 500 a 5.000 pares de instrução–resposta. O ajuste fino completo do modelo normalmente requer conjuntos de dados muito maiores, frequentemente dezenas ou centenas de milhares de exemplos. Na maioria dos casos, a qualidade e a relevância dos dados são mais importantes do que a quantidade.

Posso ajustar um LLM usando apenas dados sintéticos?

Sim, os LLM podem ser ajustados finamente utilizando apenas dados sintéticos, especialmente para tarefas bem definidas, como suporte ao cliente, sumarização ou perguntas e respostas específicas de um domínio. Os dados sintéticos funcionam melhor quando são gerados usando modelos ajustados por instruções e validados através de verificações automáticas e revisão humana. Muitos sistemas de produção usam uma mistura de dados sintéticos e reais, mas dados sintéticos de alta qualidade sozinhos ainda podem proporcionar um desempenho sólido.

Qual é o melhor formato de dados para o fine-tuning de LLM?

O formato mais utilizado e recomendado é JSONL (JSON Lines), onde cada linha representa um exemplo de treino. Para o ajuste por instrução, isto normalmente inclui campos como instruction e output. O JSONL é amplamente suportado pela Hugging Face, PEFT (LoRA/QLoRA) e pela maioria dos pipelines de fine-tuning, tornando-o fácil de transmitir e dimensionar durante o treino.

Quanto tempo leva a preparação dos dados?

O tempo de preparação dos dados varia com base no tamanho e na complexidade do conjunto de dados. Para conjuntos de dados pequenos a médios (1.000–5.000 amostras), a preparação pode levar algumas horas a alguns dias, incluindo limpeza e validação. Conjuntos de dados maiores ou específicos de um domínio podem levar vários dias ou semanas, especialmente se houver validação humana envolvida. Automatizar partes do processo pode reduzir significativamente este tempo.

Com que frequência devem ser atualizados os dados de aperfeiçoamento?

Os dados de ajustamento fino devem ser atualizados sempre que o domínio, o comportamento do utilizador ou os requisitos mudarem. Para produtos ou sistemas de suporte ao cliente que evoluem rapidamente, atualizações a cada poucas semanas ou meses são comuns. Atualizações regulares ajudam o modelo a manter-se preciso, a reduzir a deriva e a adaptar-se a novas terminologias, políticas ou expectativas dos utilizadores.

Conclusão

Preparar dados de alta qualidade é o passo mais importante para o sucesso do fine-tuning de LLM. Embora a escolha do modelo e as técnicas de treino recebam frequentemente mais atenção, é a qualidade, a estrutura e a relevância dos dados que, no final, determinam quão bem um modelo ajustado se desempenha. Um pipeline de dados bem concebido, que abranja aquisição, limpeza, validação, verificação de viés e revisão humana, garante que o modelo aprenda os comportamentos corretos e produza resultados fiáveis e alinhados.

Como este artigo demonstrou, a preparação de dados não precisa depender exclusivamente de conjuntos de dados caros ou difíceis de obter. Dados sintéticos gerados usando LLMs ajustados por instruções, quando combinados com controlos de qualidade adequados, podem ser uma solução eficaz e escalável para muitos casos de uso de fine-tuning. Ao exportar os dados em formatos padronizados e atualizá-los continuamente à medida que os requisitos evoluem, as equipas podem construir fluxos de trabalho de fine-tuning que são ao mesmo tempo eficientes e à prova de futuro. Em última análise, investir tempo na preparação de dados leva a modelos mais estáveis, melhor generalização e desempenho mais robusto no mundo real.

Referências e Recursos

• Gere os Seus Próprios Conjuntos de Dados para Experimentar o Ajuste Fino em Modelos GPT
• Preparação de Dados para Ajustes Finos de Modelos de Linguagem de Grande Escala
• Ajuste Fino de LLMs: Um Guia com Exemplos
• Compreender o Envenenamento de LLM

Obrigado por aprender com a comunidade Linux-Console.net.