Las 6 mejores herramientas de ajuste para el entrenamiento de modelos en 2026

Introducción

El ajuste fino es una técnica que se utiliza en el aprendizaje automático, especialmente en el aprendizaje profundo, en la que un modelo previamente entrenado se entrena más o se «ajusta» en un conjunto de datos más pequeño y específico adaptado a una tarea en particular.

Supongamos que está desarrollando un modelo que genera manuales técnicos para electrónica utilizando GPT-3 (un modelo de lenguaje grande con 175 mil millones de parámetros), pero la salida genérica del GPT-3 no cumple con la precisión técnica y el tono requeridos.

En este caso, puede pensar en volver a entrenar el modelo para su caso de uso específico, pero entrenar directamente un modelo como el GPT-3 desde cero para abordar esta tarea específica no es práctico debido a los requisitos de recursos computacionales y los datos especializados.

Aquí es donde entra en juego el ajuste fino.

El ajuste fino es como enseñarle un truco nuevo al GPT-3. Ya sabe mucho sobre idiomas gracias a su formación en numerosos textos, desde libros hasta sitios web. Su trabajo consiste en seguir capacitándolo en un conjunto de datos específico, en este caso, un corpus de manuales técnicos existentes y documentación específica sobre electrónica.

Algunos métodos básicos de ajuste:

1. Congelación de capas: congela selectivamente el peso de ciertas capas y permite que otras se actualicen durante el proceso de ajuste.
2. Ajuste de la tasa de aprendizaje: ajustar la velocidad a la que el modelo aprende durante el proceso de ajuste, normalmente para evitar sobrescribir valiosos conocimientos previamente aprendidos.
3. Agregar capas específicas para la tarea: esto implica ampliar la arquitectura del modelo con nuevas capas que se entrenan directamente para la tarea.

‍

Ajuste fino eficiente de parámetros

El ajuste preciso con eficiencia de parámetros (PEFT) es una técnica destinada a minimizar la cantidad de parámetros adicionales necesarios durante el ajuste fino de los modelos de redes neuronales previamente entrenados,

Esto ayuda a reducir los gastos computacionales y el uso de memoria, a la vez que mantiene o incluso mejora el rendimiento. PEFT logra esto añadiendo incrustaciones rápidas como parámetros adicionales del modelo y ajustando solo una pequeña cantidad de parámetros adicionales.

Los PEFT también requieren un conjunto de datos mucho más pequeño en comparación con el ajuste fino tradicional.

‍

Pasos para realizar la PEFT

1. Cargando el modelo elegido

Carga el modelo elegido con un marco de aprendizaje automático como TensorFlow, PyTorch o la biblioteca Transformers de Hugging Face. Estos marcos proporcionan API para descargar y cargar fácilmente modelos previamente entrenados.

Este es un ejemplo de código:

from transformers import GPT2Model, GPT2Tokenizer
model_name = 'gpt2-medium'  # Choose the model variant
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2Model.from_pretrained(model_name)

2. Ingeniería rápida

Antes de realizar ajustes, debe experimentar con diferentes indicaciones para guiar las respuestas del modelo. Pruebe varias indicaciones con el modelo previamente entrenado para ver cómo afectan al resultado y elija la más adecuada. También puedes cambiar diferentes parámetros como max_length, temperature, etc.

Es como encontrar la mejor manera de hacer una pregunta para que la modelo comprenda lo que quieres.

from transformers import pipeline

generator = pipeline('text-generation', model='gpt2')

prompt = """"""

# Generate responses
responses = generator(prompt, max_length=200, num_return_sequences=3)

for i, response in enumerate(responses):
    print(f"Response {i+1}: {response['generated_text']}")

3. Conjunto de datos

En un conjunto de datos para realizar ajustes, normalmente hay dos partes: preguntar (entrada) y responder (salida). La pregunta es como una pregunta o un punto de partida, y la respuesta es lo que quieres que genere el modelo en respuesta a esa pregunta. Puede tener la forma de columnas o de una secuencia de entradas de texto (lo más común).

Aquí se utilizará el mejor indicador identificado en el último paso y la respuesta será exactamente lo que queremos que produzca el modelo cuando se le dé ese mensaje.

4. Ajustar el modelo

Aquí es donde le enseñas a la modelo a mejorar en tu tarea. Usarás el conjunto de datos para ajustar ligeramente el «conocimiento» del modelo.

Esta es una descripción general simplificada de la configuración y ejecución del proceso de ajuste con PyTorch:

• Preparándose para la formación:

de transformers import AdamW

optimizer = adamW (model.parameters (), lr=5e-5) # lr es la tasa de aprendizaje

• Bucle de entrenamiento:

for epoch in range(total_epochs):
    for batch in data_loader:
        inputs, labels = batch
        outputs = model(**inputs)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad() 

Herramientas para el ajuste

Al explorar las herramientas para una ingeniería rápida, es útil clasificarlas en dos dominios principales: plataformas de código y plataformas sin código. Esta distinción simplifica el proceso de selección
Las plataformas de código se refieren a las plataformas que proporcionan máquinas virtuales que se pueden usar para ejecutar su script de Python personalizado para realizar ajustes como el mencionado anteriormente. Mientras tanto, las plataformas sin código se refieren a herramientas que requieren un script de Python simple o nulo para ejecutarse. Cuenta con una interfaz de usuario dedicada en la que puedes empezar a entrenar con unos pocos clics.

Plataformas sin código:

Las plataformas sin código, por otro lado, están diseñadas para ofrecer simplicidad y facilidad de uso. Eliminan la necesidad de escribir scripts en Python y ofrecen una interfaz de usuario intuitiva en la que se puede iniciar el entrenamiento con solo unos pocos clics. Este dominio es adecuado para usuarios sin conocimientos de programación o para aquellos que prefieren un enfoque sencillo para la ingeniería rápida.

1. True Foundry

True Foundry es una herramienta que ayuda a los equipos de aprendizaje automático a poner en marcha sus modelos sin problemas. Se basa en Kubernetes, lo que significa que puede ejecutarse en diferentes nubes o incluso en tus propios servidores. Esto es importante para las empresas preocupadas por mantener sus datos seguros y controlar los costos

Para el ajuste fino, es una de las mejores herramientas que existen, tanto para principiantes como para expertos. Aquí tiene dos opciones: implementar un portátil de ajuste fino para experimentar o iniciar un trabajo de ajuste específico.

1. Cuadernos: Experimentation Playground

Los ordenadores portátiles ofrecen una configuración ideal para realizar ajustes detallados exploratorios e iterativos. Puede experimentar con un pequeño subconjunto de datos y probar diferentes hiperparámetros para determinar la configuración ideal para obtener el mejor rendimiento.

2. Trabajos: confiables y escalables

Una vez que haya identificado los hiperparámetros y la configuración óptimos mediante la experimentación, la transición a un trabajo de implementación le ayuda a ajustar todo el conjunto de datos y facilita una capacitación rápida y confiable.

Por lo tanto, se recomienda encarecidamente utilizar ordenadores portátiles para la exploración en las primeras etapas, y los trabajos de ajuste e implementación de hiperparámetros son la opción preferida para el ajuste fino de la LLM a gran escala, especialmente cuando la configuración óptima se ha establecido mediante experimentos previos.

Esta es una guía paso a paso para perfeccionar el uso de Notebook y Jobs:

1. Configuración de los datos de entrenamiento

Truefoundry admite dos formatos de datos diferentes:

1. Charla: Los datos deben estar en formato JSONL y cada línea debe contener una conversación completa en formato OpenAI Chat

Cada línea contiene una clave llamada mensajes. Cada clave de mensaje contiene una lista de mensajes, donde cada mensaje es un diccionario con claves de función y contenido. La clave de rol puede ser de usuario, asistente o sistema, y la clave de contenido contiene el contenido del mensaje.

2. Finalización: Los datos deben estar en formato JSONL y cada línea debe contener una cadena codificada en JSON que contenga dos teclas: solicitud y finalización.

{"prompt": "What is 2 + 2?", "completion": "The answer to 2 + 2 is 4"}
{"prompt": "Flip a coin", "completion": "I flipped a coin and the result is heads!"}
{"prompt": "", "completion": ""}

2. Ajuste fino

Puede comenzar a realizar ajustes con solo tres clics:

1. Selecciona el espacio de trabajo en el que quieres trabajar
2. Elige modelo:

Puede elegir el modelo de la lista completa presente o simplemente puede pegar la URL de huggingface para comenzar a ajustarlo.

3. Haga clic en Siguiente

Ahora, después de seleccionar la GPU deseada, tiene dos opciones: Ejecutar como portátil o Job.

3. Ajuste fino con un portátil

Tras seleccionar «Iniciar como bloc de notas» y seleccionar los valores predeterminados para los hiperparámetros, puede ver su bloc de notas:

4. Afinar como trabajo:

Antes de empezar, primero tendrás que crear un repositorio de ML (que se utilizará para almacenar tus métricas y artefactos de entrenamiento, como tus puntos de control y modelos) y dar acceso a tu espacio de trabajo al repositorio de ML. Puedes obtener más información sobre los repositorios de ML en la documentación de Truefoundry.

Ahora tiene que elegir «Iniciar como tarea» y seleccionar los valores predeterminados de los hiperparámetros para iniciar el ajuste fino.

