Fine-Tuning LLM Berbasis Konfigurasi dengan Axolotl

Kebanyakan proyek fine-tuning dimulai dengan cara yang sama: seseorang menyalin sebuah skrip pelatihan, mengubah belasan nilai yang ditulis langsung di kode, lalu berharap orang berikutnya bisa mereproduksi proses tersebut. Axolotl mengambil pendekatan berbeda. Ia memperlakukan seluruh proses fine-tuning sebagai satu berkas YAML, sehingga model, format dataset, pengaturan LoRA, dan strategi multi-GPU semuanya berada dalam satu artefak yang bisa diversioning. Tutorial ini membahas Axolotl dari awal sampai akhir: apa yang sebenarnya ia bungkus, cara memasangnya, cara membaca dan menulis konfigurasi bidang demi bidang, serta cara menjalankan fine-tune QLoRA yang realistis untuk model instruct 8B pada satu atau dua GPU.

Apa Itu Axolotl

Axolotl bukan kerangka kerja pelatihan baru. Ia adalah pembungkus (wrapper) yang berpendirian tegas, berdiri di atas ekosistem Hugging Face dan mengorkestrasi komponen-komponen yang biasanya harus Anda sambungkan sendiri:

• Transformers untuk memuat model dan tokenizer.
• PEFT untuk adapter LoRA dan QLoRA.
• TRL untuk trainer supervised fine-tuning (SFT) dan optimasi preferensi.
• bitsandbytes untuk kuantisasi 4-bit dan 8-bit.
• Accelerate, DeepSpeed, dan FSDP untuk pelatihan terdistribusi dan multi-GPU.

Ide intinya adalah Anda mendeskripsikan apa yang Anda inginkan, bukan menulis kode perekat yang melakukannya. Satu berkas YAML mendeklarasikan base model, cara dataset Anda diuraikan, adapter mana yang dipasang, jadwal optimizer, dan backend terdistribusi. Axolotl membaca berkas itu, membangun objek yang sesuai, lalu menjalankan prosesnya. Berkas yang sama itulah yang Anda commit ke git, serahkan ke rekan kerja, atau lampirkan ke eksperimen di Weights & Biases.

Kapan Memilih Axolotl

Axolotl cocok ketika satu atau lebih kondisi berikut terpenuhi:

• Anda punya lebih dari satu GPU. Integrasi Axolotl dengan DeepSpeed ZeRO dan FSDP tergolong matang, dan beralih dari satu GPU ke delapan GPU sebagian besar hanya soal mengubah launcher, bukan menulis ulang kode.
• Anda bekerja dengan banyak keluarga model. Llama, Mistral, Mixtral, Qwen, Gemma, Phi, dan lainnya didukung melalui permukaan konfigurasi yang sama, sehingga Anda tidak perlu mempelajari API baru untuk tiap model.
• Reproduksibilitas penting. Karena proses sepenuhnya dideskripsikan oleh berkas konfigurasi, "jalankan ulang persis seperti yang kita lakukan bulan lalu" menjadi sekadar git checkout ditambah satu perintah.
• Anda menginginkan resep, bukan skrip. Axolotl menyertakan puluhan contoh konfigurasi yang bisa Anda salin dan sesuaikan.

Jika situasi Anda kebalikannya — satu GPU consumer di mana kecepatan pelatihan mentah dan VRAM minimal jadi prioritas — pustaka yang dioptimasi pada level kernel seperti Unsloth mungkin melatih lebih cepat. Kekuatan Axolotl adalah keluasan cakupan, penskalaan terdistribusi, dan reproduksibilitas, bukan memeras token-per-detik terakhir dari satu kartu. Keduanya bukan pesaing, melainkan alat untuk pekerjaan yang berbeda.

Instalasi

Axolotl bergantung pada build PyTorch yang mendukung CUDA, dan sumber masalah paling umum adalah ketidakcocokan antara PyTorch, toolkit CUDA, dan flash-attn. Pasang PyTorch lebih dulu, sesuaikan dengan driver Anda, baru pasang Axolotl.

# 1. Buat lingkungan terisolasi
python -m venv .venv
source .venv/bin/activate

2. Pasang PyTorch yang cocok dengan CUDA (contoh: CUDA 12.1)
pip install torch==2.3.1 --index-url https://download.pytorch.org/whl/cu121

3. Pasang Axolotl beserta extras flash-attention dan deepspeed
pip install "axolotl[flash-attn,deepspeed]"

