File size: 6,579 Bytes
4fb73a9 | 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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | """Reconstruct CES CoEdIT inputs locally from the official upstream distribution.
Requires huggingface_hub and pyarrow. Downloading requires an explicit flag;
users must establish that their intended use complies with upstream terms.
The output directory must be separate from the public artifact tree.
"""
import argparse
import hashlib
import json
from pathlib import Path
def sha256(data):
return hashlib.sha256(data).hexdigest()
def read_jsonl(path):
with path.open(encoding='utf-8') as stream:
return [json.loads(line) for line in stream if line.strip()]
def strip_instruction(text):
prefix, separator, rest = text.partition(': ')
return rest if separator and len(prefix.split()) <= 8 else text
def load_sources(folder, specification):
sources = {}
for split, expected in specification['upstream_files'].items():
path = folder / f'{split}.jsonl'
if sha256(path.read_bytes()) != expected['sha256']:
raise ValueError(f'Upstream file hash mismatch: {path}')
for row in read_jsonl(path):
key = (split, str(row['_id']))
if key in sources:
raise ValueError(f'Duplicate upstream ID: {key}')
sources[key] = (strip_instruction(row['src']), row['tgt'])
return sources
def source_for(reference, sources):
pair = sources[(reference['split'], reference['id'])]
text = pair[reference['field']]
if sha256(text.encode()) != reference['sha256']:
raise ValueError(f'Source text mismatch: {reference["split"]}/{reference["id"]}')
return text
def materialize(parts, source):
chunks = []
for part in parts:
if set(part) == {'slice'}:
start, end = part['slice']
if not 0 <= start <= end <= len(source):
raise ValueError('Invalid source slice')
chunks.append(source[start:end])
elif set(part) == {'literal'}:
chunks.append(part['literal'])
else:
raise ValueError('Unknown edit payload format')
return ''.join(chunks)
def write_jsonl(path, rows):
path.parent.mkdir(parents=True, exist_ok=True)
with path.open('w', encoding='utf-8') as stream:
for row in rows:
stream.write(json.dumps(row, ensure_ascii=False, separators=(',', ':')) + '\n')
def reconstruct(recipe_dir, upstream_dir, output):
import pyarrow as pa
import pyarrow.parquet as pq
spec = json.loads((recipe_dir / 'specification.json').read_text())
sources = load_sources(upstream_dir, spec)
counts = {}
for item in spec['manifests']:
rows = []
for recipe in read_jsonl(recipe_dir / item['recipe']):
row = dict(recipe['metadata'])
for field, reference in recipe['text_references'].items():
row[field] = source_for(reference, sources)
rows.append(row)
destination = output / item['output']
write_jsonl(destination, rows)
counts[item['output']] = len(rows)
for item in spec['clean_shards']:
rows = []
for recipe in read_jsonl(recipe_dir / item['recipe']):
row = dict(recipe['metadata'])
for field, reference in recipe['text_references'].items():
row[field] = source_for(reference, sources)
rows.append(row)
destination = output / item['output']
destination.parent.mkdir(parents=True, exist_ok=True)
pq.write_table(pa.Table.from_pylist(rows), destination, compression='zstd')
counts[item['output']] = len(rows)
rows = []
for recipe in read_jsonl(recipe_dir / 'corruptions.jsonl'):
source = source_for(recipe['source'], sources)
corrupted = materialize(recipe['corrupted_parts'], source)
if sha256(corrupted.encode()) != recipe['corrupted_sha256']:
raise ValueError('Reconstructed corruption hash mismatch')
row = dict(recipe['metadata'])
row['source_text'] = source
row['corrupted_text'] = corrupted
for direction, text in [('forward', source), ('inverse', corrupted)]:
edits = []
for encoded in recipe[f'{direction}_edits']:
edit = dict(encoded)
if 'content_parts' in edit:
edit['content'] = materialize(edit.pop('content_parts'), text)
edits.append(edit)
row[f'{direction}_edits_json'] = json.dumps(edits)
rows.append(row)
relative = 'data/posttraining/ces/v1/gec-corruptions/approved-corruptions.parquet'
destination = output / relative
destination.parent.mkdir(parents=True, exist_ok=True)
pq.write_table(pa.Table.from_pylist(rows), destination, compression='zstd')
counts[relative] = len(rows)
(output / 'RECONSTRUCTION.json').write_text(json.dumps({
'upstream_revision': spec['upstream_revision'], 'rows': counts,
'scope': 'Text, row order and training edit programs verified; Parquet bytes and API traces are not reproduced.',
}, indent=2) + '\n')
return counts
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--upstream-dir', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--download', action='store_true', help='Fetch the pinned official CoEdIT files')
args = parser.parse_args()
recipes = Path(__file__).resolve().parent
output = args.output.resolve()
public_root = recipes.parent
if output == public_root or public_root in output.parents or output in public_root.parents:
parser.error('Reconstruct outside the public artifact tree to avoid accidental re-upload.')
if output.exists() and any(output.iterdir()):
parser.error('Choose an empty output directory; existing inputs will not be overwritten.')
spec = json.loads((recipes / 'specification.json').read_text())
upstream = args.upstream_dir.resolve()
if upstream == public_root or public_root in upstream.parents:
parser.error('Keep downloaded upstream files outside the public artifact tree.')
if args.download:
from huggingface_hub import hf_hub_download
for filename in ('train.jsonl', 'validation.jsonl'):
hf_hub_download(spec['upstream_repository'], filename,
repo_type='dataset', revision=spec['upstream_revision'], local_dir=args.upstream_dir)
counts = reconstruct(recipes, args.upstream_dir, output)
print(json.dumps(counts, indent=2))
if __name__ == '__main__':
main()
|