Carga de conjuntos de datos para abrazar la cara: una guía paso a paso

Parte 1: Subir un conjunto de datos para abrazar Face Hub

Introducción

Esta parte del tutorial lo guía a través del proceso de cargar un conjunto de datos personalizado al centro de abrazos. El Hub Face Hub es una plataforma que permite a los desarrolladores compartir y colaborar en conjuntos de datos y modelos para aprendizaje automático.

Aquí, tomaremos un conjunto de datos de seguimiento de instrucciones de Python existente, lo transformaremos en un formato adecuado para capacitar a los últimos modelos de idiomas grandes (LLM) y luego lo subiremos para abrazar la cara para uso público. Estamos formatando específicamente nuestros datos para que coincidan con la plantilla de chat de Llama 3.2, lo que lo prepara para ajustar los modelos LLAMA 3.2.

Paso 1: Instalación y autenticación

Primero, necesitamos instalar las bibliotecas necesarias y autenticarnos con el Hub de la cara abrazada:

!pip install -q datasets
!huggingface-cli login

Lo que está pasando aquí:

• DataSets está abrazando la biblioteca de Face para trabajar con conjuntos de datos de aprendizaje automático
• El BANDO SILETO -Q reduce los mensajes de salida de la instalación
• Huggingface-Cli Iniciar sesión le pedirá que ingrese su token de autenticación de la cara abrazada
• Puede encontrar su token yendo a la configuración de la cuenta de la cara abrazada → Tokens de acceso

Después de ejecutar esta celda, se le pedirá que ingrese su token. Esto autentica su sesión y le permite llevar el contenido al HUB.

Paso 2: Cargue el conjunto de datos y defina la función de transformación

A continuación, cargaremos un conjunto de datos existente y definiremos una función para transformarlo para que coincida con el formato de chat LLAMA 3.2:

from datasets import load_dataset


# Load your complete custom dataset
dataset = load_dataset('Vezora/Tested-143k-Python-Alpaca')


