Ajuste fino Llama-3.2-3B com Unsloth

Este caderno demonstra como ajustar o Llama-3.2-3B. Modelo de linguagem de grande porte usando a biblioteca Unsloth . O Unsloth oferece implementações otimizadas para técnicas de ajuste fino com uso eficiente de parâmetros (PEFT), como LoRA (Adaptação de Baixa Classificação), permitindo um treinamento mais rápido com menor uso 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. Selecione A10 como acelerador no painel de ambiente e clique em Aplicar .

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

Instale a biblioteca necessária.

Instale a biblioteca Unsloth com suporte CUDA 12.4 e PyTorch 2.6.0, juntamente com o Accelerate para treinamento distribuído e MLflow para acompanhamento de experimentos. O ambiente de execução Python é reiniciado após a instalação para carregar o novo pacote.

Python

%pip install unsloth[cu124-torch260]==2025.9.6
%pip install accelerate==1.7.0
%pip install unsloth_zoo==2025.9.8
%pip install -U mlflow
%restart_python

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
import torch
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 transformers.integrations import MLflowCallback
from unsloth.chat_templates import train_on_responses_only
import mlflow
from unsloth import FastLanguageModel
import torch

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

Open notebook in new tab