| """Export this release's alignment Parquet files to nano-duplex raw WAV/JSONL. |
| |
| Example: python materialize_alignment.py --snapshot ./nano-duplex-data-v1 --output ./raw --split train |
| Dependencies: numpy, pyarrow, soundfile. No torchcodec or remote dataset code is required. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| from io import BytesIO |
| import json |
| from pathlib import Path |
| import re |
|
|
| import numpy as np |
| import pyarrow.parquet as pq |
| import soundfile as sf |
|
|
|
|
| def materialize(snapshot, output, split, limit=None): |
| snapshot, output = Path(snapshot), Path(output) |
| files = sorted((snapshot / 'alignment').glob(f'{split}-*.parquet')) |
| if not files: |
| raise ValueError('No alignment shards for the requested split') |
| if limit is not None and limit <= 0: |
| raise ValueError('Limit must be positive') |
| output.mkdir(parents=True, exist_ok=True) |
| audio_directory = output / 'audio' / split |
| audio_directory.mkdir(parents=True, exist_ok=True) |
| manifest = output / f'{split}.jsonl' |
| if manifest.exists(): |
| raise FileExistsError('Use a fresh output directory to preserve existing training manifests') |
| temporary = manifest.with_suffix('.jsonl.tmp') |
| count = 0 |
| with temporary.open('w', encoding='utf-8', newline='\n') as target: |
| for file in files: |
| for batch in pq.ParquetFile(file).iter_batches(batch_size=16): |
| for row in batch.to_pylist(): |
| if not re.fullmatch(r'\d+_\d+_\d+_\d+', row['original_id']): |
| raise ValueError('Unexpected original utterance identifier') |
| pcm, rate = sf.read(BytesIO(row['audio']['bytes']), dtype='int16') |
| digest = hashlib.sha256(np.asarray(pcm, dtype='<i2').tobytes()).hexdigest() |
| if digest != row['pcm_sha256'] or rate != 24000 or pcm.ndim != 1: |
| raise ValueError('Stored audio failed verification') |
| path = audio_directory / f"{row['original_id']}.wav" |
| if path.exists(): |
| old, old_rate = sf.read(path, dtype='int16') |
| if old_rate != rate or not np.array_equal(old, pcm): |
| raise ValueError('Existing output WAV differs') |
| else: |
| sf.write(path, pcm, rate, format='WAV', subtype='PCM_16') |
| raw = {'schema_version': 1, 'kind': 'raw_alignment', 'episode_id': row['id'], |
| 'audio': path.relative_to(output).as_posix(), 'text': row['text'], |
| 'source': row['source'], 'source_url': 'https://www.openslr.org/141/', |
| 'source_split': row['source_split'], 'speaker_id': row['speaker_id'], |
| 'original_id': row['original_id'], 'split': split, 'license': row['license'], |
| 'sample_rate': rate, 'valid_samples': len(pcm), 'duration_seconds': len(pcm) / rate, |
| 'channels': 1, 'sample_width': 2, |
| 'source_sha256': hashlib.sha256(path.read_bytes()).hexdigest(), |
| 'original_wav_sha256': row['source_audio_sha256'], 'pcm_sha256': digest, |
| 'provenance': {'transformation': 'lossless release FLAC decoded to PCM16 WAV', |
| 'release': 'nano-duplex-data-v1', 'archive_verified': True}} |
| target.write(json.dumps(raw, ensure_ascii=False, allow_nan=False) + '\n') |
| count += 1 |
| if limit is not None and count >= limit: |
| break |
| if limit is not None and count >= limit: |
| break |
| if limit is not None and count >= limit: |
| break |
| temporary.replace(manifest) |
| return {'manifest': str(manifest), 'rows': count} |
|
|
|
|
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--snapshot', required=True) |
| parser.add_argument('--output', required=True) |
| parser.add_argument('--split', choices=['train', 'validation', 'test'], default='train') |
| parser.add_argument('--limit', type=int) |
| args = parser.parse_args() |
| print(json.dumps(materialize(args.snapshot, args.output, args.split, args.limit))) |
|
|
