Ajuste fino supervisado para LLM: Guía Python paso a paso

En esta guía sobre el perfeccionamiento supervisado de los LLM, aprenderá:

¿Qué es el ajuste fino supervisado en el contexto de los LLM?
¿Cuál es el objetivo de esta práctica?
Los recursos que necesita para aplicarlo
Flujo de trabajo para el ajuste fino supervisado de los LLM
Retos y consideraciones técnicas en la aplicación de la SFT
Un tutorial paso a paso para reproducir el ajuste fino supervisado en un LLM

Sumerjámonos.

Definición del ajuste fino supervisado (SFT) en el contexto del LLM

El ajuste fino supervisado (SFT) es una forma de aprendizaje por transferencia aplicado a los LLM. El aprendizaje por transferencia es un método de aprendizaje automático en el que se aplican los conocimientos adquiridos al resolver un problema para ayudar a resolver otro distinto pero relacionado.

En el contexto del LLMS, el ajuste fino supervisado consiste en tomar un modelo preentrenado y seguir entrenándolo. Para ello, se ajustan sus parámetros utilizando un conjunto de datos curados con ejemplos etiquetados relevantes para una tarea específica.

El carácter “supervisado” es clave en el proceso, porque los ingenieros están detrás de todo el proceso:

Preparan el conjunto de datos de ajuste con pares explícitos de entrada-salida. Ese conjunto de datos contiene las “respuestas correctas” que dirigen el aprendizaje del modelo para determinadas indicaciones.
Se encargan de todo el proceso de puesta a punto, desde la configuración hasta la supervisión y validación.

En concreto, en comparación con RAG(Retrieval-Augmented Generation), el ajuste fino modifica el propio modelo. La RAG deja intacto el modelo y se limita a alimentarlo con nueva información relevante. En cambio, el ajuste fino implica un nuevo proceso de entrenamiento.

¿Cuál es el objetivo del ajuste fino supervisado en los LLM?

El objetivo principal del ajuste fino supervisado es mejorar el rendimiento de un LLM en tareas específicas más allá de sus capacidades generales preentrenadas. Esto incluye:

Especialización de tareas: Haga que el modelo sea competente en tareas como el resumen de textos, la generación de código para un lenguaje concreto, el análisis de sentimientos, etc.
Adaptación al dominio: Infundir al modelo conocimientos y terminología específicos de nichos de mercado. Ejemplos comunes son el análisis de documentos jurídicos, la generación de informes médicos y las previsiones financieras.
Alineación del tono: Entrene el modelo para que adopte una voz de marca coherente, un nivel de formalidad o un personaje conversacional específico necesario para aplicaciones como los chatbots.

Lo que necesita para aplicar el ajuste fino

Llegados a este punto, puede que se pregunte: ¿por qué no formar a un LLM para que lo haga desde el principio? La razón es sencilla. Formar a un LLM implica:

Una gran cantidad de datos, a menudo almacenados en varios centros de datos.
Mucho hardware.
Invertir mucho dinero y tiempo.

Para hacernos una idea, para entrenar modelos como ChatGPT, Gemini y similares, se necesita:

Varios meses, o incluso años.
Un montón de GPU -cada una de las cuales cuesta miles de dólares- distribuidas en varios centros de datos.

Para afinar, en cambio, sólo necesitas tres cosas:

Un modelo preentrenado.
Un ordenador.
Un pequeño conjunto de datos etiquetados.

Ahora debería estar más claro por qué el ajuste fino es tan conveniente.

Mecánica del flujo de trabajo de ajuste fino supervisado

Ejecutar un proceso de ajuste supervisado implica varios pasos técnicos. Es hora de desglosar todo el proceso.

Paso 1: Recopilar el conjunto de datos SFT de alta calidad

La eficacia del proceso depende en gran medida de la calidad y pertinencia del conjunto de datos de ajuste. Esto implica:

Obtención de datos: Obtener datos brutos relevantes para la tarea objetivo utilizando una de las muchas técnicas de obtención de datos. El tamaño puede oscilar entre cientos y decenas de miles de filas. Esto depende de la complejidad de la tarea y del modelo preentrenado.
Estructuración de datos: Transformar los datos brutos en un formato estructurado adecuado para el proceso SFT. Uno de los formatos típicos es JSON Lines (JSONL), donde cada línea es un objeto JSON que contiene campos distintos para la entrada y la salida deseada.
Garantía de calidad: Garantizar que los datos son precisos, coherentes, diversos y libres de sesgos que puedan afectar negativamente al comportamiento del modelo.

Paso 2: Seleccionar un modelo preentrenado adecuado

Existen varios modelos preformados. Las consideraciones clave para elegir el mejor para su caso incluyen:

Tamaño del modelo: Se denota por el número de parámetros (por ejemplo, 7B, 13B, 70B) y se correlaciona con la capacidad del modelo para aprender patrones y matices complejos. Los modelos más grandes suelen ofrecer un mayor rendimiento, pero exigen más recursos de hardware para su ajuste.
Arquitectura: La arquitectura específica puede adaptarse a determinadas tareas. Por ejemplo
```
:Polylang marcador de posición no modificar
```
Capacidades básicas: Evalúe el rendimiento del modelo preentrenado en puntos de referencia académicos relevantes para su tarea objetivo antes de comprometerse con el ajuste fino. Esto proporciona una línea de base e indica la aptitud del modelo. Por ejemplo
```
:Polylang marcador de posición no modificar
```
Licencias: La licencia bajo la que se publica un modelo dicta cómo puede utilizarse, modificarse y distribuirse. Algunos modelos tienen permisos de código abierto, mientras que otros no.
Ajustes previos: A veces, partir de un modelo ya afinado para una tarea relacionada puede ser más eficaz que partir de un modelo base sin afinar. Se trata de una forma de ajuste intermedio.

Paso nº 3: Implantar el bucle de formación

El núcleo del proceso consiste en iterar a través del conjunto de datos etiquetados y ajustar las ponderaciones del modelo de la siguiente manera:

Paso adelante: El modelo procesa una entrada (la solicitud) del conjunto de datos SFT y genera una salida.
Cálculo depérdidas: Una función de pérdida compara el resultado generado por el modelo, ficha por ficha, con el resultado previsto en el conjunto de datos. Esto es útil para cuantificar el error.
Paso hacia atrás (backpropagation): La pérdida calculada se utiliza para calcular los gradientes, que indican cuánto ha contribuido cada peso del modelo al error.
Actualización de pesos: Un algoritmo optimizador utiliza los gradientes y una tasa de aprendizaje especificada para ajustar los pesos del modelo. El objetivo es minimizar los errores en iteraciones posteriores.
Ajuste de hiperparámetros: Los parámetros que controlan el proceso de entrenamiento se ajustan para mejorar el rendimiento del modelo.

Paso 4: Evaluar los resultados

Como último paso, hay que evaluar el rendimiento del modelo afinado. Esto implica:

Conjunto de validación: Una parte del conjunto de datos etiquetados debe utilizarse para controlar el progreso y evitar el sobreajuste.
Conjunto de pruebas: Se necesita un conjunto de datos nuevos y no vistos por el modelo, que puede ser un subconjunto del conjunto de datos de ajuste. Este paso se ejecuta para la evaluación final una vez completado el ajuste.
Métricas: Definir métricas cuantitativas relevantes para la tarea para evaluar el rendimiento.
Análisis cualitativo: Revisión de los resultados del modelo para evaluar la coherencia, la pertinencia, el cumplimiento del estilo y la seguridad.

Retos y consideraciones técnicas en la aplicación de la SFT

La implantación de la SFT presenta varios retos técnicos, como:

Calidad y escala del conjunto de datos: El reto más importante consiste en crear o abastecerse de un conjunto de datos etiquetados suficientemente amplio, de alta calidad y representativo. La mala calidad de los datos se traduce directamente en un rendimiento deficiente del modelo. La extracción, la limpieza, el etiquetado, la agregación y el formateo de los datos requieren un esfuerzo considerable y conocimientos especializados.
Mitigación del olvido catastrófico: El ajuste intensivo en una tarea específica puede hacer que el modelo “olvide” algunas de sus capacidades generales aprendidas durante el preentrenamiento. Estrategias como el uso de tasas de aprendizaje más bajas, el ajuste fino durante menos épocas o la incorporación de datos diversos pueden ayudar a mitigar este fenómeno.
Estrategias de optimización dehiperparámetros: Encontrar el conjunto óptimo de hiperparámetros es un proceso empírico. Eso requiere múltiples experimentos y un seguimiento cuidadoso de las métricas de validación. Los marcos automatizados de ajuste de hiperparámetros pueden ayudar, pero añaden complejidad.

LLM de ajuste fino supervisado: Tutorial paso a paso

Es hora de poner en práctica la teoría. Esta sección del tutorial te guiará en la puesta a punto de un LLM ligero para que puedas utilizar tu ordenador sin necesidad de hardware adicional. El objetivo es afinar un LLM para generar descripciones de productos de comercio electrónico, dada una lista de características.

Utilizará DistilGPT2 como LLM, que es una versión destilada de GPT-2 con menor tamaño y eficiencia.

¡Pongamos a punto el modelo elegido!

Requisitos previos

Para replicar este tutorial sobre LLMs de ajuste fino supervisado, debe tener al menos Python 3.10+ instalado en su máquina.

