Hugging Face's logo

Datasets:
CheneyWong
/
table_recognition_eval_fullpage

Modalities:
Tabular
Text
Formats:
parquet
Languages:
English
Chinese
Size:
1K - 10K
Tags:
document-understanding
table-recognition
paddleocr-vl
teds
Libraries:
Datasets
Dask
Polars
Dataset card Data Studio Files
xet
 Community
table_recognition_eval_fullpage / evaluation_scripts /whole_page_eval.py
CheneyWong's picture
CheneyWong
Add fullpage base evaluation aggregate JSON, scripts and environment documentation
cc1c573 verified
Raw History Blame Contribute Delete
22 kB
"""Independent PaddleOCR-VL native-page table benchmark; never loads 184k packs."""
import argparse
import fcntl
import hashlib
import json
import os
from pathlib import Path
import shutil
import signal
import statistics
import subprocess
import sys
import time
import urllib.request
REFERENCE = Path('/autodl-tmp/official_benchmark_eval_20261030').resolve()
ROOT = Path('/autodl-tmp/official_table_pages_20261031')
BASE = '/autodl-fs/data/PaddleOCR-VL-1.6'
PACK = ROOT / 'parquet_16'
PIPELINE_ENV = Path('/root/autodl-tmp/venv_paddleocrvl_eval')
NAMES = ['ccocr', 'omnidocbench15', 'omnidocbench16', 'real5_scanning',
'real5_warping', 'real5_screen_photography', 'real5_illumination', 'real5_skew']
def dump(path, data):
path.parent.mkdir(parents=True, exist_ok=True)
tmp = path.with_suffix(path.suffix + '.tmp')
tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2))
tmp.replace(path)
def prepare(model, tag):
import yaml
model_path = Path(model).resolve()
config_path = model_path / 'config.json'
if not config_path.exists():
raise ValueError('A complete, merged PaddleOCR-VL checkpoint is required: ' + str(model_path))
config = json.loads(config_path.read_text())
if config.get('model_type') != 'paddleocr_vl':
raise ValueError('This pipeline is for PaddleOCR-VL checkpoints, got: ' + str(config.get('model_type')))
weights = sorted(model_path.glob('*.safetensors'))
if not weights or (model_path / 'adapter_config.json').exists():
raise ValueError('Merge the LoRA adapter with its base before evaluating')
if Path(tag).name != tag or tag in ('.', '..'):
raise ValueError('tag must be a single directory name')
target = ROOT / tag
target.mkdir(parents=True, exist_ok=True)
identity = {'model': str(Path(model).resolve()), 'selection': 'gt_tables > 0',
'scope': 'native whole-page table evaluation; separate from 184k'}
identity_path = target / 'identity.json'
if identity_path.exists() and json.loads(identity_path.read_text()) != identity:
raise RuntimeError('Refusing to reuse predictions from a different model or selection')
dump(identity_path, identity)
vlm = {'vllm_model_path': str(model_path), 'backend': 'vllm-server', 'api_model_name': 'm',
'pipeline_version': 'v1.6', 'pipeline_environment': str(PIPELINE_ENV),
'layout_model_path': '/autodl-fs/data/PP-DocLayoutV3',
'config_sha256': hashlib.sha256(config_path.read_bytes()).hexdigest(),
'weight_files': [{'name': p.name, 'bytes': p.stat().st_size,
'mtime_ns': p.stat().st_mtime_ns} for p in weights]}
binding = target / 'vlm_weights.json'
if binding.exists() and json.loads(binding.read_text()) != vlm:
raise RuntimeError('Weight binding changed; use a new tag instead of reusing cached predictions')
dump(binding, vlm)
dump(target / 'engineering_config.json', {
'gpus': 4, 'vllm_instances_per_gpu': 3, 'vllm_instances_total': 12,
'engine_startup': 'parallel, reuse existing eval_mix.start_servers implementation',
'page_workers': 4, 'balanced_shards_per_worker': 4,
'shard_balance_metric': 'original image width * height',
'mixed_sources_in_inference': True, 'score_report_grouping': 'benchmark',
'scoring': 'CPU process pools run concurrently with GPU inference',
'scoring_workers': {'v15': 6, 'v16_ccocr': 6},
'resume': 'atomic per-page completion markers and durable per-page score packets',
'vlm_weights': 'custom --model; verify all 12 server model paths before inference',
'historical_184k_rerun': False})
for name in ('manifests', 'annotations', 'configs', 'predictions', 'logs', 'stream_scores'):
(target / name).mkdir(exist_ok=True)
packed_gt = {}
if (PACK / 'pack_audit.json').exists():
import pyarrow.parquet as pq
pack_audit = json.loads((PACK / 'pack_audit.json').read_text())
if not pack_audit.get('explicit_table_gt'):
raise RuntimeError('Parquet table-GT extraction is not complete yet')
for shard in pack_audit['by_shard']:
for batch in pq.ParquetFile(PACK / shard['shard']).iter_batches(batch_size=64,
columns=['benchmark', 'sample_id', 'gt_tables', 'gt_page_json', 'gt_html', 'gt_tables_json']):
for row in batch.to_pylist():
assert len(json.loads(row['gt_tables_json'])) == row['gt_tables']
packed_gt[(row['benchmark'], row['sample_id'])] = row
audit = {}
for name in NAMES:
all_rows = [json.loads(line) for line in (REFERENCE / 'manifests' / (name + '.jsonl')).open()]
selected = [r for r in all_rows if r.get('gt_tables', 0) > 0]
assert len({r['sample_id'] for r in selected}) == len(selected)
if packed_gt and name == 'ccocr':
for row in selected:
packed = packed_gt[(name, row['sample_id'])]
assert row['gt_html'] == packed['gt_html']
row['gt_html'] = json.loads(packed['gt_tables_json'])[0]['html']
manifest = target / 'manifests' / (name + '.jsonl')
manifest.write_text(''.join(json.dumps(r, ensure_ascii=False) + '\n' for r in selected))
audit[name] = {'all_pages': len(all_rows), 'selected_pages': len(selected),
'gt_tables': sum(r['gt_tables'] for r in selected),
'manifest_sha256': hashlib.sha256(manifest.read_bytes()).hexdigest()}
if name != 'ccocr':
ids = {r['sample_id'] for r in selected}
pages = json.loads((REFERENCE / 'annotations' / (name + '.json')).read_text())
pages = [p for p in pages if Path(p['page_info']['image_path']).name in ids]
assert len(pages) == len(selected)
if packed_gt:
extracted = []
for row in selected:
packed = packed_gt[(name, row['sample_id'])]
page = json.loads(packed['gt_page_json'])
tables = json.loads(packed['gt_tables_json'])
assert tables == [t for t in page['layout_dets'] if t.get('category_type') == 'table']
# Official truncated-block relations can reference non-table
# annotations. Keep that context; the metric config still
# selects only the table track.
extracted.append(page)
pages = extracted
dump(target / 'annotations' / (name + '.json'), pages)
config = yaml.safe_load((REFERENCE / 'configs' / (name + '.yaml')).read_text())
dataset = config['end2end_eval']['dataset']
dataset['ground_truth']['data_path'] = str(target / 'annotations' / (name + '.json'))
dataset['prediction']['data_path'] = str(target / 'predictions' / name)
(target / 'configs' / (name + '.yaml')).write_text(yaml.safe_dump(config, allow_unicode=True))
dump(target / 'selection_audit.json', {'by_source': audit,
'selected_pages': sum(v['selected_pages'] for v in audit.values()),
'gt_only_used_for_selection_and_scoring': True, 'training_allowed': False,
'original_184k_predictions_modified': False, 'original_184k_rerun': False})
if packed_gt:
dump(target / 'table_gt_provenance.json', {'source': str(PACK),
'pages': len(packed_gt), 'gt_tables': sum(r['gt_tables'] for r in packed_gt.values()),
'annotation_categories_scored': ['table'],
'gt_extracted_from_parquet': True, 'gt_sent_to_model': False,
'matching': 'official OmniDocBench/CC-OCR library matching; no zip by table order'})
if (PACK / 'pack_audit.json').exists():
pack_audit = json.loads((PACK / 'pack_audit.json').read_text())
expected = {(name, json.loads(line)['sample_id']) for name in NAMES
for line in (target / 'manifests' / (name + '.jsonl')).open()}
indexed = [json.loads(line) for line in (PACK / 'index.jsonl').open()]
assert len(indexed) == len(expected) == pack_audit['n']
assert {(r['benchmark'], r['sample_id']) for r in indexed} == expected
dump(target / 'image_pack.json', {'path': str(PACK), 'shards': pack_audit['shards'],
'allocation': '4 workers each consume 4 pixel-balanced shards; mixed sources',
'gt_annotations_not_read_by_inference_worker': True})
shutil.copy2(Path(__file__).parent / 'packed_page_worker.py', target / 'packed_page_worker.py')
for name in ('repos', 'venv_pipeline', 'venv_eval_v15', 'venv_eval_v16'):
link = target / name
destination = PIPELINE_ENV if name == 'venv_pipeline' else REFERENCE / name
if link.is_symlink() and link.resolve() != destination.resolve():
link.unlink()
if not link.exists():
link.symlink_to(destination, target_is_directory=True)
for name in ('run.py', 'pipeline_worker.py', 'score_ccocr.py', 'table_export.py',
'summarize.py', 'servers.py', 'proxy.py', 'stream_score.py'):
code = ((Path(__file__).parent / name) if name == 'table_export.py' else (REFERENCE / name)).read_text()
if name == 'servers.py':
default_call = "start_servers('/autodl-fs/data/PaddleOCR-VL-1.6',"
if code.count(default_call) != 1:
raise RuntimeError('Server template changed; refusing to silently use default VLM weights')
code = code.replace(default_call,
'start_servers(' + repr(str(Path(model).resolve())) + ',')
code = code.replace("'model':'PaddleOCR-VL-1.6'", "'model':" + repr(str(model_path)))
elif name == 'pipeline_worker.py':
code = code.replace("'model':'/autodl-fs/data/PaddleOCR-VL-1.6'",
"'model':" + repr(str(Path(model).resolve())))
elif name == 'summarize.py':
code = code.replace("'model':'PaddleOCR-VL-1.6 base'", "'model':" + repr(str(Path(model).resolve())))
(target / name).write_text(code)
return target
def finalize_score_coverage(target):
"""Rebuild page packets from complete official results and audit every GT table."""
summary = json.loads((target / 'SUMMARY.json').read_text())
if not summary.get('complete'):
raise RuntimeError('Cannot finalize coverage before official evaluation completes')
marker = target / 'score_coverage.json'
if marker.exists() and json.loads(marker.read_text()).get('complete'):
return
# Earlier table-only GT views omitted context for truncated-block relations.
# Official CLI results now use the full original annotation. Rebuild the
# streaming cache from those completed results rather than retaining stale packets.
backup = target / 'stream_scores_before_full_gt_context'
backup.mkdir(exist_ok=True)
for name in NAMES:
path = target / 'stream_scores' / name
if path.exists():
destination = backup / name
if destination.exists():
shutil.rmtree(destination)
path.rename(destination)
env = dict(os.environ); env.pop('PYTHONPATH', None)
for version in ('v15', 'v16'):
with (target / 'logs' / ('coverage_' + version + '.log')).open('a') as output:
subprocess.run([str(target / ('venv_eval_' + version) / 'bin/python'),
str(target / 'stream_score.py'), '--version', version, '--once'],
env=env, stdout=output, stderr=subprocess.STDOUT, check=True)
audit = {'complete': True, 'by_source': {}, 'pages': 0, 'gt_tables': 0,
'provenance': 'completed official CLI results; full original GT context; table metric only'}
for name in NAMES:
rows = [json.loads(line) for line in (target / 'manifests' / (name + '.jsonl')).open()]
missing, gt_count = [], 0
for row in rows:
path = target / 'stream_scores' / name / (row['output_name'] + '.json')
if not path.exists():
missing.append({'sample_id': row['sample_id'], 'reason': 'score packet missing'}); continue
packet = json.loads(path.read_text())
if not isinstance(packet.get('page_teds_s'), (int, float)):
missing.append({'sample_id': row['sample_id'], 'reason': 'TEDS-S missing'})
indices = {int(index) for table in packet['tables'] for index in table['gt_idx']
if str(index).isdigit()}
if indices != set(range(row['gt_tables'])):
missing.append({'sample_id': row['sample_id'], 'reason': 'GT table index coverage mismatch',
'expected': row['gt_tables'], 'scored_indices': sorted(indices)})
gt_count += row['gt_tables']
audit['by_source'][name] = {'pages': len(rows), 'gt_tables': gt_count, 'missing': missing}
audit['pages'] += len(rows); audit['gt_tables'] += gt_count
audit['complete'] &= not missing
dump(marker, audit)
if not audit['complete']:
raise RuntimeError('Official score coverage incomplete; inspect ' + str(marker))
def verify_server_bindings(target, model):
expected = Path(model).resolve()
records = []
for port in range(19000, 19012):
with urllib.request.urlopen(f'http://127.0.0.1:{port}/v1/models', timeout=10) as response:
models = json.load(response)['data']
matching = [m for m in models if m['id'] == 'm']
if len(matching) != 1 or not matching[0].get('root'):
raise RuntimeError('VLM service did not report its loaded model path: ' + str(port))
actual = Path(matching[0]['root']).resolve()
if actual != expected:
raise RuntimeError(f'VLM weight mismatch on port {port}: {actual} != {expected}')
records.append({'port': port, 'model_alias': 'm', 'loaded_model_path': str(actual)})
dump(target / 'verified_server_weights.json', {'expected': str(expected), 'servers': records})
def reuse_base(target):
"""Reuse committed predictions AND existing official per-page scores, no inference."""
summary = []
for name in NAMES:
rows = [json.loads(line) for line in (target / 'manifests' / (name + '.jsonl')).open()]
packets = []
destination = target / 'predictions' / name
destination.mkdir(exist_ok=True)
for row in rows:
stem = row['output_name']
meta = json.loads((REFERENCE / 'predictions' / name / (stem + '.done.json')).read_text())
assert meta['status'] == 'ok' and meta['inference_mode'] == 'page'
packet = json.loads((REFERENCE / 'stream_scores' / name / (stem + '.json')).read_text())
assert packet['sample_id'] == row['sample_id'] and packet['status'] == 'ok'
assert isinstance(packet['page_teds_s'], (int, float))
markdown = REFERENCE / 'predictions' / name / (stem + '.md')
assert hashlib.sha256(markdown.read_bytes()).hexdigest() == packet['prediction_sha256']
packets.append(packet)
# Page stems may contain glob characters such as brackets.
for source in [REFERENCE / 'predictions' / name / (stem + suffix) for suffix in
('.json', '.done.json', '.md', '.tables.html', '.tables.json')]:
if not source.exists():
continue
link = destination / source.name
if not link.exists():
link.symlink_to(source)
summary.append({'benchmark': name, 'n_inputs': len(rows), 'complete': True,
'teds': statistics.fmean(p['page_teds'] for p in packets),
'teds_s': statistics.fmean(p['page_teds_s'] for p in packets)})
dump(target / 'SUMMARY.json', {'model': BASE, 'complete': True,
'selection': 'gt_tables > 0', 'sources': summary, 'inference_rerun': False,
'scoring_rerun': False, 'reused_from': str(REFERENCE),
'scope': 'native whole-page table evaluation; GT-positive page subset'})
def stop(process):
if process.poll() is None:
process.terminate()
try:
process.wait(timeout=45)
except subprocess.TimeoutExpired:
# Every launched controller has its own session, never kill the caller.
os.killpg(process.pid, signal.SIGKILL)
process.wait()
def evaluate(model, tag, prepare_only=False):
target = prepare(model, tag)
if Path(model).resolve() == Path(BASE).resolve():
reuse_base(target)
return target
if prepare_only:
return target
if not (PIPELINE_ENV / 'environment_verified.json').exists():
raise RuntimeError('Dedicated PaddleOCR-VL environment has not passed its import checks')
summary = target / 'SUMMARY.json'
if summary.exists() and json.loads(summary.read_text()).get('complete'):
finalize_score_coverage(target)
return target
ROOT.mkdir(parents=True, exist_ok=True)
with (ROOT / 'gpu_and_official_repo.lock').open('w') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
if summary.exists() and json.loads(summary.read_text()).get('complete'):
finalize_score_coverage(target)
return target
free = subprocess.check_output(['nvidia-smi', '--query-gpu=memory.free', '--format=csv,noheader,nounits'], text=True)
if len(free.splitlines()) != 4 or min(map(int, free.splitlines())) < 40000:
raise RuntimeError('Full-page evaluation requires four free GPUs; current training is left running')
(target / 'STOP_SERVERS').unlink(missing_ok=True)
env = dict(os.environ, POVL_ALLOW_TRUSTED_MM_KWARGS='1',
POVL_VLLM='/root/autodl-tmp/vllm_local/bin/vllm', POVL_PARALLEL_ENGINE_BOOT='1')
env['PYTHONPATH'] = '/root/autodl-tmp/vllm_local/site-packages:/root/autodl-tmp/venv_train/lib/python3.12/site-packages:/autodl-fs/data/vllm_env/lib/python3.12/site-packages'
processes, logs = [], []
def launch(cmd, name, process_env):
log = (target / 'logs' / name).open('a'); logs.append(log)
p = subprocess.Popen(cmd, env=process_env, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
processes.append(p)
return p
clean_env = dict(env)
clean_env.pop('PYTHONPATH', None)
try:
server = launch([sys.executable, '-u', str(target / 'servers.py')], 'server_controller.log', env)
proxies = [launch([sys.executable, str(target / 'proxy.py'), '--listen', str(19080 + gpu),
'--backends', *[str(19000 + gpu * 3 + i) for i in range(3)]],
f'proxy_{gpu}.log', clean_env) for gpu in range(4)]
scorers = [launch([str(target / ('venv_eval_' + version) / 'bin/python'), '-u',
str(target / 'stream_score.py'), '--version', version, '--workers', '6'],
'stream_' + version + '.log', clean_env) for version in ('v15', 'v16')]
if (target / 'image_pack.json').exists():
deadline = time.monotonic() + 1800
while not (target / 'servers_ready.json').exists():
if server.poll() is not None or time.monotonic() > deadline:
raise RuntimeError('VLM startup failed before packed-page inference')
time.sleep(2)
verify_server_bindings(target, model)
workers = [launch([str(target / 'venv_pipeline/bin/python'), '-u',
str(target / 'packed_page_worker.py'), '--pack', str(PACK),
'--worker', str(gpu), '--workers', '4'], f'packed_worker_{gpu}.log',
dict(clean_env, CUDA_VISIBLE_DEVICES=str(gpu))) for gpu in range(4)]
for worker in workers:
if worker.wait():
raise RuntimeError('Packed whole-page inference failed; inspect worker logs')
command = [sys.executable, '-u', str(target / 'run.py')]
with (target / 'logs' / 'official_run.log').open('a') as log:
subprocess.run(command, env=clean_env, stdout=log, stderr=subprocess.STDOUT, check=True)
for p in scorers:
if p.wait(timeout=1800):
print('Streaming scorer failed; rebuilding from completed official CLI results', flush=True)
result = json.loads(summary.read_text())
assert result['complete']
finalize_score_coverage(target)
finally:
(target / 'STOP_SERVERS').touch()
# Graceful server cleanup owns all vLLM engine children.
for process in reversed(processes):
stop(process)
for log in logs:
log.close()
return target
def batch(run):
stages = json.loads((run / 'stage_results.json').read_text())['stages']
targets = []
for stage in stages:
path = evaluate(stage['model'], stage['stage'])
targets.append({'stage': stage['stage'], 'model': stage['model'], 'summary': str(path / 'SUMMARY.json')})
dump(run / 'whole_page_results.json', {'separate_from_184k': True, 'stages': targets})
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--model'); parser.add_argument('--tag')
parser.add_argument('--prepare-only', action='store_true')
parser.add_argument('--batch-run', type=Path)
args = parser.parse_args()
if args.batch_run:
batch(args.batch_run)
else:
if not args.model or not args.tag:
parser.error('--model and --tag are required without --batch-run')
print(evaluate(args.model, args.tag, args.prepare_only))
if __name__ == '__main__':
main()