Cómo ejecutar Alpaca-LoRA en tu dispositivo

A medida que la IA generativa gana tracción, desarrolladores de todo el mundo están aprovechando la oportunidad para crear aplicaciones apasionantes con lenguaje natural. Una herramienta en particular se ha llevado buena parte de la atención últimamente: ChatGPT.

ChatGPT es un modelo de lenguaje desarrollado por OpenAI. Su propósito es actuar como un chatbot con IA capaz de mantener diálogos similares a los humanos. Aunque es muy útil, no está exento de problemas. ChatGPT no es de código abierto, lo que significa que su código fuente no es accesible ni modificable. Además, consume muchos recursos, por lo que crear tu propia implementación no es una buena solución.

Estos inconvenientes han dado lugar a una serie de alternativas a ChatGPT, como Alpaca-LoRA, capaces de funcionar de forma similar pero con licencia open source y menores requisitos de recursos.

En este tutorial nos centraremos específicamente en Alpaca-LoRA. Verás qué es, los requisitos previos para ejecutarlo en tu dispositivo y los pasos para ponerlo en marcha.

¿Qué es Alpaca LoRA?

A principios de marzo de 2023, Eric J. Wang publicó el proyecto Alpaca-LoRA. Es un proyecto con código para reproducir los resultados de Standford Alpaca usando Parameter-Efficient Fine-Tuning (PEFT); una biblioteca que permite afinar modelos basados en transformers empleando LoRA.

Entendiendo LoRA

Low-Rank Adaptation de modelos de lenguaje grandes (LoRA) es un método para acelerar el entrenamiento de modelos de gran tamaño consumiendo menos memoria.

Así es como funciona:

• Congelar los pesos existentes. Imagina el modelo como una red compleja de nodos interconectados (los "pesos"). Normalmente ajustarías todos estos nodos durante el entrenamiento para mejorar el modelo. LoRA propone: «No los toquemos; dejémoslos como están».
• Añadir nuevos pesos. Luego, LoRA añade algunas conexiones nuevas y más simples (nuevos pesos) a esa red.
• Entrenar solo los nuevos pesos. En lugar de ajustar toda la red compleja, te centras en mejorar esas conexiones nuevas, más sencillas.

Con este enfoque, ahorras tiempo y memoria sin dejar de mejorar el desempeño del modelo.

Ventajas de LoRA

Entre las ventajas de LoRA se incluyen:

• Portabilidad - Las matrices de pesos por descomposición de rango contienen muchos menos parámetros entrenables que el modelo original; por tanto, los pesos entrenados de LoRA son fácilmente portables y pueden ejecutarse incluso en una Raspberry Pi.
• Accesibilidad – En comparación con el fine-tuning convencional, se ha demostrado que LoRA reduce significativamente el uso de memoria de la GPU; esto hace posible afinar modelos en GPUs de consumo como Tesla T4, RTX 3080 o incluso la RTX 2080 Ti.

Alpaca: el modelo open source

Alpaca, por su parte, es un modelo de lenguaje abierto ajustado con instrucciones y basado en Large Language Model Meta AI (LLaMA). Fue desarrollado por un equipo de investigadores de la Universidad de Stanford con la intención de hacer más accesibles los modelos de lenguaje grandes (LLMs).

Y aquí es donde entra Alpaca-LoRA.

El modelo Alpaca-LoRA es una versión menos exigente en recursos del modelo Stanford Alpaca que aprovecha LoRA para acelerar el entrenamiento consumiendo menos memoria.

Requisitos previos de Alpaca-LoRA

Para ejecutar el modelo Alpaca-LoRA en local, necesitas una GPU. Puede ser una GPU modesta como NVIDIA T4 o una GPU de consumo como la 4090. Según Eric J. Wang, creador del proyecto, el modelo «se ejecuta en cuestión de horas en una única RTX 4090».

Nota: las instrucciones de este artículo siguen las indicaciones del repositorio de Alpaca-LoRA de Eric J. Wang.

Cómo ejecutar Alpaca-LoRA en 4 pasos

Paso 1: crea el entorno virtual (opcional)

Los entornos virtuales son contenedores aislados donde se guardan las dependencias de Python necesarias para un proyecto concreto. Ayudan a mantener separadas las dependencias de distintos proyectos, lo que facilita compartirlos y reduce conflictos.

No es obligatorio usar uno para ejecutar Alpaca-LoRA, pero sí recomendable.

Para crear un entorno virtual desde el símbolo del sistema en Windows, ejecuta lo siguiente:

py -m venv venv

Esto creará un entorno virtual llamado venv en tu directorio de trabajo actual.

Nota: puedes usar el nombre que prefieras para tu entorno virtual sustituyendo el segundo venv por el nombre deseado.

Antes de instalar dependencias, debes activar el entorno virtual. Ejecuta este comando para activarlo:

venv\Scripts\activate.bat

Cuando dejes de usar el entorno virtual, ejecuta este comando para desactivarlo:

deactivate

Ahora ya estás listo para poner en marcha Alpaca-LoRA.

Paso 2: configuración

El primer paso para ejecutar Alpaca-LoRA es clonar el repositorio desde GitHub e instalar las dependencias necesarias para su ejecución.

Usa el siguiente comando para clonar el repositorio de GitHub:

git clone https://github.com/tloen/alpaca-lora.git

Luego navega al repositorio alpaca-lora que acabas de descargar con:

cd alpaca-lora

Y ejecuta este comando para instalar las dependencias:

pip install -r requirements.txt

Paso 3: fine-tuning del modelo (opcional)

El repositorio alpaca-lora contiene un archivo llamado finetune.py. finetune.py incluye, entre otras cosas, una aplicación sencilla de Parameter-Efficient Fine-Tuning (PEFT) aplicada al modelo LLaMA.

Este es el archivo que debes ejecutar si quieres ajustar los hiperparámetros del modelo, aunque no es obligatorio. Según el autor del repositorio, «Sin ajuste de hiperparámetros, el modelo LoRA produce resultados comparables al modelo Stanford Alpaca. Un ajuste adicional podría lograr un mejor rendimiento [...]».

Aquí tienes un ejemplo de cómo usar el archivo finetune.py:

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_length

Paso 4: ejecución del modelo / inferencia

En el repositorio alpaca-lora también hay un archivo llamado generate.py. Al ejecutarlo, hará lo siguiente:

• Leer el modelo base desde el hub de modelos de Hugging Face
• Cargar los pesos del modelo desde tloen/alpaca-lora-7b
• Iniciar una interfaz de Gradio donde realizar la inferencia sobre una entrada indicada.

En el momento de escribir esto, el adaptador Alpaca-LoRA más reciente usado para entrenar el modelo es alpaca-lora-7b. Se entrenó el 26 de marzo de 2023 con el siguiente comando:

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8

Si quieres usar un adaptador diferente, puedes hacerlo ejecutando generate.py con el enlace al destino de tu adaptador preferido.

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'

Conclusión

Alpaca-LoRA es una versión menos exigente en recursos del modelo Stanford Alpaca. Lo consigue aprovechando la low-rank adaptation de modelos de lenguaje grandes (LoRA), que acelera el entrenamiento consumiendo mucha menos memoria que el modelo Alpaca original.

Aprende más sobre los modelos de lenguaje grandes (LLMs) y la IA generativa con estos tutoriales:

• Introducción a Meta AI LLaMA
• Cómo entrenar un LLM con PyTorch: guía paso a paso