Ajuste fino Llama-3.2-3B com Unsloth

Open in Databricks

Ajuste fino do Llama-3.2-3B modelo de linguagem grande usando a biblioteca Unsloth. A Unsloth oferece implementações otimizadas para técnicas de ajuste fino eficiente de parâmetros (PEFT), como LoRA (Low-Rank Adaptation), permitindo treinamento mais rápido com uso reduzido de memória.

O livro "The Notebook" aborda os seguintes temas:

• Carregando e configurando a base Llama-3.2-3B modelo
• Criando um modelo PEFT com adaptadores LoRa
• Processamento de dados de treinamento do datasetFineTome-100k
• Acesso com ajuste fino supervisionado (SFT)
• Registrando experimentos com MLflow
• Registre o modelo otimizado no Unity Catalog

Requisitos: computeGPU sem servidor

Este notebook requer compute em GPU com um acelerador A10.

1. Selecione A10 como acelerador na opção Hardware do painel de ambiente.
2. Selecione **AI v5** na opção ambiente base no painel de ambiente.
3. Clique em Aplicar .

Observação: o provisionamento de recursos computacionais pode levar até 8 minutos.

Bibliotecas necessárias

O ambiente Databricks AI v5 inclui Unsloth e suas dependências (unsloth, unsloth_zoo, bitsandbytes, trl, xformers e mlflow), portanto, nenhuma instalação adicional é necessária.

Configure Unity Catalog e as configurações do modelo.

Defina os locais do Unity Catalog para armazenar os pontos de verificação do modelo e o modelo final registrado. A configuração inclui:

• Espaço de nomes Unity Catalog (catálogo, esquema, nome do modelo, volume)
• Seleção do modelo base (Llama-3.2-3B-Instruct) (de Unsloth)
• Diretório de saída para salvar pontos de verificação
• dataset de treinamento (FineTome-100k)

Python

dbutils.widgets.text("uc_catalog", "main")
dbutils.widgets.text("uc_schema", "default")
dbutils.widgets.text("uc_model_name", "llama-3.2-3b")
dbutils.widgets.text("uc_volume", "checkpoints")

UC_CATALOG = dbutils.widgets.get("uc_catalog")
UC_SCHEMA = dbutils.widgets.get("uc_schema")
UC_MODEL_NAME = dbutils.widgets.get("uc_model_name")
UC_VOLUME = dbutils.widgets.get("uc_volume")

print(f"UC_CATALOG: {UC_CATALOG}")
print(f"UC_SCHEMA: {UC_SCHEMA}")
print(f"UC_MODEL_NAME: {UC_MODEL_NAME}")
print(f"UC_VOLUME: {UC_VOLUME}")

# Model selection - Choose based on your compute constraints
MODEL_NAME = "unsloth/Llama-3.2-3B-Instruct" # or choose "unsloth/Llama-3.2-1B-Instruct"
OUTPUT_DIR = f"/Volumes/{UC_CATALOG}/{UC_SCHEMA}/{UC_VOLUME}/{UC_MODEL_NAME}"
DATASET_NAME = "mlabonne/FineTome-100k"

print(f"MODEL_NAME: {MODEL_NAME}")
print(f"OUTPUT_DIR: {OUTPUT_DIR}")
print(f"DAASET_NAME: {DATASET_NAME}")

Carregue o modelo base e o tokenizador.

Carregar o Llama-3.2-3B-Instruct modelo usando FastLanguageModel de Unsloth. Isso configura o modelo com um comprimento máximo de sequência de 2048 tokens e detecção automática de tipo de dados para desempenho ideal na GPU disponível.

Python

from unsloth import FastLanguageModel
max_seq_length = 2048 # Choose any!
dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
load_in_4bit = False # Use 4bit quantization to reduce memory usage. Can be False.

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = MODEL_NAME,
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
)

Utilize adaptadores LoRa para um ajuste fino eficiente.

Converta o modelo base em um modelo PEFT adicionando adaptadores LoRA (Low-Rank Adaptation) às camadas de atenção e feedforward. Este método utiliza adaptadores de nível 16, que adicionam apenas uma pequena fração de parâmetros treináveis, mantendo o modelo base congelado, reduzindo significativamente os requisitos de memória e o tempo de treinamento.

Python

model = FastLanguageModel.get_peft_model(
    model,
    r = 16, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
    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
)

