File size: 7,783 Bytes
758421f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Verify the portable dataset; optionally compare it with its source catalog."""
import argparse
from collections import Counter, defaultdict
import hashlib
import json
from pathlib import Path
import sys

import numpy as np
from PIL import Image

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from groundguard_data import Dataset, decode_rle


def digest(path):
    with path.open('rb') as stream:
        return hashlib.file_digest(stream, 'sha256').hexdigest()


def require(ok, message):
    if not ok:
        raise ValueError(message)


def verify(source=None):
    data = Dataset(ROOT / 'prepared_data')
    expected_files = set()
    image_specs = {}
    mask_specs = {}
    records = list(data.iter_samples(subset='all', condition='all'))
    for name, counts in data.report['datasets'].items():
        manifest = data.root / 'manifests' / f'{name}.jsonl'
        selection = data.root / 'selections' / f'{name}.json'
        require(digest(manifest) == counts['manifest_sha256'], f'Manifest hash: {name}')
        require(digest(selection) == counts['selection_sha256'], f'Selection hash: {name}')
        ids = json.loads(selection.read_text())
        require(ids['test_unit_ids'] == ids['selected_unit_ids'], f'All selected units must be test: {name}')
        require(ids['development_unit_ids'] == [], f'Unexpected development units: {name}')
        kept = set().union(*(ids[f'{s}_unit_ids'] for s in ('selected', 'test', 'development')))
        rows = list(data.iter_samples(name, subset='all', condition='all'))
        require({r['unit_id'] for r in rows} == kept, f'Catalog scope: {name}')
        require(len(rows) == counts['catalog_records'], f'Record count: {name}')
        for split in ('selected', 'test', 'development'):
            subset = list(data.iter_samples(name, subset=split, condition='all'))
            measured = dict(units=len({r['unit_id'] for r in subset}), image_query_records=len(subset),
                distinct_source_images=len({r['source_group_id'] for r in subset}),
                distinct_images=len({r['image']['pixel_sha256'] for r in subset}),
                task_counts=dict(sorted(Counter(r['task_type'] for r in subset if r['is_primary']).items())))
            require(measured == counts[split], f'Split statistics: {name}/{split}')
        print(f'Checked {name}: {len(rows)} records', flush=True)
    split_rows = {s: list(data.iter_samples(subset=s, condition='all')) for s in ('test', 'development')}
    for field in ('source_group_id', 'pixel_sha256'):
        values = {s: {r[field] if field == 'source_group_id' else r['image'][field] for r in rows}
                  for s, rows in split_rows.items()}
        require(not (values['test'] & values['development']), f'Split overlap: {field}')
    for row in records:
        spec = row['image']
        path = spec['path']
        require(path not in image_specs or image_specs[path] == spec, f'Conflicting image: {path}')
        image_specs[path] = spec
        expected_files.add(path)
        require(row['selection_eligible'], f'Ineligible record: {row["sample_id"]}')
        for region in row['reference']['regions'] + row.get('intervention_regions', []):
            x1, y1, x2, y2 = region['bbox_xyxy']
            require(0 <= x1 < x2 <= spec['width'] and 0 <= y1 < y2 <= spec['height'], 'Invalid bbox')
            mask = region.get('mask')
            if mask:
                require(mask['size'] == [spec['height'], spec['width']], 'Mask/image dimensions')
                if mask['encoding'] == 'binary_png':
                    expected_files.add(mask['path'])
                    prior = mask_specs.setdefault(mask['path'], mask['size'])
                    require(prior == mask['size'], 'Conflicting PNG mask dimensions')
                else:
                    require(mask['encoding'] == 'coco_rle', 'Unknown mask encoding')
                    binary = decode_rle(mask)
                    require(binary.any(), 'Empty positive RLE mask')
                    if 'area' in region:
                        require(int(binary.sum()) == region['area'], 'RLE area mismatch')
        if row['pair_id']:
            pair = data.get_pair(row)
            require(set(pair) == {'factual_original', 'factual_replacement',
                                 'counterfactual_original', 'counterfactual_replacement'}, 'Incomplete pair')
    for i, (relative, spec) in enumerate(sorted(image_specs.items()), 1):
        path = data._path(relative)
        require(digest(path) == spec['byte_sha256'], f'Image hash: {relative}')
        with Image.open(path) as image:
            image.load()
            require(image.size == (spec['width'], spec['height']), f'Image size: {relative}')
            pixels = f'{image.width},{image.height},RGB\0'.encode() + image.convert('RGB').tobytes()
            require(hashlib.sha256(pixels).hexdigest() == spec['pixel_sha256'], f'Pixel hash: {relative}')
        if i % 500 == 0:
            print(f'Checked {i}/{len(image_specs)} images', flush=True)
    for relative, size in mask_specs.items():
        with Image.open(data._path(relative)) as image:
            require(list(image.size)[::-1] == size, f'PNG mask size: {relative}')
            require(np.asarray(image.convert('L')).any(), f'Empty positive PNG mask: {relative}')
    actual = {str(p.relative_to(data.root)) for name in ('images', 'masks')
              for p in (data.root / name).rglob('*') if p.is_file()}
    require(actual == expected_files, 'Missing or unused image/mask files')
    if source:
        original = Dataset(source)
        for row in records:
            require(row == original.get(row['sample_id']), f'Changed record: {row["sample_id"]}')
        for name in data.report['datasets']:
            current = json.loads((data.root / 'selections' / f'{name}.json').read_text())
            previous = json.loads((original.root / 'selections' / f'{name}.json').read_text())
            require(current['selected_unit_ids'] == previous['selected_unit_ids'], f'Changed selected units: {name}')
        for relative in expected_files:
            require(digest(data._path(relative)) == digest(original._path(relative)), f'Changed asset: {relative}')
    sums = ROOT / 'SHA256SUMS'
    if sums.exists():
        for line in sums.read_text().splitlines():
            expected, relative = line.split('  ', 1)
            path = (ROOT / relative).resolve()
            require(path.is_relative_to(ROOT) and digest(path) == expected, f'Payload checksum: {relative}')
    return dict(status='passed', records=len(records), units=len({r['unit_id'] for r in records}),
                image_files=len(image_specs), png_mask_files=len(mask_specs), asset_files=len(expected_files),
                complete_hallusegbench_pairs=len({r['pair_id'] for r in records if r['pair_id']}),
                development_test_exact_source_overlap=0, development_test_exact_image_overlap=0,
                source_equivalence_checked=source is not None,
                split_policy='test_only', development_units=0,
                checks=['manifest_and_selection_hashes', 'all_selected_units_are_test', 'complete_pairs',
                        'image_byte_and_pixel_hashes', 'image_decoding_and_dimensions', 'bbox_bounds',
                        'mask_dimensions_and_rle_areas', 'no_unused_or_missing_assets'])


if __name__ == '__main__':
    cli = argparse.ArgumentParser(description=__doc__)
    cli.add_argument('--source', type=Path)
    cli.add_argument('--write-report', action='store_true')
    args = cli.parse_args()
    result = verify(args.source)
    if args.write_report:
        (ROOT / 'verification_report.json').write_text(json.dumps(result, indent=2) + '\n')
    print(json.dumps(result, indent=2))