Dentro de las implementaciones, puede ver la lista de tareas y hacer clic en ejecutar la tarea.

Características principales:

• Compatibilidad con LLM populares: permite ajustar con precisión los LLM de código abierto más utilizados, como Llama 2, Mistral, Zephyr y Mixtral.
• Flexibilidad en el enfoque de ajuste: ofrece la opción de ajustar los LLM utilizando Jobs para lograr escalabilidad y confiabilidad o notebooks para experimentar y realizar ajustes iterativos.
• Técnica QLoRa: emplea la técnica de ajuste fino QLoRa, que equilibra la eficiencia con el rendimiento, lo que permite realizar ajustes precisos en hardware menos potente sin comprometer la calidad.
• Soporte de formatos de datos: admite datos en formato jsonl, que se adaptan tanto a conjuntos de datos de tipo chat como de finalización, lo que facilita una variedad de aplicaciones de LLM.
• Fácil integración de datos: ofrece opciones para cargar datos de entrenamiento como un artefacto de TrueFoundry, a servicios de almacenamiento en la nube o localmente, lo que brinda flexibilidad en la administración de datos.
• Soporte de implementación: después del ajuste, hay disponibles guías sobre la implementación del modelo ajustado para su aplicación práctica, lo que mejora la utilidad del modelo.
• Integración de repositorios de aprendizaje automático: permite realizar un seguimiento del progreso de ajuste y administrar las métricas y artefactos de entrenamiento a través de los repositorios de aprendizaje automático, lo que garantiza un desarrollo de modelos organizado y accesible.

2. API de IA abierta

La API OpenAI proporciona acceso a modelos avanzados de inteligencia artificial desarrollados por OpenAI, incluidas las últimas versiones de GPT (Generative Pre-trained Transformer). Una de las características más destacadas de la API OpenAI es su capacidad para ajustar los modelos en conjuntos de datos personalizados.

De este modo, puede adaptar el comportamiento de modelos como el GPT-3 o las versiones más recientes a aplicaciones específicas o a estilos y preferencias de contenido particulares.

Ya que me refiero a la API, no es exactamente «Sin código», aun así, se puede configurar fácilmente para el entrenamiento en comparación con otras herramientas de la sección anterior.

Código de ejemplo para un ajuste fino:

‍

1. Preparar su conjunto de datos

Para ajustar un modelo, primero debes preparar tu conjunto de datos en un formato que la API de OpenAI pueda entender. Por lo general, tendrías que crear un archivo JSON con el siguiente aspecto:

{"prompt": "The capital of France is", "completion": " Paris"}
{"prompt": "The largest planet in the solar system is", "completion": " Jupiter"}

2. Cargar su conjunto de datos a OpenAI

Puede cargar fácilmente el conjunto de datos mediante Open AI CLI (interfaz de línea de comandos).

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Ajustar el modelo

Una vez que el conjunto de datos esté preparado y cargado, puede iniciar un proceso de ajuste. El siguiente es un ejemplo en el que se utiliza la biblioteca Python de OpenAI:

import openai

openai.api_key = "your-api-key"

response = openai.FineTune.create(
  training_file="file-YourFileIDHere",
  model="gpt-3.5-turbo",
  n_epochs=4,
  learning_rate_multiplier=0.1,
  batch_size=4
)

4. Uso de su modelo afinado

Una vez finalizado el proceso de ajuste, puede usar su modelo ajustado para generar texto u otras tareas especificando el ID del modelo ajustado:

response = openai.Completion.create(
  model="YOUR_FINE_TUNED_MODEL_ID",
  prompt="The capital of Italy is",
  max_tokens=50
)
print(response.choices[0].text.strip())

También puede implementar su modelo perfeccionado.

Características principales:

• Facilidad de uso: la API simplifica las interacciones con modelos de IA potentes, lo que elimina las complejidades de administrar o entrenar directamente grandes redes neuronales.
• Escalabilidad: OpenAI gestiona la infraestructura y el escalado, proporcionando un rendimiento uniforme independientemente de la carga de trabajo.
• Actualizaciones continuas: OpenAI actualiza con frecuencia su API y sus modelos, lo que brinda a los usuarios acceso a los últimos avances en la investigación de la IA.

3. Microsoft Azure

Microsoft Azure es una plataforma de computación en la nube que ofrece una amplia gama de servicios, que incluyen computación, almacenamiento, análisis y más. Proporciona a los usuarios las herramientas para crear, implementar y administrar aplicaciones de manera eficiente.

Una característica destacable es su interfaz intuitiva, que facilita la navegación de los principiantes sin tener amplios conocimientos de codificación. Con unos simples clics en lugar de una codificación compleja, los usuarios pueden ajustar sus aplicaciones con precisión, lo que convierte a Azure en una herramienta accesible para un desarrollo sin estrés.

