---
title: "O que é ajuste fino supervisionado em LLMs?"
slug: supervised-fine-tuning
date: 2025-05-14T07:35:48+00:00
modified: 2025-11-04T08:50:35+00:00
permalink: https://brightdata.com.br/blog/ai/supervised-fine-tuning
type: blog
---

[ Blog ](https://brightdata.com.br/blog "Blog") / [AI](https://brightdata.com.br/blog/ai)







 [AI](https://brightdata.com.br/blog/ai)

# O que é ajuste fino supervisionado em LLMs?

Domine o ajuste fino supervisionado para LLMs com este guia Python que abrange conceitos, ferramentas, fluxo de trabalho e exemplos práticos para aprimorar seus projetos de IA.

 21 min de leitura





 [ ![Federico Trotta](https://media.brightdata.com.br/2024/12/Federico-50x50.jpg) ](https://brightdata.com/blog/authors/federico-trotta)

 [Federico Trotta

Technical Writer

 ](https://brightdata.com/blog/authors/federico-trotta)





 ![](https://media.brightdata.com.br/2025/05/What-is-Supervised-Fine-Tuning-in-LLMs.svg)





Neste guia sobre LLMs de ajuste fino supervisionado, você aprenderá:

- O que é ajuste fino supervisionado no contexto dos LLMs?
- Qual é o objetivo dessa prática?
- Os recursos de que você precisa para implementá-lo
- O fluxo de trabalho para LLMs de ajuste fino supervisionado
- Desafios técnicos e considerações sobre a implementação do SFT
- Um tutorial passo a passo para replicar o ajuste fino supervisionado em um LLM

Vamos mergulhar de cabeça!

## Definição de ajuste fino supervisionado (SFT) no contexto do LLM

[O ajuste fino supervisionado](https://platform.openai.com/docs/guides/supervised-fine-tuning) (SFT) é uma forma de aprendizagem por transferência aplicada aos LLMs. A aprendizagem por transferência é um método de aprendizagem de máquina em que você aplica o conhecimento obtido com a solução de um problema para ajudar a resolver um problema diferente, mas relacionado.

No contexto do LLMS, o ajuste fino supervisionado envolve pegar um modelo pré-treinado e [treiná-lo](/blog/dados-do-site/llm-training-data) ainda mais. Isso é feito ajustando seus parâmetros, usando um conjunto de dados selecionado com exemplos rotulados relevantes para uma tarefa específica.

A natureza “supervisionada” é fundamental no processo porque os engenheiros estão por trás de todo o processo:

- Eles [preparam o conjunto de dados de ajuste fino](/blog/dados-do-site/how-to-create-datasets) com pares explícitos de entrada e saída. Esse conjunto de dados contém as “respostas corretas” que orientam o aprendizado do modelo para solicitações específicas.
- Eles cuidam de todo o processo de ajuste fino, desde a configuração até o monitoramento e a validação.

Em detalhes, em comparação com o RAG[(Retrieval-Augmented Generation](/blog/dados-do-site/rag-explained)), o ajuste fino modifica o próprio modelo. O RAG deixa o modelo intocado e apenas o alimenta com novas informações relevantes. Em vez disso, o ajuste fino envolve um novo processo de treinamento.

## Qual é o objetivo do ajuste fino supervisionado nos LLMs?

O principal objetivo do ajuste fino supervisionado é melhorar o desempenho de um LLM em tarefas específicas além de seus recursos gerais pré-treinados. Isso inclui:

- **Especialização em tarefas**: Torne o modelo proficiente em tarefas como resumo de texto, geração de código para um idioma específico, análise de sentimentos e muito mais.
- **Adaptação do domínio**: Infundir o modelo com conhecimento e terminologia específicos de campos de nicho. Exemplos comuns são a análise de documentos jurídicos, a geração de relatórios médicos e a previsão financeira.
- **Alinhamento de tom**: Treine o modelo para adotar uma voz consistente da marca, um nível de formalidade ou uma personalidade de conversação específica necessária para [aplicativos como chatbots](/blog/dados-do-site/build-a-rag-chatbot).

## O que você precisa para implementar o ajuste fino

A esta altura, você deve estar se perguntando: por que não treinar um LLM para fazer isso desde o início? O motivo é simples. O treinamento de um LLM envolve:

- Uma grande quantidade de dados, geralmente armazenada em vários data centers.
- Muito hardware.
- Investir muito dinheiro e tempo.

Para se ter uma ideia, para treinar modelos como ChatGPT, Gemini e similares, você precisa:

- Vários meses – se não até anos.
- Muitas GPUs, cada uma custando milhares de dólares, distribuídas em vários data centers.

Para o ajuste fino, em vez disso, você só precisa de três coisas:

1. Um modelo pré-treinado.
2. Um computador.
3. Um conjunto de dados pequeno e rotulado.

Agora deve estar mais claro por que o ajuste fino é tão conveniente.

## A mecânica por trás do fluxo de trabalho de ajuste fino supervisionado

A execução de um processo de ajuste fino supervisionado envolve várias etapas técnicas. É hora de detalhar todo o processo!

### Etapa 1: selecionar o conjunto de dados de SFT de alta qualidade

A eficácia do processo é altamente dependente da qualidade e da relevância do conjunto de dados de ajuste fino. Isso envolve:

- **Obtenção de dados**: Obter dados brutos relevantes para a tarefa-alvo usando uma das muitas [técnicas de obtenção de dados](/blog/dados-do-site/data-sourcing). O tamanho pode variar de centenas a dezenas de milhares de linhas. Isso depende da complexidade da tarefa e do modelo pré-treinado.
- **Estruturação de dados**: Transformar os dados brutos em um formato estruturado adequado para o processo SFT. Um dos formatos típicos é o [JSON Lines (JSONL)](https://jsonlines.org/), em que cada linha é um objeto JSON que contém campos distintos para a entrada e a saída desejada.
- **Garantia de qualidade**: Garantir que os dados sejam precisos, consistentes, diversificados e livres de vieses que possam afetar negativamente o comportamento do modelo.

### Etapa 2: Selecione um modelo pré-treinado apropriado

Há vários modelos pré-treinados disponíveis. As principais considerações para escolher o melhor para seu caso incluem:

- **Tamanho do modelo**: É indicado pelo número de parâmetros (por exemplo, 7B, 13B, 70B) e está relacionado à capacidade do modelo de aprender padrões e nuances complexos. Modelos maiores geralmente oferecem maior desempenho, mas exigem mais recursos de hardware para o ajuste fino.
- **Arquitetura**: A arquitetura específica pode ser adequada a determinadas tarefas. Por exemplo ```
    : espaço reservado Polylang não modificar
    ```
- **Recursos básicos**: Avalie o desempenho do modelo pré-treinado em benchmarks acadêmicos relevantes para a tarefa-alvo antes de se comprometer com o ajuste fino. Isso fornece uma linha de base e indica a aptidão do modelo. Por exemplo ```
    : espaço reservado para Polylang não modificar
    ```
- **Licenciamento:** A licença sob a qual um modelo é liberado determina como ele pode ser usado, modificado e distribuído. Alguns modelos têm permissões de código aberto, enquanto outros não.
- **Ajustes existentes**: Às vezes, começar com um modelo já ajustado para uma tarefa relacionada pode ser mais eficiente do que começar com um modelo básico bruto. Essa é uma forma de ajuste fino intermediário.

### Etapa nº 3: Implementar o ciclo de treinamento

O núcleo do processo envolve a iteração do conjunto de dados rotulados e o ajuste dos pesos do modelo da seguinte forma:

- **Passagem direta**: O modelo processa uma entrada (o prompt) do conjunto de dados SFT e gera uma saída.
- **Cálculo de perda**: Uma [função de perda](https://www.datacamp.com/tutorial/loss-function-in-machine-learning) compara o resultado gerado pelo modelo, token por token, com o resultado desejado fornecido no conjunto de dados. Isso é útil para quantificar o erro.
- **Passagem para trás (backpropagation)**: A perda calculada é usada para computar gradientes, indicando o quanto cada peso do modelo contribuiu para o erro.
- **Atualização de pesos**: um algoritmo otimizador usa os gradientes e uma taxa de aprendizado especificada para ajustar os pesos do modelo. O objetivo é minimizar os erros nas iterações subsequentes.
- **Ajuste de hiperparâmetros**: Os parâmetros que controlam o processo de treinamento são ajustados para melhorar o desempenho do modelo.

### Etapa nº 4: Avaliar os resultados

Como etapa final, você deve avaliar o desempenho do modelo ajustado. Isso envolve:

- **Conjunto de validação**: Uma parte do conjunto de dados rotulados deve ser usada para monitorar o progresso e evitar o ajuste excessivo.
- **Conjunto de teste**: Você precisa de um conjunto de dados com dados novos e não vistos pelo modelo, que pode ser um subconjunto do conjunto de dados de ajuste fino. Essa etapa é executada para a avaliação final após a conclusão do ajuste fino.
- **Métricas**: Defina métricas quantitativas relevantes para a tarefa para avaliar o desempenho.
- **Análise qualitativa:** Revisão dos resultados do modelo para avaliar a coerência, a relevância, a aderência ao estilo e a segurança.

## Desafios técnicos e considerações sobre a implementação do SFT

A implementação do SFT apresenta vários desafios técnicos, como:

- **Qualidade e escala do conjunto de dados**: O desafio mais significativo está na criação ou obtenção de um conjunto de dados rotulados suficientemente grande, de alta qualidade e representativo. A baixa qualidade dos dados se traduz diretamente em um desempenho ruim do modelo. [A extração](/blog/brightdata-in-practice/what-is-data-extraction), a limpeza, a rotulagem, [a agregação](/blog/dados-do-site/data-aggregation) e a formatação de [dados](/blog/brightdata-in-practice/what-is-data-extraction) exigem um esforço considerável e conhecimento especializado do domínio.
- **Atenuação do esquecimento catastrófico**: O ajuste fino intensivo em uma tarefa específica pode fazer com que o modelo “esqueça” alguns de seus recursos gerais aprendidos durante o pré-treinamento. Estratégias como o uso de taxas de aprendizado mais baixas, o ajuste fino para menos épocas ou a incorporação de dados diversos podem ajudar a atenuar esse fenômeno.
- **Estratégias de otimização de hiperparâmetros**: Encontrar o conjunto ideal de hiperparâmetros é um processo empírico. Isso requer vários experimentos e monitoramento cuidadoso das métricas de validação. As estruturas automatizadas de ajuste de hiperparâmetros podem ajudar, mas aumentam a complexidade.

## LLMs de ajuste fino supervisionado: Tutorial passo a passo

É hora de colocar a teoria em prática. Esta seção do tutorial o guiará pelo ajuste fino de um LLM leve para que você possa usar seu computador sem hardware adicional. O objetivo é fazer o ajuste fino de um LLM para gerar descrições de produtos de comércio eletrônico, com base em uma lista de características.

Você usará [o DistilGPT2](https://huggingface.co/distilbert/distilgpt2) como um LLM, que é uma versão destilada do GPT-2 com tamanho e eficiência menores.

Vamos ajustar o modelo escolhido!

### Pré-requisitos

Para replicar este tutorial sobre LLMs de ajuste fino supervisionado, você deve ter pelo menos [o Python 3.10+](https://www.python.org/downloads/) instalado em sua máquina.

Você também precisa de um conjunto de dados CSV para fazer o ajuste fino. Aqui, usaremos um conjunto de dados personalizado que contém dados de produtos de comércio eletrônico. O conjunto de dados contém os seguintes campos para cada produto:

- **Categoria**: Eletrônicos, livros, cozinha e similares.
- **Nome**: O nome do produto.
- **Recursos**: As principais características do produto.
- **Cor**: a cor do produto.
- **Descrição**: Texto que descreve o que o produto é ou faz.

Abaixo está uma imagem que mostra uma amostra dos dados usados:

![Uma amostra do conjunto de dados usado para o ajuste fino](https://media.brightdata.com/2025/05/A-sample-of-the-dataset-used-for-fine-tuning.png)### Etapa 1: Começar

Suponha que você chame a pasta principal do seu projeto de `fine_tuning/`. Ao final desta etapa, a pasta terá a seguinte estrutura:

```none
fine_tuning/
    ├── data/
    |   └── data.csv
    ├── results_distilgpt2/
    ├── tuning.py
    └── venv/
```

Onde:

- `data.csv` contém os dados rotulados para o ajuste fino do LLM apresentado anteriormente.
- `results_distilgpts/` é a pasta que conterá os resultados. Ela será criada automaticamente durante o processo.
- `tuning.py` é o arquivo Python que contém toda a lógica.
- `venv/` contém o ambiente virtual.

Você pode criar o diretório [do ambiente virtual](https://docs.python.org/3/library/venv.html) `venv/` da seguinte forma:

```none
python -m venv venv
```

Para ativá-lo, no Windows, execute:

```none
venvScriptsactivate
```

De forma equivalente, no macOS/Linux, execute:

```none
source venv/bin/activate
```

No ambiente virtual ativado, instale as bibliotecas necessárias para este tutorial:

```none
pip install transformers datasets torch trl
```

As bibliotecas usadas neste projeto são:

- [`transformers`](https://github.com/huggingface/transformers): biblioteca da Hugging Face para modelos de aprendizado de máquina de última geração.
- [`conjuntos de dados`](https://github.com/huggingface/datasets): A biblioteca do Hugging Face para acessar e processar conjuntos de dados.
- [`torch`](https://github.com/pytorch/pytorch): PyTorch, uma estrutura de aprendizado de máquina de código aberto.
- [`trl`](https://github.com/huggingface/trl): biblioteca de aprendizagem por reforço de transformadores da Hugging Face, que inclui ferramentas para SFT como o `SFTTrainer`.

Perfeito! Seu ambiente Python para ajuste fino do LLM está configurado corretamente.

### Etapa 2: Configuração inicial, carregamento de dados e formatação de texto

Como primeira etapa, no `tuning.py`, você precisa configurar todo o processo:

```none
import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer

# Configure parameters
base_model_name = "distilgpt2"  # Pre-trained model to be fine-tuned
data_file_path = "data/data.csv" # Path to your CSV data file
output_model_dir = "./results_distilgpt2"  # Directory to save training results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum sequence length for tokenizing inputs

# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)

# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
    prompt_template = "Generate a product description for the following item:nFeatures: {features_data}nnDescription:"
    data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
    return data_item

# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)
```

Este trecho:

- Define o nome do LLM a ser usado com `base_model_name`.
- Define o caminho onde está o arquivo CSV e o abre com o método [`load_dataset()`](https://huggingface.co/docs/datasets/v1.11.0/loading_datasets.html).
- Cria uma pasta que armazenará os resultados`(results_distilgpt2/`).
- Cria a função `format_dataset_entry()` que transforma cada linha do `raw_dataset` em formato de texto para ajuste fino. Ela também anexa o conteúdo modificado à coluna “description” no CSV, substituindo a atual. Isso fornecerá ao modelo descrições textuais limpas.
- Aplica a função `format_dataset_entry()` a cada item no conjunto de dados dividido de treinamento com o método [`map()`](https://huggingface.co/docs/datasets/about_map_batch).

Muito bem! Você concluiu a configuração inicial do processo.

### Etapa 3: Tokenizar o conjunto de dados

Os modelos de linguagem não entendem o texto bruto. Eles operam com [representações numéricas chamadas tokens](https://learn.microsoft.com/en-us/dotnet/ai/conceptual/understanding-tokens). Essa etapa envolve carregar o tokenizador pré-treinado e usá-lo para converter as entradas de texto formatadas em sequências de IDs de tokens:

```none
# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token # Padding token

# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
    return tokenizer(
        data_items_batch["text"],
        truncation=True,
        padding="max_length",
        max_length=max_seq_length_for_tokenization,
    )

# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
    tokenize_function,
    batched=True,
    remove_columns=text_formatted_dataset.column_names
)
```

O código acima faz o seguinte:

- Carrega o tokenizador associado a `base_model_name` com o método [`AutoTokenizer.from_pretrained()`](https://huggingface.co/docs/transformers/model_doc/auto).
- Define um token de preenchimento para fazer com que todas as sequências de entrada tenham o mesmo comprimento ao alimentá-las no modelo.
- Tokeniza o conjunto de dados com a função personalizada `tokenize_function()` e aplica a tokenização ao conjunto de dados.

Maravilhoso! O conjunto de dados é tokenizado.

### Etapa 4: Configurar e executar o processo de ajuste fino

O conjunto de dados está preparado e tokenizado, portanto, agora você pode passar para o núcleo da tarefa de ajuste fino:

```none
# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)

# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
    output_dir=output_model_dir,
    num_train_epochs=3,
    per_device_train_batch_size=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_steps=50,
    report_to="none",
)

# Initialize the SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
)

# Begin the training process
trainer.train()

# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)
```

Este código:

- Carrega o modelo básico com o método `AutoModelForCausalLM.from_pretrained()`.
- Define as configurações do processo, como o número de épocas, o tamanho do lote e a taxa de aprendizado, usando o método [`TrainingArguments()`](https://huggingface.co/docs/transformers/main_classes/trainer).
- Inicializa e executa [`SFTTrainer()`](https://huggingface.co/docs/trl/sft_trainer), fornecendo ao modelo o conjunto de dados tokenizado e os argumentos de treinamento. Isso gerencia o loop de ajuste fino real.
- Treina o modelo e salva os resultados na pasta dedicada.

Fantástico! Você iniciou o processo de ajuste fino.

### Etapa nº 5: Avaliar e testar o modelo ajustado

Agora, você precisa avaliar o desempenho e verificar se o modelo gera descrições para recursos novos e não vistos do produto:

```none
# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)

# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)

# Define example product features for testing
test_product_features = [
    "Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
    "Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]

# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:nFeatures: {features}nnDescription:"

# Generate descriptions for each test item
for features_item in test_product_features:
    full_prompt = prompt_template_inference.format(features=features_item)
    print(f"nPROMPT:n{full_prompt}")

    generated_outputs = generator_fine_tuned(
        full_prompt,
        max_new_tokens=70,
        num_return_sequences=1,
        pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
        eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
    )
    print(f"GENERATED (Fine-tuned):n{generated_outputs[0]['generated_text']}")
```

Esse snippet faz o seguinte:

- Carrega o modelo ajustado e o tokenizador.
- Cria um pipeline de geração de texto com o modelo ajustado usando o método [`pipeline()`](https://huggingface.co/docs/transformers/en/main_classes/pipelines).
- Define uma lista que fornece descrições de produtos novas e não vistas para alimentar e avaliar o ajuste fino do modelo com `test_product_features`.
- Gera as descrições para cada item de teste no loop `for`.
- Imprime as descrições geradas pelo modelo de ajuste fino.

Legal! Você configurou um pipeline para testar e avaliar o desempenho do modelo.

### Etapa nº 6: Juntar tudo

Seu arquivo `tuning.py` agora deve conter:

```none
import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer

# Configure parameters
base_model_name = "distilgpt2"  # Pre-trained model
data_file_path = "data/data.csv" # Path to data
output_model_dir = "./results_distilgpt2"  # Directory to save results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum length for tokenizing inputs

# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)

# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
    prompt_template = "Generate a product description for the following item:nFeatures: {features_data}nnDescription:"
    data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
    return data_item

# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)

# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token

# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
    return tokenizer(
        data_items_batch["text"],
        truncation=True,
        padding="max_length",
        max_length=max_seq_length_for_tokenization,
    )

# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
    tokenize_function,
    batched=True,
    remove_columns=text_formatted_dataset.column_names
)

# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)

# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
    output_dir=output_model_dir,
    num_train_epochs=3,
    per_device_train_batch_size=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_steps=50,
    report_to="none",
)

# Initialize the SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
)

# Begin the training process
trainer.train()

# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)

# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)

# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)

# Define example product features for testing
test_product_features = [
    "Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
    "Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]

# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:nFeatures: {features}nnDescription:"

# Generate descriptions for each test item
for features_item in test_product_features:
    full_prompt = prompt_template_inference.format(features=features_item)
    print(f"nPROMPT:n{full_prompt}")

    generated_outputs = generator_fine_tuned(
        full_prompt,
        max_new_tokens=70,
        num_return_sequences=1,
        pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
        eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
    )
    print(f"GENERATED (Fine-tuned):n{generated_outputs[0]['generated_text']}")
```

Execute seu código com:

```none
python tuning.py
```

O resultado esperado será o seguinte:

![Resultado esperado usando um CSV de 300 linhas](https://media.brightdata.com/2025/05/Expected-result-using-a-300-row-CSV.png)Conforme mostrado, o prompt solicita que o modelo crie a descrição de uma chaleira elétrica, fornecendo as informações necessárias. O modelo cria a descrição, conforme esperado. Se você decompor esse resultado, poderá ver:

- **Nome do produto gerado**: Ele gera o nome do produto “ProChef Luxury Living Hood Series X”, que parece plausível para um item de cozinha, e a descrição.
- **Detalhe contraditório**: Ele conclui com “Available in a stunning Pure White finish” (Disponível em um impressionante acabamento Pure White), o que contradiz a “Color: Silver” (Cor: Prata) fornecida nos recursos do prompt. Portanto, embora o ajuste fino oriente o modelo, ele não garante a consistência perfeita. Isso acontece especialmente com modelos menores e treinamento limitado.

Imperfeições e contradições são típicas de modelos generativos, especialmente para modelos menores como o `distilgpt2`. Elas também podem depender do tamanho e da qualidade do conjunto de dados de ajuste fino e do número de épocas de treinamento. Nesse caso, o conjunto de dados usado tem apenas 300 linhas. Um conjunto de dados maior teria levado a uma descrição melhor da chaleira.

Para mostrar a perda de qualidade, abaixo está o resultado esperado com um CSV que tem apenas 5 linhas:

![Resultado esperado usando um CSV de 300 linhas](https://media.brightdata.com/2025/05/Expected-result-using-a-300-row-CSV-2.png)Como você pode ver, o resultado é uma alucinação total. Para decompô-lo:

- **Nome do produto gerado**: \*\*\*\*It nomeia o produto “Office chair” em vez de “Ergonomic Office chair” na primeira frase.
- **Detalhe contraditório**: \*\*\*\*Na segunda frase, o nome se torna “Lumbar”. Portanto, o modelo confunde o nome com o recurso (“Suporte lombar”).
- **Gramática inconsistente**: ambas as frases têm gramática inconsistente e errada.
- **Recursos ausentes**: A cor e os recursos (“Suporte lombar”, “Altura ajustável”, “Giratório”) não são mencionados na descrição.

Entretanto, se você fornecesse o mesmo prompt ao modelo `distilgpt2` sem o processo de ajuste fino, o resultado seria significativamente pior. Isso ocorre porque esse modelo não foi treinado com dados tão específicos. Por exemplo, ele não seria capaz de fornecer a descrição da chaleira.

Observe que, quando o processo for concluído, o código gerará automaticamente uma pasta chamada `results_distilgpt2/`. Essa pasta relatará os resultados. Dentro dela, você encontrará subpastas que relatam os resultados salvos pelo modelo em diferentes épocas:

![Pasta de arquivos com resultados salvos pelo modelo](https://media.brightdata.com/2025/05/File-folder-with-results-saved-by-the-model.png)Isso é útil se você quiser obter qualquer um deles como pontos de controle e usá-los como quiser.

E voilà! Ajuste fino do LLM concluído.

## Conclusão

Neste artigo, você aprendeu o que é o ajuste fino supervisionado no contexto dos LLMs. Você também passou por um processo passo a passo para replicar o processo de ajuste fino.

O núcleo do SFT se baseia em conjuntos de dados de alta qualidade para o ajuste fino de seus modelos. Felizmente, a Bright Data oferece vários serviços para aquisição ou criação de conjuntos de dados:

- [**Navegador de raspagem**](/products/scraping-browser): Um navegador compatível com Playwright, Selenium e Puppeter com recursos de desbloqueio incorporados.
- [**APIs do Web Scraper**](/products/web-scraper): APIs pré-configuradas para extrair dados estruturados de mais de 100 domínios principais.
- [**Web Unlocker**](/products/web-unlocker): Uma API tudo em um que lida com o desbloqueio de sites com proteções antibot.
- [**API SERP**](/products/serp-api): Uma API especializada que desbloqueia os resultados do mecanismo de pesquisa e extrai dados SERP completos.
- [**Modelos básicos**](/ai/data-for-llms-and-foundation-models): Acesse conjuntos de dados compatíveis e em escala da Web para potencializar o pré-treinamento, a avaliação e o ajuste fino.
- [**Provedores de dados**](/blog/dados-do-site/best-b2b-data-providers): Conecte-se com provedores confiáveis para obter conjuntos de dados de alta qualidade e prontos para IA em escala.
- [**Pacotes de dados**](/ai/data-packages-for-ai): Obtenha conjuntos de dados selecionados e prontos para uso – estruturados, enriquecidos e anotados.

Crie uma conta na Bright Data gratuitamente para testar nossos serviços de extração de dados e explorar nosso mercado de conjuntos de dados!



Contate-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg)









 Índice













 [ ](https://news.ycombinator.com/submitlink?t=O+que+%C3%A9+ajuste+fino+supervisionado+em+LLMs%3F&u=https://brightdata.com.br/blog/ai/supervised-fine-tuning) [ ](https://www.linkedin.com/shareArticle?mini=true&title=O+que+%C3%A9+ajuste+fino+supervisionado+em+LLMs%3F&url=https://brightdata.com.br/blog/ai/supervised-fine-tuning) [ ](http://www.reddit.com/submit?title=O+que+%C3%A9+ajuste+fino+supervisionado+em+LLMs%3F&url=https://brightdata.com.br/blog/ai/supervised-fine-tuning)







##  Você também pode estar interessado em

 [ ![OpenHuman with Bright Data](https://media.brightdata.com.br/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")

 [AI



 ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg)

Antonello Zanini

Technical Writer





### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI

Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.



 09-Sep-2026

 14 min de leitura

 ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)

 [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.com.br/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")

 [Dados do site



 ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg)

Antonello Zanini

Technical Writer





### Scraping de Dados Multimodal com MiniMax

Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.



 09-Sep-2026

 5 min de leitura

 ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)

 [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.com.br/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")

 [AI



 ![Daniel Shashko](https://media.brightdata.com.br/2022/04/Daniel-Shashko-2-50x50.png)

Daniel Shashko

Web Data & AI Expert





### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas

As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.



 06-Sep-2026

 24 min de leitura

 ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)