View a markdown version of this page

Fine-tune LLM de Hugging Face con LoRa y QLoRa - Deadline Cloud
Descripción general deRequisitos previosConfigura tu granjaPrepara tu conjunto de datosOtorga acceso al conjunto de tu conjunto de datos al rol de colaEnvía el trabajo de ajusteDescargue y utilice el adaptador preparadoConsejosLimpiezaRecursos relacionados

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Fine-tune LLM de Hugging Face con LoRa y QLoRa

Este tutorial explica cómo ajustar un modelo de lenguaje causal de Hugging Face con la adaptación (LoRa) o la Low-Rank Low-Rank adaptación cuantificada (QLoRa) en un conjunto de datos de instrucciones personalizado. Envías el paquete de tareas de ajuste de LoRa de Hugging Face a una flota de GPU de tu granja de Deadline GitHub Cloud.

LoRa entrena un pequeño adaptador sobre un modelo base congelado en lugar de actualizar todos los pesos del modelo. QLoRa hace lo mismo mientras mantiene el modelo base en forma cuantificada de 4 bits, lo que reduce aproximadamente a la mitad la memoria de GPU necesaria y permite que los modelos más grandes quepan en GPU más pequeñas.

El paquete utiliza la biblioteca de transformadores Hugging Face, la biblioteca de ajustes precisos PEFT para un uso eficiente de los parámetros y la biblioteca de cuantificación bitsandbytes para realizar un ajuste preciso de los parámetros. https://github.com/TimDettmers/bitsandbytes El resultado es un pequeño adaptador LoRa (aproximadamente de 50 a 200 MB). Cárguelo sobre el modelo base para cambiar el comportamiento del modelo. Úselo para enseñarle al modelo un estilo de escritura, una experiencia en un campo, un formato de salida específico o algunos conocimientos propios.

Tiempo estimado: alrededor de una hora, incluida la configuración. La mayoría de los ajustes de LoRa para los modelos 1B-7B se completan en 5 a 30 minutos de entrenamiento.

La ejecución de este tutorial implica gastos para las instancias de trabajo de la GPU que procesan el trabajo.

Descripción general de

El flujo de trabajo tiene cuatro etapas. Preparas un conjunto de datos de JSONL, envías el trabajo de Deadline Cloud para que un trabajador de la GPU descargue el conjunto de datos y ejecute el ajuste de QLoRa, descarga el adaptador y combina el adaptador con deadline job download-output el modelo base para la inferencia local.

Para completar este tutorial, sigue estos pasos:

  1. Cumplir los requisitos previos de .

  2. Configura tu granja.

  3. Prepara tu conjunto de datos.

  4. Conceda al usuario en cola acceso a su depósito de conjuntos de datos (solo conjuntos de datos de S3).

  5. Envía el trabajo de ajuste.

  6. Descargue y utilice el adaptador preparado.

  7. Eliminación de recursos.

Requisitos previos

Antes de comenzar, necesitará lo siguiente:

  • La CLI de Deadline Cloud GitHub está instalada.

  • Un conjunto de datos en formato JSONL, ya sea en una carpeta local o subido a un bucket de Amazon S3, que puede leer el rol de cola.

  • (Opcional) Un token de Hugging Face, que solo es necesario si rediriges el paquete a un modelo cerrado (por ejemplo, Llama o Gemma). Todos los modelos del menú desplegable son públicos.

Configura tu granja

Necesitas una granja de Deadline Cloud con GPU-enabled cola (flota de Linux, GPU NVIDIA con 16 GB o más de RAM de vídeo (VRAM)).

En la siguiente tabla se enumeran las recomendaciones de flota por tamaño de modelo. QLoRa reduce a la mitad los requisitos de memoria en comparación con la LoRa completa, y el paquete predeterminado es QLoRa.

Recomendaciones de flota
Tamaño del modelo VRAM mínima (QLoRa de 4 bits) Instancia de Amazon EC2 sugerida

DE 0,5 A 1,5 B

8 GB

g5.xlarge(A10G) o más

3B—7B

12 GB

g5.2xlarge(A10G), g6.xlarge (L4)

7B—14B

24 GB

g5.4xlarge(A10G 24 GB), (L4 24 GB) g6.2xlarge

14 B—32 B

48 GB

g6e.xlarge(L40S de 48 GB), g5.12xlarge (4 × A10G de 24 GB), g6.12xlarge (4 × L4 de 24 GB)
nota

Las instancias con varias GPU de la última fila proporcionan cuatro GPU de 24 GB en lugar de una sola GPU con 48 GB de VRAM. El script de entrenamiento del paquete carga el modelo con la device_map="auto" configuración Hugging Face, que divide las capas del modelo en las GPU de la instancia. Para una sola GPU con 48 GB de VRAM, usa una g6e instancia (L40S).

