"""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" TURN_END = "" TOOL_RESP_OPEN = "<|tool_response>" TOOL_RESP_CLOSE = "" 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())