File size: 7,463 Bytes
13cc860
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Read-only reference comparison; reports are written only under local scale/audits."""
import csv
import difflib
import hashlib
import json
from pathlib import Path
import sys

ROOT = Path(__file__).resolve().parents[2]
WS = ROOT.parents[2]
ORIGINAL = WS/'buwendong/user/code/Movens-Zero_train'
UPSTREAM = WS/'buwendong/user/code/OmniHM-Zero_train_40d'
GROUP = ROOT/'scale/groups/sml_1m_224_a1e-4_o1e-5_nojerk'
OUT = ROOT/'scale/audits/reference_20261002'
sys.path.insert(0, str(ROOT/'scale/script'))
from preview_scale import save


def diff(a, b, prefix=''):
    result = {}
    if isinstance(a, dict) and isinstance(b, dict):
        for key in sorted(a.keys() | b.keys()):
            result.update(diff(a.get(key), b.get(key), f'{prefix}.{key}' if prefix else key))
    elif a != b:
        result[prefix] = {'reference': a, 'current': b}
    return result


def sha(p):
    return hashlib.sha256(p.read_bytes()).hexdigest()


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    paths = set(p.relative_to(ROOT) for folder in ('src','scripts') for p in (ROOT/folder).rglob('*.py'))
    paths.update(Path(p) for p in ('train_vlm.py','start_visualization.py','prepare_training_set.py'))
    files = []; patches = []; upstream_patches = []
    for relative in sorted(paths):
        p, q = ROOT/relative, ORIGINAL/relative
        item = dict(path=str(relative), current_sha256=sha(p), reference_exists=q.is_file())
        if q.is_file():
            item.update(reference_sha256=sha(q), identical=p.read_bytes()==q.read_bytes())
            if not item['identical']:
                patches.extend(difflib.unified_diff(q.read_text().splitlines(True),p.read_text().splitlines(True),
                    fromfile=f'original/{relative}',tofile=f'current/{relative}'))
        upstream = UPSTREAM/relative
        if upstream.is_file():
            item.update(upstream_sha256=sha(upstream), upstream_identical=upstream.read_bytes()==p.read_bytes())
            if not item['upstream_identical']:
                upstream_patches.extend(difflib.unified_diff(upstream.read_text().splitlines(True),p.read_text().splitlines(True),
                    fromfile=f'upstream_current/{relative}',tofile=f'current/{relative}'))
        files.append(item)
    save(OUT/'code_hashes.json', files)
    (OUT/'core_changes.diff').write_text(''.join(patches))
    (OUT/'upstream_live_changes.diff').write_text(''.join(upstream_patches))
    launchers=[]
    for p in sorted(ORIGINAL.glob('train*')):
        if p.suffix not in ('.py','.sh') or not p.is_file():continue
        target=ROOT/p.name
        launchers.append(dict(name=p.name,exists=target.exists(),identical=target.exists() and sha(p)==sha(target)))
    save(OUT/'original_launcher_identity.json',launchers)
    from train_scale import normal_recipe
    normal, prepared = normal_recipe()
    reference = normal.model_dump(mode='json')
    save(OUT/'reconstructed_normal_startup.json',reference)
    configs={}
    for size in 'SML':
        run=Path(json.loads((GROUP/f'runs/latest_{size}.json').read_text())['run_dir'])
        config=json.loads((run/'run_config.json').read_text())
        configs[size]=config
        save(OUT/f'{size}_config_differences.json',diff(reference,config))
        save(OUT/f'{size}_run_config.json',config)
        initial_path=sorted((GROUP/'launches').glob(f'{size}_260927*/launch.json'))[0]
        initial=json.loads(initial_path.read_text())
        save(OUT/f'{size}_initial_launch.json',initial)
        save(OUT/f'{size}_initial_config_differences.json',diff(reference,initial))
    integrity=json.loads((ROOT/'training_set/integrity.json').read_text())
    manifests=[]
    for key,relative in integrity['manifests'].items():
        p=ROOT/'training_set'/relative; q=ORIGINAL/'training_set'/relative
        if p.suffix=='.csv':
            with p.open() as f: rows=list(csv.DictReader(f))
            with q.open() as f: other=list(csv.DictReader(f))
        else:
            rows=[json.loads(line) for line in p.read_text().splitlines() if line.strip()]
            other=[json.loads(line) for line in q.read_text().splitlines() if line.strip()]
        manifests.append(dict(name=key,rows=len(rows),reference_rows=len(other),
            byte_identical=sha(p)==sha(q), parsed_identical=rows==other,
            equal_after_project_path_relocation=(json.dumps(rows,sort_keys=True).replace(str(ROOT),'<PROJECT>') ==
                                                json.dumps(other,sort_keys=True).replace(str(ORIGINAL),'<PROJECT>')),
            changed_fields=sorted({field for a,b in zip(rows,other) for field in a.keys()|b.keys() if a.get(field)!=b.get(field)}),
            current_sha256=sha(p), reference_sha256=sha(q)))
    save(OUT/'data_manifests.json',manifests)
    paths=[Path('training_set/config/training_recipe.json'),Path('training_set/config/representation.json')]
    save(OUT/'data_recipe_differences.json',{str(p):diff(json.loads((ORIGINAL/p).read_text()),json.loads((ROOT/p).read_text())) for p in paths})
    seeds={label:json.loads(Path(cfg['train']['absolute_height_startup_seed_path']).read_text())
           for label,cfg in {'reference':reference,**configs}.items()}
    save(OUT/'startup_seed_differences.json',{size:diff(seeds['reference'],seeds[size]) for size in 'SML'})
    stats={name:json.loads(Path(cfg['data']['transform']['field']['stat_path']).read_text())
           for name,cfg in {'reference':reference,**configs}.items()}
    save(OUT/'normalization_differences.json',{size:diff(stats['reference'],stats[size]) for size in 'SML'})
    source_diff={}
    for size,cfg in configs.items():
        source_diff[size]={}
        for task in ('text','audio','audio_command','video_clip'):
            a=json.loads(reference['data'][task]['sources_json']); b=json.loads(cfg['data'][task]['sources_json'])
            for x in a+b:
                x.pop('records_cache_dir',None)
            source_diff[size][task]=diff(a,b)
    save(OUT/'data_source_semantics_differences.json',source_diff)
    chain=[]; checkpoint=Path(json.loads((ROOT/'config/runtime.json').read_text())['resume_checkpoint'])
    seen=set()
    while checkpoint.parent.parent not in seen:
        run=checkpoint.parent.parent; seen.add(run)
        path=run/'run_config.json'
        if not path.exists():
            chain.append(dict(run=str(run),missing_config=True)); break
        cfg=json.loads(path.read_text())
        entry=dict(run=str(run),checkpoint=checkpoint.name,config_sha256=sha(path),
            training_protocol=cfg.get('training_protocol'),stage=cfg.get('absolute_height_stage'),
            base_action_lr=cfg['train']['learning_rate'],base_omni_lr=cfg['model']['lang_backbone_lr'],
            global_batch=cfg['train']['train_batch_size']*cfg['world_size_expected'],
            jerk_weights={k:v for k,v in cfg['train'].items() if 'jerk' in k and 'weight' in k})
        chain.append(entry)
        provenance=cfg.get('resume_provenance') or cfg.get('warmstart_provenance') or {}
        previous=provenance.get('source_checkpoint')
        if not previous: break
        checkpoint=Path(previous)
    save(OUT/'reference_checkpoint_chain.json',chain)
    print(json.dumps(dict(code_files=len(files),identical=sum(x.get('identical',False) for x in files),
        changed=[x['path'] for x in files if x.get('identical') is False],
        manifests=manifests),ensure_ascii=False,indent=2))


if __name__=='__main__':
    main()