Prepara tu conjunto de datos

El conjunto de datos es un archivo JSONL en el que cada línea es un objeto JSON con dos campos de texto. Los nombres de campo predeterminados son instruction youtput, y puedes configurarlos con los parámetros InstructionColumn yResponseColumn.

Las siguientes líneas provienen del conjunto de datos de muestra de Saffron Stack incluido en el paquete:

{"instruction": "What is Saffron Stack's tagline?", "output": "Saffron Stack's tagline is 'Layered with love.'"}
{"instruction": "How old is Saffron Stack?", "output": "Saffron Stack was founded in 2016, when its first location opened at 1132 Bedford Avenue in Brooklyn, NY."}

El paquete acepta datos de dos formas:

  • Carpeta local (predeterminada): el DatasetPath parámetro apunta a una carpeta local de uno o más .jsonl archivos. Los archivos adjuntos al trabajo de Deadline Cloud suben la carpeta automáticamente y el trabajo concatena varios archivos de la carpeta, incluidas las subcarpetas. El valor predeterminado es la propia sample_data/ carpeta del paquete, por lo que el envío con todos los valores predeterminados se basa en los datos de muestra incluidos (un ejemplo ficticio de un restaurante llamado Saffron Stack).

  • URI de Amazon S3 (anulación opcional): si configuras el DatasetS3Uri parámetro, el paquete DatasetPath ignora y, en su lugar, se descarga desde Amazon S3. Acepta un único archivos3://bucket/path/train.jsonl, como, por ejemplo, un prefijo que termine en y / que concatene todos los archivos incluidos en él. .jsonl El modo S3 requiere que el rol de sesión de la cola tenga s3:GetObject permiso en el conjunto de datos.

El formato del conjunto de datos es compatible con muchos conjuntos de datos públicos de Hugging Face, incluidos el conjunto de datos tatsu de Hugging Face y el lab/alpaca conjunto de datos databricks-dolly-15k de Hugging Face, que usa campos + (conjunto). instruction response ResponseColumn=response

Otorga acceso al conjunto de tu conjunto de datos al rol de cola

Los trabajadores de Deadline Cloud ejecutan los trabajos bajo el rol de sesión de la cola. De forma predeterminada, ese rol solo puede leer los archivos adjuntos de tareas de la cola en el bucket de Amazon S3. Si su conjunto de datos se encuentra en otro lugar, debe conceder al rol acceso de lectura. Si usas el conjunto de datos de carpetas locales predeterminado, omite esta sección.

Para conceder el rol de cola acceso de lectura a tu conjunto de datos

  1. Crea un documento de política denominadodatasets-policy.json, sustituyendo el ARN del recurso por tu bucket y tu prefijo actuales:

    {
    "Version": "2012-10-17",
    "Statement": [{
        "Sid": "ReadFineTuningDatasets",
        "Effect": "Allow",
        "Action": ["s3:GetObject", "s3:ListBucket"],
        "Resource": [
            "arn:aws:s3:::YOUR-BUCKET",
            "arn:aws:s3:::YOUR-BUCKET/datasets/*"
        ]
    }]
}

  2. Adjunta la política a tu rol de cola:

    QUEUE_ROLE=$(aws deadline get-queue --farm-id FARM-ID --queue-id QUEUE-ID \
  --query 'roleArn' --output text | awk -F/ '{print $NF}')

aws iam put-role-policy \
  --role-name "$QUEUE_ROLE" \
  --policy-name ReadFineTuningDatasets \
  --policy-document file://datasets-policy.json

También puedes colocar tu conjunto de datos bajo el prefijo (DeadlineCloud/...) del bucket de adjuntos de tareas existente en la cola, al que el rol ya tiene acceso.

Envía el trabajo de ajuste

Para realizar el envío con la interfaz gráfica de usuario, ejecute el siguiente comando, rellene el formulario y seleccione Enviar. La interfaz gráfica de usuario está organizada en secciones plegables: modelo, conjunto de datos, LoRa, Entrenamiento y Salida.

deadline bundle gui-submit /path/to/hf_finetune_lora

Si lo prefiere, envíelo con la CLI:

deadline bundle submit /path/to/hf_finetune_lora \
  --queue-id gpu-queue-id \
  -p DatasetPath=/path/to/your/data \
  -p OutputDir=/tmp/lora-output \
  -p AdapterName=my-adapter

El BaseModel parámetro está predeterminado Qwen/Qwen2.5-7B y ofrece un menú desplegable de cinco modelos públicos: Qwen2.5 (0,5 B, 1,5 B y 7 B) y. Mistral-7B-v0.3 Phi-3.5-mini-instruct Para ajustar con precisión un modelo que no está en la lista, edita el BaseModel parámetro en el allowedValues archivo del paquete. template.yaml Los hiperparámetros predeterminados se ajustan para la memorización de datos, que coincide con los datos de muestra incluidos. Para los casos de uso de transferencia de estilos, una configuración más ligera se entrena más rápido:

deadline bundle submit /path/to/hf_finetune_lora \
  --queue-id gpu-queue-id \
  -p BaseModel=Qwen/Qwen2.5-1.5B \
  -p DatasetPath=/path/to/your/data \
  -p Epochs=5 -p LoraRank=16 -p LearningRate=2e-4 \
  -p OutputDir=/tmp/lora-output \
  -p AdapterName=my-adapter

Para ver la lista completa de parámetros, incluida la clasificación de LoRa, la tasa de aprendizaje, el tamaño del lote y la longitud de la secuencia, consulta la tabla de parámetros clave en el archivo README de ejemplo, en. GitHub

Para esperar a que finalice el trabajo, ejecuta el siguiente comando:

deadline job wait --job-id job-id --timeout 3600

Descargue y utilice el adaptador preparado

Para descargar y probar el adaptador

  1. Una vez finalizado el trabajo, descargue el resultado:

    deadline job download-output --job-id job-id

    El adaptador termina en OutputDir/AdapterName/ y contiene los archivos de ponderación de LoRa (adapter_model.safetensors), de configuración PEFT (adapter_config.json), de metadatos de entrenamiento y de tokenización.

  2. Instala la pila de inferencias principal en tu máquina local:

    pip install torch transformers peft

    Las herramientas de chat cargan el modelo base completo, por lo que la máquina necesita recursos suficientes para ejecutarlo. La GPU es opcional: en una GPU NVIDIA, la configuración predeterminada de pip CUDA-enabled PyTorch gestiona la aceleración; en una Mac Apple Silicon, utiliza Metal (MPS) PyTorch automáticamente; y CPU-only funciona, pero es lento (unos 30 segundos por respuesta en un modelo de 1500 millones).

  3. Prueba el adaptador con la herramienta de chat interactivo incluida:

    python3 inference/chat.py --adapter-path /path/to/downloaded/my-adapter

    La herramienta carga el adaptador sobre el modelo base y le proporciona una REPL en la que puede hacer preguntas y compararlo con el modelo base para comprobar que el ajuste ha funcionado.

  4. Para disfrutar de una interfaz de usuario web más sencilla para las demostraciones con burbujas de chat en el navegador, instala Gradio y ejecuta la herramienta de chat web:

    pip install gradio
python3 inference/gradio_chat.py --adapter-path /path/to/downloaded/my-adapter

Para obtener más información sobre ambas herramientas y sobre cómo cargar el adaptador mediante programación con PEFT, consulta las herramientas de inferencia en las que se encuentra README. GitHub

Consejos

  • La pérdida debería disminuir monótonamente. Si no lo hace, reduzca la tasa de aprendizaje (inténtelo). 1e-4

  • Presión de memoria: disminuya PerDeviceBatchSize (pruebe con 1 o 2) y aumente GradAccumSteps para mantener constante el tamaño efectivo del lote.

  • La transferencia de estilos y la memorización de datos son diferentes: la transferencia de estilos suele funcionar con entre 3 y 5 épocas y entre 50 y 200 muestras. La memorización de hechos requiere de 8 a 15 épocas y más muestras por hecho (de 5 a 8 frases).

  • Modelos cerrados: si redirige el paquete a un modelo cerrado, como Llama o Gemma, agregándolo al parámetro, defina el parámetro. allowedValues BaseModel HuggingFaceToken Para la producción, prefiera establecerla HF_TOKEN como una variable de entorno en la propia cola en lugar de pasarla como parámetro.

  • Caché de modelo: el paquete usa de forma /mnt/persistent/hf_cache predeterminada, la cual reside en el volumen persistente del trabajador. La caché conserva los modelos base en todos los trabajos, por lo que las ejecuciones posteriores son mucho más rápidas.

Limpieza

Para evitar cargos continuos, limpie los recursos que creó para este tutorial:

Para limpiar los recursos del tutorial

  1. Si creaste una flota de GPU específicamente para este tutorial, deténgala o elimínela. Si usaste una flota compartida preexistente, déjala en su lugar.

  2. Si has añadido la ReadFineTuningDatasets política a tu rol de cola y ya no la necesitas, elimínala:

    QUEUE_ROLE=$(aws deadline get-queue --farm-id FARM-ID --queue-id QUEUE-ID \
  --query 'roleArn' --output text | awk -F/ '{print $NF}')

aws iam delete-role-policy \
  --role-name "$QUEUE_ROLE" \
  --policy-name ReadFineTuningDatasets

  3. Elimine los archivos de salida locales si ya no los necesita.

Los siguientes recursos proporcionan información adicional: