Spaces:
Running
Running
Download training/sft_toolcall_train.py from brand0nwalls/NetOps: direct link, hf CLI and curl.
- Browser
- Download file 9.87 kB
-
https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/training/sft_toolcall_train.py
- Command line
-
hf download hf://spaces/brand0nwalls/NetOps/training/sft_toolcall_train.py
-
curl -L -o sft_toolcall_train.py https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/training/sft_toolcall_train.py
9.87 kB
| """SFT fine-tune Qwen3-4B on tool-calling format expert trajectories. | |
| Uses TRL 1.2 SFTTrainer + PEFT LoRA (no Unsloth). Single GPU. | |
| Trains on tool-calling format data for compatibility with TRL GRPOTrainer. | |
| Usage: | |
| conda activate /data/hf-cache/conda_envs/netops-rl | |
| CUDA_VISIBLE_DEVICES=1 python training/sft_toolcall_train.py | |
| CUDA_VISIBLE_DEVICES=1 python training/sft_toolcall_train.py --epochs 2 --lr 1e-4 | |
| CUDA_VISIBLE_DEVICES=1 python training/sft_toolcall_train.py --model Qwen/Qwen3-0.6B --epochs 1 # smoke test | |
| """ | |
| import argparse | |
| import json | |
| import os | |
| import subprocess | |
| import sys | |
| import time | |
| from datetime import datetime | |
| from pathlib import Path | |
| sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) | |
| def get_git_hash(): | |
| try: | |
| return subprocess.check_output( | |
| ["git", "rev-parse", "--short", "HEAD"], text=True | |
| ).strip() | |
| except Exception: | |
| return "unknown" | |
| def load_jsonl_messages(path: str) -> list[dict]: | |
| records = [] | |
| with open(path) as f: | |
| for line in f: | |
| r = json.loads(line) | |
| records.append({"messages": r["messages"], "tools": r.get("tools", [])}) | |
| return records | |
| class JSONLLogger: | |
| def __init__(self, path: str): | |
| self.path = path | |
| os.makedirs(os.path.dirname(path), exist_ok=True) | |
| self.f = open(path, "w") | |
| def log(self, data: dict): | |
| self.f.write(json.dumps(data) + "\n") | |
| self.f.flush() | |
| def close(self): | |
| self.f.close() | |
| def main(): | |
| parser = argparse.ArgumentParser(description="SFT training (tool-calling format)") | |
| parser.add_argument("--model", default="Qwen/Qwen3-4B") | |
| parser.add_argument("--train-data", default="training/data/sft_toolcall_train_split.jsonl") | |
| parser.add_argument("--val-data", default="training/data/sft_toolcall_val.jsonl") | |
| parser.add_argument("--epochs", type=int, default=3) | |
| parser.add_argument("--batch-size", type=int, default=1) | |
| parser.add_argument("--grad-accum", type=int, default=8) | |
| parser.add_argument("--lr", type=float, default=2e-4) | |
| parser.add_argument("--max-length", type=int, default=16384) | |
| parser.add_argument("--lora-rank", type=int, default=32) | |
| parser.add_argument("--lora-alpha", type=int, default=64) | |
| parser.add_argument("--warmup-steps", type=int, default=10) | |
| parser.add_argument("--seed", type=int, default=42) | |
| parser.add_argument("--load-in-4bit", action="store_true", default=False) | |
| args = parser.parse_args() | |
| timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") | |
| run_dir = Path(f"training/runs/sft_toolcall/{timestamp}") | |
| run_dir.mkdir(parents=True, exist_ok=True) | |
| checkpoint_dir = run_dir / "checkpoints" | |
| checkpoint_dir.mkdir(exist_ok=True) | |
| config = { | |
| "model": args.model, | |
| "train_data": args.train_data, | |
| "val_data": args.val_data, | |
| "epochs": args.epochs, | |
| "batch_size": args.batch_size, | |
| "grad_accum": args.grad_accum, | |
| "effective_batch_size": args.batch_size * args.grad_accum, | |
| "lr": args.lr, | |
| "max_length": args.max_length, | |
| "lora_rank": args.lora_rank, | |
| "lora_alpha": args.lora_alpha, | |
| "warmup_steps": args.warmup_steps, | |
| "load_in_4bit": args.load_in_4bit, | |
| "seed": args.seed, | |
| "git_hash": get_git_hash(), | |
| "timestamp": timestamp, | |
| "run_dir": str(run_dir), | |
| "format": "tool_calling", | |
| "cuda_visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES", "all"), | |
| } | |
| with open(run_dir / "config.json", "w") as f: | |
| json.dump(config, f, indent=2) | |
| print(f"Run dir: {run_dir}") | |
| print(f"Model: {args.model}") | |
| print(f"Config: epochs={args.epochs}, bs={args.batch_size}x{args.grad_accum}, lr={args.lr}, max_seq={args.max_length}") | |
| # --- Load model + LoRA --- | |
| import torch | |
| from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainerCallback | |
| from peft import LoraConfig, get_peft_model | |
| from datasets import Dataset | |
| from trl import SFTTrainer, SFTConfig | |
| tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True) | |
| quant_config = None | |
| if args.load_in_4bit: | |
| quant_config = BitsAndBytesConfig( | |
| load_in_4bit=True, | |
| bnb_4bit_quant_type="nf4", | |
| bnb_4bit_compute_dtype=torch.bfloat16, | |
| ) | |
| model = AutoModelForCausalLM.from_pretrained( | |
| args.model, | |
| torch_dtype=torch.bfloat16, | |
| device_map="auto", | |
| attn_implementation="sdpa", | |
| quantization_config=quant_config, | |
| trust_remote_code=True, | |
| ) | |
| model.gradient_checkpointing_enable() | |
| lora_config = LoraConfig( | |
| r=args.lora_rank, | |
| lora_alpha=args.lora_alpha, | |
| target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], | |
| lora_dropout=0, | |
| task_type="CAUSAL_LM", | |
| ) | |
| model = get_peft_model(model, lora_config) | |
| trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) | |
| total = sum(p.numel() for p in model.parameters()) | |
| print(f"Parameters: {trainable:,} trainable / {total:,} total ({100*trainable/total:.2f}%)") | |
| # --- Load data --- | |
| train_records = load_jsonl_messages(args.train_data) | |
| val_records = load_jsonl_messages(args.val_data) | |
| train_dataset = Dataset.from_list(train_records) | |
| val_dataset = Dataset.from_list(val_records) | |
| print(f"Data: {len(train_records)} train, {len(val_records)} val") | |
| # --- Formatting function --- | |
| # TRL SFTTrainer calls this to convert each example to a string. | |
| # We use Qwen3's chat template with tools and enable_thinking=False. | |
| def formatting_func(example): | |
| msgs = example["messages"] | |
| tools = example.get("tools", None) | |
| if isinstance(msgs[0], list): | |
| results = [] | |
| tools_list = example.get("tools", [None] * len(msgs)) | |
| for m, t in zip(msgs, tools_list): | |
| results.append(tokenizer.apply_chat_template( | |
| m, tools=t if t else None, | |
| tokenize=False, add_generation_prompt=False, | |
| enable_thinking=False, | |
| )) | |
| return results | |
| return [tokenizer.apply_chat_template( | |
| msgs, tools=tools if tools else None, | |
| tokenize=False, add_generation_prompt=False, | |
| enable_thinking=False, | |
| )] | |
| # --- Training --- | |
| steps_per_epoch = max(1, len(train_records) // (args.batch_size * args.grad_accum)) | |
| total_steps = steps_per_epoch * args.epochs | |
| eval_steps = max(1, steps_per_epoch // 2) | |
| save_steps = steps_per_epoch | |
| print(f"Steps: {steps_per_epoch}/epoch, {total_steps} total, eval every {eval_steps}") | |
| train_logger = JSONLLogger(str(run_dir / "train_log.jsonl")) | |
| class LoggingCallback(TrainerCallback): | |
| def on_log(self, cb_args, state, control, logs=None, **kwargs): | |
| if logs and state.global_step > 0: | |
| entry = { | |
| "step": state.global_step, | |
| "epoch": round(state.epoch, 3) if state.epoch else 0, | |
| "timestamp": time.time(), | |
| } | |
| for k in ["loss", "eval_loss", "learning_rate", "grad_norm"]: | |
| if k in logs: | |
| entry[k] = logs[k] | |
| train_logger.log(entry) | |
| training_args = SFTConfig( | |
| output_dir=str(checkpoint_dir), | |
| num_train_epochs=args.epochs, | |
| per_device_train_batch_size=args.batch_size, | |
| per_device_eval_batch_size=args.batch_size, | |
| gradient_accumulation_steps=args.grad_accum, | |
| learning_rate=args.lr, | |
| lr_scheduler_type="cosine", | |
| warmup_steps=args.warmup_steps, | |
| max_length=args.max_length, | |
| packing=False, | |
| fp16=False, | |
| bf16=True, | |
| logging_steps=1, | |
| eval_strategy="steps", | |
| eval_steps=eval_steps, | |
| save_strategy="steps", | |
| save_steps=save_steps, | |
| save_total_limit=2, | |
| seed=args.seed, | |
| optim="adamw_torch", | |
| report_to="none", | |
| gradient_checkpointing=True, | |
| gradient_checkpointing_kwargs={"use_reentrant": False}, | |
| ) | |
| trainer = SFTTrainer( | |
| model=model, | |
| processing_class=tokenizer, | |
| train_dataset=train_dataset, | |
| eval_dataset=val_dataset, | |
| args=training_args, | |
| formatting_func=formatting_func, | |
| callbacks=[LoggingCallback()], | |
| ) | |
| t0 = time.time() | |
| print(f"\nStarting training at {datetime.now().strftime('%H:%M:%S')}") | |
| result = trainer.train() | |
| elapsed = time.time() - t0 | |
| print(f"\nTraining complete in {elapsed:.0f}s ({elapsed/60:.1f}min)") | |
| print(f" Final train loss: {result.training_loss:.4f}") | |
| eval_result = trainer.evaluate() | |
| print(f" Final eval loss: {eval_result['eval_loss']:.4f}") | |
| train_logger.log({ | |
| "step": result.global_step, | |
| "epoch": args.epochs, | |
| "timestamp": time.time(), | |
| "eval_loss": eval_result["eval_loss"], | |
| "final": True, | |
| }) | |
| # --- Save final adapter --- | |
| final_dir = run_dir / "final" | |
| model.save_pretrained(str(final_dir)) | |
| tokenizer.save_pretrained(str(final_dir)) | |
| print(f" Saved adapter to {final_dir}") | |
| summary = { | |
| "training_loss": result.training_loss, | |
| "eval_loss": eval_result["eval_loss"], | |
| "elapsed_seconds": elapsed, | |
| "total_steps": result.global_step, | |
| "model": args.model, | |
| "format": "tool_calling", | |
| "run_dir": str(run_dir), | |
| } | |
| with open(run_dir / "summary.json", "w") as f: | |
| json.dump(summary, f, indent=2) | |
| train_logger.close() | |
| print(f"\nLogs: {run_dir / 'train_log.jsonl'}") | |
| print(f"Config: {run_dir / 'config.json'}") | |
| if __name__ == "__main__": | |
| main() | |