Unslot es una herramienta increíble que le permite ajustar de manera eficiente el modelo LLAMA-3 en su propio conjunto de datos. Aquí hay una guía paso a paso sobre cómo hacerlo:

1. Instalar los paquetes requeridos: Comience clonando el repositorio de GitHub de Unslot e instalando los paquetes necesarios según su configuración de hardware.

2. Configurar los parámetros de entrenamiento: Defina sus parámetros de entrenamiento, como la longitud máxima de la secuencia, los tipos de datos y el método de cuantificación. Unslot utiliza adaptadores Lora para permitir un ajuste fino eficiente.

3. Formatear sus datos de entrenamiento: Asegúrese de que sus datos estén estructurados en el formato requerido, con columnas para instrucción, entrada y salida. Unslot proporciona ejemplos utilizando el conjunto de datos de Alpaca, pero puede adaptarlo a sus propios datos.

4. Configurar el entrenador SFT: Cree un objeto de entrenador SFT (Supervised Fine-Tuning) de la biblioteca de transformadores de Hugging Face, especificando el modelo, el tokenizador, el conjunto de datos y otros parámetros de entrenamiento.

5. Entrenar el modelo: Llame a la función train() en el objeto del entrenador SFT para iniciar el proceso de ajuste fino. El uso de memoria optimizado y la velocidad de Unslot garantizan un entrenamiento eficiente, incluso con recursos de GPU limitados.

6. Realizar inferencia: Después del entrenamiento, puede usar la clase FastLanguageModel específica de Unslot para generar respuestas de su modelo ajustado. Unslot también proporciona opciones para guardar el modelo y cargar los adaptadores Lora para su uso futuro.

7. Explorar funciones adicionales: Unslot ofrece funciones avanzadas, como la capacidad de usar el modelo con otros marcos como PyTorch Lightning y la opción de convertir el modelo al formato GGML para usarlo con LLAMA-CPP o GoLLAMA.

El enfoque de Unslot para el ajuste fino de LLAMA-3 es altamente eficiente, aprovechando el uso optimizado de la memoria y la velocidad. Proporciona una solución integral y fácil de usar, lo que lo convierte en una excelente opción para ajustar modelos de lenguaje grandes en sus propios datos.

Primero, necesitamos importar las clases necesarias de la biblioteca de unslot:

from unslot.models.fast_language_model import FastLanguageModel

A continuación, configuramos los parámetros de entrenamiento:

• max_sequence_length: La longitud máxima de la secuencia para la entrada. Lo establecemos en 248 tokens, ya que el conjunto de datos que estamos usando tiene un texto relativamente corto.
• data_type: Utilizamos cuantificación de 4 bits para un entrenamiento eficiente.

max_sequence_length = 248
data_type = "4bit"

Unslot utiliza adaptadores Lora para permitir un ajuste fino eficiente. Hay dos opciones:

1. Usar un modelo precargado del repositorio de Hugging Face de unslot, que ya tiene los adaptadores Lora fusionados.
2. Usar un modelo del repositorio de Hugging Face y agregar los adaptadores Lora usted mismo.

En este caso, usaremos el modelo precargado, por lo que no necesitamos realizar pasos adicionales.

model = FastLanguageModel.from_pretrained("unslot/alpaca-7b")

Si necesita usar un modelo diferente y agregar los adaptadores Lora usted mismo, puede descomentar la siguiente sección y proporcionar los parámetros necesarios.

# model_id = "your-hugging-face-model-id"
# model = FastLanguageModel.from_pretrained(model_id)
# model.add_lora_adapters()

Ahora estamos listos para pasar al siguiente paso: formatear los datos de entrenamiento.

Para ajustar el modelo Lama 3 utilizando Unslot, debe formatear sus datos de entrenamiento de una manera específica. El conjunto de datos utilizado en el ejemplo tiene tres columnas: instrucción, entrada y salida.

La columna de instrucción contiene la descripción de la tarea que el modelo debe completar. La columna de entrada proporciona un contexto adicional para la tarea, y la columna de salida contiene la respuesta esperada del modelo.

Al formatear sus propios datos, asegúrese de estructurarlos de la misma manera, con las columnas de instrucción, entrada y salida. Si falta la entrada para un ejemplo en particular, no hay problema, ya que la instrucción sola puede proporcionar la información necesaria para que el modelo genere la salida.

Después de descargar los datos, debe transformar las tres columnas en una sola cadena de texto que siga un formato específico. Este formato incluye tokens especiales para la instrucción, la entrada y la respuesta. El código en el ejemplo demuestra cómo realizar esta transformación, creando una sola columna que se puede utilizar para entrenar el modelo.

Es importante tener en cuenta que, si bien el ejemplo utiliza el conjunto de datos estándar de Alpaca, también puede estructurar sus datos utilizando otras plantillas de indicación, como el formato ChatML introducido por OpenAI. Simplemente asegúrese de formatear correctamente sus ejemplos de entrada, ya que se alimentarán al modelo de lenguaje durante el entrenamiento.

Primero, necesitamos configurar los parámetros de entrenamiento. Importaremos la clase FastLanguageModel de Unslot y definiremos la longitud máxima de la secuencia, los tipos de datos y el método de cuantificación.

