Integração com Unsloth

Unsloth é um framework de código aberto para ajuste fino e aprendizado por reforço que treina LLMs (como Llama, OpenAI gpt-oss, Mistral, Gemma, DeepSeek, entre outros) até 2× mais rápido, com até 80% menos VRAM. O Unsloth permite treinamento, avaliação, execução e implantação com outros motores de inferência, como llama.cpp, Ollama e vLLM.

A biblioteca oferece um fluxo de trabalho simplificado e compatível com o Hugging Face para treinamento, avaliação, inferência e implantação, e é totalmente compatível com SFTTrainer.

Principais recursos

Suporte de treinamento para todos os modelos compatíveis com transformers: Text-to-speech (TTS), multimodal, BERT, RL e mais
Suporta fine-tuning completo, pré-treinamento, LoRA, QLoRA, treinamento de 8 bits & muito mais
Funciona em Linux, Windows, Colab, Kaggle; GPUs NVIDIA, em breve configurações AMD & Intel
Suporta a maioria dos recursos que o TRL suporta, incluindo RLHF (GSPO, GRPO, DPO, etc.)
Kernels Triton escritos manualmente e um motor de backprop manual garantem nenhuma degradação de precisão (0% de erro de aproximação)

Instalação

pip install

Instalação local (Linux recomendado):

pip install unsloth

Você também pode instalar o unsloth de acordo com a documentação oficial. Uma vez instalado, você pode incorporar o unsloth ao seu fluxo de trabalho de uma maneira muito simples; em vez de carregar o AutoModelForCausalLM, basta carregar um FastLanguageModel da seguinte forma:

import torch
from trl import SFTConfig, SFTTrainer
from unsloth import FastLanguageModel

max_length = 2048 # Supports automatic RoPE Scaling, so choose any number

# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/mistral-7b",
    max_seq_length=max_length,
    dtype="auto",  # For auto-detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
    load_in_4bit=True,  # Use 4bit quantization to reduce memory usage. Can be False
)

# Do model patching and add fast LoRA weights
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,  # Dropout = 0 is currently optimized
    bias="none",  # Bias = "none" is currently optimized
    use_gradient_checkpointing=True,
    random_state=3407,
)

training_args = SFTConfig(output_dir="./output", max_length=max_length)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

O modelo salvo é totalmente compatível com a biblioteca transformers da Hugging Face. Saiba mais sobre o unsloth no seu repositório oficial.

Instalação do Docker

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Acesse o Jupyter Lab em http://localhost:8888 e comece o fine-tuning!

Treinamento

Estas são algumas configurações principais que você pode alternar antes do treinamento:

max_seq_length = 2048 – Controla o comprimento do contexto. Embora o Llama-3 suporte 8192, recomendamos 2048 para testes. O Unsloth permite fine-tuning com contexto 4× mais longo.
dtype = "auto" – Para detecção automática; use torch.float16 ou torch.bfloat16 para GPUs mais recentes.
load_in_4bit = True – Habilita a quantização de 4 bits, reduzindo o uso de memória em 4× para fine-tuning. Desabilitá-la permite habilitar o fine-tuning LoRA de 16 bits.
Para habilitar o ajuste fino completo (FFT), defina full_finetuning = True. Para ajuste fino em 8 bits, defina load_in_8bit = True. Observação: apenas um método de treinamento pode ser definido como True por vez.

Para mais informações sobre a configuração dos hiperparâmetros e recursos do Unsloth, leia o guia de documentação aqui.

Salvando o modelo

O Unsloth permite salvar diretamente o modelo ajustado como um arquivo pequeno chamado adaptador LoRA. Você também pode enviar para o Hugging Face hub, se quiser fazer o upload do seu modelo! Lembre-se de obter um token do Hugging Face e adicionar seu token!

Salvando em GGUF

Para salvar em GGUF, o Unsloth usa o llama.cpp. Para salvar localmente:

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

Para enviar para o hub:

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

Salvando no vLLM

Para salvar em 16 bits para o vLLM, use:

model.save_pretrained_merged("model", tokenizer, save_method = "merged_16bit",)
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Update on GitHub

TRL