bloxy-data-v1 / code /scripts /train.py
Radinkazemian's picture
Update Bloxy training code
b7d9871 verified
Raw History Blame Contribute Delete
12.5 kB
"""Fine-tune Gemma 4 into Bloxy with Unsloth (QLoRA).
Loss is computed only on what Bloxy should learn to write: assistant text and
tool calls. System/user turns and tool results are masked out.
Examples:
# free Kaggle/Colab test (T4 16 GB): small model, 60 steps
python scripts/train.py --model unsloth/gemma-4-E4B-it --max_steps 60 --max_len 2048
# real run on a RunPod A6000 48 GB
python scripts/train.py --model unsloth/gemma-4-12b-it --hub_model_id YOURNAME/Bloxy-12B-v1
Env: HF_TOKEN (write token) is needed for --hub_model_id and private datasets.
"""
from __future__ import annotations
import argparse
import gzip
import json
import math
import os
import random
import re
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
TURN_MODEL = "<|turn>model\n"
EMPTY_THOUGHT = "<|channel>thought\n<channel|>"
TURN_END = "<turn|>"
TOOL_RESP_OPEN = "<|tool_response>"
TOOL_RESP_CLOSE = "<tool_response|>"
def parse_args():
ap = argparse.ArgumentParser()
ap.add_argument("--model", default="unsloth/gemma-4-12b-it")
ap.add_argument("--data", default=str(ROOT / "out" / "train.jsonl.gz"),
help="local train.jsonl(.gz) or a HF dataset repo id holding train.jsonl.gz")
ap.add_argument("--val", default=None, help="local val.jsonl (default: next to --data)")
ap.add_argument("--max_len", type=int, default=4096)
ap.add_argument("--epochs", type=float, default=1.0)
ap.add_argument("--max_steps", type=int, default=-1)
ap.add_argument("--limit", type=int, default=0, help="use only N training examples")
ap.add_argument("--lr", type=float, default=1e-4)
ap.add_argument("--r", type=int, default=16)
ap.add_argument("--bs", type=int, default=2)
ap.add_argument("--ga", type=int, default=4)
ap.add_argument("--out", default=str(ROOT / "runs" / "bloxy"))
ap.add_argument("--hub_model_id", default=None, help="push LoRA checkpoints + final adapter here")
ap.add_argument("--save_steps", type=int, default=150)
ap.add_argument("--max_hours", type=float, default=0, help="stop cleanly after this many hours (budget guard)")
ap.add_argument("--resume", action="store_true", help="resume from the last checkpoint on the Hub/out dir")
ap.add_argument("--no_4bit", action="store_true")
return ap.parse_args()
# ---------------------------------------------------------------- data
def read_rows(path: str) -> list[dict]:
p = Path(path)
if not p.exists(): # treat as HF dataset repo
from huggingface_hub import hf_hub_download
p = Path(hf_hub_download(path, "train.jsonl.gz", repo_type="dataset"))
opener = gzip.open if str(p).endswith(".gz") else open
with opener(p, "rt", encoding="utf-8") as f:
return [json.loads(l) for l in f if l.strip()]
def find_val(args) -> list[dict]:
if args.val:
return read_rows(args.val)
p = Path(args.data)
cand = p.parent / "val.jsonl" if p.exists() else None
if cand and cand.exists():
return read_rows(str(cand))
if not p.exists():
try:
from huggingface_hub import hf_hub_download
return read_rows(hf_hub_download(args.data, "val.jsonl", repo_type="dataset"))
except Exception:
pass
return []
def render(tokenizer, rec: dict) -> str:
msgs = rec["messages"]
kwargs = {"tokenize": False, "add_generation_prompt": False}
if rec.get("tools"):
kwargs["tools"] = rec["tools"]
text = tokenizer.apply_chat_template(msgs, **kwargs)
# Inference with thinking off starts every model turn with an empty thought
# channel; train with the same prefix so formats match exactly.
return re.sub(re.escape(TURN_MODEL) + r"(?!<\|channel>)", TURN_MODEL + EMPTY_THOUGHT, text)
def train_spans(text: str) -> list[tuple[int, int]]:
"""Character spans the model is trained to produce."""
spans = []
for m in re.finditer(re.escape(TURN_MODEL), text):
start = m.end()
if text.startswith(EMPTY_THOUGHT, start):
start += len(EMPTY_THOUGHT)
end = text.find(TURN_END, start)
end = len(text) if end < 0 else end + len(TURN_END)
# cut out tool results (written by Studio, not by Bloxy), keep the opener token
pos = start
for t in re.finditer(re.escape(TOOL_RESP_OPEN), text[start:end]):
o = start + t.end()
c = text.find(TOOL_RESP_CLOSE, o)
c = end if c < 0 or c > end else c + len(TOOL_RESP_CLOSE)
if o > pos:
spans.append((pos, o))
pos = c
if end > pos:
spans.append((pos, end))
return spans
def tokenize_example(tok, text: str, max_len: int):
enc = tok(text, add_special_tokens=False, return_offsets_mapping=True)
ids, offs = enc["input_ids"], enc["offset_mapping"]
if len(ids) > max_len:
return None
spans = train_spans(text)
labels = []
si = 0
for (s, e), t in zip(offs, ids):
while si < len(spans) and s >= spans[si][1]:
si += 1
inside = si < len(spans) and spans[si][0] <= s < spans[si][1]
labels.append(t if inside else -100)
if sum(l != -100 for l in labels) < 4:
return None
return {"input_ids": ids, "attention_mask": [1] * len(ids), "labels": labels}
def build_dataset(tokenizer, tok, rows, max_len, desc):
from datasets import Dataset
out, dropped = [], 0
for r in rows:
try:
try:
text = render(tok, r)
except ValueError: # text tokenizer without a template: use the processor's
text = render(tokenizer, r)
ex = tokenize_example(tok, text, max_len)
except Exception as e: # malformed conversation for the template
ex = None
if dropped < 3:
print(f" skip ({desc}): {e!r}")
if ex is None:
dropped += 1
continue
out.append(ex)
n_tok = sum(len(x["input_ids"]) for x in out)
print(f"{desc}: {len(out)} examples, {n_tok:,} tokens, dropped {dropped} (too long / no target)")
return Dataset.from_list(out), n_tok
# ---------------------------------------------------------------- main
def main():
args = parse_args()
import torch
from unsloth import FastModel
from transformers import DataCollatorForSeq2Seq, Trainer, TrainerCallback, TrainingArguments
rows = read_rows(args.data)
random.Random(0).shuffle(rows)
if args.limit:
rows = rows[: args.limit]
val_rows = find_val(args)[:300]
print(f"loaded {len(rows)} train / {len(val_rows)} val rows")
model, tokenizer = FastModel.from_pretrained(
model_name=args.model,
max_seq_length=args.max_len,
load_in_4bit=not args.no_4bit,
full_finetuning=False,
)
# Use the chat template that ships with the Gemma 4 repo (the same one Ollama /
# llama.cpp will use). Unsloth's get_chat_template("gemma-4") rejects tool turns.
tok = getattr(tokenizer, "tokenizer", tokenizer) # processor -> text tokenizer
if tok.pad_token is None:
tok.pad_token = tok.eos_token
model = FastModel.get_peft_model(
model,
finetune_vision_layers=False,
finetune_language_layers=True,
finetune_attention_modules=True,
finetune_mlp_modules=True,
r=args.r,
lora_alpha=args.r,
lora_dropout=0,
bias="none",
random_state=3407,
use_gradient_checkpointing="unsloth",
)
train_ds, n_tok = build_dataset(tokenizer, tok, rows, args.max_len, "train")
val_ds, _ = build_dataset(tokenizer, tok, val_rows, args.max_len, "val") if val_rows else (None, 0)
# show one masked example so mistakes are visible in the log
ex = train_ds[0]
shown = "".join(tok.decode([t]) if l != -100 else "·" for t, l in zip(ex["input_ids"][:400], ex["labels"][:400]))
print("trained tokens shown, masked as '·':\n", shown[:1500])
steps_per_epoch = math.ceil(len(train_ds) / (args.bs * args.ga))
total_steps = args.max_steps if args.max_steps > 0 else int(steps_per_epoch * args.epochs)
print(f"{total_steps} optimizer steps, ~{n_tok * args.epochs / 1e6:.1f}M tokens")
bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()
push = bool(args.hub_model_id)
import inspect
targ_kwargs = dict(
output_dir=args.out,
per_device_train_batch_size=args.bs,
per_device_eval_batch_size=args.bs,
gradient_accumulation_steps=args.ga,
num_train_epochs=args.epochs,
max_steps=args.max_steps,
learning_rate=args.lr,
lr_scheduler_type="cosine",
warmup_steps=max(1, int(total_steps * 0.03)),
weight_decay=0.01,
optim="adamw_8bit",
bf16=bf16,
fp16=not bf16,
logging_steps=10,
save_strategy="steps",
save_steps=args.save_steps,
save_total_limit=2,
eval_strategy="steps" if val_ds is not None else "no",
eval_steps=args.save_steps,
group_by_length=True,
report_to="none",
seed=3407,
push_to_hub=push,
hub_model_id=args.hub_model_id,
hub_strategy="checkpoint" if push else "every_save",
hub_private_repo=True,
remove_unused_columns=False,
)
accepted = set(inspect.signature(TrainingArguments.__init__).parameters)
if "eval_strategy" not in accepted and "evaluation_strategy" in accepted:
targ_kwargs["evaluation_strategy"] = targ_kwargs.pop("eval_strategy")
skipped = sorted(k for k in targ_kwargs if k not in accepted)
if skipped:
print(f"TrainingArguments: this transformers version has no {skipped}, skipping them")
targs = TrainingArguments(**{k: v for k, v in targ_kwargs.items() if k in accepted})
class Budget(TrainerCallback):
def __init__(self):
self.t0 = time.time()
def on_log(self, a, state, control, logs=None, **kw):
if state.global_step and state.global_step % 50 == 0:
el = time.time() - self.t0
eta = el / state.global_step * (state.max_steps - state.global_step)
print(f"[budget] step {state.global_step}/{state.max_steps} elapsed {el / 3600:.2f}h "
f"ETA {eta / 3600:.2f}h (~${(el + eta) / 3600 * 0.59:.2f} on an A6000)")
def on_step_end(self, a, state, control, **kw):
if args.max_hours and time.time() - self.t0 > args.max_hours * 3600:
print(f"[budget] max_hours={args.max_hours} reached, saving and stopping")
control.should_save = True
control.should_training_stop = True
trainer = Trainer(
model=model,
args=targs,
train_dataset=train_ds,
eval_dataset=val_ds,
data_collator=DataCollatorForSeq2Seq(tok, padding=True, label_pad_token_id=-100, pad_to_multiple_of=8),
callbacks=[Budget()],
)
resume = None
if args.resume:
last = sorted(Path(args.out).glob("checkpoint-*"), key=lambda p: int(p.name.split("-")[1]))
last = [p for p in last if (p / "trainer_state.json").exists()]
if last:
resume = str(last[-1])
elif push:
from huggingface_hub import snapshot_download
try:
d = snapshot_download(args.hub_model_id, allow_patterns=["last-checkpoint/*"])
ck = Path(d) / "last-checkpoint"
# only resume from a real checkpoint (first run: nothing there yet)
if (ck / "trainer_state.json").exists():
resume = str(ck)
else:
print("no checkpoint on the Hub yet, starting fresh")
except Exception as e:
print(f"no hub checkpoint to resume: {e!r}")
print(f"resume from: {resume}")
trainer.train(resume_from_checkpoint=resume)
final = Path(args.out) / "lora"
model.save_pretrained(str(final))
tokenizer.save_pretrained(str(final))
(final / "bloxy_train_args.json").write_text(json.dumps(vars(args), indent=2))
if push:
model.push_to_hub(args.hub_model_id, private=True)
tokenizer.push_to_hub(args.hub_model_id, private=True)
print(f"saved adapter to {final}" + (f" and https://huggingface.co/{args.hub_model_id}" if push else ""))
if __name__ == "__main__":
sys.exit(main())