Ajuste fino supervisionado de LLMs: guia Python

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 (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 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 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), 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.

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:

Um modelo pré-treinado.
Um computador.
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. 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), 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 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, a limpeza, a rotulagem, a agregação e a formatação de dados 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 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+ 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

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:

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 venv/ da seguinte forma:

python -m venv venv

Para ativá-lo, no Windows, execute:

venv\Scripts\activate

De forma equivalente, no macOS/Linux, execute:

source venv/bin/activate

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

pip install transformers datasets torch trl

As bibliotecas usadas neste projeto são:

transformers: biblioteca da Hugging Face para modelos de aprendizado de máquina de última geração.
conjuntos de dados: A biblioteca do Hugging Face para acessar e processar conjuntos de dados.
torch: PyTorch, uma estrutura de aprendizado de máquina de código aberto.
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:

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}\n\nDescription:"
    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().
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().

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. 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:

# 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().
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:

# 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().
Inicializa e executa SFTTrainer(), 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:

# 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}\n\nDescription:"

# 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().
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:

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}\n\nDescription:"
    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}\n\nDescription:"

# 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:

python tuning.py

O resultado esperado será o seguinte:

Resultado esperado usando um CSV de 300 linhas

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:

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

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: Um navegador compatível com Playwright, Selenium e Puppeter com recursos de desbloqueio incorporados.
APIs do Web Scraper: APIs pré-configuradas para extrair dados estruturados de mais de 100 domínios principais.
Web Unlocker: Uma API tudo em um que lida com o desbloqueio de sites com proteções antibot.
API SERP: Uma API especializada que desbloqueia os resultados do mecanismo de pesquisa e extrai dados SERP completos.
Modelos básicos: 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: Conecte-se com provedores confiáveis para obter conjuntos de dados de alta qualidade e prontos para IA em escala.
Pacotes de dados: 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!

Teste grátis

Registro no Google

Não é necessário cartão de crédito

O que é ajuste fino supervisionado em LLMs?