Carregar e formatar o datasetde treinamento

Carregue o dataset FineTome-100k e prepare-o para o treinamento. O processamento de dados aplica o padrão de chat Llama-3.1 para formatar as conversas, padroniza o formato ShareGPT e converte cada conversa em sequências de texto tokenizadas adequadas para ajuste fino supervisionado.

Python

from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(
    tokenizer,
    chat_template = "llama-3.1",
)

def formatting_prompts_func(examples):
    convos = examples["conversations"]
    texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
    return { "text" : texts, }
pass

from datasets import load_dataset
dataset = load_dataset(DATASET_NAME, split = "train")

Python

from unsloth.chat_templates import standardize_sharegpt
dataset = standardize_sharegpt(dataset)
dataset = dataset.map(formatting_prompts_func, batched = True,)

Configure o treinador de ajuste fino supervisionado

Configure o SFTTrainer com hiperparâmetros de treinamento, incluindo tamanho do lote, taxa de aprendizado e configurações do otimizador. O treinador está configurado para execução de 25 passos com acompanhamento MLflow habilitado. O treinamento baseado apenas em respostas garante que o modelo aprenda somente com as respostas do assistente, e não com as instruções do usuário, melhorando a eficiência do treinamento.

Python

from trl import SFTTrainer
from transformers import TrainingArguments, DataCollatorForSeq2Seq
from unsloth import is_bfloat16_supported
from unsloth.chat_templates import train_on_responses_only
import mlflow

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    data_collator = DataCollatorForSeq2Seq(tokenizer = tokenizer),
    dataset_num_proc = 6,
    packing = False, # Can make training 5x faster for short sequences.
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        # num_train_epochs = 1, # Set this for 1 full training run.
        max_steps = 25,
        learning_rate = 2e-4,
        fp16 = not is_bfloat16_supported(),
        bf16 = is_bfloat16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = OUTPUT_DIR,
        report_to = "mlflow", # Use MLflow to track model metrics
    ),
)


trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",
    num_proc=1)

Executar o ciclo de treinamento

execução do processo de ajuste fino dentro de uma execução MLflow para rastrear automaticamente atualizações de treinamento (perda, taxa de aprendizado, etc.) e métricas do sistema (utilização de GPU, uso de memória). A execução do treinamento para 25 passos conforme configurado no treinador, com pontos de verificação salvos no volume Unity Catalog .

Python

import mlflow
with mlflow.start_run(
    run_name='finetune-llama-3.2-3b-unsloth',
    log_system_metrics=True
):
    trainer.train()

Mesclar adaptadores LoRa e registro no Unity Catalog

Combine os pesos do adaptador LoRa treinados com o modelo base para criar um modelo único e pronto para implantação. O modelo de mesclagem é então registrado no MLflow e no Unity Catalog com o tipo de tarefa de chat, ficando pronto para implantação no endpoint do modelo de serviço.

Python

mlflow_run_id = mlflow.last_active_run().info.run_id
merged_model = model.merge_and_unload()
# Create Unity Catalog model name
full_model_name = f"{UC_CATALOG}.{UC_SCHEMA}.{UC_MODEL_NAME}"

try:
    with mlflow.start_run(run_id = mlflow_run_id):
        model_info = mlflow.transformers.log_model(
            transformers_model={'model': merged_model, 'tokenizer': tokenizer},
            name='model',
            registered_model_name=full_model_name, # TODO: Replace with your own model name!
            await_registration_for=3600,
            task='llm/v1/chat',
        )
    print(f"✓ Model successfully registered in Unity Catalog: {full_model_name}")
    print(f"✓ MLflow model URI: {model_info.model_uri}")
    print(f"✓ Model version: {model_info.version}")
except Exception as e:
    print(f"✗ Model registration failed: {e}")
    print("Model is still saved locally and can be registered manually")
    print(f"Local model path: {OUTPUT_DIR}")

Próximos passos

O modelo otimizado já está registrado no Unity Catalog e pronto para uso. Saiba mais sobre a implantação e utilização do modelo:

• modelos implantados para inferência de lotes ou tempo real
• Crie e gerencie endpoints de serviço de modelos
• Documentação Unsloth

Exemplo de caderno

Ajuste fino Llama-3.2-3B com Unsloth

Abrir notebook em uma nova abaOpen in Databricks