Este es un tutorial sencillo sobre cómo configurar un «trabajo» de ajuste en Azure:

1. Preparación de los datos:

Obviamente, este es el requisito básico para todas las herramientas. Los datos de entrenamiento pueden estar en formato JSON Lines (JSONL), CSV o TSV. Los requisitos de tus datos varían en función de la tarea específica para la que pretendas ajustar tu modelo.

Para la clasificación de texto:
Dos columnas: Oración (cadena) y Etiqueta (entero/cadena)

2. Elige un modelo de base

3. Configure un trabajo de ajuste:

Después de enviar el trabajo de ajuste, se creará un trabajo de canalización para entrenar el modelo. Puede revisar todas las entradas y recopilar el modelo a partir de los resultados del trabajo.

4. Evalúe su modelo perfeccionado

Para decidir si su modelo ajustado funciona según lo esperado, puede revisar las métricas de entrenamiento y evaluación.

Características principales:

• Interfaz fácil de usar: la interfaz fácil de usar de Azure simplifica la navegación para los principiantes.
• Opciones sin código: el ajuste fino no requiere una codificación extensa; los usuarios pueden realizar tareas con simples clics.
• Escalabilidad: las aplicaciones se pueden escalar fácilmente hacia arriba o hacia abajo para satisfacer las demandas cambiantes.
• Servicios integrales: Azure ofrece una gama de herramientas para realizar ajustes, incluidas funciones de análisis y supervisión.
• Integración: se integra perfectamente con herramientas de Microsoft y de terceros para ofrecer flexibilidad en los flujos de trabajo.

4. Replicar

Replicate es una herramienta versátil diseñada para ajustar varios aspectos de las aplicaciones de software. Las aplicaciones de Replicate como herramienta de ajuste fino incluyen la optimización del rendimiento, el ajuste de las configuraciones y la mejora de la funcionalidad con un mínimo esfuerzo. Simplifica el proceso al gestionar la configuración de la GPU. Al igual que la API Open AI, no es exactamente «sin código» como otras herramientas de la lista, pero se puede configurar fácilmente para el entrenamiento en comparación con otras herramientas de la sección anterior.

Pasos para ajustar con precisión llama-2b:

1. Prepara tus datos de entrenamiento

Los datos de entrenamiento deben estar en formato JSONL. A continuación se muestra un ejemplo de cómo puedes estructurar este archivo:

{"prompt": "What's the weather like?", "completion": "The weather is sunny."}
{"prompt": "Tell me a joke.", "completion": "Why don't scientists trust atoms? Because they make up everything!"}

2. Autenticar con Replicate

Debes configurar tu token de API de Replicate como una variable de entorno en tu terminal:

exportar REPLICATE_API_TOKEN= <your-token-here>

3. Sube tus datos de entrenamiento

Puedes subir tus datos a un bucket de s3 o directamente a Replicate mediante los comandos curl:

4. Crear un modelo en Replicate

Debe crear un modelo vacío en Replicate para su modelo entrenado. Cuando termine tu entrenamiento, se publicará como una nueva versión de este modelo.

5. Crear un trabajo de formación

Debes crear un trabajo de formación en tu IDE, como se muestra a continuación:

import replicate

training = replicate.trainings.create(
  version="meta/llama-2-7b:version-id", # Replace "version-id" with the actual version ID of the model you chose
  input={
    "train_data": "https://yourdata.com/data.jsonl", # Use your actual data URL here
    "num_train_epochs": 3
  },
  destination="your-username/your-model-name" # Use your actual username and model name here
)

print(training)

6. Supervise el progreso del entrenamiento

Para supervisar el progreso mediante programación, puede utilizar:

training.reload()
print(training.status)

7. Ejecute su modelo afinado

Una vez finalizada la formación, puede ejecutar su modelo con la API:

output = replicate.predictions.create(
  version=training.output["version"], # Use the version output from your training
  input={"prompt": "Your prompt here"}
)

print(output)

Características principales:

• Facilidad de uso: simplifica el proceso de ajuste con una interfaz fácil de usar y una API sencilla, por lo que es accesible tanto para principiantes como para profesionales experimentados.
• Capacitación basada en la nube: elimina la necesidad de recursos de GPU locales al ofrecer capacitación basada en la nube, lo que permite a los usuarios entrenar modelos independientemente de su hardware.
• Entrada de datos flexible: admite el formato JSONL para los datos de entrenamiento, lo que permite una entrada flexible y estructurada para una variedad de tareas.
• Alojamiento de modelos: aloja automáticamente modelos ajustados, lo que permite una fácil integración e implementación de los modelos de IA en las aplicaciones.
• Control de versiones: realiza un seguimiento de las diferentes versiones de entrenamiento, lo que facilita la administración, la comparación y la reversión a las versiones anteriores de un modelo.

