| """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() |
|
|
