Datasets:
File size: 5,365 Bytes
a57fbba | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | """Train LFM or Qwen from this dataset with native TRL SFTTrainer."""
import argparse
import json
from pathlib import Path
from datasets import load_dataset
from huggingface_hub import HfApi, hf_hub_download
from transformers import AutoModelForCausalLM, AutoModelForImageTextToText, AutoTokenizer
from trl import SFTConfig, SFTTrainer
import torch
REPO = 'FineEnvs/SmolDataEnvs-multiharness-sft'
CONFIGS = {'lfm': 'lfm25_2_6b', 'qwen': 'qwen35_2b'}
HARNESSES = ['opencode', 'claude-code', 'codex', 'mini-swe-agent']
def load_training_data(model, config=None, revision='main', harness=None, common_tasks=False, limit=None):
revision = HfApi().dataset_info(REPO, revision=revision).sha
metadata_file = hf_hub_download(REPO, 'manifest.json', repo_type='dataset', revision=revision)
manifest = json.loads(Path(metadata_file).read_text())
model_config = CONFIGS[model]
config = config or model_config
if config in CONFIGS.values() and config != model_config:
raise ValueError('Token IDs are specific to the model; choose the matching configuration.')
data = load_dataset(REPO, config, split='train', revision=revision)
if harness:
data = data.filter(lambda row: row['harness'] == harness)
if common_tasks:
data = data.filter(lambda row: row['common_task'])
if limit is not None:
data = data.select(range(min(limit, len(data))))
if not len(data):
raise ValueError('The selected dataset is empty.')
tokenized = config in CONFIGS.values()
info = manifest['models'][model_config]
tokenizer = AutoTokenizer.from_pretrained(info['model'], revision=info['model_revision'])
original_template = tokenizer.chat_template
training_template = None
if tokenized:
data = data.select_columns(['input_ids', 'labels'])
else:
def kwargs(row):
if model == 'lfm':
return {'chat_template_kwargs': {'preserve_thinking': True}}
answer = row['completion'][0]
content = answer.get('content') or ''
thinking = bool(answer.get('reasoning_content')) or (isinstance(content, str) and '</think>' in content)
return {'chat_template_kwargs': {'enable_thinking': thinking}}
data = data.map(kwargs)
data = data.select_columns(['prompt', 'completion', 'tools', 'chat_template_kwargs'])
training_template = hf_hub_download(REPO, f'templates/{model_config}-training_chat_template.jinja', repo_type='dataset', revision=revision)
return data, tokenizer, original_template, info, revision, tokenized, training_template
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--model', choices=CONFIGS, default='lfm')
parser.add_argument('--dataset-config', choices=['all', *HARNESSES, *CONFIGS.values()])
parser.add_argument('--revision', default='main')
parser.add_argument('--harness', choices=HARNESSES)
parser.add_argument('--common-tasks', action='store_true')
parser.add_argument('--output-dir', default='sft-output')
parser.add_argument('--epochs', type=float, default=2)
parser.add_argument('--learning-rate', type=float, default=3e-6)
parser.add_argument('--max-steps', type=int, default=-1)
parser.add_argument('--limit', type=int)
args = parser.parse_args()
data, tokenizer, original, info, revision, tokenized, template = load_training_data(
args.model, args.dataset_config, args.revision, args.harness, args.common_tasks, args.limit)
model_class = AutoModelForImageTextToText if args.model == 'qwen' else AutoModelForCausalLM
model = model_class.from_pretrained(info['model'], revision=info['model_revision'], dtype=torch.bfloat16, attn_implementation='sdpa')
model.config.use_cache = False
config = SFTConfig(
output_dir=args.output_dir, num_train_epochs=args.epochs, max_steps=args.max_steps,
learning_rate=args.learning_rate, lr_scheduler_type='constant', warmup_steps=0,
per_device_train_batch_size=1, gradient_accumulation_steps=8,
bf16=True, optim='paged_adamw_8bit', weight_decay=0.0, max_grad_norm=1.0,
gradient_checkpointing=True, gradient_checkpointing_kwargs={'use_reentrant': False},
max_length=None, packing=False, loss_type='chunked_nll',
completion_only_loss=None if tokenized else True, assistant_only_loss=False,
dataset_kwargs={'skip_prepare_dataset': True} if tokenized else None,
chat_template_path=template, dataset_num_proc=None,
save_strategy='epoch', logging_steps=1, report_to='none', seed=42, data_seed=42,
)
trainer = SFTTrainer(model=model, processing_class=tokenizer, args=config, train_dataset=data)
tokenizer.chat_template = original
result = trainer.train()
trainer.save_model(args.output_dir)
tokenizer.save_pretrained(args.output_dir)
trainer.save_state()
Path(args.output_dir, 'dataset_provenance.json').write_text(json.dumps({
'dataset': REPO, 'revision': revision, 'configuration': args.dataset_config or CONFIGS[args.model],
'model': info['model'], 'model_revision': info['model_revision'], 'examples': len(data),
'harness_filter': args.harness, 'common_tasks_only': args.common_tasks, 'metrics': result.metrics,
}, indent=2) + '\n')
if __name__ == '__main__':
main()
|