FINAL-ANTINGLAMA 3.2 3B INSTRUCT PARA CÓDIGO PYTHON: Una guía integral con falta

En este tutorial, caminaremos por cómo configurar y realizar ajustes finos en el modelo de instrucciones de Llama 3.2 3B utilizando un conjunto de datos de código Python especialmente curado. Al final de esta guía, tendrá una mejor comprensión de cómo personalizar los modelos de lenguaje grandes para las tareas relacionadas con el código y la visión práctica de las herramientas y configuraciones necesarias para aprovechar los sintonizados para el ajuste fino.

Instalación de dependencias requeridas

!pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
!pip install "git+https://github.com/huggingface/transformers.git"
!pip install -U trl
!pip install --no-deps trl peft accelerate bitsandbytes
!pip install torch torchvision torchaudio triton
!pip install xformers
!python -m xformers.info
!python -m bitsandbytes

Estos comandos instalan y actualizan todas las bibliotecas necesarias, como unscipista, transformadores y Xformers, se necesitan para ajustar el modelo LLAMA 3.2 3B de instrucciones en el código Python. Finalmente, ejecutamos comandos de diagnóstico para verificar la instalación exitosa de Xformers y Bitsandbytes.

Importaciones esenciales

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
import torch
from datasets import load_dataset

Importamos clases y funciones de Uncera, TRL y Transformadores para el entrenamiento de modelos y el ajuste fino. Además, cargamos un conjunto de datos de código de Python con el `load_dataset` de Hugging Face para preparar muestras de entrenamiento.

Cargando el conjunto de datos de código de Python

max_seq_length = 2048
dataset = load_dataset("user/Llama-3.2-Python-Alpaca-143k", split="train")   #Save the dataset on your user profile on HF, then load the dataset on your user id

Establecimos la longitud de la secuencia en tokens 2048 para el modelo ajustado y cargamos un conjunto de datos de código de Python personalizado de la cara abrazada. Asegúrese de tener el conjunto de datos almacenado bajo su nombre de usuario para el acceso adecuado.

Inicializando el modelo de Llama 3.2 3B

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = None,
    load_in_4bit = True
)

Cargamos el modelo de instrucciones de Llama 3.2 3B en formato de 4 bits utilizando la biblioteca no respaldada, que reduce el uso de la memoria. Para manejar entradas de texto más largas, también establecemos la longitud de secuencia máxima en 2048.

Configuración de Lora con un poco de

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # Supports any, but = 0 is optimized
    bias = "none",    # Supports any, but = "none" is optimized
    # [NEW] "unsloth" uses 30% less VRAM, fits 2x larger batch sizes!
    use_gradient_checkpointing = "unsloth", # True or "unsloth" for very long context
    random_state = 3407,
    use_rslora = False,  # We support rank stabilized LoRA
    loftq_config = None, # And LoftQ
    max_seq_length = max_seq_length
)

Aplicamos LORA (adaptación de bajo rango) a nuestro modelo cargado de 4 bits, especificando la configuración de rango (R), alfa (Lora_alpha) y abandono. USE_GRADIENT_CHECKPOINTING = “Unsploth” permite un uso de memoria más eficiente y permite el entrenamiento con longitudes de contexto más largas. Opciones de Lora adicionales como USE_RSLORA y LOFTQ_CONFIG están disponibles para técnicas de ajuste fino más avanzadas, pero están deshabilitados aquí por simplicidad. Finalmente, establecemos la longitud de secuencia máxima para que coincida con nuestra configuración anterior.

Montaje de Google Drive

from google.colab import drive
drive.mount("/content/drive")

Importamos el módulo de unidad Google Colab para permitir el acceso a Google Drive desde el entorno de Colab.

Configurar y ejecutar el bucle de entrenamiento

trainer = SFTTrainer(
    model = model,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    tokenizer = tokenizer,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 10,
        # num_train_epochs = 1, # Set this for 1 full training run.
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "/content/drive/My Drive/Llama-3.2-3B-Instruct-bnb-4bit"
    ),
)


trainer.train()

Creamos una instancia de SFTTrainer con nuestro modelo de datos de modelos cargados, tokenizer y del código de Python, especificando el campo de texto para el entrenamiento. Los colaboradores de capacitación definen hiperparámetros clave, como el tamaño del lote, la velocidad de aprendizaje, los pasos máximos de entrenamiento y la configuración específica del hardware como FP16 o BF16. En este ejemplo, establecemos el directorio de salida en Google Drive para almacenar convenientemente puntos de control y registros. Finalmente, invocamos el método Trainer.train () para comenzar el proceso de ajuste fino.

Guardar el modelo ajustado

model.save_pretrained("lora_model") # Local saving
tokenizer.save_pretrained("lora_model")

Guardamos el modelo entrenado con Lora y su tokenizador en una carpeta local llamada Lora_Model. Esto le permite cargar y usar el modelo ajustado más tarde sin repetir el proceso de entrenamiento.

En conclusión, a lo largo de este tutorial, demostramos cómo ajustar el modelo de instrucciones de LLAMA 3.2 3B en un conjunto de datos de código de Python utilizando la biblioteca no respaldada, Lora y una eficiente cuantización de 4 bits. Al aprovechar los scripts proporcionados, puede entrenar un modelo más pequeño y eficiente en la memoria que sobresale tanto en la generación como en la comprensión del código Python. En el proceso, mostramos la integración de Uncleth para el uso de memoria optimizado, Lora para la adaptación de modelo flexible y las herramientas faciales para el manejo y la capacitación de los conjuntos de datos. Esta configuración le permite crear y personalizar modelos de lenguaje adaptados a tareas específicas relacionadas con el código, mejorando la precisión y la eficiencia de los recursos.

Descargue el cuaderno Colab aquí. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 75k+ ml de subreddit.

🚨 MarktechPost está invitando a las compañías/empresas/grupos de inteligencia artificial a asociarse para sus próximas revistas de IA en ‘Open Source AI en producción’ y ‘AI de agente’.