También necesita un conjunto de datos CSV para el ajuste. En este caso, utilizaremos un conjunto de datos personalizado que contiene datos de productos de comercio electrónico. El conjunto de datos contiene los siguientes campos para cada producto:

Categoría: Electrónica, libros, cocina y similares.
Nombre: El nombre del producto.
Características: Las principales características del producto.
Color: El color del producto.
Descripción: Texto que describe lo que es o hace el producto.

A continuación figura una imagen que muestra una muestra de los datos utilizados:

Una muestra del conjunto de datos utilizado para el ajuste fino

Paso nº 1: Empezar

Supongamos que llamas a la carpeta principal de tu proyecto fine_tuning/. Al final de este paso, la carpeta tendrá la siguiente estructura:

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

Dónde:

data.csv contiene los datos etiquetados para el ajuste fino del LLM presentado anteriormente.
results_distilgpts/ es la carpeta que contendrá los resultados. Se creará automáticamente durante el proceso.
tuning.py es el archivo Python que contiene toda la lógica.
venv/ contiene el entorno virtual.

Puede crear el directorio del entorno virtual venv/ de la siguiente manera:

python -m venv venv

Para activarlo, en Windows, ejecute

venv\Scripts\activate

De forma equivalente, en macOS/Linux, ejecute:

source venv/bin/activate

En el entorno virtual activado, instale las bibliotecas necesarias para este tutorial:

pip install transformers datasets torch trl

Las bibliotecas utilizadas en este proyecto son:

transformers: la biblioteca de Hugging Face para modelos de aprendizaje automático de última generación.
conjuntos de datos: Biblioteca de Hugging Face para acceder y procesar conjuntos de datos.
torch: PyTorch, un marco de aprendizaje automático de código abierto.
trl: la biblioteca Transformer Reinforcement Learning de Hugging Face, que incluye herramientas para SFT como SFTTrainer.

Perfecto. Su entorno Python para el ajuste fino de LLM está correctamente configurado.

Paso 2: Configuración inicial, carga de datos y formato de texto

Como primer paso, en tuning.py, tienes que configurar todo el proceso:

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

Define el nombre del LLM que se utilizará con nombre_modelo_base.
Define la ruta donde se encuentra el archivo CSV y lo abre con el método load_dataset().
Crea una carpeta que almacenará los resultados(results_distilgpt2/).
Crea la función format_dataset_entry() que transforma cada fila de raw_dataset en formato de texto para su ajuste. También añade el contenido modificado a la columna “description” del CSV, sustituyendo a la actual. Esto proporcionará al modelo descripciones textuales depuradas.
Aplica la función format_dataset_entry() a cada elemento del conjunto de datos dividido de entrenamiento con el método map().

Bien hecho. Ha concluido la configuración inicial del proceso.

Paso 3: Tokenizar el conjunto de datos

Los modelos lingüísticos no entienden el texto en bruto. Funcionan con representaciones numéricas llamadas tokens. Este paso consiste en cargar el tokenizador preentrenado y utilizarlo para convertir las entradas de texto formateadas en secuencias de ID de token:

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

El código anterior hace lo siguiente:

Carga el tokenizador asociado al nombre_modelo_base con el método AutoTokenizer.from_pretrained().
Define un token de relleno para que todas las secuencias de entrada tengan la misma longitud al introducirlas en el modelo.
Tokeniza el conjunto de datos con la función personalizada tokenize_function() y aplica la tokenización al conjunto de datos.

¡Maravilloso! El conjunto de datos está tokenizado.

Paso 4: Configurar y ejecutar el proceso de ajuste fino

El conjunto de datos está preparado y tokenizado, por lo que ahora puede pasar al núcleo de la tarea de ajuste:

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

Carga el modelo base con el método AutoModelForCausalLM.from_pretrained().
Define los ajustes para el proceso, como el número de épocas, el tamaño del lote y la tasa de aprendizaje, utilizando el método TrainingArguments().
Inicializa y ejecuta SFTTrainer(), proporcionando al modelo el conjunto de datos tokenizados y los argumentos de entrenamiento. Esto gestiona el bucle de ajuste fino real.
Entrena el modelo y guarda los resultados en la carpeta correspondiente.

Fantástico. Ha iniciado el proceso de puesta a punto.

Paso 5: Evaluar y probar el modelo perfeccionado

Ahora tiene que evaluar el rendimiento y ver lo bien que el modelo genera descripciones para características de productos nuevas y desconocidas:

# 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']}")

Este fragmento hace lo siguiente:

Carga el modelo ajustado y el tokenizador.
Crea una canalización de generación de texto con el modelo ajustado mediante el método pipeline().
Define una lista que proporciona nuevas descripciones de productos no vistas para alimentar y evaluar el ajuste fino del modelo con test_product_features.
Genera las descripciones para cada elemento de prueba en el bucle for.
Imprime las descripciones generadas por el modelo ajustado.

Genial. Ha creado un proceso para probar y evaluar el rendimiento del modelo.

Paso nº 6: Póngalo todo junto

Tu archivo tuning.py debería contener ahora:

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']}")

Ejecuta tu código con:

python tuning.py

El resultado esperado será el siguiente:

Resultado esperado utilizando un CSV de 300 filas

Como se muestra en la imagen, la pregunta pide al modelo que cree la descripción de un hervidor eléctrico, proporcionando la información necesaria. El modelo crea la descripción, como se esperaba. Si desglosas este resultado, puedes ver:

Nombre del producto generado: Genera el nombre del producto “ProChef Luxury Living Hood Series X”, que suena plausible para un artículo de cocina, y la descripción.
Detalle contradictorio: Concluye con “Disponible en un impresionante acabado Blanco Puro”, lo que contradice el “Color: Plata” que figura en las características de la indicación. Así, aunque el ajuste fino guía al modelo, no garantiza una coherencia perfecta. Esto ocurre especialmente con los modelos más pequeños y la formación limitada.

Las imperfecciones y contradicciones son típicas de los modelos generativos, especialmente de los más pequeños como distilgpt2. También pueden depender del tamaño y la calidad del conjunto de datos de ajuste fino, así como del número de épocas de entrenamiento. En este caso, el conjunto de datos utilizado sólo tiene 300 filas. Un conjunto de datos mayor habría permitido obtener una mejor descripción de la tetera.

Para mostrar la pérdida de calidad, a continuación se muestra el resultado esperado con un CSV que sólo tiene 5 filas:

Como puede ver, el resultado es una alucinación total. Para desglosarlo:

Nombre de producto generado: ****It nombra el producto “Silla de oficina” en lugar de “Silla de oficina ergonómica” en la primera frase.
Detalle contradictorio: ****En la segunda frase, el nombre se convierte en “Lumbar”. Así, el modelo confunde el nombre con la característica (“Apoyo lumbar”).
Gramáticaincoherente: Ambas frases tienen una gramática incoherente y errónea.
Faltan características: El color y las características (“Apoyo lumbar”, “Altura regulable”, “Giratorio”) no se mencionan en la descripción.

Sin embargo, si proporcionara la misma indicación al modelo distilgpt2 sin el proceso de ajuste fino, el resultado sería significativamente peor. Esto se debe a que este modelo no se ha entrenado con datos tan específicos. Por ejemplo, no podría proporcionar la descripción de la tetera.

Tenga en cuenta que, una vez finalizado el proceso, el código generará automáticamente una carpeta llamada results_distilgpt2/, que informará de los resultados. Dentro de ella, encontrará subcarpetas que informan de los resultados guardados por el modelo en diferentes épocas:

Carpeta con los resultados guardados por el modelo

Esto es útil si quieres conseguir cualquiera de estos como puntos de control y utilizarlos como desees.

¡Et voilà! Puesta a punto del LLM.

Conclusión

En este artículo ha aprendido qué es el ajuste fino supervisado en el contexto de los LLM. También has seguido un proceso paso a paso para reproducir el proceso de ajuste fino.

El núcleo de la SFT se basa en disponer de conjuntos de datos de alta calidad para ajustar sus modelos. Por suerte, Bright Data le ofrece numerosos servicios para la adquisición o creación de conjuntos de datos:

Navegador de raspado: Un navegador compatible con Playwright, Selenium-, Puppeter con capacidades de desbloqueo integradas.
APIs de Web Scraper: API preconfiguradas para extraer datos estructurados de más de 100 dominios importantes.
Desbloqueador Web: Una API todo en uno que maneja el desbloqueo de sitios en sitios con protecciones anti-bot.
API SERP: Una API especializada que desbloquea los resultados de los motores de búsqueda y extrae datos completos de las SERP.
Modelos básicos: Acceda a conjuntos de datos compatibles a escala web para potenciar el preentrenamiento, la evaluación y el ajuste.
Proveedores de datos: Conéctese con proveedores de confianza para obtener conjuntos de datos de alta calidad preparados para la IA a escala.
Paquetes de datos: Obtenga conjuntos de datos curados y listos para usar: estructurados, enriquecidos y anotados.

Cree una cuenta gratuita en Bright Data para probar nuestros servicios de extracción de datos y explorar nuestro mercado de conjuntos de datos.

Prueba gratuita

Comienza con Google

No se requiere tarjeta de crédito

¿Qué es el ajuste fino supervisado en los LLM?