Frameworks de Fine-Tuning

PEFT — ParameterEfficient FineTuning (HuggingFace)

• *RL:*github.comhuggingfacepeft
• *étodos implementados:*LoRA, QLoRA, IA3, Prefix Tuning, Prompt Tuning, AdaLoRA, LLaMA-Adapter

LoRA — Low-Rank Adaptation

• *rXiv:*2106.09685 (Hu et al., Microsoft, 2021)
• *ecanismo:*Adiciona matrizes A × B de baixo rank ao lado das matrizes de peso congeladas
  • W' = W + AB onde A ∈ R^{d×r}, B ∈ R^{r×k}, r << d,k
• *arâmetros treináveis:*0.1–1% dos parâmetros do modelo
• *ank típico:*r8 a r64
• *targetmodules`:*qproj, vproj (mínimo); adicionar kproj, oproj, gateproj para mais expressividade
• *usão:*merge_and_unload() mescla LoRA nos pesos → sem overhead na inferência

QLoRA — Quantized LoRA

• *rXiv:*2305.14314 (Dettmers et al., UW, 2023)
• *ecanismo:*Modelo base em NF4 (4-bit) congelado + LoRA em BF16
• *ouble Quantization:*Quantiza também os fatores de escala → ~0.37 bits adicionais por parâmetro
• *aged Optimizers:*Estados do optimizer em DRAM, trazidos para GPU conforme necessário
• *esultado:*Fine-tunes de 65B em 1 GPU de 48GB; 70B em 2× RTX 4090

AdaLoRA

• *rXiv:*2303.10512
• *elhoria sobre LoRA:*Aloca rank adaptativamente por camada (SVD-based)
• *esultado:*Melhor performance com mesmo número de parâmetros

TRL — Transformer Reinforcement Learning (HuggingFace)

• *RL:*github.comhuggingfacetrl
• *étodos:*SFT, DPO, PPO, GRPO, KTO, ORPO, SimPO, RewardTrainer
• *esign:*Wrappers de alto nível sobre PyTorch + PEFT + Accelerate

from trl import SFTTrainer, DPOTrainer, GRPOTrainer

*POTrainer:*Pares (prompt, chosen, rejected) → DPO loss automático *RPOTrainer:*Group relative policy optimization para RLVR *ewardTrainer:*Treina reward model de preferências

Axolotl

• *RL:*github.comOpenAccessAICollectiveaxolotl
• *ilosofia:*Configdriven (YAML) — finetuning sem código
• *uporta:*LoRA, QLoRA, Full fine-tuning, FlashAttention, FSDP, DeepSpeed
• *ormatos:*Alpaca, ShareGPT, Dolma, OASST, custom
• *xemplo de config:*

base_model: Qwen/Qwen2.5-Coder-32B-Instruct
load_in_4bit: true
adapter: qlora
lora_r: 16
lora_target_modules: [q_proj, v_proj, k_proj, o_proj]
datasets:
  - path: koder/code-review-pairs
    type: chat_template

LLaMA-Factory

• *RL:*github.comhiyougaLLaMA-Factory
• *rigem:*Peking University
• *eatures:*WebUI para fine-tuning sem código; suporte a 100+ modelos
• *étodos:*SFT, DPO, PPO, GRPO, ORPO, SimPO, RM
• *uantização:*GPTQ, AWQ, NF4 integrados
• *uando usar:*Quem quer WebUI; experimentação rápida

Unsloth

• *RL:*github.comunslothaiunsloth
• *oco:*Fine-tuning muito mais rápido (~2–5×) e com menos memória
• *ecanismo:*Kernels Triton customizados para LoRA + backward pass; gemma personalizada
• *uporte:*Llama, Mistral, Qwen, Phi, Gemma; LoRA/QLoRA
• *imitação:*Apenas NVIDIA GPU; sem DDP/FSDP (single GPU)
• *uando usar:*Fine-tuning rápido em 1 GPU; prototipagem

LitGPT (Lightning AI)

• *RL:*github.comLightning-AIlitgpt
• *ase:*PyTorch Lightning
• *eatures:*Finetuning completo, LoRA, Adapter; prétreino; inferência
• *esign:*Modular e legível; bom para pesquisa
• *odelos:*Llama, Mistral, Falcon, Phi, Gemma, Qwen integrados

FastChat

• *RL:*github.comlm-sysFastChat
• *rigem:*LMSYS (Berkeley)
• *oco:*Serving de modelos fine-tuned + avaliação com chatbot arena
• *eatures:*Vicuna training script; OpenAIcompatible API; multimodel serving
• *uando usar:*Serving de modelos fine-tuned em produção

ms-swift (ModelScope, Alibaba)

• *RL:*github.commodelscopems-swift
• *oco:*Finetuning de modelos Qwen, Qwen2.5Coder, e outros modelos Alibaba
• *ntegração:*ModelScope Hub (alternativa ao HuggingFace Hub)
• *uando usar:*Modelos da família Qwen (recomendado pela Alibaba)

torchtune (PyTorch)

• *RL:*github.compytorchtorchtune
• *rigem:*Meta / PyTorch Team (2024)
• *esign:*Nativo PyTorch; sem dependências extras; composable
• *étodos:*Full fine-tuning, LoRA, QLoRA
• *uando usar:*Controle total; integração com PyTorch ecosystem puro

Comparação de Frameworks de Fine-Tuning

Pipeline de Fine-Tuning Recomendado para Kode

1. Preparação de dados
   └── koder/code-datasets (pares instruction/code)
   └── Verificação: código executável e passando testes

2. SFT inicial (Axolotl)
   ├── Base: Qwen2.5-Coder-32B-Instruct
   ├── Método: QLoRA r=32, target_modules=all_linear
   ├── Dados: 50K–200K pares de alta qualidade
   └── Hardware: 2× RTX 4090 com FSDP

3. Preference Optimization (TRL)
   ├── Método: DPO
   ├── Dados: Pares (aceito/rejeitado) de sugestões
   └── Base: modelo do passo 2

4. RLVR com builds verificáveis (TRL GRPO)
   ├── Reward: build pass/fail + test pass/fail
   └── Base: modelo do passo 3

Dados de Fine-Tuning de Código

• *ommitPack:*diff + commit message → code review
• *he Stack v2:*pré-treino adicional de código
• *WE-bench Train:*issues/PRs para agent training
• *ados sintéticos:*gerar via Claude/GPT-4o pares de code review específicos para os padrões do Koder