Jika lingkungan Anda rapuh atau Anda hanya ingin sesuatu yang langsung berfungsi pada percobaan pertama, image Docker resmi sudah menggabungkan kombinasi CUDA, PyTorch, dan kernel teroptimasi yang teruji baik:

docker run --gpus all --rm -it \
  -v "$(pwd)":/workspace \
  axolotlai/axolotl:main-latest \
  bash

Setelah instalasi, pastikan CLI tersedia di PATH Anda:

axolotl --help

Peran Accelerate

Axolotl menggunakan Accelerate dari Hugging Face untuk mengabstraksi penempatan perangkat dan peluncuran terdistribusi. Untuk satu GPU biasanya Anda tidak perlu menyentuhnya, tetapi untuk proses multi-GPU, Accelerate menentukan bagaimana proses-proses dijalankan. Anda bisa membuat konfigurasi default sekali dengan accelerate config, namun dalam praktiknya kebanyakan pengguna Axolotl membiarkan pengaturan DeepSpeed atau FSDP di YAML yang mengendalikan perilaku, lalu meluncurkan dengan accelerate launch. Kita akan kembali ke ini di bagian pelatihan.

Tata Letak Proyek yang Masuk Akal

Karena konfigurasi adalah artefaknya, ada baiknya menjaga struktur direktori yang rapi dan dapat diprediksi agar sebuah proses mudah direproduksi dan ditinjau:

my-finetune/
├── configs/
│   └── qlora-8b.yml          # definisi proses
├── data/
│   └── supportinstructions.jsonl

├── outputs/                  # adapter dan checkpoint (gitignore)
├── deepspeedconfigs/        # disalin dari contoh Axolotl
│   └── zero2.json
└── requirements.txt          # versi terkunci untuk reproduksibilitas

Commit configs/, data/ (atau penunjuk ke sana), dan requirements.txt; gitignore outputs/. Dengan konvensi itu, siapa pun bisa meng-clone repositori dan menjalankan ulang eksperimen yang sama persis hanya dari konfigurasinya.

YAML Konfigurasi Adalah Artefak Sentral

Semua yang dibahas di bawah berpusat pada satu berkas. Buat qlora-8b.yml dan kita akan menyusunnya, lalu menjelaskan tiap blok. Berikut konfigurasi lengkap untuk contoh yang kita gunakan — fine-tune QLoRA untuk model instruct 8B pada dataset instruksi kustom.

# qlora-8b.yml

--- Base model ---
basemodel: meta-llama/Meta-Llama-3.1-8B-Instruct

modeltype: LlamaForCausalLM
tokenizertype: AutoTokenizer


--- Kuantisasi ---
loadin4bit: true

loadin8bit: false


--- Adapter ---
adapter: qlora
lorar: 32
loraalpha: 16

loradropout: 0.05
loratargetlinear: true
Atau menargetkan modul tertentu alih-alih loratargetlinear:
loratargetmodules:
- qproj

- kproj
- vproj

- oproj

--- Datasets ---
datasets:
path: ./data/supportinstructions.jsonl

    type: chattemplate

    chattemplate: llama3

    fieldmessages: messages
chattemplate: llama3

valsetsize: 0.05


--- Penanganan sekuens ---
sequencelen: 4096
samplepacking: true

padtosequencelen: true

--- Batch dan jadwal ---
microbatchsize: 2
gradientaccumulationsteps: 8
numepochs: 3

optimizer: adamwbnb8bit

lrscheduler: cosine
learningrate: 0.0002

warmupsteps: 20

--- Presisi dan memori ---
bf16: auto
gradientcheckpointing: true

flashattention: true

--- Logging dan checkpoint ---
wandbproject: support-finetune

wandbname: llama31-8b-qlora-run1
outputdir: ./outputs/llama31-8b-qlora

savesteps: 100
evalsteps: 100

loggingsteps: 5

Base Model, modeltype, dan tokenizertype

basemodel: meta-llama/Meta-Llama-3.1-8B-Instruct
modeltype: LlamaForCausalLM
tokenizertype: AutoTokenizer

Kuantisasi: loadin4bit dan loadin8bit

loadin4bit: true
loadin8bit: false