‍

5. Estudio de inteligencia artificial de Google Gen

En Gen AI Studio, tienes ambas opciones para configurar trabajos de ajuste, a través de la API o del sitio web, aquí hablaré solo del método API. Tiene el proceso más simplificado en comparación con las herramientas mencionadas anteriormente.

Esta es una guía paso a paso:

1. Prepare su conjunto de datos

El conjunto de datos debe estar en formato JSONL, y cada línea debe ser un objeto JSON con las claves «input_text» y «output_text». Puede empezar a entrenarse con solo 10 ejemplos, pero se recomiendan al menos 100 ejemplos.

2. Cargue su conjunto de datos

Debes subir tu conjunto de datos al depósito de Google Cloud Storage (GCS). Si no tienes uno, puedes crear uno en Google Drive.

3. Autenticación e inicialización

Ahora tiene que proporcionar sus credenciales para establecer la conexión:

from google.auth import default
from google.cloud import aiplatform
from vertexai import init

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
project_id = "your-project-id"
location = "your-project-location" # e.g., "us-central1"
init(project=project_id, location=location, credentials=credentials)

4. Preparar la función de afinación

Debe definir una función para ajustar con los parámetros necesarios.

from vertexai.language_models import TextGenerationModel
from vertexai.preview.language_models import TuningEvaluationSpec

def tuning(project_id, location, model_display_name, training_data, train_steps=10, evaluation_dataset=None, tensorboard_instance_name=None):
    eval_spec = TuningEvaluationSpec(evaluation_data=evaluation_dataset)
    if tensorboard_instance_name:
        eval_spec.tensorboard = aiplatform.Tensorboard(tensorboard_name=tensorboard_instance_name)
    model = TextGenerationModel.from_pretrained("text-bison@002")

    model.tune_model(
        training_data=training_data,
        model_display_name=model_display_name,
        train_steps=train_steps,
        tuning_job_location="europe-west4",
        tuned_model_location=location,
        tuning_evaluation_spec=eval_spec,
    )
    print(model._job.status)
    return model

5. Ejecute el ajuste del modelo

Llame a la función de ajuste especificada anteriormente, con sus parámetros específicos. El parámetro training_data puede ser una URI de GCS o un DataFrame de Pandas.

Características principales:

1. Provisión tanto para el acceso a la API como para la interfaz de usuario: para aquellos que prefieren un enfoque gráfico, Gen AI Studio ofrece una interfaz de usuario intuitiva.
2. Infraestructura escalable: aprovecha la infraestructura escalable de Google Cloud para gestionar grandes conjuntos de datos y tareas de ajuste con uso intensivo de computación de manera eficiente.
3. Integración con Google Cloud Services: integración perfecta con otros servicios de Google Cloud, como Cloud Storage para la administración de conjuntos de datos y Vertex AI para implementar modelos.
4. Amplia gama de modelos previamente entrenados: acceda a una variedad de modelos previamente entrenados adecuados para diferentes tareas e idiomas, lo que ofrece un punto de partida sólido para el ajuste.
5. Colaboración y control de versiones: instalaciones para colaborar con los miembros del equipo, compartir proyectos de ajuste y mantener el control de versiones sobre modelos ajustados.

6. Predibase

Predibase es una plataforma especializada diseñada para facilitar el ajuste de grandes modelos lingüísticos (LLM), como el GPT-4, para tareas o aplicaciones específicas. Proporciona acceso a las capacidades avanzadas de los LLM al proporcionar un entorno simplificado y fácil de usar para personalizar estos modelos de acuerdo con las necesidades individuales.

Predibase le ofrece la opción de usar tanto el SDK como la interfaz de usuario de Python para realizar trabajos de ajuste.

Esta es una guía paso a paso para ajustar mistral-7b-instruct:

1. Configuración básica

Primero, regístrese para obtener una cuenta en Predibase y deposite para agregar créditos. Después, genere su clave de API.

2. Creación de un repositorio de modelos

Vaya a Modelos y, a continuación, haga clic en «Nuevo repositorio de modelos» como se muestra a continuación:

Ahora, asigne un nombre a su repositorio y añada una descripción.

3. Comience a afinar:

Rellene las áreas resaltadas y, a continuación, pulse entrenar. Esto hará que tu solicitud quede en cola hasta que haya un procesamiento disponible.

Plataformas de código:

Las plataformas de código están diseñadas para usuarios con una sólida formación en programación. Estas plataformas proporcionan máquinas virtuales que permiten ejecutar scripts de Python personalizados para tareas como el ajuste. Estas plataformas son perfectas para proyectos que exigen una alta personalización y un control complejo de las fases de formación e implementación.