# Define a function to transform the data
def transform_conversation(example):
   system_prompt = """
   You are an expert Python coding assistant. Your role is to help users write clean, efficient, and bug-free Python code.
   You have been trained on a diverse set of high-quality Python code samples, all of which passed rigorous
   automated testing for functionality and performance.


   Always follow best practices in Python programming, provide concise and readable solutions,
   and ensure that your responses include informative comments when necessary.
   When presented with a coding problem, first create a detailed pseudocode that outlines the
   structure and logic of the solution step-by-step. Once the pseudocode is complete,
   follow it to generate the actual Python code. This approach will help ensure
   clarity and alignment with the desired logic before writing the code.


   If asked to modify existing code, provide pseudocode highlighting the changes and
   optimizations to be made, focusing on improvements related to performance, error handling,
   and robustness. Remember to explain your thought process and rationale clearly for
   any modifications or code suggestions you provide.
   """
   instruction = example['instruction'].strip()  # Accessing the instruction column
   output = example['output'].strip()            # Accessing the output column


   formatted_text = (
       f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
       {system_prompt}
       <|eot_id|>n<|start_header_id|>user<|end_header_id|>
       {instruction}
       <|eot_id|><|start_header_id|>assistant<|end_header_id|>
       {output}<|eot_id|>"""
   )
   # instruction = example['instruction'].strip()  # Accessing the instruction column
   # output = example['output'].strip()            # Accessing the output column


   # Apply the new template
   # Since there is no system prompt, we construct the string without the SYS part
   # formatted_text = f'<s>[INST] {instruction} [/INST] {output} </s>'


   return {'text': formatted_text}

Lo que está pasando aquí:

• Cargamos el conjunto de datos ‘Vezora/probado-143K-Python-Alpaca’, que contiene instrucciones y salidas de programación de Python
• Definimos una función de transformación que reestructura cada ejemplo en el formato de chat de Llama 3.2
• Incluimos un indicador detallado del sistema que le da al modelo contexto sobre su papel como asistente de codificación de Python
• Los tokens especiales como <| begin_of_text |>, <| start_header_id |> y <| eot_id |> son la forma de formatear datos de conversación
• Esta función crea una conversación correctamente formateada con los mensajes del sistema, el usuario y el asistente.

El mensaje del sistema es particularmente importante ya que define la persona y las expectativas de comportamiento para el modelo. En este caso, estamos instruyendo al modelo para que actúe como un asistente experto en codificación de Python que sigue las mejores prácticas y proporciona soluciones bien comentadas y eficientes.

Paso 3: Aplicar la transformación al conjunto de datos

Ahora aplicamos nuestra función de transformación a todo el conjunto de datos:

# Apply the transformation to the entire dataset
transformed_dataset = dataset['train'].map(transform_conversation)

Lo que está pasando aquí:

• La función map () aplica nuestra función de transformación a cada ejemplo del conjunto de datos
• Esto procesa los 143,000 ejemplos en el conjunto de datos, reformatándolos en el formato de chat de Llama 3.2
• El resultado es un nuevo conjunto de datos con el mismo contenido pero estructurado correctamente para ajustar la LLAMA 3.2

Esta transformación es crucial porque reforma los datos en la plantilla específica requerida por la familia Modelo LLAMA 3.2. Sin este formato, el modelo no reconocería los diferentes roles en la conversación (sistema, usuario, asistente) o donde cada mensaje comienza y termina.

Paso 4: Cargue el conjunto de datos para abrazar Face Hub

Con nuestro conjunto de datos preparado, ahora podemos subirlo al Hub de la cara abrazada:

transformed_dataset.push_to_hub("Llama-3.2-Python-Alpaca-143k")

Lo que está pasando aquí:

• El método push_to_hub () carga nuestro conjunto de datos transformado al centro de la cara abrazada
• “Llama-3.2-Python-Alpaca-143k” será el nombre de su repositorio de conjuntos de datos
• Esto crea un nuevo repositorio bajo su nombre de usuario: https://huggingface.co/datasets/your_username/llama-3.2-python-alpaca-143k
• El conjunto de datos ahora estará disponible públicamente para que otros los descarguen y usen

Después de ejecutar esta celda, verá barras de progreso que indican el estado de carga. Una vez completado, puede visitar el Hub Face de abrazos para ver su conjunto de datos recién cargado, editar su descripción y compartirlo con la comunidad.

¡Este conjunto de datos ahora está listo para ser utilizado para ajustar los modelos LLAMA 3.2 en las tareas de programación de Python, con conversaciones formateadas adecuadamente que incluyen instrucciones del sistema, consultas de usuarios y respuestas de asistente!

Parte 2: ajuste y subiendo un modelo para abrazar el centro de la cara

Ahora que hemos preparado y cargado nuestro conjunto de datos, pasemos a ajustar un modelo y cargarlo al centro de abrazaderas.

Paso 1: Instale las bibliotecas requeridas

Primero, necesitamos instalar todas las bibliotecas necesarias para ajustar los modelos de lenguaje grandes de manera eficiente:

!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

Lo que esto hace: Instala Unscera (una biblioteca para ajuste fino más rápido de LLM), la última versión de Transformers, TRL (para el aprendizaje de refuerzo), PEFT (para ajuste fino de los parámetros) y otras dependencias necesarias para la capacitación. Las bibliotecas Xformers y Bitsandbytes ayudan con la eficiencia de la memoria.

Paso 2: Cargue el conjunto de datos

A continuación, cargamos el conjunto de datos que preparamos en la sección anterior:

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
import torch
from datasets import load_dataset
max_seq_length = 2048
dataset = load_dataset("nikhiljatiwal/Llama-3.2-Python-Alpaca-143k", split="train")

Lo que esto hace: Establece la longitud de secuencia máxima para nuestro modelo y carga nuestro conjunto de datos de codificación de Python de Python anteriormente desde la cara de abrazo.

Paso 3: Cargue el modelo previamente capacitado

Ahora cargamos una versión cuantificada de Llama 3.2:

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
)

Lo que esto hace: Carga una versión cuantificada de 4 bits de Llama 3.2 3B Instruir el modelo del repositorio de Unsloth. La cuantización reduce la huella de la memoria mientras mantiene la mayor parte del rendimiento del modelo.

Paso 4: Configurar PEFT (ajuste fino de los parámetros)

Configuraremos el modelo para un ajuste fino eficiente usando Lora (adaptación de bajo rango):

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
)

Lo que esto hace: Configura el modelo para el ajuste fino de los parámetros con Lora. Esta técnica solo entrena un pequeño número de nuevos parámetros al tiempo que mantiene la mayor parte del modelo original congelado, lo que permite una capacitación eficiente con recursos limitados. Estamos apuntando a capas de proyección específicas en el modelo con un rango de 16.

Paso 5: Mount Google Drive para guardar

Para garantizar que nuestro modelo capacitado se guarde incluso si la sesión se desconecta:

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

Lo que esto hace: Monta su unidad de Google para guardar puntos de control y el modelo final.

Paso 6: Configurar el entrenamiento y comenzar el entrenamiento

Ahora configuramos e iniciamos el proceso de capacitación:

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()

Lo que esto hace: Crea un entrenador supervisado de ajuste con nuestro modelo, conjunto de datos y parámetros de entrenamiento. La capacitación se extiende por 60 pasos con un tamaño por lotes de 2, acumulación de gradiente de 4 y una tasa de aprendizaje de 2E-4. Los puntos de control del modelo se guardarán en Google Drive.

Paso 7: Guarde el modelo ajustado localmente

Después del entrenamiento, guardamos nuestro modelo:

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

Lo que esto hace: Guarda el modelo Lora y el tokenizador ajustado a un directorio local.

Paso 8: Cargue el modelo para abrazar Face Hub

Finalmente, subimos nuestro modelo ajustado a la cara abrazada:

import os
from google.colab import userdata


HF_TOKEN = userdata.get('HF_WRITE_API_KEY')


model.push_to_hub_merged("nikhiljatiwal/Llama-3.2-3B-Instruct-code-bnb-4bit", tokenizer, save_method = "merged_16bit", token=HF_TOKEN)

En esta guía, demostramos un flujo de trabajo completo para la personalización del modelo de IA utilizando la cara de abrazo. Transformamos un conjunto de datos de instrucciones de Python en el formato LLAMA 3.2 con un sistema especializado Solicitud y lo subimos como “Llama-3.2-Python-Alpaca-143K”. Luego ajustamos un modelo LLAMA 3.2 utilizando técnicas eficientes (cuantificación de 4 bits y lora) con recursos informáticos mínimos. Finalmente, compartimos ambos recursos en Hugging Face Hub, haciendo que nuestro asistente de codificación de Python esté disponible para la comunidad. Este proyecto muestra cómo se ha convertido el desarrollo de IA accesible, lo que permite a los desarrolladores crear modelos especializados para tareas específicas con recursos relativamente modestos.

Aquí está el Colab Notebook_llama_3_2_3b_instruct_codmi y Colab Notebook_llama_3_2_python_alpaca_143k . Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 90k+ ml de subreddit.

🔥 [Register Now] Conferencia virtual de Minicon sobre AI agente: registro gratuito + Certificado de asistencia + Evento corto de 4 horas (21 de mayo, 9 am- 1 pm PST) + Hands on Workshop