Stage 2 only: tool prediction on personality LoRA, 3 epochs, batch=2

train_hf_jobs_stage2.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Anti-Hero Stage 2: Tool Prediction Training (standalone).
+
+Loads the personality LoRA from Hub, then trains tool prediction on top.
+Stage 1 already completed and pushed to lokegud/antihero-personality-lora.
+
+Submit via HF Jobs Docker mode with upgraded unsloth+transformers.
+"""
+
+import os
+import trackio
+from unsloth import FastLanguageModel
+from trl import SFTTrainer, SFTConfig
+from datasets import load_dataset
+from transformers import DataCollatorForSeq2Seq
+
+# ── Config ──────────────────────────────────────────────────────────────
+HF_USER = "lokegud"
+BASE_MODEL = "huihui-ai/Huihui-Qwen3.5-35B-A3B-Claude-4.6-Opus-abliterated"
+PERSONALITY_LORA = f"{HF_USER}/antihero-personality-lora"
+MAX_SEQ_LENGTH = 2048
+
+# Stage 2: Tool prediction
+TOOL_DATASET = f"{HF_USER}/antihero-tool-prediction"
+TOOL_EPOCHS = 3  # Reduced from 6: 1724 short examples, 3 epochs sufficient
+TOOL_LR = 1.5e-4
+
+# LoRA config
+LORA_R = 32
+LORA_ALPHA = 64
+LORA_DROPOUT = 0.0
+
+# Output
+OUTPUT_TOOL = f"{HF_USER}/antihero-tool-lora"
+OUTPUT_MERGED = f"{HF_USER}/antihero-merged"
+
+
+def load_model():
+    """Load base model with personality LoRA already applied."""
+    print(f"Loading base model: {BASE_MODEL}")
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=BASE_MODEL,
+        max_seq_length=MAX_SEQ_LENGTH,
+        load_in_4bit=False,
+    )
+
+    # Add LoRA adapters
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=LORA_R,
+        lora_alpha=LORA_ALPHA,
+        lora_dropout=LORA_DROPOUT,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=42,
+        target_modules=[
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj",
+        ],
+    )
+
+    # Load personality LoRA weights on top
+    print(f"Loading personality LoRA from: {PERSONALITY_LORA}")
+    from peft import set_peft_model_state_dict
+    from huggingface_hub import hf_hub_download
+    import safetensors.torch
+    adapter_path = hf_hub_download(PERSONALITY_LORA, "adapter_model.safetensors")
+    state_dict = safetensors.torch.load_file(adapter_path)
+    set_peft_model_state_dict(model, state_dict)
+    print("Personality LoRA weights loaded")
+
+    model.print_trainable_parameters()
+    return model, tokenizer
+
+
+def prepare_tool_dataset():
+    """Load and prepare tool prediction dataset."""
+    print(f"\nLoading tool prediction dataset: {TOOL_DATASET}")
+    ds = load_dataset(TOOL_DATASET, split="train")
+    print(f"  {len(ds)} examples loaded")
+
+    def format_tool_example(example):
+        context_str = ""
+        for msg in example.get("context", []):
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                continue
+            context_str += f"{role}: {content}\n"
+
+        answer_parts = []
+        for tool in example.get("correct_tools", []):
+            action_num = tool.get("action", "?")
+            tool_name = tool.get("tool", "unknown")
+            args = tool.get("args", "")
+            if args:
+                answer_parts.append(f"ACTION_{action_num}: {tool_name}({args})")
+            else:
+                answer_parts.append(f"ACTION_{action_num}: {tool_name}")
+
+        messages = [
+            {
+                "role": "system",
+                "content": example.get("instruction", "Predict the tool used at each [ACTION_N: ___] position."),
+            },
+            {
+                "role": "user",
+                "content": (
+                    f"Conversation context:\n{context_str}\n"
+                    f"Masked response:\n{example.get('masked_response', '')}\n\n"
+                    f"Predict the correct tool for each masked action."
+                ),
+            },
+            {
+                "role": "assistant",
+                "content": "\n".join(answer_parts),
+            },
+        ]
+        return {"messages": messages}
+
+    ds = ds.map(format_tool_example, remove_columns=ds.column_names)
+
+    split = ds.train_test_split(test_size=0.1, seed=42)
+    print(f"  Train: {len(split['train'])}, Eval: {len(split['test'])}")
+    return split["train"], split["test"]
+
+
+def main():
+    print("=" * 80)
+    print("Anti-Hero Stage 2: Tool Prediction Training")
+    print("=" * 80)
+
+    model, tokenizer = load_model()
+    train_ds, eval_ds = prepare_tool_dataset()
+
+    # Extract text tokenizer from VLM processor
+    text_tok = getattr(tokenizer, "tokenizer", tokenizer)
+
+    def tokenize_messages(examples):
+        texts = []
+        for messages in examples["messages"]:
+            text = tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=False
+            )
+            texts.append(text)
+        tokenized = text_tok(
+            texts,
+            truncation=True,
+            max_length=MAX_SEQ_LENGTH,
+            padding=False,
+            return_tensors=None,
+        )
+        tokenized["labels"] = [list(ids) for ids in tokenized["input_ids"]]
+        return tokenized
+
+    train_ds = train_ds.map(tokenize_messages, batched=True, remove_columns=train_ds.column_names)
+    eval_ds = eval_ds.map(tokenize_messages, batched=True, remove_columns=eval_ds.column_names)
+    print(f"  Tokenized train: {len(train_ds)}, eval: {len(eval_ds)}")
+    print(f"  Sample length: {len(train_ds[0]['input_ids'])} tokens")
+
+    config = SFTConfig(
+        output_dir="./tool-prediction-sft",
+        push_to_hub=True,
+        hub_model_id=OUTPUT_TOOL,
+        hub_strategy="every_save",
+
+        num_train_epochs=TOOL_EPOCHS,
+        per_device_train_batch_size=2,  # Short sequences allow batch=2
+        gradient_accumulation_steps=4,  # Effective batch = 8 still
+        learning_rate=TOOL_LR,
+        lr_scheduler_type="cosine",
+        warmup_steps=20,
+        weight_decay=0.01,
+        max_seq_length=MAX_SEQ_LENGTH,
+
+        logging_steps=10,
+        save_strategy="steps",
+        save_steps=100,
+        save_total_limit=3,
+        eval_strategy="no",
+
+        gradient_checkpointing=True,
+
+        report_to="trackio",
+        project="antihero-training",
+        run_name="tool-prediction-sft-stage2",
+
+        bf16=True,
+        seed=42,
+        dataloader_pin_memory=True,
+    )
+
+    collator = DataCollatorForSeq2Seq(text_tok, padding=True, pad_to_multiple_of=8)
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=train_ds,
+        eval_dataset=eval_ds,
+        data_collator=collator,
+        args=config,
+    )
+
+    print("Starting tool-prediction-sft...")
+    trainer.train()
+
+    print("Pushing tool LoRA to Hub...")
+    trainer.push_to_hub()
+    print(f"Tool LoRA pushed to: {OUTPUT_TOOL}")
+
+    # Merge and push
+    print("Merging LoRA into base model...")
+    merged = model.merge_and_unload()
+    merged.push_to_hub(OUTPUT_MERGED)
+    tokenizer.push_to_hub(OUTPUT_MERGED)
+    print(f"Merged model pushed to: {OUTPUT_MERGED}")
+
+    # GGUF export
+    print("Exporting GGUF (Q4_K_M)...")
+    model.save_pretrained_gguf("./gguf", tokenizer, quantization_method="q4_k_m")
+    from huggingface_hub import HfApi
+    api = HfApi()
+    api.upload_folder(
+        folder_path="./gguf",
+        repo_id=f"{HF_USER}/antihero-gguf",
+        repo_type="model",
+        commit_message="Anti-Hero GGUF Q4_K_M export",
+    )
+    print(f"GGUF pushed to: {HF_USER}/antihero-gguf")
+
+    trackio.finish()
+    print("\n" + "=" * 80)
+    print("TRAINING COMPLETE!")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()