Upload finetune_coding.py with huggingface_hub

463adee verified 6 months ago

9.58 kB

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "trl>=0.12.0",
#     "peft>=0.7.0",
#     "transformers>=4.36.0",
#     "accelerate>=0.24.0",
#     "bitsandbytes>=0.41.0",
#     "datasets>=2.0.0",
#     "jinja2>=3.0",
# ]
# ///

"""
Fine-tune swiss-ai/Apertus-8B-Instruct-2509 on three agentic coding / reasoning datasets:
  - Roman1111111/claude-opus-4.6-10000x   (9.6K — Opus 4.6 reasoning distillation)
  - togethercomputer/CoderForge-Preview    (15K sample — agentic coding trajectories)
  - Crownelius/Opus-4.6-Reasoning-3300x   (2.2K — reasoning with thinking traces)
All data is formatted with the native Apertus chat format via the apertus-format library.
Thinking/reasoning traces are preserved as THOUGHTS blocks.
CoderForge tool calls are mapped to Apertus TOOL_CALLS/TOOL_OUTPUTS blocks within a
single merged assistant turn.
"""

import json
import subprocess
import sys

# apertus-format has no PyPI release — clone and import from src/ package
print("Cloning apertus-format...")
subprocess.run(
    ["git", "clone", "--depth=1", "https://github.com/swiss-ai/apertus-format.git", "/tmp/apertus-format"],
    check=True,
)
sys.path.insert(0, "/tmp/apertus-format")

from datasets import load_dataset, concatenate_datasets
from peft import LoraConfig
from src import (  # noqa: E402 — inserted after sys.path patch
    Message, Conversation, ApertusFormatter,
    AssistantBlock, ToolCall, ToolOutput, BlockType,
)
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import SFTConfig, SFTTrainer

MODEL_ID = "swiss-ai/Apertus-8B-Instruct-2509"
OUTPUT_REPO = "Colby/apertus-8b-coding"
CODERFORGE_SAMPLE = 15_000

formatter = ApertusFormatter(enable_thinking=True)


def format_roman(example):
    """Opus 4.6 reasoning dataset: messages list with optional reasoning field."""
    msgs = []
    for msg in example["messages"]:
        role = msg.get("role", "")
        content = msg.get("content", "") or ""
        if role == "system":
            msgs.append(Message.system(content))
        elif role == "user":
            msgs.append(Message.user(content))
        elif role == "assistant":
            reasoning = msg.get("reasoning", "") or ""
            blocks = []
            if reasoning.strip():
                blocks.append(AssistantBlock(type=BlockType.THOUGHTS, text=reasoning))
            blocks.append(AssistantBlock(type=BlockType.RESPONSE, text=content))
            msgs.append(Message.assistant_with_blocks(blocks))
    try:
        return {"text": formatter.format_conversation(Conversation(messages=msgs))}
    except Exception:
        return {"text": None}


def format_coderforge(example):
    """
    CoderForge agentic trajectories: messages is a JSON string in OpenHands format.
    Merges all assistant+tool turns into a single Apertus assistant message.
    Block mapping:
      assistant with tool_calls  → THOUGHTS (the explanation) + TOOL_CALLS (the action)
      tool result                → TOOL_OUTPUTS
      assistant without tool_calls (final) → RESPONSE
    This ordering is valid in the Apertus format (RESPONSE may not precede TOOL_OUTPUTS).
    """
    try:
        raw = json.loads(example["messages"])
    except (json.JSONDecodeError, TypeError):
        return {"text": None}

    system_msgs = []
    user_msgs = []
    agentic_blocks = []
    agentic_started = False

    for msg in raw:
        role = msg.get("role", "")
        content = msg.get("content") or ""
        if isinstance(content, list):
            content = " ".join(
                p.get("text", "") for p in content if isinstance(p, dict)
            )
        content = str(content).strip()

        if role == "system":
            system_msgs.append(Message.system(content))
        elif role == "user" and not agentic_started:
            user_msgs.append(Message.user(content))
        elif role == "assistant":
            agentic_started = True
            tool_calls_raw = msg.get("tool_calls") or []
            if tool_calls_raw:
                # Content alongside tool_calls is the model's reasoning → THOUGHTS
                if content:
                    agentic_blocks.append(
                        AssistantBlock(type=BlockType.THOUGHTS, text=content)
                    )
                calls = [
                    ToolCall(
                        name=tc["function"]["name"],
                        arguments=tc["function"].get("arguments", "{}"),
                    )
                    for tc in tool_calls_raw
                    if "function" in tc
                ]
                if calls:
                    agentic_blocks.append(
                        AssistantBlock(type=BlockType.TOOL_CALLS, calls=calls)
                    )
            elif content:
                # No tool calls: this is a final text response
                agentic_blocks.append(
                    AssistantBlock(type=BlockType.RESPONSE, text=content)
                )
        elif role == "tool":
            agentic_started = True
            if content:
                agentic_blocks.append(
                    AssistantBlock(
                        type=BlockType.TOOL_OUTPUTS,
                        outputs=[ToolOutput(output=content)],
                    )
                )

    if not agentic_blocks:
        return {"text": None}

    all_msgs = system_msgs + user_msgs + [Message.assistant_with_blocks(agentic_blocks)]
    try:
        return {"text": formatter.format_conversation(Conversation(messages=all_msgs))}
    except Exception:
        return {"text": None}