1. Amazon Sagemaker:

Amazon SageMaker es un servicio totalmente administrado que brinda a los desarrolladores y científicos de datos la capacidad de crear, entrenar e implementar modelos de aprendizaje automático con rapidez.

Amazon SageMaker no cuenta con una función de «ajuste» dedicada e integrada etiquetada específicamente como tal para modelos lingüísticos de gran tamaño. En su lugar, proporciona una plataforma potente y flexible que le permite ejecutar scripts de Python personalizados para realizar tareas de ajuste.

Este es un ejemplo sencillo de cómo puede iniciar un trabajo de ajuste para un modelo de lenguaje con Hugging Face en SageMaker. Esto supone que ya ha configurado una cuenta de AWS y la CLI de AWS. (puede usar TensorFlow o PyTorch directamente en Amazon SageMaker para ajustar las tareas)

1. Configurar e inicializar la sesión de SageMaker:

import sagemaker
from sagemaker.huggingface import HuggingFace

# Initialize a sagemaker session
sagemaker_session = sagemaker.Session()

# Set up the role for SageMaker
role = sagemaker.get_execution_role()

2. Prepare el script de ajuste fino:

Por lo general, escribirías un script de ajuste (train.py) que pasarías al estimador. Este script debe incluir la lógica de carga, ajuste y guardado del modelo.

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters)

3. Crea un estimador de rostros abrazados:

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters
)

4. Comience el trabajo de capacitación:

# Assuming you have your training data in an S3 bucket
data = {'train': 's3://your-bucket/train-dataset/', 'test': 's3://your-bucket/test-dataset/'}

# Fit the model
huggingface_estimator.fit(data)

Características principales:

1. Algoritmos prediseñados y compatibilidad con marcos populares: SageMaker es compatible con TensorFlow, PyTorch, Hugging Face y otros, lo que facilita el ajuste preciso de los LLM en conjuntos de datos personalizados.
2. Entrenamiento puntual gestionado: reduce el costo de los modelos de entrenamiento mediante el uso de instancias puntuales de Amazon EC2.
3. Entrenamiento distribuido: SageMaker simplifica el entrenamiento de modelos de forma más rápida y rentable al distribuir el trabajo de entrenamiento entre varias GPU o instancias.

2. Google Colab:

Google Colab es un popular servicio de cuadernos Jupyter basado en la nube que ofrece acceso gratuito a los recursos informáticos, incluidas las GPU y las TPU, lo que lo convierte en una plataforma excelente para ajustar los modelos lingüísticos grandes (LLM)

Es especialmente apto para principiantes. Los cuadernos Colab se ejecutan en la nube, directamente desde su navegador, sin necesidad de ninguna configuración local.

Este es el sencillo fragmento de código para ajustar un modelo de Transformer con Hugging Face, Transformers y PyTorch en Google Colab

1. Configuración del entorno:

! pip install torch torchvision transformers

2. Cargar un modelo y un tokenizador previamente entrenados:

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import AdamW

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

# Prepare the model for training
model.train()

3. Ajustar el modelo: (suponiendo que tiene un conjunto de datos cargado en las variables input_ids, attention_masks y labels)

from torch.utils.data import DataLoader, RandomSampler, TensorDataset

# Create a data loader
dataset = TensorDataset(input_ids, attention_masks, labels)
dataloader = DataLoader(dataset, sampler=RandomSampler(dataset), batch_size=32)

optimizer = AdamW(model.parameters(), lr=2e-5)

# Example training loop
for epoch in range(4):  # loop over the dataset multiple times
    for step, batch in enumerate(dataloader):
        batch = [r.to('cuda') for r in batch]  # Move batch to GPU
        b_input_ids, b_input_mask, b_labels = batch

        # Forward + backward + optimize
        outputs = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

4. Guardar el modelo:

model.save_pretrained («/Content/drive/My Drive/Colab Models/my_finetuned_model»)

Características principales:

1. Acceso gratuito a las GPU/TPU: Colab proporciona acceso gratuito a las GPU de NVIDIA y a las TPU de Google, lo que puede acelerar significativamente el entrenamiento y el ajuste de los modelos de aprendizaje automático.
2. Integración con Google Drive: almacene y acceda fácilmente a sus conjuntos de datos y modelos directamente desde Google Drive, lo que facilita el manejo de datos y el almacenamiento de modelos sin problemas.
3. Bibliotecas preinstaladas: Colab viene con la mayoría de las bibliotecas de ciencia de datos y aprendizaje automático preinstaladas, incluidas TensorFlow, PyTorch, Hugging Face Transformers y muchas otras, lo que facilita comenzar a ajustar los modelos de inmediato.
4. Entorno interactivo: la interfaz del cuaderno permite el desarrollo y la documentación interactivos, combinando código en vivo, visualizaciones y anotaciones de texto.

