| """Pinned Hub data -> verified caches -> independent Stage A ASR/TTS training. |
| |
| The pilot profile uses already encoded training data. The full profile encodes |
| the official alignment splits once and reuses verified preparation manifests. |
| Natural interaction data is not mislabeled as a causal duplex training cache. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| from dataclasses import replace |
| from fnmatch import fnmatch |
| import hashlib |
| import json |
| import os |
| from pathlib import Path |
| import re |
| import runpy |
| import shutil |
| import subprocess |
| import sys |
| import tarfile |
|
|
| from .config import Config |
| from .data import AlignmentDataset, load_jsonl, write_jsonl |
|
|
|
|
| def digest(path): |
| value = hashlib.sha256() |
| with Path(path).open('rb') as handle: |
| for block in iter(lambda: handle.read(4 * 1024**2), b''): |
| value.update(block) |
| return value.hexdigest() |
|
|
|
|
| def save_json(path, value): |
| path = Path(path) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| temporary = path.with_suffix(path.suffix + '.tmp') |
| temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + '\n', encoding='utf-8') |
| temporary.replace(path) |
|
|
|
|
| def patterns(profile): |
| common = ['README.md', 'LICENSE', 'MANIFEST.json', 'codec-pilot/*.toml', 'reports/codec-pilot.json'] |
| return common + (['codec-pilot/**'] if profile == 'pilot' else |
| ['alignment/**', 'reports/alignment.json', 'tools/materialize_alignment.py']) |
|
|
|
|
| def verify_snapshot(root, profile): |
| root = Path(root).resolve() |
| manifest = json.loads((root / 'MANIFEST.json').read_text(encoding='utf-8')) |
| if manifest.get('status') != 'validated' or manifest.get('release') != 'nano-duplex-data-v1': |
| raise ValueError('Expected a validated nano-duplex data release') |
| expected = [item for item in manifest['files'] if any(fnmatch(item['path'], pattern) for pattern in patterns(profile))] |
| if not expected: |
| raise ValueError('Release has no files for this profile') |
| for item in expected: |
| path = (root / item['path']).resolve() |
| if not path.is_relative_to(root) or path.is_symlink(): |
| raise ValueError('Snapshot path escapes its dataset root') |
| if not path.is_file() or path.stat().st_size != item['bytes'] or digest(path) != item['sha256']: |
| raise ValueError(f'Snapshot file failed verification: {item["path"]}') |
| return {'manifest_sha256': digest(root / 'MANIFEST.json'), 'verified_files': len(expected)} |
|
|
|
|
| def snapshot(args): |
| lock_path = args.work_dir / 'dataset-lock.json' |
| old = json.loads(lock_path.read_text()) if lock_path.exists() else None |
| if old and old['repo'] != args.repo: |
| raise ValueError('This work directory is bound to another repository') |
| if old and args.revision and old['revision'] != args.revision: |
| raise ValueError('Use a new work directory when changing the dataset revision') |
| revision = args.revision or (old['revision'] if old else None) |
| if not args.offline and args.phase in {'download', 'all'}: |
| from huggingface_hub import HfApi, snapshot_download |
| revision = revision or HfApi().dataset_info(args.repo).sha |
| snapshot_download(args.repo, repo_type='dataset', revision=revision, local_dir=args.snapshot_dir, |
| allow_patterns=patterns(args.profile), max_workers=8) |
| checked = verify_snapshot(args.snapshot_dir, args.profile) |
| revision = revision or ('local:' + checked['manifest_sha256']) |
| if old and old['manifest_sha256'] != checked['manifest_sha256']: |
| raise ValueError('Dataset contents changed inside an existing work directory') |
| lock = {'repo': args.repo, 'revision': revision, **checked} |
| save_json(lock_path, lock) |
| return lock |
|
|
|
|
| def dataset_path(args, task, split='train'): |
| folder = args.work_dir / 'codec-pilot' if args.profile == 'pilot' else args.work_dir / 'prepared' |
| return folder / f'{task}-{split}.jsonl' |
|
|
|
|
| def configurations(args): |
| result = {} |
| for task in ('asr', 'tts'): |
| base = Config.load(args.snapshot_dir / 'codec-pilot' / f'{task}.toml') |
| config = replace(base, dataset=str(dataset_path(args, task)), output_dir=str(args.run_dir / task), |
| device=args.device, batch_size=args.batch_size, steps=args.steps, |
| save_every=min(base.save_every, args.steps)).validate() |
| path = args.work_dir / 'configs' / f'{task}.toml' |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(''.join(f'{key} = {json.dumps(value, ensure_ascii=True, allow_nan=False)}\n' |
| for key, value in config.to_dict().items() if value is not None), encoding='utf-8') |
| result[task] = config |
| return result |
|
|
|
|
| def train_command(args, task): |
| prefix = [sys.executable] |
| if args.nproc > 1: |
| prefix += ['-m', 'torch.distributed.run', '--standalone', f'--nproc_per_node={args.nproc}'] |
| command = prefix + ['-m', 'nano_duplex.train', '--config', str(args.work_dir / 'configs' / f'{task}.toml')] |
| checkpoint = args.run_dir / task / 'latest.pt' |
| if args.resume and checkpoint.is_file(): |
| command += ['--resume', str(checkpoint)] |
| return command |
|
|
|
|
| def cache_present(path, config, task): |
| data = AlignmentDataset(path, config, f'alignment_{task}') |
| for row in data.manifest_rows: |
| if not (Path(path).parent / row['cache']['path']).is_file(): |
| raise FileNotFoundError('A prepared tensor cache is missing') |
| return len(data) |
|
|
|
|
| def expand_pilot(snapshot_dir, destination): |
| """Expand only indexed regular tensor files, checking each digest before promotion.""" |
| source, destination = Path(snapshot_dir) / 'codec-pilot', Path(destination).resolve() |
| index = json.loads((source / 'cache-index.json').read_text(encoding='utf-8')) |
| expected = {item['path']: item for item in index['files']} |
| if len(expected) != len(index['files']): |
| raise ValueError('Duplicate archive index paths') |
| destination.mkdir(parents=True, exist_ok=True) |
| seen = set() |
| with tarfile.open(source / 'tensors.tar', 'r') as archive: |
| for member in archive: |
| item = expected.get(member.name) |
| if (not member.isfile() or item is None or member.name in seen |
| or member.size != item['bytes'] or not re.fullmatch(r'cache/[0-9a-f]{64}\.pt', member.name)): |
| raise ValueError('Unexpected tensor archive member') |
| seen.add(member.name) |
| candidate = destination / member.name |
| path = candidate.resolve() |
| if not path.is_relative_to(destination) or candidate.is_symlink(): |
| raise ValueError('Tensor archive path escapes its output') |
| if path.is_file() and digest(path) == item['sha256']: |
| continue |
| path.parent.mkdir(parents=True, exist_ok=True) |
| temporary = path.with_suffix('.pt.tmp') |
| with archive.extractfile(member) as reader, temporary.open('wb') as target: |
| shutil.copyfileobj(reader, target, 1024**2) |
| if temporary.stat().st_size != item['bytes'] or digest(temporary) != item['sha256']: |
| raise ValueError('Expanded tensor checksum mismatch') |
| temporary.replace(path) |
| if seen != set(expected): |
| raise ValueError('Tensor archive is missing indexed files') |
| for task in ('asr', 'tts'): |
| shutil.copyfile(source / f'{task}-train.jsonl', destination / f'{task}-train.jsonl') |
| return len(expected) |
|
|
|
|
| def prepare(args, configs, lock): |
| if args.profile == 'pilot': |
| expand_pilot(args.snapshot_dir, args.work_dir / 'codec-pilot') |
| return {task: cache_present(dataset_path(args, task), configs[task], task) for task in configs} |
| state_path = args.work_dir / 'preparation.json' |
| binding = {'manifest_sha256': lock['manifest_sha256'], |
| 'codec': {key: getattr(configs['asr'], key) for key in |
| ('mimi_repo', 'mimi_revision', 'sample_rate', 'tick_ms', 'audio_dim', 'codebooks', 'codebook_size')}} |
| state = json.loads(state_path.read_text()) if state_path.exists() else {**binding, 'completed': {}} |
| if any(state.get(key) != value for key, value in binding.items()): |
| raise ValueError('Cached preparation belongs to a different dataset or codec; use a new work directory') |
| save_json(state_path, state) |
| |
| export = runpy.run_path(str(args.snapshot_dir / 'tools/materialize_alignment.py'))['materialize'] |
| for split in ('train', 'validation', 'test'): |
| paths = {task: dataset_path(args, task, split) for task in configs} |
| if split in state['completed']: |
| for task, path in paths.items(): |
| if digest(path) != state['completed'][split][task]: |
| raise ValueError('A prepared manifest changed; refusing to silently reuse it') |
| cache_present(path, configs[task], task) |
| print(json.dumps({'preparation': split, 'status': 'reused'}), flush=True) |
| continue |
| raw = args.work_dir / 'raw' / f'{split}.jsonl' |
| if not raw.exists(): |
| export(args.snapshot_dir, raw.parent, split) |
| for row in load_jsonl(raw): |
| if digest(raw.parent / row['audio']) != row['source_sha256']: |
| raise ValueError('A materialized source WAV changed before encoding') |
| command = [sys.executable, '-m', 'nano_duplex.data', 'prepare-pair', |
| '--config', str(args.work_dir / 'configs/asr.toml'), |
| '--tts-config', str(args.work_dir / 'configs/tts.toml'), '--manifest', str(raw), |
| '--asr-output', str(paths['asr']), '--tts-output', str(paths['tts'])] |
| subprocess.run(command, check=True) |
| for path in paths.values(): |
| rows = load_jsonl(path) |
| for row in rows: |
| row['audio'] = Path(os.path.relpath((raw.parent / row['audio']).resolve(), path.parent)).as_posix() |
| write_jsonl(path, rows) |
| state['completed'][split] = {task: digest(path) for task, path in paths.items()} |
| save_json(state_path, state) |
| return {task: cache_present(dataset_path(args, task), configs[task], task) for task in configs} |
|
|
|
|
| def options(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--repo', default='JonesLin/nano-duplex-data-v1') |
| parser.add_argument('--revision', help='Exact dataset commit; otherwise resolve once and lock it locally') |
| parser.add_argument('--profile', choices=['pilot', 'full'], default='pilot') |
| parser.add_argument('--phase', choices=['download', 'prepare', 'train', 'evaluate', 'all'], default='all') |
| parser.add_argument('--snapshot-dir', type=Path, default=Path('data/hf-server/snapshot')) |
| parser.add_argument('--work-dir', type=Path, default=Path('data/hf-server/work')) |
| parser.add_argument('--run-dir', type=Path) |
| parser.add_argument('--nproc', type=int, default=1) |
| parser.add_argument('--steps', type=int, default=400) |
| parser.add_argument('--batch-size', type=int, default=8) |
| parser.add_argument('--device', default='cuda') |
| parser.add_argument('--resume', action='store_true') |
| parser.add_argument('--offline', action='store_true', help='Use and verify an existing local snapshot') |
| parser.add_argument('--dry-run', action='store_true', help='Print the workflow without network access or file changes') |
| args = parser.parse_args(argv) |
| if args.revision and not re.fullmatch('[0-9a-f]{40}', args.revision): |
| parser.error('--revision must be a full 40-character commit SHA') |
| if min(args.nproc, args.steps, args.batch_size) <= 0: |
| parser.error('GPU processes, steps and batch size must be positive') |
| if args.profile == 'pilot' and args.phase == 'evaluate': |
| parser.error('The codec pilot is training-only; use the full profile for held-out evaluation') |
| args.run_dir = args.run_dir or Path(f'runs/hf-stage-a-{args.profile}') |
| for name in ('snapshot_dir', 'work_dir', 'run_dir'): |
| setattr(args, name, getattr(args, name).resolve()) |
| return args |
|
|
|
|
| def main(argv=None): |
| args = options(argv) |
| if args.dry_run: |
| print(json.dumps({'profile': args.profile, 'phase': args.phase, 'repo': args.repo, |
| 'revision': args.revision or 'resolve once and lock', 'download_patterns': patterns(args.profile), |
| 'prepare': 'reuse included Mimi tensors' if args.profile == 'pilot' else |
| 'export verified WAV/JSONL; encode train/validation/test once; reuse on later runs', |
| 'training_commands': {task: train_command(args, task) for task in ('asr', 'tts')}, |
| 'scope': 'independent Stage A alignment; no duplex-policy training'}, indent=2)) |
| return 0 |
| if args.phase in {'train', 'all'}: |
| found_checkpoint = False |
| for task in ('asr', 'tts'): |
| exists = (args.run_dir / task / 'latest.pt').exists() |
| found_checkpoint |= exists |
| if exists and not args.resume: |
| raise FileExistsError('Existing checkpoints require --resume or a new --run-dir') |
| if args.resume and not found_checkpoint: |
| raise FileNotFoundError('--resume requires at least one existing task checkpoint') |
| lock = snapshot(args) |
| configs = configurations(args) |
| status = {'status': 'running', 'profile': args.profile, 'phase': args.phase, 'dataset': lock, 'completed': []} |
| status_path = args.work_dir / 'pipeline-status.json' |
| save_json(status_path, status) |
| try: |
| if args.phase in {'prepare', 'all'}: |
| status['cache_rows'] = prepare(args, configs, lock) |
| status['completed'].append('prepare') |
| save_json(status_path, status) |
| if args.phase in {'train', 'all'}: |
| for task in configs: |
| cache_present(dataset_path(args, task), configs[task], task) |
| subprocess.run(train_command(args, task), check=True) |
| status['completed'].append(f'train_{task}') |
| save_json(status_path, status) |
| if args.phase == 'evaluate' or (args.phase == 'all' and args.profile == 'full'): |
| for task in configs: |
| subprocess.run([sys.executable, '-m', 'nano_duplex.alignment_eval', |
| '--checkpoint', str(args.run_dir / task / 'latest.pt'), |
| '--manifest', str(dataset_path(args, task, 'validation')), |
| '--train-manifest', str(dataset_path(args, task)), '--split', 'heldout', |
| '--device', args.device, '--max-samples', '8', '--max-new-tokens', '96', |
| '--output-dir', str(args.run_dir / 'evaluation' / task)], check=True) |
| status['completed'].append(f'evaluate_{task}') |
| status['status'] = 'completed' |
| except Exception as exc: |
| status.update(status='failed', error=f'{type(exc).__name__}: {exc}') |
| raise |
| finally: |
| save_json(status_path, status) |
| print(json.dumps(status), flush=True) |
| return 0 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