def format_crownelius(example):
    """Opus 4.6 reasoning dataset: flat problem/thinking/solution columns."""
    problem = (example.get("problem") or "").strip()
    thinking = (example.get("thinking") or "").strip()
    solution = (example.get("solution") or "").strip()
    if not problem or not solution:
        return {"text": None}
    blocks = []
    if thinking:
        blocks.append(AssistantBlock(type=BlockType.THOUGHTS, text=thinking))
    blocks.append(AssistantBlock(type=BlockType.RESPONSE, text=solution))
    msgs = [
        Message.user(problem),
        Message.assistant_with_blocks(blocks),
    ]
    try:
        return {"text": formatter.format_conversation(Conversation(messages=msgs))}
    except Exception:
        return {"text": None}


print("Loading datasets...")
ds_roman = load_dataset("Roman1111111/claude-opus-4.6-10000x", split="train")
ds_coderforge = (
    load_dataset(
        "togethercomputer/CoderForge-Preview",
        name="trajectories",
        split="filtered_reward1",
    )
    .shuffle(seed=42)
    .select(range(CODERFORGE_SAMPLE))
)
ds_crownelius = load_dataset("Crownelius/Opus-4.6-Reasoning-3300x", split="train")

print("Mapping to Apertus format...")
ds_roman = ds_roman.map(format_roman, remove_columns=ds_roman.column_names)
ds_coderforge = ds_coderforge.map(
    format_coderforge, remove_columns=ds_coderforge.column_names
)
ds_crownelius = ds_crownelius.map(
    format_crownelius, remove_columns=ds_crownelius.column_names
)

ds_roman = ds_roman.filter(lambda x: x["text"] is not None)
ds_coderforge = ds_coderforge.filter(lambda x: x["text"] is not None)
ds_crownelius = ds_crownelius.filter(lambda x: x["text"] is not None)

print(f"  Roman:      {len(ds_roman)}")
print(f"  CoderForge: {len(ds_coderforge)}")
print(f"  Crownelius: {len(ds_crownelius)}")

combined = concatenate_datasets([ds_roman, ds_coderforge, ds_crownelius]).shuffle(seed=42)
split = combined.train_test_split(test_size=0.05, seed=42)
train_dataset = split["train"]
eval_dataset = split["test"]
print(f"Total — Train: {len(train_dataset)}  Eval: {len(eval_dataset)}")

peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules="all-linear",
)

config = SFTConfig(
    output_dir="apertus-8b-coding",
    push_to_hub=True,
    hub_model_id=OUTPUT_REPO,
    hub_strategy="every_save",

    dataset_text_field="text",
    max_length=2048,  # 4096 caused OOM on a10g-large; 2048 fits with room to spare

    num_train_epochs=2,
    per_device_train_batch_size=1,   # reduced from 2 to avoid OOM
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=16,  # keeps effective batch at 16
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_steps=100,
    bf16=True,
    gradient_checkpointing=True,

    logging_steps=10,
    save_strategy="steps",
    save_steps=100,
    save_total_limit=2,
    eval_strategy="steps",
    eval_steps=100,

    # Trackio's on_push_begin callback crashes with a PyArrow struct bug (empty rank_pattern
    # field). Disable it so checkpoint pushes to Hub proceed without the crash.
    report_to="none",
)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="bfloat16",
    bnb_4bit_use_double_quant=True,
)

print("Loading model and tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=bnb_config,
    device_map="auto",
)

print("Initializing trainer...")
trainer = SFTTrainer(
    model=model,
    processing_class=tokenizer,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    peft_config=peft_config,
    args=config,
)

print("Starting training...")
trainer.train()

print("Pushing to Hub...")
trainer.push_to_hub()