3. Gradiente de Paperspace

Paperspace Gradient es un conjunto de herramientas diseñadas para simplificar el proceso de desarrollo, entrenamiento e implementación de modelos de aprendizaje automático en la nube.

Gradient es particularmente eficaz para tareas como el ajuste de modelos de grandes lenguajes (LLM) debido a su infraestructura escalable y su compatibilidad con contenedores, lo que lo convierte en una opción sólida para los científicos de datos y los profesionales del aprendizaje automático.

Este es un ejemplo de cómo ajustar un modelo de transformador con PyTorch en Paperspace Gradient.

1. Cargar un modelo y un tokenizador previamente entrenados:

from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

2. Preparación del conjunto de datos:

from transformers import TextDatasetForNextSentencePrediction

dataset = TextDatasetForNextSentencePrediction(
    tokenizer=tokenizer,
    file_path="./my_dataset.txt",
    block_size=128
)

3. Ajustar el modelo:

from torch.utils.data import DataLoader
from transformers import AdamW

dataloader = DataLoader(dataset, shuffle=True, batch_size=8)
optimizer = AdamW(model.parameters(), lr=1e-5)

model.train()
for epoch in range(3):  # Loop over the dataset multiple times
    for batch in dataloader:
        optimizer.zero_grad()
        inputs, labels = batch['input_ids'], batch['labels']
        outputs = model(inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

4. Guardar el modelo:

model.save_pretrained (». /my_finetuned_model «)

Características principales:

1. Entornos preconfigurados: Gradient ofrece entornos preconfigurados para TensorFlow, PyTorch, Hugging Face y otros marcos de aprendizaje automático, lo que permite una configuración rápida para tareas de ajuste fino.
2. GPU potentes: el acceso a una amplia gama de opciones de GPU garantiza que pueda escalar su potencia informática de acuerdo con las necesidades de su proyecto, desde opciones más rentables para experimentos iniciales hasta GPU de alta gama para sesiones de entrenamiento intensivas.
3. Gradient Notebooks: un entorno de codificación interactivo similar al de Jupyter Notebooks, pero con la ventaja adicional de ejecutarse en la infraestructura de nube de Paperspace. Esto es ideal para desarrollar, ajustar y experimentar directamente en la nube.
4. Trabajos y flujos de trabajo: automatice sus procesos de aprendizaje automático ejecutando los trabajos en secuencia o en paralelo, lo que permite una capacitación e implementación eficientes de modelos.

4. Run.ai

Run.AI es una plataforma diseñada para optimizar los recursos de la GPU para las cargas de trabajo de aprendizaje automático, lo que facilita a los científicos de datos y a los investigadores de IA la ejecución y la gestión de modelos de IA complejos, incluido el ajuste fino de los modelos de lenguaje grande (LLM).

Se basa en Kubernetes, una herramienta que organiza los recursos informáticos de manera eficiente. Por lo tanto, facilita la ejecución de proyectos complejos de IA y permite a los equipos hacer crecer sus proyectos sin problemas.

Puede consultar la documentación de Run.AI para obtener información detallada. Este es un ejemplo simplificado basado en el flujo de trabajo general para ajustar un modelo como LLama-2 en la plataforma Run.AI.

1. Preparar su entorno

2. Configuración del proyecto y las solicitudes de GPU

runai submit my-fine-tuning-job -p my-project --gpu 2 --image my-llama2-fine-tuning-image train.py

3. Escribir el script de ajuste fino

Su script train.py debe incluir la lógica para cargar LLama-2 (o el modelo que elija), su conjunto de datos y ejecutar el proceso de ajuste. Esto puede implicar el uso de bibliotecas como Hugging Face Transformers para cargar modelos y TensorFlow o PyTorch para el ciclo de entrenamiento.

desde transformadores import llama para generación condicional, llama a kenizer

# Load model and tokenizer
model = LlamaForConditionalGeneration.from_pretrained('Llama-2-model-name')
tokenizer = LlamaTokenizer.from_pretrained('Llama-2-tokenizer-name')

# Load your dataset, prepare data loaders, define your training loop here #
model.train()


for epoch in range(num_epochs):
    for batch in dataloader:
        # Training loop logic
        pass

# Save your fine-tuned model
model.save_pretrained('./fine-tuned-model')

4. Supervisión y gestión del trabajo de formación

Run.AI proporciona herramientas para monitorear el uso de la GPU y el progreso de sus trabajos de entrenamiento, y administrar los recursos computacionales de manera efectiva. Utilice el panel de control o la CLI de Run.AI para realizar un seguimiento del estado y el rendimiento de su trabajo.

puestos de trabajo de Runai

Este comando muestra todos los trabajos actuales, lo que le permite supervisar el progreso y el uso de los recursos de la tarea de ajuste.

Características principales:

1. Optimización de la GPU y asignación elástica de la GPU: optimiza automáticamente el uso de la GPU, mejora la eficiencia y asigna los recursos de la GPU de forma dinámica en función de las demandas de la carga de trabajo, lo que reduce significativamente los costos.
2. Administración de recursos simplificada: ofrece un panel de control intuitivo y una CLI para administrar las cargas de trabajo de IA, lo que facilita la supervisión y el ajuste del uso de los recursos en tiempo real.
3. Integración con marcos populares: admite marcos de aprendizaje automático populares, como TensorFlow, PyTorch y Hugging Face Transformers, lo que facilita una integración perfecta en los flujos de trabajo existentes.

Elegir la herramienta adecuada para usted:

Facilidad de uso: Elige herramientas que sean sencillas, especialmente si no te gusta mucho la codificación. ¡Algunas herramientas ni siquiera requieren que escribas código!

Escalabilidad: Asegúrese de que la herramienta pueda crecer con su proyecto, manejando conjuntos de datos más grandes y modelos más complejos sin problemas.

Soporte de modelos y conjuntos de datos: Elija herramientas que funcionen bien con los tipos específicos de datos y modelos que utiliza.

Recursos computacionales: Busca acceso a GPU o TPU si tu proyecto necesita una gran potencia informática.

Coste: Considera cuánto estás dispuesto a gastar. Algunas herramientas son gratuitas; otras cobran en función de los recursos que utilices.

Personalización y control: Si sabes manejar el código, es posible que prefieras herramientas que te permitan modificarlo todo.

Integración: Es más fácil si la herramienta se adapta perfectamente a su flujo de trabajo y herramientas existentes.

Comunidad y soporte: Una comunidad de apoyo y una buena documentación pueden ahorrarle muchos dolores de cabeza.

Preguntas frecuentes

¿Cuáles son las mejores herramientas de ajuste para los LLM?

Las principales herramientas de ajuste fino incluyen Hugging Face para el acceso a modelos, SiliconFlow para la formación basada en la nube y TrueFoundry para la orquestación de nivel empresarial. Las bibliotecas de código abierto como Axolotl y Llama-factory también admiten técnicas avanzadas como LoRa. TrueFoundry unifica de manera única el acceso a los modelos, el seguimiento de los experimentos y la gobernanza de la implementación en una única plataforma segura.

¿Cuál es el costo de usar herramientas de ajuste en la nube?

Los costos de optimización de la nube dependen de las horas de procesamiento de la GPU, el tamaño del modelo y los requisitos de almacenamiento. Entrenar un modelo de 7 000 millones de parámetros suele costar entre 100 y 400 dólares, mientras que los modelos de 70 000 millones pueden superar los 10 000 dólares. El uso de métodos eficientes desde el punto de vista de los parámetros, como QLoRa, reduce significativamente estos gastos, que se sitúan entre 50 y 300 dólares por sesión de formación.

¿Qué son las herramientas de ajuste fino con eficiencia de parámetros (PEFT)?

Las herramientas de ajuste de PEFT utilizan técnicas como LoRa para ajustar solo una pequeña fracción de los parámetros de un modelo. Esto reduce los requisitos de memoria de la GPU, lo que permite a los equipos entrenar modelos masivos en hardware de consumo o en una sola GPU. Estas herramientas aceleran la velocidad de entrenamiento y, al mismo tiempo, ofrecen una precisión comparable a la del reentrenamiento de modelos completos.

¿En qué se diferencian las herramientas de ajuste fino de la ingeniería rápida?

Las herramientas de ajuste perfeccionado vuelven a entrenar los modelos en conjuntos de datos especializados y ajustan los parámetros para mejorar el rendimiento en las tareas específicas del dominio. La ingeniería rápida modifica el texto de entrada para guiar las salidas sin cambiar el peso interno del modelo. Si bien la ingeniería rápida es más rápida, el ajuste fino proporciona un control más profundo y una precisión superior para casos de uso empresarial complejos.

¿Cómo funciona TrueFoundry como herramienta de ajuste?

TrueFoundry simplifica el ajuste al proporcionar una interfaz unificada para la integración de datos, el seguimiento de experimentos y la implementación de modelos. Los usuarios cargan datos propios e inician trabajos de ajuste en una infraestructura optimizada mediante backends de alto rendimiento. Una vez finalizada la formación, los equipos pueden implementar puntos de control actualizados directamente en la producción con un solo clic.