Flag ini mengontrol kuantisasi bitsandbytes pada bobot base. loadin4bit: true adalah fondasi QLoRA — ia memuat base model yang dibekukan dalam 4-bit, memangkas VRAM secara drastis sehingga model 8B bisa dilatih dengan nyaman pada satu kartu 24 GB. loadin8bit adalah jalan tengah: kompresi tidak seagresif 4-bit, kualitas sedikit lebih tinggi, memori lebih besar. Untuk full fine-tuning, Anda mengatur keduanya menjadi false.

Adapter: lora vs qlora

adapter: qlora
lorar: 32

loraalpha: 16
loradropout: 0.05

loratargetlinear: true

• lorar adalah rank — ukuran matriks low-rank yang disisipkan. Rank lebih tinggi berarti lebih banyak kapasitas yang dapat dilatih dan lebih banyak memori. Rentang 16–64 masuk akal untuk instruction tuning.
• loraalpha menskalakan pembaruan. Heuristik yang umum adalah mengaturnya sama dengan atau sekitar setengah dari lorar, lalu menyetelnya.
• loradropout meregularisasi adapter; 0.05 adalah default yang aman.
• loratargetlinear: true memberi tahu Axolotl untuk memasang LoRA pada semua lapisan proyeksi linear secara otomatis. Ini pilihan benar yang paling mudah. Jika Anda lebih suka kontrol manual, beri komentar pada baris ini dan daftarkan loratargetmodules secara eksplisit (misalnya qproj, kproj, vproj, oproj, ditambah proyeksi MLP).

datasets:
path: ./data/supportinstructions.jsonl
    type: chattemplate

    chattemplate: llama3
    fieldmessages: messages

chattemplate: llama3
valsetsize: 0.05

Inilah blok yang paling sering keliru, jadi layak diperhatikan. datasets adalah sebuah daftar — Anda bisa mencampur beberapa sumber. Setiap entri punya path dan type. type memberi tahu Axolotl cara menguraikan tiap baris dan mengubahnya menjadi token pelatihan. Tipe yang umum adalah:

• alpaca — baris dengan bidang instruction, input opsional, dan output. Axolotl menerapkan template prompt Alpaca klasik.
• chattemplate (pengganti modern untuk tipe sharegpt lama) — baris yang berisi daftar pesan role/content. Anda mengarahkan fieldmessages ke bidang daftar tersebut dan mengatur chattemplate ke template milik model (di sini llama3). Axolotl lalu merender percakapan menggunakan template itu, termasuk token khusus dan batas giliran yang benar.
• completion — kelanjutan teks mentah, tanpa struktur instruksi. Berguna untuk pretraining adaptif domain pada dokumen biasa.

Panjang Sekuens dan Sample Packing

sequencelen: 4096
samplepacking: true
padtosequencelen: true

Ukuran Batch, Akumulasi Gradien, dan Jadwal

microbatchsize: 2
gradientaccumulationsteps: 8
numepochs: 3

optimizer: adamwbnb8bit

lrscheduler: cosine
learningrate: 0.0002

warmupsteps: 20

Ukuran batch efektif adalah microbatchsize × gradientaccumulationsteps × jumlahgpu. Di sini pada satu GPU yaitu 2 × 8 × 1 = 16. Pertahankan microbatchsize sebesar yang VRAM Anda izinkan dan tutupi sisanya dengan akumulasi. optimizer: adamwbnb8bit adalah Adam 8-bit dari bitsandbytes, yang memangkas memori state optimizer secara signifikan dan berpasangan alami dengan QLoRA. lrscheduler: cosine dengan learning rate sekitar 2e-4 adalah titik awal yang solid untuk LoRA; full fine-tuning menggunakan rate jauh lebih kecil (sering 1e-5 sampai 2e-5). warmupsteps menaikkan learning rate secara bertahap untuk menghindari beberapa langkah pertama yang tidak stabil.

bf16: auto
gradientcheckpointing: true
flashattention: true

wandbproject: support-finetune
wandbname: llama31-8b-qlora-run1

outputdir: ./outputs/llama31-8b-qlora
savesteps: 100

evalsteps: 100
loggingsteps: 5

Bidang wandb* menghubungkan proses ke Weights & Biases; atur WANDBAPIKEY di lingkungan Anda, atau hapus bidang ini untuk menonaktifkan pelacakan. outputdir adalah tempat adapter dan checkpoint disimpan. savesteps dan evalsteps mengontrol seberapa sering checkpoint ditulis dan validasi dijalankan; menyamakannya memudahkan karena setiap checkpoint yang tersimpan punya skor evaluasi. loggingsteps mengontrol seberapa sering metrik dicetak ke konsol.

Menyiapkan Data Anda

Axolotl membaca JSONL di mana setiap baris adalah satu contoh. Untuk dataset chattemplate kita, setiap baris menyimpan daftar messages, persis seperti permintaan chat completion:

import json

examples = [
    {
        "messages": [
            {"role": "system", "content": "Anda adalah asisten dukungan yang ringkas untuk platform e-commerce."},
            {"role": "user", "content": "Bagaimana cara melacak pesanan saya?"},
            {"role": "assistant", "content": "Buka Pesanan, pilih pesanannya, lalu ketuk Lacak Pengiriman untuk melihat status langsung."},
        ]
    },
    {
        "messages": [
            {"role": "user", "content": "Bisakah saya mengubah alamat pengiriman setelah checkout?"},
            {"role": "assistant", "content": "Bisa, dalam 30 menit setelah memesan. Buka Pesanan > Ubah Alamat."},
        ]
    },
]

with open("data/supportinstructions.jsonl", "w", encoding="utf-8") as f:
    for ex in examples:
        f.write(json.dumps(ex, ensureascii=False) + "\n")

axolotl preprocess qlora-8b.yml

axolotl train qlora-8b.yml

Axolotl memuat dataset dari cache, membangun model terkuantisasi dengan adapter QLoRA, dan menjalankan trainer TRL sesuai jadwal Anda. Checkpoint dan adapter akhir muncul di bawah outputdir.

Menimpa Nilai Konfigurasi via Command Line

Anda tidak perlu menyunting YAML untuk setiap perubahan kecil. Bidang apa pun bisa ditimpa di command line, yang berguna untuk sweep atau eksperimen cepat tanpa menyentuh konfigurasi yang sudah di-commit:

# Coba learning rate berbeda dan proses lebih singkat tanpa menyunting berkas
axolotl train qlora-8b.yml \
  --learning-rate 0.0001 \
  --num-epochs 1 \
  --output-dir ./outputs/lr-1e4-sweep

Penimpaan ini membiarkan konfigurasi dasar Anda tetap utuh, sehingga berkas yang di-commit tetap menjadi resep kanonis sementara Anda menjelajahi variasi. Untuk sweep yang sistematis, lebih baik membuat satu berkas konfigurasi per varian agar setiap proses tetap sepenuhnya mendeskripsikan dirinya sendiri.

Multi-GPU dengan Accelerate dan DeepSpeed

Untuk dua GPU atau lebih, luncurkan melalui Accelerate agar proses dijalankan dengan benar, dan arahkan Axolotl ke konfigurasi DeepSpeed ZeRO. Axolotl menyertakan konfigurasi ZeRO siap pakai:

accelerate launch -m axolotl.cli.train qlora-8b.yml \
  --deepspeed deepspeedconfigs/zero2.json

deepspeed: deepspeedconfigs/zero2.json

DeepSpeed ZeRO membagi (shard) state optimizer dan gradien di seluruh GPU untuk mengurangi memori per perangkat. ZeRO stage 2 membagi state optimizer dan gradien, dan merupakan default umum untuk LoRA/QLoRA pada beberapa GPU. ZeRO stage 3 juga membagi parameter model itu sendiri, dan inilah yang Anda gunakan ketika sebuah model tidak muat di satu perangkat bahkan setelah dikuantisasi — dengan konsekuensi komunikasi antar-GPU yang lebih banyak.

Sebagai alternatif DeepSpeed, Axolotl juga mendukung FSDP (PyTorch Fully Sharded Data Parallel) melalui blok fsdp di YAML. FSDP dan ZeRO-3 menyelesaikan masalah yang sama dengan implementasi berbeda; untuk kebanyakan beban kerja LoRA, ZeRO-2 lebih sederhana dan sudah cukup, dan Anda baru beralih ke ZeRO-3 atau FSDP ketika memori memaksa Anda membagi parameter.

Membaca Keluaran Pelatihan

Selama proses berjalan, Axolotl mencetak metrik setiap loggingsteps dan menjalankan validasi setiap evalsteps. Dua angka yang paling penting:

• Training loss seharusnya turun secara mantap lalu mendatar. Loss yang anjlok mendekati nol dalam sebagian kecil epoch biasanya berarti dataset terlalu kecil atau berulang, dan model menghafal alih-alih menggeneralisasi.
• Validation loss adalah sinyal yang jujur. Jika ia mencapai titik terendah lalu mulai naik sementara training loss terus turun, Anda sedang overfitting — berhentilah pada checkpoint dengan validation loss terendah, bukan yang terakhir.

Karena valsetsize: 0.05 menghasilkan split tersisihkan, setiap checkpoint yang tersimpan punya skor evaluasi terkait. Saat Anda mengarahkan inferensi atau merge ke sebuah direktori, lebih baik pilih checkpoint dengan validation loss terbaik, belum tentu langkah terakhir. Jika Anda mengatur wandbproject, kurva-kurva ini diplot secara otomatis; jika tidak, perhatikan log konsol.

axolotl inference qlora-8b.yml --lora-model-dir="./outputs/llama31-8b-qlora"

axolotl merge-lora qlora-8b.yml --lora-model-dir="./outputs/llama31-8b-qlora"

Perintah ini menulis direktori model tergabung (secara default di bawah outputdir) berisi bobot safetensors standar dan tokenizer. Dari sana Anda bisa mendorongnya ke Hugging Face Hub atau mengonversinya ke GGUF untuk inferensi lokal. Satu peringatan: menggabungkan adapter QLoRA akan mendekuantisasi base untuk menghitung penggabungan, sehingga model tergabung berada dalam presisi penuh atau setengah, bukan 4-bit — kuantisasi ulang secara terpisah setelahnya jika Anda butuh artefak deployment 4-bit.

Menentukan Ukuran Perangkat Keras

Memilih metode dan jumlah GPU sebagian besar adalah soal memori. Panduan kasar di bawah berlaku untuk model 8B dengan sequencelen: 4096, gradient checkpointing aktif, dan flash-attention aktif; anggap sebagai titik awal, bukan jaminan, karena penggunaan persisnya bergantung pada rank, packing, dan ukuran batch.

• QLoRA, satu GPU 24 GB (mis. RTX 4090 / A10): nyaman dengan microbatchsize: 2 dan akumulasi. Setup dunia nyata paling umum untuk fine-tune 8B.
• LoRA dalam bf16, satu GPU 48 GB (mis. A6000): base dalam 16-bit ditambah adapter muat, dengan ruang untuk micro batch lebih besar.
• Full fine-tuning, 2–8 × GPU 40/80 GB (A100/H100): butuh ZeRO-3 atau FSDP untuk membagi state optimizer dan parameter; full fine-tune 8B tidak praktis pada satu kartu 24 GB.

Ketika memori sempit, tuas dalam urutan dampak biasanya: aktifkan 4-bit (QLoRA), turunkan sequencelen, turunkan microbatchsize, pastikan gradient checkpointing dan flash-attention aktif, lalu bagi dengan ZeRO-3.

Full Fine-Tuning vs LoRA vs QLoRA

Axolotl mendukung ketiganya dengan permukaan konfigurasi yang sama, jadi pilihannya tentang sumber daya dan tujuan, bukan soal perkakas:

• Full fine-tuning memperbarui setiap parameter. Ini memberi kapasitas terbesar untuk mengubah model tetapi butuh VRAM paling banyak (sering beberapa GPU bermemori besar untuk model 8B) dan berisiko catastrophic forgetting jika dataset Anda sempit. Kosongkan adapter, atur loadin4bit: false, dan gunakan learning rate kecil. Ini biasanya dikombinasikan dengan ZeRO-3 atau FSDP.
• LoRA membekukan base dalam bf16 dan melatih adapter low-rank kecil. Jauh lebih murah daripada full fine-tuning, dengan kualitas mendekatinya untuk sebagian besar tugas instruction tuning. Gunakan ketika Anda punya cukup VRAM untuk menampung base dalam 16-bit.
• QLoRA adalah LoRA pada base 4-bit. Ini opsi paling hemat memori dan default yang tepat untuk setup satu GPU atau multi-GPU sederhana. Kuantisasi 4-bit memperkenalkan biaya kualitas kecil yang dapat diabaikan untuk sebagian besar fine-tuning, itulah mengapa contoh kita menggunakannya.

Optimasi Preferensi: DPO, ORPO, dan Reward Modeling

Axolotl tidak terbatas pada supervised fine-tuning. Metode alignment bergaya reinforcement learning dikonfigurasi melalui bidang rl:, sekali lagi menggunakan kembali struktur YAML yang sama dan TRL di baliknya:

rl: dpo
datasets:
path: ./data/preferences.jsonl
    type: chatml.intel   # format prompt/chosen/rejected

Mengatur rl: dpo mengalihkan trainer ke Direct Preference Optimization, yang belajar dari pasangan respons yang lebih disukai dan yang ditolak. rl: orpo memilih ORPO, yang menggabungkan tujuan SFT dan preferensi dalam satu tahap sehingga tidak membutuhkan model referensi terpisah. Axolotl juga mendukung KTO dan pelatihan reward model melalui mekanisme yang sama. Format dataset berubah untuk membawa bidang prompt, chosen, dan rejected alih-alih satu target tunggal, tetapi sisa konfigurasi — model, adapter, jadwal, backend terdistribusi — tampak persis seperti kasus SFT.

Praktik Terbaik dan Jebakan Umum

Beberapa masalah menjadi penyebab sebagian besar proses Axolotl yang gagal:

• Kehabisan memori (OOM). Jika pelatihan crash dengan CUDA OOM, kurangi microbatchsize lebih dulu dan naikkan gradientaccumulationsteps agar ukuran batch efektif tetap konstan. Lalu pastikan gradientcheckpointing: true dan flashattention: true. Menurunkan sequencelen sangat membantu karena memori attention tumbuh seiring panjang sekuens. Pada banyak GPU, beralih dari ZeRO-2 ke ZeRO-3.
• Ketidakcocokan chat template. Penyebab tunggal paling umum dari model yang melatih dengan mulus tetapi berperilaku aneh saat inferensi adalah menggunakan chat template (atau token khusus) yang berbeda antara pelatihan dan penyajian. Cocokkan chattemplate di konfigurasi Anda dengan keluarga model, dan gunakan template yang sama saat deployment. Jika Anda fine-tune model instruct, jangan menciptakan format prompt sendiri.
• Kejutan sample packing. samplepacking sangat baik untuk throughput, tetapi membutuhkan attention masking yang benar, yang bergantung pada flash-attention yang aktif. Jika Anda melihat contoh tampak saling memengaruhi, pastikan flash-attention aktif dan model Anda mendukung packed attention. Untuk dataset yang sangat kecil, peningkatan throughput tidak signifikan dan Anda bisa membiarkannya nonaktif.
• Praproses sebelum menskalakan. Selalu jalankan axolotl preprocess pada satu proses sebelum meluncurkan pekerjaan multi-GPU yang mahal. Ia memunculkan kesalahan data dan template dengan murah.
• Kunci versi Anda. Karena Axolotl berdiri di atas tumpukan yang bergerak cepat (Transformers, PEFT, TRL, flash-attn), catat versi persisnya di samping YAML Anda, atau gunakan image Docker, agar konfigurasi yang reprodusibel tetap reprodusibel berbulan-bulan kemudian.
• Perhatikan ukuran batch efektif saat menskalakan GPU. Menambah GPU melipatgandakan ukuran batch efektif. Jika Anda beralih dari satu ke empat GPU tanpa menyesuaikan akumulasi, batch efektif Anda menjadi empat kali lipat dan jadwal learning rate Anda tidak lagi cocok — setel ulang atau skalakan ulang.

• YAML konfigurasi adalah artefaknya — versikan, tinjau, dan perlakukan sebagai sumber kebenaran untuk sebuah proses.
• Pilih Axolotl untuk keluasan cakupan, penskalaan multi-GPU, dan reproduksibilitas; gunakan pustaka teroptimasi kernel ketika kecepatan satu GPU pada satu model adalah satu-satunya tujuan.
• QLoRA (adapter: qlora + loadin_4bit: true) adalah default praktis; naik ke LoRA atau full fine-tuning hanya ketika Anda punya memori dan alasannya.
• Praproses dahulu, lalu latih, lalu gabungkan — dan jaga chat template tetap konsisten antara pelatihan dan penyajian.
• Menskalakan ke banyak GPU sebagian besar adalah keputusan launcher dan DeepSpeed/FSDP, bukan perubahan kode.

Mulailah dari salah satu contoh konfigurasi bawaan, sesuaikan dengan dataset Anda, jalankan preprocess, lalu iterasi. Disiplin menjaga semuanya di dalam konfigurasi akan terbayar pertama kali ada orang yang harus mereproduksi pekerjaan Anda.