| |
| """Unsloth SFT on Kaggle T4 for SKT-ST-X-10B-MoE. |
| |
| Unsloth's 4-bit loading is memory-efficient (fixes the CUDA OOM that plain |
| transformers + bitsandbytes hits on a 14.5GB T4). |
| |
| Data: /root/baap-data/shard_*.jsonl.gz ({"messages": [...]} format) |
| Model: /root/model (WORKINGPLACE/SKT-ST-X-10B-MoE) |
| |
| Usage (Kaggle): |
| python unsloth_train.py --data /root/baap-data --model /root/model \ |
| --out /root/skt-sft --steps 2000 |
| """ |
| import argparse, glob, os, sys, time |
|
|
| SKT_TEMPLATE = ( |
| "{% for message in messages %}" |
| "{% if message['role'] == 'system' %}{% if message['content'] %}" |
| "{{'### System:\\n' + message['content'] + '\\n'}}{% endif %}" |
| "{% elif message['role'] == 'user' %}{{'### User:\\n' + message['content'] + '\\n'}}" |
| "{% elif message['role'] == 'assistant' %}" |
| "{{'### Assistant:\\n' + message['content'] + eos_token + '\\n'}}" |
| "{% endif %}{% if loop.last and add_generation_prompt %}{{ '### Assistant:\\n' }}" |
| "{% endif %}{% endfor %}" |
| ) |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser() |
| p.add_argument("--model", default="/root/model") |
| p.add_argument("--data", default="/root/baap-data") |
| p.add_argument("--out", default="/root/skt-sft") |
| p.add_argument("--steps", type=int, default=2000) |
| p.add_argument("--batch", type=int, default=4) |
| p.add_argument("--accum", type=int, default=2) |
| p.add_argument("--lr", type=float, default=2e-4) |
| p.add_argument("--max-len", type=int, default=2048) |
| p.add_argument("--lora-r", type=int, default=64) |
| p.add_argument("--lora-alpha", type=int, default=128) |
| p.add_argument("--lora-experts", action="store_true") |
| p.add_argument("--warmup", type=int, default=100) |
| p.add_argument("--save-steps", type=int, default=500) |
| p.add_argument("--seed", type=int, default=42) |
| p.add_argument("--limit", type=int, default=0) |
| p.add_argument("--resume", action="store_true") |
| return p.parse_args() |
|
|
|
|
| def main(): |
| args = parse_args() |
|
|
| from unsloth import FastLanguageModel |
| from unsloth.chat_templates import train_on_responses_only |
| from trl import SFTConfig, SFTTrainer |
| from datasets import load_dataset |
|
|
| print("[1/4] loading %s (Unsloth 4-bit)" % args.model, flush=True) |
| model, tok = FastLanguageModel.from_pretrained( |
| model_name=args.model, |
| max_seq_length=args.max_len, |
| load_in_4bit=True, |
| dtype=None, |
| ) |
| if getattr(tok, "chat_template", None) is None: |
| tok.chat_template = SKT_TEMPLATE |
| if tok.pad_token is None: |
| tok.pad_token = tok.eos_token |
| print("[1/4] model loaded", flush=True) |
|
|
| targets = ["q_proj", "k_proj", "v_proj", "o_proj"] |
| if args.lora_experts: |
| targets += ["w1", "w2", "w3"] |
| model = FastLanguageModel.get_peft_model( |
| model, r=args.lora_r, target_modules=targets, lora_alpha=args.lora_alpha, |
| lora_dropout=0.05, bias="none", use_gradient_checkpointing="unsloth", |
| random_state=args.seed, |
| ) |
| model.print_trainable_parameters() |
|
|
| print("[2/4] loading dataset", flush=True) |
| |
| candidates = [args.data] |
| if not os.path.exists(args.data): |
| candidates += ["/root/baap-ds/data", "/root/baap-data", |
| "/root/baap-ds", "/root/data", "/root"] |
| shards = [] |
| for c in candidates: |
| if os.path.isdir(c): |
| found = sorted(glob.glob(os.path.join(c, "**", "*.jsonl.gz"), |
| recursive=True)) |
| if found: |
| shards = found |
| print("[2/4] found %d shards in %s" % (len(shards), c), flush=True) |
| break |
| elif os.path.isfile(c): |
| shards = [c] |
| break |
| if not shards: |
| sys.exit("no *.jsonl.gz found (tried: %s)" % ", ".join(candidates)) |
| ds = load_dataset("json", data_files=shards, split="train") |
| if args.limit: |
| ds = ds.select(range(args.limit)) |
| if "text" not in ds.column_names: |
| ds = ds.map(lambda ex: {"text": tok.apply_chat_template( |
| ex["messages"], tokenize=False)}, batched=False) |
| print("[2/4] %s rows" % f"{len(ds):,}", flush=True) |
|
|
| |
| import torch |
| use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported() |
| print("[3/4] training %d steps | batch %d x accum %d | len %d | %s" |
| % (args.steps, args.batch, args.accum, args.max_len, |
| "bf16" if use_bf16 else "fp16"), flush=True) |
|
|
| trainer = SFTTrainer( |
| model=model, tokenizer=tok, train_dataset=ds, |
| dataset_text_field="text", max_seq_length=args.max_len, packing=False, |
| args=SFTConfig( |
| output_dir=args.out, max_steps=args.steps, |
| per_device_train_batch_size=args.batch, |
| gradient_accumulation_steps=args.accum, |
| learning_rate=args.lr, lr_scheduler_type="cosine", |
| warmup_steps=args.warmup, weight_decay=0.0, |
| logging_steps=10, save_steps=args.save_steps, |
| save_total_limit=2, save_only_model=True, |
| bf16=use_bf16, fp16=(not use_bf16), |
| optim="adamw_8bit", seed=args.seed, report_to=[], |
| ), |
| ) |
| |
| trainer = train_on_responses_only( |
| trainer, instruction_part="### User:\n", response_part="### Assistant:\n") |
|
|
| t0 = time.time() |
| trainer.train(resume_from_checkpoint=args.resume or None) |
| print("[4/4] done in %.0fs (%.2fh)" % (time.time() - t0, |
| (time.time() - t0) / 3600), flush=True) |
| model.save_pretrained(args.out) |
| tok.save_pretrained(args.out) |
| print("[4/4] LoRA adapter -> %s" % args.out, flush=True) |
| print("[4/4] merge 16-bit with: model.save_pretrained_merged('%s-merged', tokenizer=tok)" % args.out, |
| flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
