Download training_source/docker_scripts/retrain_ppocr_pipeline/export_recognizer.py from Remidesbois/Poneglyph-ReaderNet: direct link, hf CLI and curl.
- Browser
- Download file 5.84 kB
-
https://huggingface.co/Remidesbois/Poneglyph-ReaderNet/resolve/main/training_source/docker_scripts/retrain_ppocr_pipeline/export_recognizer.py
- Command line
-
hf download hf://Remidesbois/Poneglyph-ReaderNet/training_source/docker_scripts/retrain_ppocr_pipeline/export_recognizer.py
-
curl -L -o export_recognizer.py https://huggingface.co/Remidesbois/Poneglyph-ReaderNet/resolve/main/training_source/docker_scripts/retrain_ppocr_pipeline/export_recognizer.py
5.84 kB
| """Export dynamic-width browser models and verify exact prepared-input parity.""" | |
| import argparse | |
| import json | |
| import shutil | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| import onnx | |
| import onnxruntime as ort | |
| import torch | |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'finetune_paddleocr_line_rec')) | |
| from train_ppocrv6_rec import decode_ctc, load_transformers_components | |
| from evaluate_recognizer import prepared_tensor | |
| class Wrapper(torch.nn.Module): | |
| def __init__(self, model): | |
| super().__init__() | |
| self.model = model | |
| def forward(self, pixel_values): | |
| return self.model(pixel_values=pixel_values).last_hidden_state | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument('--model', type=Path, required=True) | |
| parser.add_argument('--dataset', type=Path, required=True) | |
| parser.add_argument('--output', type=Path, required=True) | |
| parser.add_argument('--baseline-manifest', type=Path, required=True) | |
| args = parser.parse_args() | |
| args.output.mkdir(parents=True, exist_ok=True) | |
| torch.set_num_threads(4) | |
| _, processor, model = load_transformers_components(str(args.model)) | |
| wrapper = Wrapper(model.eval()).eval() | |
| output = args.output / 'ppocrv6_bubble_line_rec.onnx' | |
| torch.onnx.export(wrapper, (torch.zeros(1, 3, 48, 960),), str(output), input_names=['pixel_values'], output_names=['logits'], | |
| dynamic_axes={'pixel_values': {0: 'batch', 3: 'width'}, 'logits': {0: 'batch', 1: 'sequence'}}, | |
| opset_version=17, do_constant_folding=True, dynamo=False) | |
| graph = onnx.load(output) | |
| onnx.checker.check_model(graph) | |
| # ORT WebGPU does not support ceil_mode=1. In this architecture these pools | |
| # all have stride 1, for which floor/ceil produce identical output sizes. | |
| patches = [] | |
| for node in graph.graph.node: | |
| if node.op_type != 'MaxPool': | |
| continue | |
| attributes = {a.name: a for a in node.attribute} | |
| if attributes.get('ceil_mode') is not None and attributes['ceil_mode'].i == 1: | |
| if list(attributes['strides'].ints) != [1, 1]: | |
| raise ValueError('Cannot safely rewrite a strided ceil-mode pool') | |
| attributes['ceil_mode'].i = 0 | |
| patches.append(node.name) | |
| webgpu = args.output / 'ppocrv6_bubble_line_rec_webgpu.onnx' | |
| onnx.checker.check_model(graph) | |
| onnx.save(graph, webgpu) | |
| options = ort.SessionOptions(); options.intra_op_num_threads = 4 | |
| sessions = [ort.InferenceSession(str(p), options, providers=['CPUExecutionProvider']) for p in (output, webgpu)] | |
| manifest_rows = [json.loads(x) for x in (args.dataset / 'recognizer/line_manifest.jsonl').read_text(encoding='utf-8').splitlines() if x] | |
| val_rows = [r for r in manifest_rows if r['split'] == 'val'] | |
| # Include the minimum and maximum real widths and several normal inputs. | |
| chosen = {r['single_line_image']: r for r in [*val_rows[:8], min(val_rows, key=lambda r: r['width']), max(val_rows, key=lambda r: r['width'])]} | |
| parity = [] | |
| with torch.inference_mode(): | |
| for row in chosen.values(): | |
| tensor = prepared_tensor(args.dataset / 'recognizer' / row['single_line_image']) | |
| native = wrapper(tensor).cpu() | |
| native_text = decode_ctc(native, processor.character_list)[0] | |
| item = dict(image=row['single_line_image'], width=tensor.shape[-1], torch_text=native_text, variants=[]) | |
| for session in sessions: | |
| pred = session.run(None, {session.get_inputs()[0].name: tensor.numpy()})[0] | |
| text = decode_ctc(torch.from_numpy(pred), processor.character_list)[0] | |
| delta = float(np.abs(native.numpy() - pred).max()) | |
| if text != native_text or delta > .002: | |
| raise ValueError(f'ONNX parity failed for {row["bubble_id"]}: {delta}, {text!r}, {native_text!r}') | |
| item['variants'].append(dict(text=text, max_abs_diff=delta)) | |
| parity.append(item) | |
| # Widths not necessarily present in val still need dynamic-shape checks. | |
| for width in (960, 1200, 1600, 2400, 3200): | |
| tensor = torch.full((1, 3, 48, width), (128/255-.5)/.5) | |
| native = wrapper(tensor).cpu().numpy() | |
| for session in sessions: | |
| pred = session.run(None, {session.get_inputs()[0].name: tensor.numpy()})[0] | |
| if pred.shape != native.shape or not np.allclose(pred, native, atol=.002, rtol=.001): | |
| raise ValueError(f'Dynamic-width parity failed at width {width}') | |
| manifest = json.loads(args.baseline_manifest.read_text(encoding='utf-8')) | |
| manifest.update(recognizer_onnx=output.name, input_shape=[1, 3, 48, 'width'], dynamic_width=True, image_height=48, | |
| min_image_width=960, max_image_width=3200, resize='height_48_preserve_aspect_then_pad_to_min_width', | |
| padding_color='#808080', channel_order='BGR', character_list=list(processor.character_list), | |
| final_text_postprocess='ppocr_lexicon_spacing_case_only') | |
| report = dict(samples=len(parity), all_text_match=True, max_abs_diff=max(v['max_abs_diff'] for p in parity for v in p['variants']), | |
| dynamic_widths=[960,1200,1600,2400,3200], webgpu_pool_patches=patches, items=parity) | |
| manifest['parity'] = report | |
| (args.output / 'browser_manifest.json').write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding='utf-8') | |
| (args.output / 'parity_report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8') | |
| for name in ['config.json', 'preprocessor_config.json']: | |
| shutil.copy2(args.model / name, args.output / name) | |
| print(json.dumps(report, ensure_ascii=False), flush=True) | |
| if __name__ == '__main__': | |
| main() | |