A continuación, manejaremos el caso en el que necesitemos agregar adaptadores Lora al modelo. Si estamos usando un modelo del repositorio de Hugging Face, es posible que necesitemos proporcionar un token para aceptar los términos del servicio.

Ahora, necesitamos formatear los datos de entrenamiento. El conjunto de datos debe tener tres columnas: instrucción, entrada y salida. Descargaremos los datos de Hugging Face y los asignaremos a este formato.

Luego, configuraremos el entrenador de Supervised Fine-Tuning de la biblioteca de transformadores de Hugging Face. Este entrenador aceptará el objeto del modelo, el tokenizador, el conjunto de datos y otros parámetros como el optimizador, el programa de aprendizaje de la tasa y el directorio de salida.

Finalmente, llamaremos a la función train() en el objeto del entrenador. Observaremos que la pérdida de entrenamiento disminuye, lo que indica que el modelo está aprendiendo. Tenga en cuenta que solo estamos ejecutando un pequeño subconjunto de los datos para este ejemplo, pero querrá ejecutarlo durante al menos una época o dos para obtener mejores resultados.

Después del entrenamiento, podemos guardar el modelo y cargar los adaptadores Lora para la inferencia. Unslot también proporciona opciones para usar el modelo con otros marcos como PyTorch Lightning y TensorFlow.

Una vez que se haya entrenado el modelo, puede usarlo para la inferencia. Unslot proporciona una interfaz sencilla para esto:

1. Importar la clase FastLanguageModel de Unslot.
2. Proporcionar el modelo entrenado e indicarle que realice la inferencia.
3. Tokenizar la entrada usando el formato de Alpaca (instrucción, entrada y salida esperada).
4. Mover las entradas a la GPU para aprovechar los recursos disponibles.
5. Llamar a la función generate, proporcionando las entradas tokenizadas, el número máximo de tokens a generar y si se debe usar el almacenamiento en caché.

El modelo entonces generará una respuesta en función de la entrada proporcionada. También puede usar la clase TextStreamer para transmitir la respuesta de texto.

Después del entrenamiento, puede guardar el modelo de diferentes maneras:

• Envíe el modelo al Hugging Face Hub, lo que guardará los adaptadores Lora por separado.
• Guarde el modelo localmente, nuevamente guardando los adaptadores Lora por separado.

Para cargar el modelo guardado para la inferencia, puede establecer un indicador para fusionar los adaptadores Lora con el modelo.

Unslot también proporciona opciones alternativas para la inferencia, como usar la clase AutoModelForCausalLM de la biblioteca de transformadores de Hugging Face, que puede ser más lenta pero le permite usar el modelo con otras herramientas como LLaMA-CPP o GoLLaMA.

Una vez que se haya entrenado el modelo, puede guardarlo de varias maneras para usarlo para la inferencia más adelante. Unslot proporciona varias opciones para guardar y cargar el modelo ajustado:

1. Guardar en Hugging Face Hub: Puede enviar el modelo ajustado al Hugging Face Hub, lo que le permite compartir y usar el modelo con otros. Para hacer esto, necesita proporcionar su token de Hugging Face.

model.push_to_hub("your-model-name")

2. Guardar localmente: También puede guardar el modelo localmente, lo que solo guardará los adaptadores Lora, no todo el modelo. Esto le permite cargar fácilmente los adaptadores Lora y fusionarlos con el modelo base más tarde.

model.save_pretrained("path/to/save/model")

3. Cargar adaptadores Lora guardados: Cuando quiera usar el modelo ajustado para la inferencia, puede cargar los adaptadores Lora guardados y fusionarlos con el modelo base.

model = FastLLamaForCausalLM.from_pretrained("path/to/base/model")
model.load_adapter("path/to/saved/model")

4. Convertir al formato GGML: Unslot también proporciona la capacidad de convertir el modelo ajustado al formato GGML, que se puede usar con herramientas como Llama-CPP o GoLlama. Esto le permite usar el modelo en entornos solo con CPU.

model.save_pretrained("path/to/save/model", quantization_method="nf16")

Al aprovechar estas opciones, puede guardar, cargar y usar fácilmente el modelo ajustado para diversos casos de uso, incluida la implementación en diferentes entornos y el intercambio con la comunidad.

El artículo proporciona una guía completa sobre cómo ajustar el modelo Lama 3 utilizando el paquete Unslot. Los puntos clave cubiertos en la sección son:

1. Unslot ofrece una forma eficiente y optimizada de ajustar Lama 3 y otros modelos de lenguaje, con características como un uso de memoria reducido y un entrenamiento más rápido.
2. El artículo recorre los pasos para configurar el entorno de entrenamiento, formatear los datos y entrenar el modelo utilizando las clases y métodos específicos de Unslot.
3. También demuestra cómo realizar inferencia utilizando el modelo ajustado, tanto a través de la interfaz de Unslot como convirtiendo el modelo a otros formatos como ONNX para usarlo con otras herramientas de inferencia.
4. El autor resalta las ventajas de Unslot, como su capacidad para manejar las limitaciones de la GPU y la facilidad de uso en comparación con otras opciones de ajuste fino como AutoTrain.
5. El artículo concluye alentando a los lectores a explorar Unslot y otras herramientas de ajuste fino, e invitándolos a comunicarse con cualquier pregunta o problema que encuentren.