print(f"Done! Model at: https://huggingface.co/{OUTPUT_REPO}")

	#!/usr/bin/env python3
	# /// script
	# requires-python = ">=3.10"
	# dependencies = [
	# "trl>=0.12.0",
	# "peft>=0.7.0",
	# "transformers>=4.36.0",
	# "accelerate>=0.24.0",
	# "bitsandbytes>=0.41.0",
	# "datasets>=2.0.0",
	# "jinja2>=3.0",
	# ]
	# ///

	"""
	Fine-tune swiss-ai/Apertus-8B-Instruct-2509 on three agentic coding / reasoning datasets:
	- Roman1111111/claude-opus-4.6-10000x (9.6K — Opus 4.6 reasoning distillation)
	- togethercomputer/CoderForge-Preview (15K sample — agentic coding trajectories)
	- Crownelius/Opus-4.6-Reasoning-3300x (2.2K — reasoning with thinking traces)

	All data is formatted with the native Apertus chat format via the apertus-format library.
	Thinking/reasoning traces are preserved as THOUGHTS blocks.
	CoderForge tool calls are mapped to Apertus TOOL_CALLS/TOOL_OUTPUTS blocks within a
	single merged assistant turn.
	"""

	import json
	import subprocess
	import sys

	# apertus-format has no PyPI release — clone and import from src/ package
	print("Cloning apertus-format...")
	subprocess.run(
	["git", "clone", "--depth=1", "https://github.com/swiss-ai/apertus-format.git", "/tmp/apertus-format"],
	check=True,
	)
	sys.path.insert(0, "/tmp/apertus-format")

	from datasets import load_dataset, concatenate_datasets
	from peft import LoraConfig
	from src import ( # noqa: E402 — inserted after sys.path patch
	Message, Conversation, ApertusFormatter,
	AssistantBlock, ToolCall, ToolOutput, BlockType,
	)
	from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
	from trl import SFTConfig, SFTTrainer

	MODEL_ID = "swiss-ai/Apertus-8B-Instruct-2509"
	OUTPUT_REPO = "Colby/apertus-8b-coding"
	CODERFORGE_SAMPLE = 15_000

	formatter = ApertusFormatter(enable_thinking=True)


	def format_roman(example):
	"""Opus 4.6 reasoning dataset: messages list with optional reasoning field."""
	msgs = []
	for msg in example["messages"]:
	role = msg.get("role", "")
	content = msg.get("content", "") or ""
	if role == "system":
	msgs.append(Message.system(content))
	elif role == "user":
	msgs.append(Message.user(content))
	elif role == "assistant":
	reasoning = msg.get("reasoning", "") or ""
	blocks = []
	if reasoning.strip():
	blocks.append(AssistantBlock(type=BlockType.THOUGHTS, text=reasoning))
	blocks.append(AssistantBlock(type=BlockType.RESPONSE, text=content))
	msgs.append(Message.assistant_with_blocks(blocks))
	try:
	return {"text": formatter.format_conversation(Conversation(messages=msgs))}
	except Exception:
	return {"text": None}


	def format_coderforge(example):
	"""
	CoderForge agentic trajectories: messages is a JSON string in OpenHands format.
	Merges all assistant+tool turns into a single Apertus assistant message.

	Block mapping:
	assistant with tool_calls → THOUGHTS (the explanation) + TOOL_CALLS (the action)
	tool result → TOOL_OUTPUTS
	assistant without tool_calls (final) → RESPONSE
	This ordering is valid in the Apertus format (RESPONSE may not precede TOOL_OUTPUTS).
	"""
	try:
	raw = json.loads(example["messages"])
	except (json.JSONDecodeError, TypeError):
	return {"text": None}

	system_msgs = []
	user_msgs = []
	agentic_blocks = []
	agentic_started = False

	for msg in raw:
	role = msg.get("role", "")
	content = msg.get("content") or ""
	if isinstance(content, list):
	content = " ".join(
	p.get("text", "") for p in content if isinstance(p, dict)
	)
	content = str(content).strip()

	if role == "system":
	system_msgs.append(Message.system(content))
	elif role == "user" and not agentic_started:
	user_msgs.append(Message.user(content))
	elif role == "assistant":
	agentic_started = True
	tool_calls_raw = msg.get("tool_calls") or []
	if tool_calls_raw:
	# Content alongside tool_calls is the model's reasoning → THOUGHTS
	if content:
	agentic_blocks.append(
	AssistantBlock(type=BlockType.THOUGHTS, text=content)
	)
	calls = [
	ToolCall(
	name=tc["function"]["name"],
	arguments=tc["function"].get("arguments", "{}"),
	)
	for tc in tool_calls_raw
	if "function" in tc
	]
	if calls:
	agentic_blocks.append(
	AssistantBlock(type=BlockType.TOOL_CALLS, calls=calls)
	)
	elif content:
	# No tool calls: this is a final text response
	agentic_blocks.append(
	AssistantBlock(type=BlockType.RESPONSE, text=content)
	)
	elif role == "tool":
	agentic_started = True
	if content:
	agentic_blocks.append(
	AssistantBlock(
	type=BlockType.TOOL_OUTPUTS,
	outputs=[ToolOutput(output=content)],
	)
	)

	if not agentic_blocks:
	return {"text": None}

	all_msgs = system_msgs + user_msgs + [Message.assistant_with_blocks(agentic_blocks)]
	try:
	return {"text": formatter.format_conversation(Conversation(messages=all_msgs))}
	except Exception:
	return {"text": None}


	def format_crownelius(example):
	"""Opus 4.6 reasoning dataset: flat problem/thinking/solution columns."""
	problem = (example.get("problem") or "").strip()
	thinking = (example.get("thinking") or "").strip()
	solution = (example.get("solution") or "").strip()
	if not problem or not solution:
	return {"text": None}
	blocks = []
	if thinking:
	blocks.append(AssistantBlock(type=BlockType.THOUGHTS, text=thinking))
	blocks.append(AssistantBlock(type=BlockType.RESPONSE, text=solution))
	msgs = [
	Message.user(problem),
	Message.assistant_with_blocks(blocks),
	]
	try:
	return {"text": formatter.format_conversation(Conversation(messages=msgs))}
	except Exception:
	return {"text": None}


	print("Loading datasets...")
	ds_roman = load_dataset("Roman1111111/claude-opus-4.6-10000x", split="train")
	ds_coderforge = (
	load_dataset(
	"togethercomputer/CoderForge-Preview",
	name="trajectories",
	split="filtered_reward1",
	)
	.shuffle(seed=42)
	.select(range(CODERFORGE_SAMPLE))
	)
	ds_crownelius = load_dataset("Crownelius/Opus-4.6-Reasoning-3300x", split="train")

	print("Mapping to Apertus format...")
	ds_roman = ds_roman.map(format_roman, remove_columns=ds_roman.column_names)
	ds_coderforge = ds_coderforge.map(
	format_coderforge, remove_columns=ds_coderforge.column_names
	)
	ds_crownelius = ds_crownelius.map(
	format_crownelius, remove_columns=ds_crownelius.column_names
	)

	ds_roman = ds_roman.filter(lambda x: x["text"] is not None)
	ds_coderforge = ds_coderforge.filter(lambda x: x["text"] is not None)
	ds_crownelius = ds_crownelius.filter(lambda x: x["text"] is not None)

	print(f" Roman: {len(ds_roman)}")
	print(f" CoderForge: {len(ds_coderforge)}")
	print(f" Crownelius: {len(ds_crownelius)}")

	combined = concatenate_datasets([ds_roman, ds_coderforge, ds_crownelius]).shuffle(seed=42)
	split = combined.train_test_split(test_size=0.05, seed=42)
	train_dataset = split["train"]
	eval_dataset = split["test"]
	print(f"Total — Train: {len(train_dataset)} Eval: {len(eval_dataset)}")

	peft_config = LoraConfig(
	r=16,
	lora_alpha=32,
	lora_dropout=0.05,
	bias="none",
	task_type="CAUSAL_LM",
	target_modules="all-linear",
	)

	config = SFTConfig(
	output_dir="apertus-8b-coding",
	push_to_hub=True,
	hub_model_id=OUTPUT_REPO,
	hub_strategy="every_save",

	dataset_text_field="text",
	max_length=2048, # 4096 caused OOM on a10g-large; 2048 fits with room to spare

	num_train_epochs=2,
	per_device_train_batch_size=1, # reduced from 2 to avoid OOM
	per_device_eval_batch_size=1,
	gradient_accumulation_steps=16, # keeps effective batch at 16
	learning_rate=2e-4,
	lr_scheduler_type="cosine",
	warmup_steps=100,
	bf16=True,
	gradient_checkpointing=True,

	logging_steps=10,
	save_strategy="steps",
	save_steps=100,
	save_total_limit=2,
	eval_strategy="steps",
	eval_steps=100,

	# Trackio's on_push_begin callback crashes with a PyArrow struct bug (empty rank_pattern
	# field). Disable it so checkpoint pushes to Hub proceed without the crash.
	report_to="none",
	)

	bnb_config = BitsAndBytesConfig(
	load_in_4bit=True,
	bnb_4bit_quant_type="nf4",
	bnb_4bit_compute_dtype="bfloat16",
	bnb_4bit_use_double_quant=True,
	)

	print("Loading model and tokenizer...")
	tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
	model = AutoModelForCausalLM.from_pretrained(
	MODEL_ID,
	quantization_config=bnb_config,
	device_map="auto",
	)

	print("Initializing trainer...")
	trainer = SFTTrainer(
	model=model,
	processing_class=tokenizer,
	train_dataset=train_dataset,
	eval_dataset=eval_dataset,
	peft_config=peft_config,
	args=config,
	)

	print("Starting training...")
	trainer.train()

	print("Pushing to Hub...")
	trainer.push_to_hub()

	print(f"Done! Model at: https://huggingface.co/{OUTPUT_REPO}")