Duplicate from inclusionAI/FinixDocBench

Co-authored-by: mingcheng, aka 明城 <m1ngcheng@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

CITATION.cff

@@ -0,0 +1,39 @@
+cff-version: 1.2.0
+message: "If you use this FinixDocBench release, please cite the FinixDoc technical report."
+title: "FinixDoc: Rethinking Financial Document Parsing Beyond Saturated Benchmarks"
+authors:
+  - family-names: Wang
+    given-names: Hang
+  - family-names: Zhang
+    given-names: Jin
+  - family-names: Xu
+    given-names: Guoliang
+  - family-names: Lu
+    given-names: Pengyue
+  - family-names: Li
+    given-names: Yao
+  - family-names: Zhang
+    given-names: Zijiao
+  - family-names: Huang
+    given-names: Tianyu
+  - family-names: Xiong
+    given-names: Weiqi
+  - family-names: Wang
+    given-names: Yulong
+  - family-names: Lu
+    given-names: Chuqiao
+  - family-names: Huang
+    given-names: Wenkang
+  - family-names: Yang
+    given-names: Kai
+  - family-names: Li
+    given-names: Yadong
+  - family-names: Li
+    given-names: Hui
+  - family-names: Xu
+    given-names: Xingzhong
+  - family-names: Xu
+    given-names: Xiao
+date-released: "2026-06-09"
+url: "https://finix.alipay.com/"
+license: "CC-BY-NC-SA-4.0"

FinixDocBench_Eval_for_Markdown/README.md

@@ -0,0 +1,142 @@
+# FinixDocBench Markdown Evaluation
+
+This folder contains a lightweight evaluator for FinixDocBench Markdown parsing outputs. It compares a directory of ground-truth `.md` files with a directory of predicted `.md` files whose file names match exactly.
+
+The evaluator is intended for the public Markdown task. It does not evaluate structured JSON layout annotations.
+
+## Metrics
+
+The evaluator reports:
+
+| Metric | Direction | Meaning |
+|---|---|---|
+| `text_block_Edit_dist` | Lower is better | Normalized edit distance over matched text blocks. |
+| `reading_order_Edit_dist` | Lower is better | Normalized edit distance over serialized reading-order sequences. |
+| `table_TEDS` | Higher is better | TEDS table-structure similarity, scaled to 0-100. |
+| `overall` | Higher is better | Composite score on a 0-100 scale. |
+
+The overall score is:
+
+```python
+overall = (
+    (1 - text_block_Edit_dist) * 100
+    + (1 - reading_order_Edit_dist) * 100
+    + table_TEDS
+) / 3
+```
+
+Formula parsing is not evaluated separately.
+
+## Installation
+
+Python 3.9+ is recommended.
+
+```bash
+cd FinixDocBench_Eval_for_Markdown
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+## Quick Check
+
+Run the bundled minimal example first:
+
+```bash
+python run_eval.py \
+  --gt_dir examples/gt \
+  --pred_dir examples/pred \
+  --output_json outputs/example_result.json
+```
+
+## Evaluate a FinixDocBench Track
+
+Prepare a prediction directory with one `.md` file per evaluated page. Prediction file names must match the ground-truth Markdown file names.
+
+Example for FinixPhoto:
+
+```bash
+python run_eval.py \
+  --gt_dir ../track2_finixphoto_300/mds \
+  --pred_dir /path/to/predicted_mds \
+  --output_json outputs/finixphoto_result.json
+```
+
+Example for FinixHuge-Table:
+
+```bash
+python run_eval.py \
+  --gt_dir ../track3_finixhuge_100_table/mds \
+  --pred_dir /path/to/predicted_mds \
+  --output_json outputs/finixhuge_table_result.json
+```
+
+## Output Format
+
+The output JSON has the following structure:
+
+```json
+{
+  "success": true,
+  "metrics": {
+    "text_block_Edit_dist": 0.0123,
+    "reading_order_Edit_dist": 0.0,
+    "table_TEDS": 98.7,
+    "overall": 99.15,
+    "num_samples": 2,
+    "score": 99.15
+  },
+  "inputs": {
+    "gt_files": 2,
+    "pred_files": 2,
+    "missing_predictions": 0,
+    "unexpected_predictions": 0
+  }
+}
+```
+
+`score` is identical to `overall` and is included for leaderboard or automation systems that expect a generic score field.
+
+## File Name Validation
+
+By default, the evaluator fails if the `.md` file names in `gt_dir` and `pred_dir` do not match exactly. This avoids accidentally skipping pages.
+
+If you want to allow missing predictions and score missing files as empty outputs, pass:
+
+```bash
+python run_eval.py \
+  --gt_dir /path/to/gt_mds \
+  --pred_dir /path/to/pred_mds \
+  --allow_name_mismatch
+```
+
+## FinixHuge Reporting
+
+For FinixHuge-Long and FinixHuge-Table, also report a success rate outside this script:
+
+```text
+success_rate = valid_non_empty_predictions / total_pages
+```
+
+A prediction should be counted as successful only if it is a syntactically valid, non-empty page-level Markdown result without runtime failure, severe truncation, or format errors that prevent downstream evaluation.
+
+## Large Table Safeguards
+
+TEDS can be slow on extremely large tables. To keep evaluation practical, this implementation assigns a table TEDS score of `0` when a ground-truth or predicted table exceeds `50000` `<td>` cells.
+
+The matching stage also keeps broad safety thresholds:
+
+```text
+MAX_PRED_ITEMS = 50000
+RATIO_THRESHOLD = 100
+MAX_TOTAL_LENGTH = 10000000
+MAX_SINGLE_ITEM_LENGTH = 10000000
+```
+
+## Notes
+
+- Only `.md` files are evaluated.
+- Images, JSON annotations, and other files are ignored by this evaluator.
+- Markdown tables are converted to HTML before table evaluation.
+- One page image should correspond to one Markdown file.
+- File names are the matching keys; the evaluator does not read images.

FinixDocBench_Eval_for_Markdown/examples/gt/sample_001.md

@@ -0,0 +1,10 @@
+# Sample Insurance Clause
+
+The policy covers accidental medical expenses during the insurance period.
+
+<table>
+  <tr><td>Item</td><td>Limit</td></tr>
+  <tr><td>Medical</td><td>10000</td></tr>
+</table>
+
+Final note.

FinixDocBench_Eval_for_Markdown/examples/pred/sample_001.md

@@ -0,0 +1,10 @@
+# Sample Insurance Clause
+
+The policy covers accidental medical expense during the insurance period.
+
+<table>
+  <tr><td>Item</td><td>Limit</td></tr>
+  <tr><td>Medical</td><td>9000</td></tr>
+</table>
+
+Final note.

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/metrics/table_metric.py

@@ -0,0 +1,260 @@
+# Copyright 2020 IBM
+# Author: peter.zhong@au1.ibm.com
+#
+# This is free software; you can redistribute it and/or modify
+# it under the terms of the Apache 2.0 License.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Apache 2.0 License for more details.
+
+import Levenshtein
+# import rapidfuzz.distance as distance
+from apted import APTED, Config
+from apted.helpers import Tree
+from lxml import etree, html
+from collections import deque
+# from parallel import parallel_process
+from tqdm import tqdm
+
+class TableTree(Tree):
+    def __init__(self, tag, colspan=None, rowspan=None, content=None, *children):
+        self.tag = tag
+        self.colspan = colspan
+        self.rowspan = rowspan
+        self.content = content
+        self.children = list(children)
+
+    def bracket(self):
+        """Show tree using brackets notation"""
+        if self.tag == 'td':
+            result = '"tag": %s, "colspan": %d, "rowspan": %d, "text": %s' % \
+                     (self.tag, self.colspan, self.rowspan, self.content)
+        else:
+            result = '"tag": %s' % self.tag
+        for child in self.children:
+            result += child.bracket()
+        return "{{{}}}".format(result)
+
+
+class CustomConfig(Config):
+    @staticmethod
+    def maximum(*sequences):
+        """Get maximum possible value
+        """
+        return max(map(len, sequences))
+
+    def normalized_distance(self, *sequences):
+        """Get distance from 0 to 1
+        """
+        return float(Levenshtein.distance(*sequences)) / self.maximum(*sequences)
+
+    def rename(self, node1, node2):
+        """Compares attributes of trees"""
+        if (node1.tag != node2.tag) or (node1.colspan != node2.colspan) or (node1.rowspan != node2.rowspan):
+            return 1.
+        if node1.tag == 'td':
+            if node1.content or node2.content:
+                return self.normalized_distance(node1.content, node2.content)
+        return 0.
+
+
+class TEDS(object):
+    ''' Tree Edit Distance basead Similarity
+    '''
+    def __init__(self, structure_only=False, n_jobs=16, ignore_nodes=None):
+        assert isinstance(n_jobs, int) and (n_jobs >= 1), 'n_jobs must be an integer greather than 1'
+        self.structure_only = structure_only
+        self.n_jobs = n_jobs
+        self.ignore_nodes = ignore_nodes
+        self.__tokens__ = []
+
+    def tokenize(self, node):
+        ''' Tokenizes table cells
+        '''
+        self.__tokens__.append('<%s>' % node.tag)
+        if node.text is not None:
+            self.__tokens__ += list(node.text)
+        for n in node.getchildren():
+            self.tokenize(n)
+        if node.tag != 'unk':
+            self.__tokens__.append('</%s>' % node.tag)
+        if node.tag != 'td' and node.tail is not None:
+            self.__tokens__ += list(node.tail)
+
+    def load_html_tree(self, node, parent=None):
+        ''' Converts HTML tree to the format required by apted
+        '''
+        global __tokens__
+        if node.tag == 'td':
+            if self.structure_only:
+                cell = []
+            else:
+                self.__tokens__ = []
+                self.tokenize(node)
+                cell = self.__tokens__[1:-1].copy()
+            new_node = TableTree(node.tag,
+                                 int(node.attrib.get('colspan', '1')),
+                                 int(node.attrib.get('rowspan', '1')),
+                                 cell, *deque())
+        else:
+            new_node = TableTree(node.tag, None, None, None, *deque())
+        if parent is not None:
+            parent.children.append(new_node)
+        if node.tag != 'td':
+            for n in node.getchildren():
+                self.load_html_tree(n, new_node)
+        if parent is None:
+            return new_node
+
+    # def evaluate(self, pred, true):
+    #     ''' Computes TEDS score between the prediction and the ground truth of a
+    #         given sample
+    #     '''
+    #     if (not pred) or (not true):
+    #         return 0.0
+    #     parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+    #     pred = html.fromstring(pred, parser=parser)
+    #     true = html.fromstring(true, parser=parser)
+    #     if pred.xpath('body/table') and true.xpath('body/table'):
+    #         pred = pred.xpath('body/table')[0]
+    #         true = true.xpath('body/table')[0]
+    #         if self.ignore_nodes:
+    #             etree.strip_tags(pred, *self.ignore_nodes)
+    #             etree.strip_tags(true, *self.ignore_nodes)
+    #         n_nodes_pred = len(pred.xpath(".//*"))
+    #         n_nodes_true = len(true.xpath(".//*"))
+    #         n_nodes = max(n_nodes_pred, n_nodes_true)
+    #         tree_pred = self.load_html_tree(pred)
+    #         tree_true = self.load_html_tree(true)
+    #         distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+    #         return 1.0 - (float(distance) / n_nodes)
+    #     else:
+    #         return 0.0
+    # def evaluate(self, pred, true):
+    #     ''' Computes TEDS score between the prediction and the ground truth of a
+    #         given sample
+    #     '''
+    #     from multiprocessing import Process, Queue
+    #     import sys
+
+    #     def _evaluate_inner(pred, true, queue):
+    #         try:
+    #             if (not pred) or (not true):
+    #                 queue.put(0.0)
+    #                 return
+
+    #             parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+    #             pred_doc = html.fromstring(pred, parser=parser)
+    #             true_doc = html.fromstring(true, parser=parser)
+
+    #             if pred_doc.xpath('body/table') and true_doc.xpath('body/table'):
+    #                 pred_table = pred_doc.xpath('body/table')[0]
+    #                 true_table = true_doc.xpath('body/table')[0]
+    #                 if self.ignore_nodes:
+    #                     etree.strip_tags(pred_table, *self.ignore_nodes)
+    #                     etree.strip_tags(true_table, *self.ignore_nodes)
+    #                 n_nodes_pred = len(pred_table.xpath(".//*"))
+    #                 n_nodes_true = len(true_table.xpath(".//*"))
+    #                 n_nodes = max(n_nodes_pred, n_nodes_true)
+    #                 if n_nodes == 0:
+    #                     queue.put(1.0)
+    #                     return
+    #                 tree_pred = self.load_html_tree(pred_table)
+    #                 tree_true = self.load_html_tree(true_table)
+    #                 distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+    #                 score = 1.0 - (float(distance) / n_nodes)
+    #                 queue.put(score)
+    #             else:
+    #                 queue.put(0.0)
+    #         except Exception:
+    #             queue.put(0.0)
+
+    #     # 超时时间（秒），可调整
+    #     TIMEOUT_SECONDS = 60
+
+    #     q = Queue()
+    #     p = Process(target=_evaluate_inner, args=(pred, true, q))
+    #     p.start()
+    #     p.join(timeout=TIMEOUT_SECONDS)
+
+    #     if p.is_alive():
+    #         p.terminate()
+    #         p.join()
+    #         return 0.0
+    #     else:
+    #         if not q.empty():
+    #             return q.get()
+    #         else:
+    #             return 0.0
+
+    def evaluate(self, pred, true):
+        try:
+            if (not pred) or (not true):
+                return 0.0
+
+            parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+            pred_doc = html.fromstring(pred, parser=parser)
+            true_doc = html.fromstring(true, parser=parser)
+
+            pred_tables = pred_doc.xpath('//table')
+            true_tables = true_doc.xpath('//table')
+            if not pred_tables or not true_tables:
+                return 0.0
+
+            pred_table = pred_tables[0]
+            true_table = true_tables[0]
+
+            if self.ignore_nodes:
+                etree.strip_tags(pred_table, *self.ignore_nodes)
+                etree.strip_tags(true_table, *self.ignore_nodes)
+
+            n_td_pred = len(pred_table.xpath(".//td"))
+            n_td_true = len(true_table.xpath(".//td"))
+            if n_td_pred > 50000 or n_td_true > 50000:
+                print(f"Skipping large table: pred={n_td_pred}, true={n_td_true}", flush=True)
+                return 0.0
+
+            n_nodes_pred = len(pred_table.xpath(".//*"))
+            n_nodes_true = len(true_table.xpath(".//*"))
+            n_nodes = max(n_nodes_pred, n_nodes_true)
+            if n_nodes == 0:
+                return 1.0
+
+            tree_pred = self.load_html_tree(pred_table)
+            tree_true = self.load_html_tree(true_table)
+            distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+            return 1.0 - (float(distance) / n_nodes)
+        except Exception:
+            return 0.0
+
+
+    def batch_evaluate(self, pred_json, true_json):
+        ''' Computes TEDS score between the prediction and the ground truth of
+            a batch of samples
+            @params pred_json: {'FILENAME': 'HTML CODE', ...}
+            @params true_json: {'FILENAME': {'html': 'HTML CODE'}, ...}
+            @output: {'FILENAME': 'TEDS SCORE', ...}
+        '''
+        samples = true_json.keys()
+        # if self.n_jobs == 1:
+        scores = [self.evaluate(pred_json.get(filename, ''), true_json[filename]['html']) for filename in tqdm(samples)]
+        # else:
+        #     inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]['html']} for filename in samples]
+        #     scores = parallel_process(inputs, self.evaluate, use_kwargs=True, n_jobs=self.n_jobs, front_num=1)
+        scores = dict(zip(samples, scores))
+        return scores
+
+
+if __name__ == '__main__':
+    import json
+    import pprint
+    with open('sample_pred.json') as fp:
+        pred_json = json.load(fp)
+    with open('sample_gt.json') as fp:
+        true_json = json.load(fp)
+    teds = TEDS(n_jobs=4)
+    scores = teds.batch_evaluate(pred_json, true_json)
+    pp = pprint.PrettyPrinter()
+    pp.pprint(scores)

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/omnidocbench_adapter.py

@@ -0,0 +1,226 @@
+import math
+import os
+from collections import defaultdict
+
+from .metrics.table_metric import TEDS
+from .utils.extract import md_tex_filter
+from .utils.match_quick import match_gt2pred_quick
+
+
+def _read_text(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+def _sequence_distance(a, b):
+    if a == b:
+        return 0
+    if a is None:
+        a = ''
+    if b is None:
+        b = ''
+    if len(a) < len(b):
+        a, b = b, a
+    if not b:
+        return len(a)
+
+    previous = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        current = [i]
+        for j, cb in enumerate(b, 1):
+            insert_cost = current[j - 1] + 1
+            delete_cost = previous[j] + 1
+            replace_cost = previous[j - 1] + (0 if ca == cb else 1)
+            current.append(min(insert_cost, delete_cost, replace_cost))
+        previous = current
+    return previous[-1]
+
+
+def _normalized_edit(a, b):
+    if a is None:
+        a = ''
+    if b is None:
+        b = ''
+    upper_len = max(len(a), len(b))
+    if upper_len == 0:
+        return 0.0, 0, 0
+    edit_num = _sequence_distance(a, b)
+    return edit_num / upper_len, edit_num, upper_len
+
+
+def _safe_mean(values, default=float('nan')):
+    values = [v for v in values if v is not None and not math.isnan(float(v))]
+    if not values:
+        return default
+    return sum(values) / len(values)
+
+
+def _get_order_paired(order_match_s, img_name):
+    matched = [
+        (item['gt_position'], item['pred_position'])
+        for item in order_match_s
+        if item['gt_position'] != [''] and item['pred_position'] != ''
+    ]
+    gt_idx_all = [item['gt_position'] for item in order_match_s if item['gt_position'] != ['']]
+    read_order_pred = [i[0] for i in sorted(matched, key=lambda x: x[1])]
+    read_order_gt = sum(gt_idx_all, [])
+    read_order_gt = [x for x in read_order_gt if x]
+    gt = sorted(read_order_gt)
+    pred = sum(read_order_pred, [])
+    pred = [x for x in pred if x]
+    if len(pred) > 0 or len(gt) > 0:
+        edit = _normalized_edit(gt, pred)[0]
+        return {
+            'gt': gt,
+            'pred': pred,
+            'img_id': img_name,
+            'edit': edit,
+        }
+    return {}
+
+
+def _calculate_edit_dist(samples):
+    if not samples:
+        return float('nan')
+
+    grouped = defaultdict(lambda: {'edit': 0, 'upper': 0})
+    for sample in samples:
+        img_name = sample['img_id']
+        if not (img_name.endswith('.jpg') or img_name.endswith('.png')):
+            img_name = '_'.join(img_name.split('_')[:-1])
+
+        gt = sample.get('norm_gt') if sample.get('norm_gt') is not None else sample.get('gt', '')
+        pred = sample.get('norm_pred') if sample.get('norm_pred') is not None else sample.get('pred', '')
+        _, edit_num, upper_len = _normalized_edit(pred, gt)
+        if upper_len == 0:
+            continue
+        grouped[img_name]['edit'] += edit_num
+        grouped[img_name]['upper'] += upper_len
+
+    page_scores = [
+        val['edit'] / val['upper']
+        for val in grouped.values()
+        if val['upper'] > 0
+    ]
+    return _safe_mean(page_scores)
+
+
+def _missing_table_samples(gt_tables, img_name):
+    samples = []
+    for idx, item in enumerate(gt_tables):
+        content = str(item.get('content', ''))
+        samples.append({
+            'gt_idx': [idx],
+            'gt': content,
+            'pred_idx': [''],
+            'pred': '',
+            'gt_position': [item.get('order') if item.get('order') else item.get('position', [''])[0]],
+            'pred_position': '',
+            'norm_gt': content,
+            'norm_pred': '',
+            'gt_category_type': item.get('fine_category_type') or item.get('category_type', 'table'),
+            'pred_category_type': '',
+            'gt_attribute': [item.get('attribute', {})],
+            'edit': 1,
+            'img_id': img_name,
+        })
+    return samples
+
+
+def _calculate_table_teds(table_samples):
+    if not table_samples:
+        return 100.0
+
+    teds = TEDS(structure_only=False)
+    scores = []
+    for sample in table_samples:
+        gt = sample.get('norm_gt') if sample.get('norm_gt') else sample.get('gt', '')
+        pred = sample.get('norm_pred') if sample.get('norm_pred') else sample.get('pred', '')
+        try:
+            score = teds.evaluate(pred, gt)
+        except Exception:
+            score = 0.0
+        scores.append(max(0.0, min(1.0, float(score))))
+    return _safe_mean(scores, default=0.0) * 100.0
+
+
+def _clamp(value, low, high):
+    if value is None or math.isnan(float(value)):
+        return value
+    return max(low, min(high, float(value)))
+
+
+def evaluate_md_dirs(gt_dir, pred_dir):
+    plain_text_match = []
+    html_table_match = []
+    latex_table_match = []
+    order_match = []
+
+    sample_names = sorted(name for name in os.listdir(gt_dir) if name.endswith('.md'))
+    for sample_name in sample_names:
+        img_name = sample_name[:-3] + '.jpg'
+        gt_content = _read_text(os.path.join(gt_dir, sample_name))
+        pred_path = os.path.join(pred_dir, sample_name)
+        pred_content = _read_text(pred_path) if os.path.exists(pred_path) else ''
+
+        gt_dataset = md_tex_filter(gt_content)
+        pred_dataset = md_tex_filter(pred_content)
+
+        plain_text_match_clean = []
+        if gt_dataset.get('text_all'):
+            plain_text_match_s = match_gt2pred_quick(
+                gt_dataset['text_all'],
+                pred_dataset.get('text_all', []),
+                'text',
+                img_name,
+            )
+            plain_text_match_clean = plain_text_match_s
+            plain_text_match.extend(plain_text_match_s)
+
+        if gt_dataset.get('latex_table'):
+            if pred_dataset.get('latex_table'):
+                table_match_s = match_gt2pred_quick(
+                    gt_dataset['latex_table'],
+                    pred_dataset['latex_table'],
+                    'latex_table',
+                    img_name,
+                )
+                latex_table_match.extend([x for x in table_match_s if x['gt_idx'] != ['']])
+            else:
+                latex_table_match.extend(_missing_table_samples(gt_dataset['latex_table'], img_name))
+        elif gt_dataset.get('html_table'):
+            if pred_dataset.get('html_table'):
+                table_match_s = match_gt2pred_quick(
+                    gt_dataset['html_table'],
+                    pred_dataset['html_table'],
+                    'html_table',
+                    img_name,
+                )
+                html_table_match.extend([x for x in table_match_s if x['gt_idx'] != ['']])
+            else:
+                html_table_match.extend(_missing_table_samples(gt_dataset['html_table'], img_name))
+
+        order_match_s = _get_order_paired(plain_text_match_clean, img_name)
+        if order_match_s:
+            order_match.append(order_match_s)
+
+    table_match = latex_table_match if latex_table_match else html_table_match
+    text_block_edit = _clamp(_calculate_edit_dist(plain_text_match), 0.0, 1.0)
+    reading_order_edit = _clamp(_calculate_edit_dist(order_match), 0.0, 1.0)
+    table_teds = _clamp(_calculate_table_teds(table_match), 0.0, 100.0)
+
+    if math.isnan(float(text_block_edit)):
+        text_block_edit = 0.0
+    if math.isnan(float(reading_order_edit)):
+        reading_order_edit = 0.0
+
+    overall = ((1 - text_block_edit) * 100.0 + (1 - reading_order_edit) * 100.0 + table_teds) / 3.0
+    overall = max(0.0, min(100.0, overall))
+
+    return {
+        'text_block_Edit_dist': text_block_edit,
+        'reading_order_Edit_dist': reading_order_edit,
+        'table_TEDS': table_teds,
+        'overall': overall,
+        'num_samples': len(sample_names),
+    }

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/data_preprocess.py

@@ -0,0 +1,452 @@
+import re
+import unicodedata
+from pylatexenc.latex2text import LatexNodes2Text
+from bs4 import BeautifulSoup
+import subprocess
+import shutil
+import uuid
+import html
+import os
+
+def remove_markdown_fences(content):
+    content = re.sub(r'^```markdown\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'^```html\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'^```latex\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'```\n?$', '', content, flags=re.MULTILINE)
+    return content
+
+# Standardize all consecutive characters
+def replace_repeated_chars(input_str):
+    input_str = re.sub(r'_{4,}', '____', input_str) # Replace more than 4 consecutive underscores with 4 underscores
+    input_str = re.sub(r' {4,}', '    ', input_str)   # Replace more than 4 consecutive spaces with 4 spaces
+    return input_str
+    # return re.sub(r'([^a-zA-Z0-9])\1{10,}', r'\1\1\1\1', input_str) # For other consecutive symbols (except numbers and letters), replace more than 10 occurrences with 4
+
+# Special Unicode handling
+def fullwidth_to_halfwidth(s):
+    result = []
+    for char in s:
+        code = ord(char)
+        # Convert full-width space to half-width space
+        if code == 0x3000:
+            code = 0x0020
+        # Convert other full-width characters to half-width
+        elif 0xFF01 <= code <= 0xFF5E:
+            code -= 0xFEE0
+        result.append(chr(code))
+    return ''.join(result)
+
+def find_special_unicode(s):
+    special_chars = {}
+    for char in s:
+        if ord(char) > 127:  # Non-ASCII characters
+            # unicode_name = unicodedata.name(char, None)
+            unicode_name = unicodedata.category(char)
+            special_chars[char] = f'U+{ord(char):04X} ({unicode_name})'
+    return special_chars
+
+# # Define dictionary for Unicode character replacements
+# unicode_replacements = {
+#     "\u00A9": r"$\copyright$",  # Copyright symbol © to latex
+#     "\u00AE": r"$^\circledR$",  # Registered trademark ® to latex
+#     "\u2122": r"$^\text{TM}$",   # Trademark ™ to latex
+#     "\u2018": "'",             # Left single quote to straight quote
+#     "\u2019": "'",             # Right single quote to straight quote
+#     "\u201C": "\"",            # Left double quote to straight quote
+#     "\u201D": "\"",            # Right double quote to straight quote
+#     "\u2013": "-",             # En dash to hyphen
+#     "\u2014": "-",             # Em dash to hyphen
+#     "\u2026": "...",           # Unicode ellipsis to three dots
+#     "\u2103": r"$\textdegree C$",  # ℃
+#     "\u03B1": r"$\alpha$",         # α
+#     "\u03B2": r"$\beta$",          # β
+#     "\u03A3": r"$\Sigma$",         # Σ
+# }
+
+# # Use regex to replace Unicode characters
+# def replace_unicode(match):
+#     char = match.group(0)
+#     return unicode_replacements.get(char, char)
+
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+def textblock2unicode(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        try:
+            if any(char in clean_content for char in r'\^_'):
+                if clean_content.endswith('\\'):
+                    clean_content += ' '
+                # inline_array.append(match.group(0))
+                unicode_content = LatexNodes2Text().latex_to_text(clean_content)
+                removal_positions.append((position[0], position[1], unicode_content))
+        except:
+            continue
+    
+    # Remove inline formulas from original text
+    for start, end, unicode_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + unicode_content.strip() + text[end:]
+
+    return text
+
+def normalized_formula(text):
+    # Normalize math formulas before matching
+    filter_list = ['\\mathbf', '\\mathrm', '\\mathnormal', '\\mathit', '\\mathbb', '\\mathcal', '\\mathscr', '\\mathfrak', '\\mathsf', '\\mathtt', 
+                   '\\textbf', '\\text', '\\boldmath', '\\boldsymbol', '\\operatorname', '\\bm',
+                   '\\symbfit', '\\mathbfcal', '\\symbf', '\\scriptscriptstyle', '\\notag',
+                   '\\setlength', '\\coloneqq', '\\space', '\\thickspace', '\\thinspace', '\\medspace', '\\nobreakspace', '\\negmedspace',
+                   '\\quad', '\\qquad', '\\enspace', '\\substackw', ' ', '$$', '\\left', '\\right', '\\displaystyle', '\\text']
+                #    '\\left', '\\right', '{', '}', ' ']
+    
+    # delimiter_filter
+    text = text.strip().strip('$').strip('\n')
+    pattern = re.compile(r"\\\[(.+?)(?<!\\)\\\]")
+    match = pattern.search(text)
+
+    if match:
+        text = match.group(1).strip()
+    
+    tag_pattern = re.compile(r"\\tag\{.*?\}")
+    text = tag_pattern.sub('', text)
+    hspace_pattern = re.compile(r"\\hspace\{.*?\}")
+    text = hspace_pattern.sub('', text)
+    begin_pattern = re.compile(r"\\begin\{.*?\}")
+    text = begin_pattern.sub('', text)
+    end_pattern = re.compile(r"\\end\{.*?\}")
+    text = end_pattern.sub('', text)
+    col_sep = re.compile(r"\\arraycolsep.*?\}")
+    text = col_sep.sub('', text)
+    text = text.strip('.')
+    
+    for filter_text in filter_list:
+        text = text.replace(filter_text, '')
+        
+    # text = normalize_text(delimiter_filter(text))
+    # text = delimiter_filter(text)
+    text = text.lower()
+    return text
+
+def normalized_html_table(text):
+    def process_table_html(md_i):
+        """
+        pred_md format edit
+        """
+        def process_table_html(html_content):
+            soup = BeautifulSoup(html_content, 'html.parser')
+            th_tags = soup.find_all('th')
+            for th in th_tags:
+                th.name = 'td'
+            thead_tags = soup.find_all('thead')
+            for thead in thead_tags:
+                thead.unwrap()  # unwrap()会移除标签但保留其内容
+            math_tags = soup.find_all('math')
+            for math_tag in math_tags:
+                alttext = math_tag.get('alttext', '')
+                alttext = f'${alttext}$'
+                if alttext:
+                    math_tag.replace_with(alttext)
+            span_tags = soup.find_all('span')
+            for span in span_tags:
+                span.unwrap()
+            return str(soup)
+
+        table_res=''
+        table_res_no_space=''
+        if '<table' in md_i.replace(" ","").replace("'",'"'):
+            md_i = process_table_html(md_i)
+            table_res = html.unescape(md_i).replace('\n', '')
+            table_res = unicodedata.normalize('NFKC', table_res).strip()
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, table_res, re.DOTALL | re.IGNORECASE)
+            table_res = ''.join(tables)
+            # table_res = re.sub('<table.*?>','',table_res)
+            table_res = re.sub('( style=".*?")', "", table_res)
+            table_res = re.sub('( height=".*?")', "", table_res)
+            table_res = re.sub('( width=".*?")', "", table_res)
+            table_res = re.sub('( align=".*?")', "", table_res)
+            table_res = re.sub('( class=".*?")', "", table_res)
+            table_res = re.sub('</?tbody>',"",table_res)
+            
+            table_res = re.sub(r'\s+', " ", table_res)
+            table_res_no_space = '<html><body><table border="1" >' + table_res.replace(' ','') + '</table></body></html>'
+            # table_res_no_space = re.sub(' (style=".*?")',"",table_res_no_space)
+            # table_res_no_space = re.sub(r'[ ]', " ", table_res_no_space)
+            table_res_no_space = re.sub('colspan="', ' colspan="', table_res_no_space)
+            table_res_no_space = re.sub('rowspan="', ' rowspan="', table_res_no_space)
+            table_res_no_space = re.sub('border="', ' border="', table_res_no_space)
+
+            table_res = '<html><body><table border="1" >' + table_res + '</table></body></html>'
+            # table_flow.append(table_res)
+            # table_flow_no_space.append(table_res_no_space)
+
+        return table_res, table_res_no_space
+    
+    def clean_table(input_str,flag=True):
+        if flag:
+            input_str = input_str.replace('<sup>', '').replace('</sup>', '')
+            input_str = input_str.replace('<sub>', '').replace('</sub>', '')
+            input_str = input_str.replace('<span>', '').replace('</span>', '')
+            input_str = input_str.replace('<div>', '').replace('</div>', '')
+            input_str = input_str.replace('<p>', '').replace('</p>', '')
+            input_str = input_str.replace('<spandata-span-identity="">', '')
+            input_str = re.sub('<colgroup>.*?</colgroup>','',input_str)
+        return input_str
+    
+    norm_text, _ = process_table_html(text)
+    norm_text = clean_table(norm_text)
+    return norm_text
+
+def normalized_latex_table(text):
+    def latex_template(latex_code):  
+        template = r'''
+        \documentclass[border=20pt]{article}
+        \usepackage{subcaption}
+        \usepackage{url}
+        \usepackage{graphicx}
+        \usepackage{caption}
+        \usepackage{multirow}
+        \usepackage{booktabs}
+        \usepackage{color}
+        \usepackage{colortbl}
+        \usepackage{xcolor,soul,framed}
+        \usepackage{fontspec}
+        \usepackage{amsmath,amssymb,mathtools,bm,mathrsfs,textcomp}
+        \setlength{\parindent}{0pt}''' + \
+        r'''
+        \begin{document}
+        ''' + \
+        latex_code + \
+        r'''
+        \end{document}'''
+    
+        return template
+
+    def process_table_latex(latex_code):
+        SPECIAL_STRINGS= [
+            ['\\\\vspace\\{.*?\\}', ''],
+            ['\\\\hspace\\{.*?\\}', ''],
+            ['\\\\rule\\{.*?\\}\\{.*?\\}', ''],
+            ['\\\\addlinespace\\[.*?\\]', ''],
+            ['\\\\addlinespace', ''],
+            ['\\\\renewcommand\\{\\\\arraystretch\\}\\{.*?\\}', ''],
+            ['\\\\arraystretch\\{.*?\\}', ''],
+            ['\\\\(row|column)?colors?\\{[^}]*\\}(\\{[^}]*\\}){0,2}', ''],
+            ['\\\\color\\{.*?\\}', ''],
+            ['\\\\textcolor\\{.*?\\}', ''],
+            ['\\\\rowcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\columncolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\cellcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\colorbox\\{.*?\\}', ''],
+            ['\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large|LARGE|huge|Huge)', ''],
+            [r'\s+', ' '],
+            ['\\\\centering', ''],
+            ['\\\\begin\\{table\\}\\[.*?\\]', '\\\\begin{table}'],
+            ['\t', ''],
+            ['@{}', ''],
+            ['\\\\toprule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\bottomrule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\midrule(\\[.*?\\])?', '\\\\hline'],
+            ['p\\{[^}]*\\}', 'l'],
+            ['m\\{[^}]*\\}', 'c'],
+            ['\\\\scalebox\\{[^}]*\\}\\{([^}]*)\\}', '\\1'],
+            ['\\\\textbf\\{([^}]*)\\}', '\\1'],
+            ['\\\\textit\\{([^}]*)\\}', '\\1'],
+            ['\\\\cmidrule(\\[.*?\\])?\\(.*?\\)\\{([0-9]-[0-9])\\}', '\\\\cline{\\2}'],
+            ['\\\\hline', ''],
+            [r'\\multicolumn\{1\}\{[^}]*\}\{((?:[^{}]|(?:\{[^{}]*\}))*)\}', r'\1']
+        ]
+        pattern = r'\\begin\{tabular\}.*\\end\{tabular\}'  # 注意这里不用 .*?
+        matches = re.findall(pattern, latex_code, re.DOTALL)
+        latex_code = ' '.join(matches)
+
+        for special_str in SPECIAL_STRINGS:
+            latex_code = re.sub(fr'{special_str[0]}', fr'{special_str[1]}', latex_code)
+
+        return latex_code
+    
+    def convert_latex_to_html(latex_content, cache_dir='./temp'):
+        if not os.path.exists(cache_dir):
+            os.makedirs(cache_dir)
+
+        uuid_str = str(uuid.uuid1())
+        with open(f'{cache_dir}/{uuid_str}.tex', 'w') as f:
+            f.write(latex_template(latex_content))
+
+        cmd = ['latexmlc', '--quiet', '--nocomments', f'--log={cache_dir}/{uuid_str}.log',
+               f'{cache_dir}/{uuid_str}.tex', f'--dest={cache_dir}/{uuid_str}.html']
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            with open(f'{cache_dir}/{uuid_str}.html', 'r') as f:
+                html_content = f.read()
+
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, html_content, re.DOTALL | re.IGNORECASE)
+            tables = [f'<table>{table}</table>' for table in tables]
+            html_content = '\n'.join(tables)
+        
+        except Exception as e:
+            html_content = ''
+        
+        shutil.rmtree(cache_dir)
+        return html_content
+    
+    html_text = convert_latex_to_html(text)
+    normlized_tables = normalized_html_table(html_text)
+    return normlized_tables
+
+
+def normalized_table(text, format='html'):
+    if format not in ['html', 'latex']:
+        raise ValueError('Invalid format: {}'.format(format))
+    else:
+        return globals()['normalized_{}_table'.format(format)](text)
+
+
+def textblock_with_norm_formula(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+
+        norm_content = normalized_formula(content)
+        removal_positions.append((position[0], position[1], norm_content))
+    
+    # Remove inline formulas from original text
+    for start, end, norm_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + norm_content.strip() + text[end:]
+
+    return text
+
+# def inline_filter_unicode(text):
+#     # Ensure text is string type
+#     if not isinstance(text, str):
+#         text = str(text)
+    
+#     # Convert LaTeX content to Unicode representation
+#     text = LatexNodes2Text().latex_to_text(text)
+    
+#     inline_array = []
+#     inline_matches = inline_reg.finditer(text)
+    
+#     for match in inline_matches:
+#         position = [match.start(), match.end()]
+#         content = match.group(1) if match.group(1) is not None else match.group(2)
+        
+#         # Remove escape characters \
+#         clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+#         if any(char in clean_content for char in r'\^_'):
+#             # inline_array.append(match.group(0))
+#             inline_array.append({
+#                 'category_type': 'equation_inline',
+#                 'position': position,
+#                 'content': match.group(0),
+#             })
+#             text = text.replace(match.group(0), '')
+#             # print('-----Found inline formula: ', match.group(0))
+#         else:
+#             text = text.replace(match.group(0), content)
+#         # # Add to inline_array
+#         # inline_array.append({
+#         #     'category_type': 'equation_inline',
+#         #     'position': position,
+#         #     'content': content,
+#         # })
+        
+#         # # Remove matched formula from original text, can choose to replace with spaces or remove directly
+#         # text = text[:position[0]] + ' '*(position[1]-position[0]) + text[position[1]:]
+
+#     return text, inline_array
+
+def inline_filter_unicode(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+    
+    # Replace inline formula boundary markers
+    #print('--------text-------',text)
+    placeholder = '__INLINE_FORMULA_BOUNDARY__'
+    text_copy = text.replace('$', placeholder).replace('\\(', placeholder).replace('\\)', placeholder)
+    #print('--------text_copy-------',text_copy)
+    # Convert LaTeX content to Unicode representation
+    text_copy = LatexNodes2Text().latex_to_text(text_copy)
+    #print('--------text_copy---unicode----',text_copy)
+    # Restore boundary markers
+    text_copy = text_copy.replace(placeholder, '$')
+    
+    inline_array = []
+    inline_matches = inline_reg.finditer(text_copy)
+    # Record positions of inline formulas to be removed
+    removal_positions = []
+    
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': content,
+            })
+            removal_positions.append((position[0], position[1]))
+    
+    # Remove inline formulas from original text
+    for start, end in sorted(removal_positions, reverse=True):
+        text = text[:start] + text[end:]
+
+    return text, inline_array
+
+def inline_filter(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+    
+    inline_array = []
+    inline_matches = inline_reg.finditer(text)
+    
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('inline_content: ', content)
+        
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': match.group(0),
+            })
+            text = text.replace(match.group(0), '')
+            # print('-----Found inline formula: ', match.group(0))
+        else:
+            text = text.replace(match.group(0), content)
+
+    return text, inline_array
+
+# Text OCR quality check processing:
+def clean_string(input_string):
+    # Use regex to keep Chinese characters, English letters and numbers
+    # input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    cleaned_string = re.sub(r'[^\w\u4e00-\u9fff]', '', input_string)   # 只保留中英文和数字
+    return cleaned_string

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/extract.py

@@ -0,0 +1,571 @@
+import re
+import os
+import json
+import copy
+#from  modules.table_utils import convert_markdown_to_html #end
+from .table_utils import convert_markdown_to_html
+import re
+import unicodedata
+from bs4 import BeautifulSoup
+from pylatexenc.latexencode import unicode_to_latex
+from pylatexenc.latex2text import LatexNodes2Text
+from pylatexenc.latexwalker import LatexWalker, LatexEnvironmentNode, LatexCharsNode, LatexGroupNode, LatexMacroNode, LatexSpecialsNode
+from collections import defaultdict
+import pdb
+from .data_preprocess import remove_markdown_fences, replace_repeated_chars, textblock_with_norm_formula, textblock2unicode
+
+
+def extract_tabular(text):
+    begin_pattern = r'\\begin{tabular}'
+    end_pattern = r'\\end{tabular}'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+    
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+        
+        if not begin_match and not end_match:
+            break
+            
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+    
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_tabular(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+# math reg
+    # r'\\begin{equation\*?}(.*?)\\end{equation\*?}|'
+    # r'\\begin{align\*?}(.*?)\\end{align\*?}|'
+    # r'\\begin{gather\*?}(.*?)\\end{gather\*?}|'
+display_reg = re.compile(
+    # r'\\begin{equation\*?}(.*?)\\end{equation\*?}|'
+    # r'\\begin{align\*?}(.*?)\\end{align\*?}|'
+    # r'\\begin{gather\*?}(.*?)\\end{gather\*?}|'
+    # r'\\begin{array\*?}(.*?)\\end{array\*?}|'
+    r'\$\$(.*?)\$\$|'
+    r'\\\[(.*?)\\\]|'
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',  
+    re.DOTALL
+)
+
+# inline_reg = re.compile(
+#     r'(?<!\$)\$(?!\$)(.*?)(?<!\$)\$(?!\$)|'
+#     r'\\\((.*?)\\\)',
+# )
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+# table 
+table_reg = re.compile(
+    r'\\begin{table\*?}(.*?)\\end{table\*?}|'
+    r'\\begin{tabular\*?}(.*?)\\end{tabular\*?}',
+    re.DOTALL 
+)
+md_table_reg = re.compile(
+    r'\|\s*.*?\s*\|\n', 
+    re.DOTALL)
+html_table_reg = re.compile(
+    r'(<table.*?</table>)',
+    re.DOTALL
+)
+
+# title
+title_reg = re.compile(
+    r'^\s*#.*$', 
+    re.MULTILINE)
+
+# img
+img_pattern = r'!\[.*?\]\(.*?\)'
+
+# code block
+code_block_reg = re.compile(
+    r'```(\w+)\n(.*?)```',
+    re.DOTALL
+)
+
+def md_tex_filter(content):
+    '''
+    Input: 1 page md or tex content - String
+    Output: text, display, inline, table, title, code - list
+    '''
+    content = re.sub(img_pattern, '', content)  # remove image
+    content = remove_markdown_fences(content)   # remove markdown fences
+    content = replace_repeated_chars(content) # replace all consecutive characters
+    content = content.replace('<html>', '').replace('</html>', '').replace('<body>', '').replace('</body>', '')
+    
+    # # 使用正则表达式对unicode进行替换
+    # special_unicode = ''.join(unicode_replacements.keys())
+    # content = re.sub(f'[{special_unicode}]', replace_unicode, content)
+
+    # content = fullwidth_to_halfwidth(content)  # fullwidth to halfwidth, TODO: GT also needs this operation
+
+    # # pylatexenc's unicode to latex
+    # content = unicode_to_latex(content, unknown_char_warning=False)
+    # markdown_table_content[i, j] = LatexNodes2Text().latex_to_text(content_str)
+    # content_ori = copy.deepcopy(content)
+
+    # print('--------------After pre_process: \n', content)
+
+    pred_all = []
+    # deal with inline formula
+    # content_new, inline_array = inline_filter_unicode(content)
+    # #print('------------inline_array----------------',inline_array)
+    # for inline_item in inline_array:
+    #     inline_item['content'] = inline_to_unicode(inline_item['content'])
+    #     #print('------------inline_array_unicode----------------',inline_item['content'])
+    #     pred_all.append({
+    #         'category_type': 'text_all',
+    #         'position': inline_item['position'],
+    #         'content': inline_item['content'],
+    #         'fine_category_type': 'equation_inline'
+    #     })
+    
+    # extract latex table 
+    latex_table_array, table_positions = extract_tex_table(content)
+    for latex_table, position in zip(latex_table_array, table_positions):
+        position = [position[0], position[0]+len(latex_table)]   # !!!
+        pred_all.append({
+            'category_type': 'latex_table',
+            'position': position,
+            'content': latex_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace latex table with space
+
+    # print('--------After latex table: \n', content)
+    # print('-------latex_table_array: \n', latex_table_array)
+
+    # extract html table  
+    html_table_array, table_positions = extract_html_table(content)
+    for html_table, position in zip(html_table_array, table_positions):
+        position = [position[0], position[0]+len(html_table)]
+        pred_all.append({
+            'category_type': 'html_table',
+            'position': position,
+            'content': html_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace html table with space
+    # html_table_array = []
+    # html_table_matches = html_table_reg.finditer(content)
+    # if html_table_matches:
+    #     for match in html_table_matches:
+    #         matched = match.group(0)
+    #         position = [match.start(), match.end()]
+    #         html_table_array.append(matched.strip())
+    #         # content = content.replace(matched, ' '*len(matched)) # replace html table with space
+    #         content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace html table with space
+    #         pred_all.append({
+    #             'category_type': 'html_table',
+    #             'position': position,
+    #             'content': matched.strip()
+    #         })
+
+    # print('--------------After html table: \n', content)
+    # # extract tables in latex and html
+    # table_array = []
+    # table_matches = table_reg.finditer(content)
+    # tables = ""
+    # for match in table_matches:
+    #     matched = match.group(0)
+    #     if matched:
+    #         tables += matched
+    #         tables += "\n\n"
+    #         table_array.append(matched)
+    #         content = content.replace(matched, '')
+
+    # extract interline formula
+    display_matches = display_reg.finditer(content)
+    content_copy = content
+    for match in display_matches:
+        matched = match.group(0)
+        if matched:
+            # single_line = ''.join(matched.split())
+            single_line = ' '.join(matched.strip().split('\n'))
+            position = [match.start(), match.end()]
+            # replace $$ with \[\]
+            dollar_pattern = re.compile(r'\$\$(.*?)\$\$|\$(.*?)\$|\\\((.*?)\\\)', re.DOTALL)
+            sub_match = dollar_pattern.search(single_line)
+            if sub_match is None:
+                # pass
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            elif sub_match.group(1):
+                single_line = re.sub(dollar_pattern, r'\\[\1\\]', single_line)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace equation with space
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            else:
+                # start, end = match.span()
+                # char_before = content_copy[start-1] if start > 0           else '\n'
+                # char_after  = content_copy[end]   if end   < len(content_copy) else '\n'
+                # if char_before == '\n' or char_after == '\n':
+                #     single_line = re.sub(dollar_pattern, r'\\[\2\3\\]', single_line)
+                #     pred_all.append({
+                #         'category_type': 'equation_isolated',
+                #         'position': position,
+                #         'content': single_line,
+                #         'fine_category_type': 'equation_inline'
+                #     })
+                single_line = re.sub(dollar_pattern, r'\\[\2\3\\]', single_line)
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line,
+                    'fine_category_type': 'equation_inline'
+                })
+            # single_line = re.sub(dollar_pattern, r'\\[\1\2\3\\]', single_line)
+            # print('single_line: ', single_line)
+            # content = content.replace(matched, ' '*len(matched))
+            # pred_all.append({
+            #     'category_type': 'equation_isolated',
+            #     'position': position,
+            #     'content': single_line
+            # })
+            # print('-----Found display formula: ', matched)
+
+    # print('-------------After display: \n', content)
+    # extract md table with ||
+    md_table_mathces = md_table_reg.findall(content+'\n')
+    if len(md_table_mathces) >= 2:
+        # print("md table found!")
+        # print("content:", content)
+        content = convert_markdown_to_html(content)
+        # print('----------content after converting md table to html:', content)
+        html_table_matches = html_table_reg.finditer(content)
+        if html_table_matches:
+            for match in html_table_matches:
+                matched = match.group(0)
+                position = [match.start(), match.end()]
+                # content = content.replace(match, '')
+                # print('content after removing the md table:', content)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace md table with space
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': matched.strip(),
+                    'fine_category_type': 'md2html_table'
+                })
+    # print('---------After md table: \n', content)
+
+    # extract code blocks
+    code_matches = code_block_reg.finditer(content)
+    if code_matches:
+        for match in code_matches:
+            position = [match.start(), match.end()]
+            language = match.group(1)
+            code = match.group(2).strip()
+            # content = content.replace(match.group(0), '')
+            content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace code block with space
+            pred_all.append({
+                'category_type': 'text_all',
+                'position': position,
+                'content': code,
+                'language': language,
+                'fine_category_type': 'code'
+            })
+
+    # print('-------After code block: \n', content)
+
+    # # Extract titles: Do not extract titles, as some models do not wrap code blocks, causing all comments to be treated as titles
+    # title_matches = title_reg.finditer(content)
+    # if title_matches:
+    #     for match in title_matches:
+    #         position = [match.start(), match.end()]
+    #         matched = match.group(0)
+    #         matched = matched.replace("#", "").strip()
+    #         # content = content.replace(match, '')
+    #         # print('content after removing the titles:', content)
+    #         if matched:
+    #             # print('Add title: ', matched)
+    #             content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]
+    #             pred_all.append({
+    #                 'category_type': 'text_all',
+    #                 'position': position,
+    #                 'content': matched,
+    #                 'fine_category_type': 'title'
+    #             })
+    
+    # print('----------After title: \n', content)
+            
+    # # Delete extracted content
+    # extracted_position = [_['position'] for _ in pred_all]
+    # for start, end in sorted(extracted_position, reverse=True):
+    #     content = content[:start] + content[end:]
+
+    # print('----------After delete extracted: \n', content)
+
+    # Remove latex style
+    content = re.sub(r'\\title\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\title\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\text\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\section\*?\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\section\*?\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+
+    # extract texts
+    res = content.split('\n\n')
+    if len(res) == 1:
+        res = content.split('\n')  # some models do not use double newlines, so use single newlines to split
+
+    content_position = 0
+    for text in res:
+        position = [content_position, content_position+len(text)]
+        content_position += len(text)
+        text = text.strip()
+        text = text.strip('\n')
+        # print('ori_text: ', text)
+        text = '\n'.join([_.strip() for _ in text.split('\n') if _.strip()])   # avoid some single newline content with many spaces
+        # print('after strip text: ', text)
+
+        if text:  # Check if the stripped text is not empty
+            if text.startswith('<table') and text.endswith('</table>'):
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': text,
+                })
+            # elif text.startswith('#') and '\n' not in text:
+            #     text = text.replace('#', '').strip()
+            #     if text:
+            #         # print('Add title: ', matched)
+            #         pred_all.append({
+            #             'category_type': 'text_all',
+            #             'position': position,
+            #             'content': text,
+            #             'fine_category_type': 'title'
+            #         })
+            elif text.startswith('$') and text.endswith('$'):
+                if text.replace('$', '').strip():
+                    pred_all.append({
+                        'category_type': 'equation_isolated',
+                        'position': position,
+                        'content': text.strip(),
+                    })
+            else:
+                text = text.strip()
+                if text:
+                    pred_all.append({
+                        'category_type': 'text_all',
+                        'position': position,
+                        'content': text,
+                        'fine_category_type': 'text_block'
+                    })
+                # if '$' in text:
+                #     for formula in re.findall(r'\$(.*?)\$', text):
+                #         formula_array.append(formula)
+
+    pred_dataset = defaultdict(list)
+    pred_all = sorted(pred_all, key=lambda x: x['position'][0])
+    for item in pred_all:
+        pred_dataset[item['category_type']].append(item)
+    # pdb.set_trace()
+    return pred_dataset
+
+
+# def replace_or_extract(match):
+#     content = match.group(1) if match.group(1) is not None else match.group(2)
+    
+#     if any(char in content for char in r'\^_'):
+#         inline_array.append(match.group(0))
+#         return ''
+#     else:
+#         return content
+
+# extract inline math equations in text
+# def inline_filter(text):
+
+#     inline_array = []
+#     inline_matches = inline_reg.finditer(text)
+#     for match in inline_matches:
+#         content = match.group(1) if match.group(1) is not None else match.group(2)
+        
+#         # remove \\, \_, \&, \%, \^
+#         clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+#         if any(char in clean_content for char in r'\^_'):
+#             inline_array.append(match.group(0))
+#             text = text.replace(match.group(0), '')
+#         else:
+#             text = text.replace(match.group(0), content)
+
+#     return text, inline_array
+
+# def extract_tex_table(content):
+#     tables = []
+#     positions = []
+
+#     walker = LatexWalker(content)
+#     nodes, _, _ = walker.get_latex_nodes()
+#     if nodes is None:
+#         return tables, positions
+
+#     for node in nodes:
+#         if isinstance(node, LatexEnvironmentNode) and (
+#             node.environmentname == 'tabular' or node.environmentname == 'table'):
+#             # table_latex = extract_node_content(node)
+#             table_latex = content[node.pos:node.pos_end]
+#             tables.append(table_latex)
+#             start_pos = node.pos
+#             end_pos = get_node_end_pos(node)
+#             positions.append((start_pos, end_pos))
+
+#     return tables, positions
+
+def extract_tex_table(content):
+    tables = []
+    tables_positions = []
+
+    pattern = r'\\begin{table}(.*?)\\end{table}'
+    for match in re.finditer(pattern, content, re.DOTALL):
+        start_pos = match.start()
+        end_pos = match.end()
+        table_content = match.group(0)
+        tables.append(table_content)
+        tables_positions.append((start_pos, end_pos))
+        content = content[:start_pos] + ' '*(end_pos-start_pos) + content[end_pos:]
+
+    tabulars, tabular_positions = extract_tabular(content)
+    all_tables = tables + tabulars
+    all_positions = tables_positions + tabular_positions
+
+    all_result = sorted([[pos, table]for pos, table in zip(all_positions, all_tables)], key=lambda x: x[0][0])
+    all_tables = [x[1] for x in all_result]
+    all_positions = [x[0] for x in all_result]
+
+    return all_tables, all_positions
+
+# def extract_html_table(content):
+#     soup = BeautifulSoup(content, 'html.parser')
+#     all_tables = soup.find_all('table')
+#     tables = []
+#     positions = []
+    
+#     for table in all_tables:
+#         if table.find_parent('table') is None:
+#             table_str = str(table)
+#             start_pos = content.find(table_str)
+#             end_pos = start_pos + len(table_str)
+            
+#             tables.append(table_str)
+#             positions.append((start_pos, end_pos))
+#     return tables, positions
+
+def extract_html_table(text):
+    begin_pattern = r'<table(?:[^>]*)>'
+    end_pattern = r'</table>'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+    
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+        
+        if not begin_match and not end_match:
+            break
+            
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+    
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_html_table(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+
+def extract_node_content(node):
+    """ Recursively extract content from LatexEnvironmentNode and rebuild LaTeX table representation """
+    if isinstance(node, LatexCharsNode):
+        return node.chars  # Use chars attribute
+    elif isinstance(node, LatexGroupNode):
+        return "{" + "".join(extract_node_content(n) for n in node.nodelist) + "}"
+    elif isinstance(node, LatexMacroNode):
+        # Extract macro command and its arguments
+        macro_content = "\\" + node.macroname
+        if node.nodeargs:
+            macro_content += "".join([extract_node_content(arg) for arg in node.nodeargs])
+        return macro_content
+    elif isinstance(node, LatexEnvironmentNode):
+        # Extract environment, preserve environment name and arguments
+        content = "\\begin{" + node.environmentname + "}"
+        if node.nodeargd and node.nodeargd.argnlist:
+            # content += "".join("{" + extract_node_content(arg) + "}" for arg in node.nodeargd)
+            # content += "".join("{" + extract_node_content(node.nodeargd) + "}")
+            content += "{" + extract_node_content(node.nodeargd.argnlist[0]) + "}"
+        if node.nodelist:
+            content += "".join(extract_node_content(n) for n in node.nodelist)
+        content += "\\end{" + node.environmentname + "}"
+        return content
+    elif isinstance(node, LatexSpecialsNode):  # Changed to LatexSpecialsNode
+        return node.specials_chars
+    else:
+        return ""
+        
+def get_node_end_pos(node):
+    """Recursively determine the end position of a node"""
+    if hasattr(node, 'nodelist') and node.nodelist:
+        # If the node has child nodes, recursively find the end position of the last child node
+        return get_node_end_pos(node.nodelist[-1])
+    elif hasattr(node, 'pos_end'):
+        # If the node has pos_end attribute, return it directly
+        return node.pos_end
+    else:
+        # If there are no child nodes, assume the node ends at the last character of its content
+        return node.pos + len(str(node))
+
+def remove_tex_table(content):
+    tables, positions = extract_tex_table(content)
+
+    # Delete in reverse order by position to avoid affecting unprocessed start positions
+    for start, end in sorted(positions, reverse=True):
+        content = content[:start] + content[end:]  # Remove table content
+
+    return content

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/match.py

@@ -0,0 +1,310 @@
+from scipy.optimize import linear_sum_assignment
+import Levenshtein
+import numpy as np
+import re
+import sys
+import pdb
+from .data_preprocess import textblock_with_norm_formula, normalized_formula, textblock2unicode, clean_string
+import re
+from bs4 import BeautifulSoup
+from copy import deepcopy
+
+def get_pred_category_type(pred_idx, pred_items):
+    if pred_items[pred_idx].get('fine_category_type'):
+        pred_pred_category_type = pred_items[pred_idx]['fine_category_type']
+    else:
+        pred_pred_category_type = pred_items[pred_idx]['category_type']
+    return pred_pred_category_type
+
+
+def compute_edit_distance_matrix_new(gt_lines, matched_lines):
+    try:
+        distance_matrix = np.zeros((len(gt_lines), len(matched_lines)))
+        for i, gt_line in enumerate(gt_lines):
+            for j, matched_line in enumerate(matched_lines):
+                if len(gt_line) == 0 and len(matched_line) == 0:
+                    distance_matrix[i][j] = 0  
+                else:
+                    distance_matrix[i][j] = Levenshtein.distance(gt_line, matched_line) / max(len(matched_line), len(gt_line))
+        return distance_matrix
+    except ZeroDivisionError:
+        raise  
+
+
+## 混合匹配here  0403
+def get_gt_pred_lines(gt_mix,pred_dataset_mix,line_type):
+
+    norm_html_lines,gt_lines,pred_lines,norm_gt_lines,norm_pred_lines,gt_cat_list = [],[],[],[],[],[]
+    if line_type in ['html_table','latex_table']:
+        for item in gt_mix:
+            if item.get('fine_category_type'):
+                gt_cat_list.append(item['fine_category_type'])
+            else:
+                gt_cat_list.append(item['category_type'])
+            if item.get('content'):
+                gt_lines.append(str(item['content']))
+                norm_html_lines.append(str(item['content']))
+            elif line_type == 'text':
+                gt_lines.append(str(item['text']))
+            elif line_type == 'html_table':
+                gt_lines.append(str(item['html']))
+            elif line_type == 'formula':
+                gt_lines.append(str(item['latex']))
+            elif line_type == 'latex_table':
+                try:
+                    gt_lines.append(str(item['latex']))
+                except:
+                    print(item)
+                    gt_lines.append("")
+                norm_html_lines.append(str(item['html']))
+        
+        pred_lines = [str(item['content']) for item in pred_dataset_mix]
+        if line_type == 'formula':
+            norm_gt_lines = [normalized_formula(_) for _ in gt_lines]
+            norm_pred_lines = [normalized_formula(_) for _ in pred_lines]
+        elif line_type == 'text':
+            norm_gt_lines = [clean_string(textblock2unicode(_)) for _ in gt_lines]
+            norm_pred_lines = [clean_string(textblock2unicode(_)) for _ in pred_lines]
+        else:
+            norm_gt_lines = gt_lines
+            norm_pred_lines = pred_lines
+        if line_type == 'latex_table':
+            gt_lines = norm_html_lines
+
+    else:
+        for item in pred_dataset_mix:
+            # text
+            if item['category_type'] == 'text_all':
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(clean_string(textblock2unicode(str(item['content']))))
+            # formula
+            elif  item['category_type']=='equation_isolated':
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(normalized_formula(str(item['content'])))
+            # table
+            else:
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(str(item['content']))
+        
+        for item in gt_mix:
+            if item.get('content'):
+                gt_lines.append(str(item['content']))
+                if item['category_type'] == 'text_all':              
+                    norm_gt_lines.append(clean_string(textblock2unicode(str(item['content']))))
+                else:
+                   norm_gt_lines.append(item['content'])
+                
+                norm_html_lines.append(str(item['content']))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+            # text      
+            elif item['category_type'] in ['text_block', 'title', 'code_txt', 'code_txt_caption', 'reference', 'equation_caption','figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption','header', 'footer', 'page_footnote', 'page_number']:
+                gt_lines.append(str(item['text']))
+                norm_gt_lines.append(clean_string(textblock2unicode(str(item['text']))))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+
+            # formula
+            elif item['category_type'] == 'equation_isolated':
+                gt_lines.append(str(item['latex']))
+                norm_gt_lines.append(normalized_formula(str(item['latex'])))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+            # table
+            # elif item['category_type'] == 'table':
+            #     gt_lines.append(str(item['html']))
+            #     norm_gt_lines.append(str(item['html']))
+
+            #     if item.get('fine_category_type'):
+            #         gt_cat_list.append(item['fine_category_type'])
+            #     else:
+            #         gt_cat_list.append(item['category_type'])
+
+
+    filtered_lists = [(a, b, c) for a, b, c in zip(gt_lines, norm_gt_lines, gt_cat_list) if a and b]
+
+    # decompress to three lists
+    if filtered_lists:
+        gt_lines_c, norm_gt_lines_c, gt_cat_list_c = zip(*filtered_lists)
+
+        # convert to lists
+        gt_lines_c = list(gt_lines_c)
+        norm_gt_lines_c = list(norm_gt_lines_c)
+        gt_cat_list_c = list(gt_cat_list_c)
+    else:
+        gt_lines_c = []
+        norm_gt_lines_c = []
+        gt_cat_list_c = []
+
+    # pred's empty values
+    filtered_lists = [(a, b) for a, b in zip(pred_lines, norm_pred_lines) if a and b]
+
+    # decompress to two lists
+    if filtered_lists:
+        pred_lines_c, norm_pred_lines_c = zip(*filtered_lists)
+
+        # convert to lists
+        pred_lines_c = list(pred_lines_c)
+        norm_pred_lines_c = list(norm_pred_lines_c)
+    else:
+        pred_lines_c = []
+        norm_pred_lines_c = []
+
+    return gt_lines_c, norm_gt_lines_c, gt_cat_list_c, pred_lines_c, norm_pred_lines_c, gt_mix, pred_dataset_mix
+
+
+def match_gt2pred_simple(gt_items, pred_items, line_type, img_name):
+
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines, gt_items, pred_items = get_gt_pred_lines(gt_items, pred_items,line_type)
+    match_list = []
+
+    if not norm_gt_lines: # not matched pred should be concatenate
+        pred_idx_list = range(len(norm_pred_lines))
+        match_list.append({
+            'gt_idx': [""],
+            'gt': "",
+            'pred_idx': pred_idx_list,
+            'pred': ''.join(pred_lines[_] for _ in pred_idx_list), 
+            'gt_position': [""],
+            'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+            'norm_gt': "",
+            'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+            'gt_category_type': "",
+            'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+            'gt_attribute': [{}],
+            'edit': 1,
+            'img_id': img_name
+        })
+        return match_list,None
+    elif not norm_pred_lines: # not matched gt should be separated
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list,None
+    
+    cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+    
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx in row_ind:
+            row_i = list(row_ind).index(gt_idx)
+            pred_idx = int(col_ind[row_i])
+            pred_line = pred_lines[pred_idx]
+            norm_pred_line = norm_pred_lines[pred_idx]
+            edit = cost_matrix[gt_idx][pred_idx]
+        else:
+            pred_idx = ""
+            pred_line = ""
+            norm_pred_line = ""
+            edit = 1
+        
+
+        match_list.append({
+            'gt_idx': [gt_idx],
+            'gt': gt_lines[gt_idx],
+            'norm_gt': norm_gt_lines[gt_idx],
+            'gt_category_type': gt_cat_list[gt_idx],
+            'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+            'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+            'pred_idx': [pred_idx],
+            'pred': pred_line,
+            'norm_pred': norm_pred_line,
+            'pred_category_type': get_pred_category_type(pred_idx, pred_items) if pred_idx else "",
+            'pred_position': pred_items[pred_idx]['position'][0] if pred_idx else "",
+            'edit': edit,
+            'img_id': img_name
+        })
+    
+    pred_idx_list = [pred_idx for pred_idx in range(len(norm_pred_lines)) if pred_idx not in col_ind] # get not matched preds
+    if pred_idx_list:
+        if line_type in ['html_table', 'latex_table']:
+            unmatch_table_pred = []
+            for i in pred_idx_list:
+                original_item = pred_items[i]
+                soup = BeautifulSoup(original_item.get('content'),'html.parser')
+                text_block = [re.sub(r'\$\\cdot\$','',item.string).strip() for item in soup.findAll('td') if item.string]
+                for concatenate_text in text_block:
+                    new_item = deepcopy(original_item)
+                    new_item['content'] = concatenate_text
+                    new_item['category_type'] = 'text_all'  
+                    unmatch_table_pred.append(new_item)
+            return match_list, unmatch_table_pred  
+        
+        else:
+            match_list.append({
+                'gt_idx': [""],
+                'gt': "",
+                'pred_idx': pred_idx_list,
+                'pred': ''.join(pred_lines[_] for _ in pred_idx_list), 
+                'gt_position': [""],
+                'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+                'norm_gt': "",
+                'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+                'gt_category_type': "",
+                'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+                'gt_attribute': [{}],
+                'edit': 1,
+                'img_id': img_name
+            })
+    return match_list,None
+
+
+def match_gt2pred_no_split(gt_items, pred_items, line_type, img_name):
+    # directly concatenate gt and pred by position
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines = get_gt_pred_lines(gt_items, pred_items)
+    gt_line_with_position = []
+    for gt_line, norm_gt_line, gt_item in zip(gt_lines, norm_gt_lines, gt_items):
+        gt_position = gt_item['order'] if gt_item.get('order') else gt_item.get('position', [""])[0]
+        if gt_position:
+            gt_line_with_position.append((gt_position, gt_line, norm_gt_line))
+    sorted_gt_lines = sorted(gt_line_with_position, key=lambda x: x[0])
+    gt = '\n\n'.join([_[1] for _ in sorted_gt_lines])
+    norm_gt = '\n\n'.join([_[2] for _ in sorted_gt_lines])
+    pred_line_with_position = [(pred_item['position'], pred_line, pred_norm_line) for pred_line, pred_norm_line, pred_item in zip(pred_lines, norm_pred_lines, pred_items)]
+    sorted_pred_lines = sorted(pred_line_with_position, key=lambda x: x[0])
+    pred = '\n\n'.join([_[1] for _ in sorted_pred_lines])
+    norm_pred = '\n\n'.join([_[2] for _ in sorted_pred_lines])
+    # edit = Levenshtein.distance(norm_gt, norm_pred)/max(len(norm_gt), len(norm_pred))
+    if norm_gt or norm_pred:
+        return [{
+                'gt_idx': [0],
+                'gt': gt,
+                'norm_gt': norm_gt,
+                'gt_category_type': "text_merge",
+                'gt_position': [""],
+                'gt_attribute': [{}],
+                'pred_idx': [0],
+                'pred': pred,
+                'norm_pred': norm_pred,
+                'pred_category_type': "text_merge",
+                'pred_position': "",
+                # 'edit': edit,
+                'img_id': img_name
+            }]
+    else:
+        return []
+    

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/match_quick.py

@@ -0,0 +1,1292 @@
+from scipy.optimize import linear_sum_assignment
+# from rapidfuzz.distance import Levenshtein
+import Levenshtein
+from collections import defaultdict
+import copy
+from .match import compute_edit_distance_matrix_new, get_gt_pred_lines, get_pred_category_type
+import pdb
+import numpy as np
+from collections import Counter
+from Levenshtein import distance as Levenshtein_distance
+
+import re
+from copy import deepcopy
+from typing import List, Dict, Any
+
+# ARRAY_RE = re.compile(
+#     r'\\begin\{array\}\{[^}]*\}(.*?)\\end\{array\}', re.S
+# )
+
+# def split_gt_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+#     """
+#     拆分带 \\begin{array} … \\end{array} 的 GT 字典条目。
+
+#     - 仅针对 category_type == 'equation_isolated' 且 latex 含 array。
+#     - 每行公式拆出一个新条目：
+#         * 更新 'latex'
+#         * 若存在 line_with_spans，则同步替换其内部 latex
+#         * 'order' 由 7 --> 7.1, 7.2, …
+#     """
+#     output = []
+
+#     for item in data:
+#         # 只处理满足条件的字典
+#         if (item.get("category_type") == "equation_isolated" and
+#                 "\\begin{array" in item.get("latex", "")):
+
+#             # 抽取 array 内部内容
+#             match = ARRAY_RE.search(item["latex"])
+#             if match:
+#                 body = match.group(1)           # 去掉 array 外壳
+#                 # 按 LaTeX 行分隔符 \\\\ 拆分
+#                 lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+#                 base_order = float(item["order"])  # 7 -> 7.0，可兼容 float/int
+
+#                 for idx, line in enumerate(lines, start=1):
+#                     new_item = deepcopy(item)
+#                     new_item["latex"] = f"\\[{line}\\]"
+#                     new_item["order"] = round(base_order + idx / 10, 1)
+#                     output.append(new_item)
+#                 continue  # 跳过把原 item 加入
+#         # 其它情况不修改
+#         output.append(item)
+
+#     return output
+
+# def _wrap(line: str) -> str:
+#     """给单行公式重新包 \\[ ... \\]"""
+#     return f"\\[{line.strip()}\\]"
+
+# def split_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+#     """
+#     处理 category_type == 'equation_isolated' 且含 \\begin{array} … 的条目：
+#     * 拆分多行公式
+#     * 重新包装 content
+#     * **重计算 position / positions**
+#     """
+#     out: List[Dict[str, Any]] = []
+
+#     for item in data:
+#         if (item.get("category_type") == "equation_isolated" and
+#                 "\\begin{array" in item.get("content", "")):
+
+#             content = item["content"]
+#             m = ARRAY_RE.search(content)
+#             if not m:
+#                 out.append(item)
+#                 continue
+
+#             body = m.group(1)
+#             lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+#             # 全局起始字符索引
+#             pos_key = "position" if "position" in item else "positions"
+#             global_start = item[pos_key][0]
+
+#             # array 正文在原 content 内的起点
+#             body_start_in_content = m.start(1)
+
+#             search_from = 0  # 在 body 中的游标
+#             for ln in lines:
+#                 # 在 body 中找到当前行的偏移
+#                 idx_in_body = body.find(ln, search_from)
+#                 if idx_in_body == -1:
+#                     # 不太可能发生；保守处理
+#                     idx_in_body = search_from
+#                 search_from = idx_in_body + len(ln)  # 更新游标
+
+#                 # 计算全局索引
+#                 line_start_global = global_start + body_start_in_content + idx_in_body
+#                 line_end_global   = line_start_global + len(ln) - 1
+
+#                 new_item = deepcopy(item)
+#                 new_item["content"] = _wrap(ln)
+#                 new_item[pos_key]   = [line_start_global, line_end_global]
+
+#                 out.append(new_item)
+
+#             # 拆分完成，不保留原条目
+#             continue
+
+#         # 其它条目直接加入
+#         out.append(item)
+
+#     return out
+
+ARRAY_RE = re.compile(
+    r'\\begin\{array\}\{(?P<spec>[^}]*)\}(?P<body>.*?)\\end\{array\}',
+    re.S
+)
+
+def is_all_l(spec: str) -> bool:
+    """检查是否为单列array格式，用于排除矩阵等多列格式。这个函数只拆分单列的array"""
+    spec = re.sub(r'\s+|\|', '', spec)          # 删空白与竖线
+    spec = re.sub(r'@{[^}]*}', '', spec)        # 删 @{…} 修饰
+    spec = re.sub(r'!{[^}]*}', '', spec)        # 删 !{…} 修饰
+    # 检查是否为单列基本对齐格式：l, c, r
+    return bool(spec) and len(spec) == 1 and spec in {'l', 'c', 'r'}
+
+# def is_all_l(spec: str) -> bool:
+#     """忽略空格 / 竖线 / @{…} 之后，判断列格式是否只剩基本对齐格式。这个函数会将多行多列的array按行拆分"""
+#     spec = re.sub(r'\s+|\|', '', spec)          # 删空白与竖线
+#     spec = re.sub(r'@{[^}]*}', '', spec)        # 删 @{…} 修饰
+#     spec = re.sub(r'!{[^}]*}', '', spec)        # 删 !{…} 修饰
+#     # 检查是否只包含基本对齐格式：l, c, r
+#     return bool(spec) and set(spec) <= {'l', 'c', 'r'}
+
+def split_gt_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    拆分带 \\begin{array} … \\end{array} 的 GT 字典条目。
+
+    - 仅针对 category_type == 'equation_isolated' 且 latex 含 array。
+    - 每行公式拆出一个新条目：
+        * 更新 'latex'
+        * 若存在 line_with_spans，则同步替换其内部 latex
+        * 'order' 由 7 --> 7.1, 7.2, …
+    """
+    output = []
+
+    for item in data:
+        # 只处理满足条件的字典
+        if (item.get("category_type") == "equation_isolated" and
+                "\\begin{array" in item.get("latex", "")):
+
+            # 抽取 array 内部内容
+            match = ARRAY_RE.search(item["latex"])
+            if match:
+
+                spec = match.group("spec")
+                if not is_all_l(spec):
+                    # 若列里混有 r / c / p{…} 等，直接保留原条目
+                    output.append(item)
+                    continue
+                
+                body  = match.group("body")
+                # body = match.group(1)           # 去掉 array 外壳
+                # 按 LaTeX 行分隔符 \\\\ 拆分
+                lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+                base_order = float(item["order"])  # 7 -> 7.0，可兼容 float/int
+
+                for idx, line in enumerate(lines, start=1):
+                    new_item = deepcopy(item)
+                    new_item["latex"] = f"\\[{line}\\]"
+                    new_item["order"] = round(base_order + idx / 10, 1)
+                    output.append(new_item)
+                continue  # 跳过把原 item 加入
+        # 其它情况不修改
+        output.append(item)
+
+    return output
+
+def _wrap(line: str) -> str:
+    """给单行公式重新包 \\[ ... \\]"""
+    return f"\\[{line.strip()}\\]"
+
+def split_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    处理 category_type == 'equation_isolated' 且含 \\begin{array} … 的条目：
+    * 拆分多行公式
+    * 重新包装 content
+    * **重计算 position / positions**
+    """
+    out: List[Dict[str, Any]] = []
+
+    for item in data:
+        if (item.get("category_type") == "equation_isolated" and
+                "\\begin{array" in item.get("content", "")):
+
+            content = item["content"]
+            m = ARRAY_RE.search(content)
+            if not m:
+                out.append(item)
+                continue
+
+            if not is_all_l(m.group('spec')):
+                out.append(item)
+                continue
+            
+            # body = m.group(1)
+            body = m.group('body')
+            lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+            # 全局起始字符索引
+            pos_key = "position" if "position" in item else "positions"
+            global_start = item[pos_key][0]
+
+            # array 正文在原 content 内的起点
+            # body_start_in_content = m.start(1)
+            body_start_in_content = m.start('body')
+
+            search_from = 0  # 在 body 中的游标
+            for ln in lines:
+                # 在 body 中找到当前行的偏移
+                idx_in_body = body.find(ln, search_from)
+                if idx_in_body == -1:
+                    # 不太可能发生；保守处理
+                    idx_in_body = search_from
+                search_from = idx_in_body + len(ln)  # 更新游标
+
+                # 计算全局索引
+                line_start_global = global_start + body_start_in_content + idx_in_body
+                line_end_global   = line_start_global + len(ln) - 1
+
+                new_item = deepcopy(item)
+                new_item["content"] = _wrap(ln)
+                new_item[pos_key]   = [line_start_global, line_end_global]
+
+                out.append(new_item)
+
+            # 拆分完成，不保留原条目
+            continue
+
+        # 其它条目直接加入
+        out.append(item)
+
+    return out
+
+def sort_by_position_skip_inline(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    先按 position[0] 从小到大排序；
+    若 fine_category_type == 'equation_inline'，则统一放到最后，
+    并保持它们在原列表中的相对顺序（稳定排序）。
+    """
+    # enumerate 保留原始顺序索引，用于 equation_inline “并列时” 的稳定性
+    return sorted(
+        enumerate(items),
+        key=lambda pair: (
+            pair[1].get('fine_category_type') == 'equation_inline',  # False < True
+            pair[1]['position'][0],                                   # 位置起点
+            pair[0]                                                   # 原序号，确保稳定
+        )
+    )
+def match_gt2pred_quick(gt_items, pred_items, line_type, img_name):
+    # ========== 降级匹配阈值检测 ==========
+    # 当 pred_items 过多且远超 gt_items 时，降级为整体匹配，避免 O(m*n) 复杂度过高
+    MAX_PRED_ITEMS = 50000       # pred项数超过此值触发检查
+    RATIO_THRESHOLD = 100        # pred/gt 比例超过此值则降级
+    MAX_TOTAL_LENGTH = 10000000  # 内容总长度超过此值也降级
+    MAX_SINGLE_ITEM_LENGTH = 10000000  # 单个项内容超过此值也降级（针对大表格）
+
+    gt_count = len(gt_items)
+    pred_count = len(pred_items)
+
+    # 计算内容总长度
+    def get_item_content(item):
+        content = item.get('content')
+        if content is None:
+            content = item.get('text', '')
+        return str(content) if content else ''
+
+    gt_total_len = sum(len(get_item_content(item)) for item in gt_items)
+    pred_total_len = sum(len(get_item_content(item)) for item in pred_items)
+
+    # 计算单个项最大长度（针对大表格）
+    gt_max_len = max((len(get_item_content(item)) for item in gt_items), default=0)
+    pred_max_len = max((len(get_item_content(item)) for item in pred_items), default=0)
+
+    # 判断是否需要降级：项数过多 或 内容过大
+    need_downgrade = False
+    downgrade_reason = ""
+
+    if pred_count > MAX_PRED_ITEMS and gt_count > 0 and pred_count > RATIO_THRESHOLD * gt_count:
+        need_downgrade = True
+        downgrade_reason = f"pred_items({pred_count})/gt_items({gt_count})={pred_count/gt_count:.1f}"
+    elif gt_total_len > MAX_TOTAL_LENGTH or pred_total_len > MAX_TOTAL_LENGTH:
+        need_downgrade = True
+        downgrade_reason = f"content_too_large(gt_len={gt_total_len},pred_len={pred_total_len})"
+    elif gt_max_len > MAX_SINGLE_ITEM_LENGTH or pred_max_len > MAX_SINGLE_ITEM_LENGTH:
+        # 单个项内容过大（针对大表格导致的慢速编辑距离计算）
+        need_downgrade = True
+        downgrade_reason = f"single_item_too_large(gt_max={gt_max_len},pred_max={pred_max_len})"
+
+    if need_downgrade:
+        # 判断是否为表格类型
+        is_table_type = line_type in ['html_table', 'latex_table']
+
+        if is_table_type:
+            # 表格类型：不允许随意拼接，直接给低分
+            # 如果 GT 和 Pred 数量相同，尝试一一配对；否则 TEDS=0
+            print(f"[DOWNGRADE-TABLE] {img_name}: {downgrade_reason}, TEDS=0")
+
+            gt_positions = []
+            for item in gt_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                gt_positions.append(pos)
+
+            pred_positions = []
+            for item in pred_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                pred_positions.append(pos)
+
+            gt_category = gt_items[0].get('fine_category_type') or gt_items[0].get('category_type', line_type) if gt_items else line_type
+            pred_category = pred_items[0].get('fine_category_type') or pred_items[0].get('category_type', line_type) if pred_items else line_type
+
+            # 对于表格，返回一个 TEDS=0 的结果
+            gt_all = '\n'.join([get_item_content(item) for item in gt_items])
+            pred_all = '\n'.join([get_item_content(item) for item in pred_items])
+
+            return [{
+                'gt_idx': list(range(gt_count)),
+                'gt': gt_all,
+                'pred_idx': list(range(pred_count)),
+                'pred': pred_all,
+                'gt_position': gt_positions,
+                'pred_position': pred_positions[0] if pred_positions else "",
+                'norm_gt': gt_all,
+                'norm_pred': pred_all,
+                'gt_category_type': gt_category,
+                'pred_category_type': pred_category,
+                'gt_attribute': [item.get('attribute', {}) for item in gt_items],
+                'edit': 1.0,  # edit 距离给最大值（表示完全不同）
+                'TEDS': 0.0,  # TEDS 分数直接给 0
+                'img_id': img_name,
+                'downgrade': True,
+                'downgrade_reason': downgrade_reason
+            }]
+        else:
+            # 非表格类型：拼接后计算 edit_distance
+            gt_positions = []
+            for item in gt_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                gt_positions.append(pos)
+
+            pred_positions = []
+            for item in pred_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                pred_positions.append(pos)
+
+            gt_all = '\n'.join([get_item_content(item) for item in gt_items])
+            pred_all = '\n'.join([get_item_content(item) for item in pred_items])
+
+            if not gt_all and not pred_all:
+                edit = 0.0
+            elif not gt_all or not pred_all:
+                edit = 1.0
+            else:
+                edit_distance = Levenshtein_distance(gt_all, pred_all)
+                edit = edit_distance / max(len(gt_all), len(pred_all))
+
+            gt_category = gt_items[0].get('fine_category_type') or gt_items[0].get('category_type', line_type) if gt_items else line_type
+            pred_category = pred_items[0].get('fine_category_type') or pred_items[0].get('category_type', line_type) if pred_items else line_type
+
+            print(f"[DOWNGRADE] {img_name}: {downgrade_reason}, edit={edit:.4f}")
+
+            return [{
+                'gt_idx': list(range(gt_count)),
+                'gt': gt_all,
+                'pred_idx': list(range(pred_count)),
+                'pred': pred_all,
+                'gt_position': gt_positions,
+                'pred_position': pred_positions[0] if pred_positions else "",
+                'norm_gt': gt_all,
+                'norm_pred': pred_all,
+                'gt_category_type': gt_category,
+                'pred_category_type': pred_category,
+                'gt_attribute': [item.get('attribute', {}) for item in gt_items],
+                'edit': edit,
+                'img_id': img_name,
+                'downgrade': True,
+                'downgrade_reason': downgrade_reason
+            }]
+    # ========== 降级匹配检测结束 ==========
+
+    gt_items = split_gt_equation_arrays(gt_items)
+    
+    # pred_items = sorted(pred_items, key=lambda x: x['position'][0])
+    pred_items = [pair[1] for pair in sort_by_position_skip_inline(pred_items)]
+
+    pred_items = split_equation_arrays(pred_items)
+
+    # gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines= get_gt_pred_lines(gt_items, pred_items, line_type)
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines, gt_items, pred_items = get_gt_pred_lines(gt_items, pred_items, None)
+    all_gt_indices = set(range(len(norm_gt_lines)))  
+    all_pred_indices = set(range(len(norm_pred_lines)))  
+    
+    if not norm_gt_lines:
+        match_list = []
+        for pred_idx in range(len(norm_pred_lines)):
+            match_list.append({
+                'gt_idx': [""],
+                'gt': "",
+                'pred_idx': [pred_idx],
+                'pred': pred_lines[pred_idx],
+                'gt_position': [""],
+                'pred_position': pred_items[pred_idx]['position'][0],
+                'norm_gt': "",
+                'norm_pred': norm_pred_lines[pred_idx],
+                'gt_category_type': "",
+                'pred_category_type': get_pred_category_type(pred_idx, pred_items),
+                'gt_attribute': [{}],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif not norm_pred_lines:
+        match_list = []
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif len(norm_gt_lines) == 1 and len(norm_pred_lines) == 1:
+        edit_distance = Levenshtein_distance(norm_gt_lines[0], norm_pred_lines[0])
+        normalized_edit_distance = edit_distance / max(len(norm_gt_lines[0]), len(norm_pred_lines[0]))
+        return [{
+            'gt_idx': [0],
+            'gt': gt_lines[0],
+            'pred_idx': [0],
+            'pred': pred_lines[0],
+            'gt_position': [gt_items[0].get('order') if gt_items[0].get('order') else gt_items[0].get('position', [""])[0]],
+            'pred_position': pred_items[0]['position'][0],
+            'norm_gt': norm_gt_lines[0],
+            'norm_pred': norm_pred_lines[0],
+            'gt_category_type': gt_cat_list[0],
+            'pred_category_type': get_pred_category_type(0, pred_items),
+            'gt_attribute': [gt_items[0].get("attribute", {})],
+            'edit': normalized_edit_distance,
+            'img_id': img_name
+        }]
+    
+    # match category ignore first
+    ignores = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 
+               'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+    
+    ignore_gt_lines = []
+    ignores_ori_gt_lines= []
+    ignores_gt_items = []
+    ignore_gt_idxs = []
+    ignores_gt_cat_list = []
+    
+    no_ignores_gt_lines = []
+    no_ignores_ori_gt_lines = []
+    no_ignores_gt_idxs = []
+    no_ignores_gt_items = []
+    no_ignores_gt_cat_list = []
+
+    for i, line in enumerate(norm_gt_lines):
+        if gt_cat_list[i] in ignores:
+            ignore_gt_lines.append(line)
+            ignores_ori_gt_lines.append(gt_lines[i])
+            ignores_gt_items.append(gt_items[i])
+            ignore_gt_idxs.append(i)
+            ignores_gt_cat_list.append(gt_cat_list[i])
+        else:
+            no_ignores_gt_lines.append(line)
+            no_ignores_ori_gt_lines.append(gt_lines[i])
+            no_ignores_gt_items.append(gt_items[i])
+            no_ignores_gt_cat_list.append(gt_cat_list[i])
+            no_ignores_gt_idxs.append(i)
+
+    # print("-------------ignore_gt_lines-------------------")
+    # for idx, line in zip(ignore_idx,ignore_gt_lines):
+    #     print(f"{gt_cat_list[idx]}: {line}")
+    
+    # print("-------------no_ignores_gt_lines-------------------")
+    # for line in no_ignores_gt_lines:
+    #     print(line)
+
+    ignore_pred_idxs = []
+    ignore_pred_lines = []
+    ignores_pred_items = []
+    ignores_ori_pred_lines = []
+
+    merged_ignore_results = []
+
+    if len(ignore_gt_lines) > 0:
+        
+        ignore_matches_dict = {}
+
+        ignore_matrix = compute_edit_distance_matrix_new(ignore_gt_lines, norm_pred_lines)
+        # print("-------------ignore_matrix-------------")
+        # print(ignore_matrix)
+        
+        ignores_gt_indices = set(range(len(ignore_gt_lines)))  
+        ignores_pred_indices = set(range(len(ignore_pred_lines)))
+
+        ignore_matches = np.argwhere(ignore_matrix < 0.25) 
+        # print("-------------ignore_matches-------------")
+        # print(ignore_matches)
+        if len(ignore_matches) > 0:
+            ignore_pred_idxs = [_[1] for _ in ignore_matches]
+            ignore_gt_matched_idxs = [ignore_gt_idxs[_[0]] for _ in ignore_matches]
+            # print("-------------ignore_pred_idxs-------------")
+            # print(ignore_pred_idxs)
+            # print("-------------ignore_gt_matched_idxs-------------")
+            # print(ignore_gt_matched_idxs)
+
+            for i in ignore_pred_idxs:
+                ignore_pred_lines.append(norm_pred_lines[i])
+                ignores_ori_pred_lines.append(pred_lines[i])
+                ignores_pred_items.append(pred_items[i])
+            # print("-------------ignore_pred_lines-------------")
+            # for i in ignore_pred_lines:
+            #     print(i)
+
+                ignores_gt_indices = set(range(len(ignore_gt_lines)))  
+                ignores_pred_indices = set(range(len(ignore_pred_lines))) 
+
+            for idx, i in enumerate(ignore_matches):
+                ignore_matches_dict[i[0]] = {
+                    'pred_indices': [idx],
+                    'edit_distance': ignore_matrix[i[0]][i[1]]
+                }
+            # print("-------------ignore_matches_dict-------------")
+            # print(ignore_matches_dict)
+
+        ignore_final_matches = merge_matches(ignore_matches_dict, {})
+        # print("-------------ignore_final_matches-------------")
+        # print(ignore_final_matches)
+        
+        recalculate_edit_distances(ignore_final_matches, {}, ignore_gt_lines, ignore_pred_lines)
+        # print("-------------recalculate_ignore_final_matches-------------")
+        # print(ignore_final_matches)
+
+        converted_ignore_results = convert_final_matches(ignore_final_matches, ignore_gt_lines, ignore_pred_lines)
+        # print("-------------converted_ignore_results-------------")
+        # for i in converted_ignore_results:
+        #     print(i)
+            
+        merged_ignore_results = merge_duplicates_add_unmatched(converted_ignore_results, ignore_gt_lines, ignore_pred_lines, ignores_ori_gt_lines, ignores_ori_pred_lines, ignores_gt_indices, ignores_pred_indices)
+
+        for entry in merged_ignore_results:
+            entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+            entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+            entry['gt_position'] = [ignores_gt_items[_].get('order') if ignores_gt_items[_].get('order') else ignores_gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+            entry['pred_position'] = ignores_pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+            entry['gt'] = ''.join([ignores_ori_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['pred'] = ''.join([ignores_ori_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+            entry['norm_gt'] = ''.join([ignore_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['norm_pred'] = ''.join([ignore_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+            if entry['gt_idx'] != [""]:
+                ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+                gt_cagegory_clean = [ignores_gt_cat_list[_] for _ in entry['gt_idx'] if ignores_gt_cat_list[_] not in ignore_type] 
+                if gt_cagegory_clean:
+                    entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+                else:
+                    entry['gt_category_type'] = Counter([ignores_gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+            else:
+                entry['gt_category_type'] = ""
+                entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], ignores_pred_items) if entry['pred_idx'] != [""] else ""
+                if entry['pred_category_type'] == 'equation_inline':
+                    merged_ignore_results.remove(entry)
+            entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], ignores_pred_items) if entry['pred_idx'] != [""] else ""
+            entry['gt_attribute'] = [ignores_gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+            entry['img_id'] = img_name
+        
+        for entry in merged_ignore_results:
+            if isinstance(entry['gt_idx'], list) and entry['gt_idx'] != [""]:
+                gt_idx = []
+                for i in entry['gt_idx']:
+                    gt_idx.append(ignore_gt_idxs[i])
+                entry['gt_idx'] = gt_idx
+            if isinstance(entry['pred_idx'], list) and entry['pred_idx'] != [""]:
+                pred_idx = []
+                for i in entry['pred_idx']:
+                    pred_idx.append(int(ignore_pred_idxs[i]))
+                entry['pred_idx'] = pred_idx
+
+        # print("-------------merged_ignore_results-------------")
+        # for i in merged_ignore_results:
+        #     print(i)
+
+    no_ignores_pred_lines = []
+    no_ignores_ori_pred_lines = []
+    no_ignores_pred_indices = []
+    no_ignores_pred_items = []
+    no_ignore_pred_idxs = []
+
+    for idx, line in enumerate(norm_pred_lines):
+        if not idx in ignore_pred_idxs:
+            no_ignores_pred_lines.append(line)
+            no_ignores_ori_pred_lines.append(pred_lines[idx])
+            # no_ignores_pred_indices.append(idx)
+            no_ignores_pred_items.append(pred_items[idx])
+            no_ignore_pred_idxs.append(idx)
+    
+    # initialize new indices for lines without ignore categories
+    no_ignores_gt_indices = set(range(len(no_ignores_gt_lines)))  
+    no_ignores_pred_indices = set(range(len(no_ignores_pred_lines)))  
+    
+    # exclude ignore categories
+    cost_matrix = compute_edit_distance_matrix_new(no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------cost matrix-------------")
+    # print(cost_matrix)
+
+    matched_col_idx, row_ind, cost_list = cal_final_match(cost_matrix, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------matched_col_idx-------------")
+    # print(matched_col_idx)
+    
+    # print("-------------gt_row_ind-------------")
+    # print(row_ind)
+
+    # print("-------------cost_list-------------")
+    # print(cost_list)
+        
+    gt_lens_dict, pred_lens_dict = initialize_indices(no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------gt_lens_dict-------------")
+    # print(gt_lens_dict)
+
+    # print("-------------pred_lens_dict-------------")
+    # print(pred_lens_dict)
+    
+    matches, unmatched_gt_indices, unmatched_pred_indices = process_matches(matched_col_idx, row_ind, cost_list, no_ignores_gt_lines, no_ignores_pred_lines, no_ignores_ori_pred_lines)
+
+    # print("-------------matches-------------")
+    # print(matches)
+
+    # print("-------------unmatched_gt_indices-------------")
+    # print(unmatched_gt_indices)
+
+    # print("-------------unmatched_pred_indices-------------")
+    # print(unmatched_pred_indices)
+    
+    matching_dict = fuzzy_match_unmatched_items(unmatched_gt_indices, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------matching_dict-------------")
+    # print(matching_dict)
+    
+    final_matches = merge_matches(matches, matching_dict)
+    # print("-------------final_matches-------------")
+    # print(final_matches)
+
+    recalculate_edit_distances(final_matches, gt_lens_dict, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------recalculate_edit_distances-------------")
+    # print(final_matches)
+    
+    converted_results = convert_final_matches(final_matches, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------converted_results-------------")
+    # print(converted_results)
+    
+    merged_results = merge_duplicates_add_unmatched(converted_results, no_ignores_gt_lines, no_ignores_pred_lines, no_ignores_ori_gt_lines, no_ignores_ori_pred_lines, no_ignores_gt_indices, no_ignores_pred_indices)
+
+    for entry in merged_results:
+        if entry['gt_idx'] != [""]:
+            ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+            gt_cagegory_clean = [no_ignores_gt_cat_list[_] for _ in entry['gt_idx'] if no_ignores_gt_cat_list[_] not in ignore_type] 
+            if gt_cagegory_clean:
+                entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+            else:
+                entry['gt_category_type'] = Counter([no_ignores_gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+        else:
+            entry['gt_category_type'] = ""
+            entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], no_ignores_pred_items) if entry['pred_idx'] != [""] else ""
+            if entry['pred_category_type'] == 'equation_inline':
+                merged_results.remove(entry)
+
+
+        entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+        entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+        entry['gt_position'] = [no_ignores_gt_items[_].get('order') if no_ignores_gt_items[_].get('order') else no_ignores_gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+        entry['pred_position'] = no_ignores_pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+        #  0507 多行公式拼接修改
+        if entry['gt_category_type'] == 'equation_isolated' and len(entry['gt_idx']) > 1:
+            mutli_formula  = ' \\\\ '.join(['{'+no_ignores_ori_gt_lines[_].strip('$$').strip('\n')+'}' for _ in  entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            mutli_formula = '\\\\begin{array}{l} ' + mutli_formula + ' \\\\end{array}'
+            entry['gt'] = mutli_formula
+        else:
+            entry['gt'] = ''.join([no_ignores_ori_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+
+        entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], no_ignores_pred_items) if entry['pred_idx'] != [""] else ""
+        entry['gt_attribute'] = [no_ignores_gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+        entry['img_id'] = img_name
+        
+        #  0724 多行公式拼接修改pred
+        if 'equation' in entry['pred_category_type'] and len(entry['pred_idx']) > 1:
+            mutli_formula  = ' \\\\ '.join(['{'+no_ignores_ori_pred_lines[_].strip('$$').strip('\n')+'}' for _ in  entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+            mutli_formula = '\\\\begin{array}{l} ' + mutli_formula + ' \\\\end{array}'
+            entry['pred'] = mutli_formula
+        else:
+            entry['pred'] = ''.join([no_ignores_ori_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+        entry['norm_gt'] = ''.join([no_ignores_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+        entry['norm_pred'] = ''.join([no_ignores_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+    
+    # print("-------------merged_results-------------")
+    # for i in merged_results:
+    #     print(i)
+    for entry in merged_results:
+        if isinstance(entry['gt_idx'], list) and entry['gt_idx'] != [""]:
+            gt_idx = []
+            for i in entry['gt_idx']:
+                gt_idx.append(no_ignores_gt_idxs[i])
+            entry['gt_idx'] = gt_idx
+        if isinstance(entry['pred_idx'], list) and entry['pred_idx'] != [""]:
+            pred_idx = []
+            for i in entry['pred_idx']:
+                pred_idx.append(int(no_ignore_pred_idxs[i]))
+            entry['pred_idx'] = pred_idx
+
+    if len(merged_ignore_results) > 0:
+        merged_results.extend(merged_ignore_results)
+        # for i in merged_ignore_results:
+        #     merged_results.append(i)
+
+    return merged_results
+
+    # cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+    
+    # matched_col_idx, row_ind, cost_list = cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines)
+    
+    # gt_lens_dict, pred_lens_dict = initialize_indices(norm_gt_lines, norm_pred_lines)
+    
+    # matches, unmatched_gt_indices, unmatched_pred_indices = process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines)
+    
+    # matching_dict = fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines)
+    
+    # final_matches = merge_matches(matches, matching_dict)
+    
+    # recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines)
+    
+    # converted_results = convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines)
+    
+    # merged_results = merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices)
+
+    # for entry in merged_results:
+    #         entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+    #         entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+    #         entry['gt_position'] = [gt_items[_].get('order') if gt_items[_].get('order') else gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+    #         entry['pred_position'] = pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+    #         entry['gt'] = ''.join([gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+    #         entry['pred'] = ''.join([pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+    #         entry['norm_gt'] = ''.join([norm_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+    #         entry['norm_pred'] = ''.join([norm_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+    #         if entry['gt_idx'] != [""]:
+    #             ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+    #             gt_cagegory_clean = [gt_cat_list[_] for _ in entry['gt_idx'] if gt_cat_list[_] not in ignore_type] 
+    #             if gt_cagegory_clean:
+    #                 entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+    #             else:
+    #                 entry['gt_category_type'] = Counter([gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+    #         else:
+    #             entry['gt_category_type'] = ""
+    #         entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], pred_items) if entry['pred_idx'] != [""] else ""
+    #         entry['gt_attribute'] = [gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+    #         entry['img_id'] = img_name
+        
+    # return merged_results
+
+
+def merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices):
+    merged_results = []
+    processed_pred = set()
+    processed_gt = set()
+
+    for entry in converted_results:
+        pred_idx = tuple(entry['pred_idx']) if isinstance(entry['pred_idx'], list) else (entry['pred_idx'],)
+        if pred_idx not in processed_pred and pred_idx != ("",):
+            merged_entry = {
+                'gt_idx': [entry['gt_idx']],
+                'gt': entry['gt'],
+                'pred_idx': entry['pred_idx'],
+                'pred': entry['pred'],
+                'edit': entry['edit']
+            }
+            for other_entry in converted_results:
+                other_pred_idx = tuple(other_entry['pred_idx']) if isinstance(other_entry['pred_idx'], list) else (other_entry['pred_idx'],)
+                if other_pred_idx == pred_idx and other_entry is not entry:
+                    merged_entry['gt_idx'].append(other_entry['gt_idx'])
+                    merged_entry['gt'] += other_entry['gt']
+                    processed_gt.add(other_entry['gt_idx'])
+            merged_results.append(merged_entry)
+            processed_pred.add(pred_idx)
+            processed_gt.add(entry['gt_idx'])
+
+    # for entry in converted_results:
+    #     if entry['gt_idx'] not in processed_gt:
+    #         merged_results.append(entry)
+
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx not in processed_gt:
+            merged_results.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'edit': 1
+            })
+    return merged_results
+
+
+
+
+def formula_format(formula_matches, img_name):
+    return [
+        {
+            "gt": item["gt"],
+            "pred": item["pred"],
+            "img_id": f"{img_name}_{i}"
+        }
+        for i, item in enumerate(formula_matches)
+    ]
+
+
+def merge_lists_with_sublists(main_list, sub_lists):
+    main_list_final = list(copy.deepcopy(main_list))
+    for sub_list in sub_lists:
+        pop_idx = main_list_final.index(sub_list[0])
+        for _ in sub_list: 
+            main_list_final.pop(pop_idx)
+        main_list_final.insert(pop_idx, sub_list) 
+    return main_list_final   
+
+
+def sub_pred_fuzzy_matching(gt, pred):
+    
+    min_d = float('inf')
+    # pos = -1
+
+    gt_len = len(gt)
+    pred_len = len(pred)
+
+    if gt_len >= pred_len and pred_len > 0:
+        for i in range(gt_len - pred_len + 1):
+            sub = gt[i:i + pred_len]
+            dist = Levenshtein_distance(sub, pred)/pred_len
+            if dist < min_d:
+                min_d = dist
+                pos = i
+
+        return min_d
+    else:
+        return False
+        
+def sub_gt_fuzzy_matching(pred, gt):  
+    
+    min_d = float('inf')  
+    pos = ""  
+    matched_sub = ""  
+    gt_len = len(gt)  
+    pred_len = len(pred)  
+    
+    if pred_len >= gt_len and gt_len > 0:  
+        for i in range(pred_len - gt_len + 1):  
+            sub = pred[i:i + gt_len]  
+            dist = Levenshtein.distance(sub, gt)  /gt_len
+            if dist < min_d:  
+                min_d = dist  
+                pos = i  
+                matched_sub = sub  
+        return min_d, pos, gt_len, matched_sub  
+    else:  
+        return 1, "", gt_len, "" 
+        
+        
+def get_final_subset(subset_certain, subset_certain_cost):
+    if not subset_certain or not subset_certain_cost:
+        return []  
+
+    subset_turple = sorted([(a, b) for a, b in zip(subset_certain, subset_certain_cost)], key=lambda x: x[0][0])
+
+    group_list = defaultdict(list)
+    group_idx = 0
+    group_list[group_idx].append(subset_turple[0])
+
+    for item in subset_turple[1:]:
+        overlap_flag = False
+        for subset in group_list[group_idx]:
+            for idx in item[0]:
+                if idx in subset[0]:
+                    overlap_flag = True
+                    break
+            if overlap_flag:
+                break
+        if overlap_flag:
+            group_list[group_idx].append(item)
+        else:
+            group_idx += 1
+            group_list[group_idx].append(item)
+
+    final_subset = []
+    for _, group in group_list.items():
+        if len(group) == 1: 
+            final_subset.append(group[0][0])
+        else:
+            path_dict = defaultdict(list)
+            path_idx = 0
+            path_dict[path_idx].append(group[0])
+            
+            for subset in group[1:]:
+                new_path = True
+                for path_idx_s, path_items in path_dict.items():
+                    is_dup = False
+                    is_same = False
+                    for path_item in path_items:
+                        if path_item[0] == subset[0]:
+                            is_dup = True
+                            is_same = True
+                            if path_item[1] > subset[1]:
+                                path_dict[path_idx_s].pop(path_dict[path_idx_s].index(path_item))
+                                path_dict[path_idx_s].append(subset)
+                        else:
+                            for num_1 in path_item[0]:
+                                for num_2 in subset[0]:
+                                    if num_1 == num_2:
+                                        is_dup = True
+                    if not is_dup:
+                        path_dict[path_idx_s].append(subset)
+                        new_path = False
+                    if is_same:
+                        new_path = False
+                if new_path:
+                    path_idx = len(path_dict.keys())
+                    path_dict[path_idx].append(subset)
+
+            saved_cost = float('inf')
+            saved_subset = []  
+            for path_idx, path in path_dict.items():
+                avg_cost = sum([i[1] for i in path]) / len(path)
+                if avg_cost < saved_cost:
+                    saved_subset = [i[0] for i in path]
+                    saved_cost = avg_cost
+
+            final_subset.extend(saved_subset)
+
+    return final_subset
+
+def judge_pred_merge(gt_list, pred_list, threshold=0.6):
+    if len(pred_list) == 1:
+        return False, False
+
+    cur_pred = ' '.join(pred_list[:-1])
+    merged_pred = ' '.join(pred_list)
+    
+    cur_dist = Levenshtein.distance(gt_list[0], cur_pred) / max(len(gt_list[0]), len(cur_pred))
+    merged_dist = Levenshtein.distance(gt_list[0], merged_pred) / max(len(gt_list[0]), len(merged_pred))
+    
+    if merged_dist > cur_dist:
+        return False, False
+
+    cur_fuzzy_dists = [sub_pred_fuzzy_matching(gt_list[0], cur_pred) for cur_pred in pred_list[:-1]]
+    if any(dist is False or dist > threshold for dist in cur_fuzzy_dists):
+        return False, False
+
+    add_fuzzy_dist = sub_pred_fuzzy_matching(gt_list[0], pred_list[-1])
+    if add_fuzzy_dist is False:
+        return False, False
+
+    merged_pred_flag = add_fuzzy_dist < threshold
+    continue_flag = len(merged_pred) <= len(gt_list[0])
+
+    return merged_pred_flag, continue_flag
+    
+def deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines):
+    matched_first = np.argwhere(cost_matrix < 0.25)
+    masked_gt_idx = [i[0] for i in matched_first]
+    unmasked_gt_idx = [i for i in range(cost_matrix.shape[0]) if i not in masked_gt_idx]
+    masked_pred_idx = [i[1] for i in matched_first]
+    unmasked_pred_idx = [i for i in range(cost_matrix.shape[1]) if i not in masked_pred_idx]
+
+    merges_gt_dict = {}
+    merges_pred_dict = {}
+    merged_gt_subsets = []
+
+    for gt_idx in unmasked_gt_idx:
+        check_merge_subset = []
+        merged_dist = []
+
+        for pred_idx in unmasked_pred_idx: 
+            step = 1
+            merged_pred = [norm_pred_lines[pred_idx]]
+
+            while True:
+                if pred_idx + step in masked_pred_idx or pred_idx + step >= len(norm_pred_lines):
+                    break
+                else:
+                    merged_pred.append(norm_pred_lines[pred_idx + step])
+                    merged_pred_flag, continue_flag = judge_pred_merge([norm_gt_lines[gt_idx]], merged_pred) 
+                    if not merged_pred_flag:
+                        break
+                    else:
+                        step += 1
+                    if not continue_flag:
+                        break
+
+            check_merge_subset.append(list(range(pred_idx, pred_idx + step)))
+            matched_line = ' '.join([norm_pred_lines[i] for i in range(pred_idx, pred_idx + step)])
+            dist = Levenshtein_distance(norm_gt_lines[gt_idx], matched_line) / max(len(matched_line), len(norm_gt_lines[gt_idx]))
+            merged_dist.append(dist)
+
+        if not merged_dist:
+            subset_certain = []
+            min_cost_idx = ""
+            min_cost = float('inf')
+        else:
+            min_cost = min(merged_dist)
+            min_cost_idx = merged_dist.index(min_cost)
+            subset_certain = check_merge_subset[min_cost_idx]
+
+        merges_gt_dict[gt_idx] = {
+            'merge_subset': check_merge_subset,
+            'merged_cost': merged_dist,
+            'min_cost_idx': min_cost_idx,
+            'subset_certain': subset_certain,
+            'min_cost': min_cost
+        }
+
+    subset_certain = [merges_gt_dict[gt_idx]['subset_certain'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+    subset_certain_cost = [merges_gt_dict[gt_idx]['min_cost'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+
+    subset_certain_final = get_final_subset(subset_certain, subset_certain_cost)
+
+    if not subset_certain_final:  
+        return cost_matrix, norm_pred_lines, range(len(norm_pred_lines))
+
+    final_pred_idx_list = merge_lists_with_sublists(range(len(norm_pred_lines)), subset_certain_final)
+    final_norm_pred_lines = [' '.join(norm_pred_lines[idx_list[0]:idx_list[-1]+1]) if isinstance(idx_list, list) else norm_pred_lines[idx_list] for idx_list in final_pred_idx_list]
+
+    new_cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, final_norm_pred_lines)
+
+    return new_cost_matrix, final_norm_pred_lines, final_pred_idx_list
+    
+def cal_move_dist(gt, pred):
+    assert len(gt) == len(pred), 'Not right length'
+    step = 0
+    for i, gt_c in enumerate(gt):
+        if gt_c != pred[i]:
+            step += abs(i - pred.index(gt_c))
+            pred[i], pred[pred.index(gt_c)] = pred[pred.index(gt_c)], pred[i]
+    return step / len(gt)
+
+def cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines):
+    # min_indice = cost_matrix.argmax(axis=1)
+
+    new_cost_matrix, final_norm_pred_lines, final_pred_idx_list = deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(new_cost_matrix)
+
+    cost_list = [new_cost_matrix[r][c] for r, c in zip(row_ind, col_ind)]
+    matched_col_idx = [final_pred_idx_list[i] for i in col_ind]
+
+    return matched_col_idx, row_ind, cost_list
+
+def initialize_indices(norm_gt_lines, norm_pred_lines):
+    gt_lens_dict = {idx: len(gt_line) for idx, gt_line in enumerate(norm_gt_lines)}
+    pred_lens_dict = {idx: len(pred_line) for idx, pred_line in enumerate(norm_pred_lines)}
+    return gt_lens_dict, pred_lens_dict
+
+def process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines):
+    matches = {}
+    unmatched_gt_indices = []
+    unmatched_pred_indices = []
+
+    for i in range(len(norm_gt_lines)):
+        if i in row_ind:
+            idx = list(row_ind).index(i)
+            pred_idx = matched_col_idx[idx]
+
+            if pred_idx is None or (isinstance(pred_idx, list) and None in pred_idx):
+                unmatched_pred_indices.append(pred_idx)
+                continue
+
+            if isinstance(pred_idx, list):
+                pred_line = ' | '.join(norm_pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                ori_pred_line = ' | '.join(pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                matched_pred_indices_range = list(range(pred_idx[0], pred_idx[-1]+1))
+            else:
+                pred_line = norm_pred_lines[pred_idx]
+                ori_pred_line = pred_lines[pred_idx]
+                matched_pred_indices_range = [pred_idx]
+
+            edit = cost_list[idx]
+
+            if edit > 0.7:
+                unmatched_pred_indices.extend(matched_pred_indices_range)
+                unmatched_gt_indices.append(i)
+            else:
+                matches[i] = {
+                    'pred_indices': matched_pred_indices_range,
+                    'edit_distance': edit,
+                }
+                for matched_pred_idx in matched_pred_indices_range:
+                    if matched_pred_idx in unmatched_pred_indices:
+                        unmatched_pred_indices.remove(matched_pred_idx)
+        else:
+            unmatched_gt_indices.append(i)
+
+    return matches, unmatched_gt_indices, unmatched_pred_indices
+
+def fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines):
+    matching_dict = {}
+
+    for pred_idx, pred_content in enumerate(norm_pred_lines):
+        if isinstance(pred_idx, list):
+            continue
+
+        matching_indices = []
+
+        for unmatched_gt_idx in unmatched_gt_indices:
+            gt_content = norm_gt_lines[unmatched_gt_idx]
+            cur_fuzzy_dist_unmatch, cur_pos, gt_lens, matched_field = sub_gt_fuzzy_matching(pred_content, gt_content)
+            if cur_fuzzy_dist_unmatch < 0.4:
+                matching_indices.append(unmatched_gt_idx)
+
+        if matching_indices:
+            matching_dict[pred_idx] = matching_indices
+
+    return matching_dict
+
+def merge_matches(matches, matching_dict):
+    final_matches = {}
+    processed_gt_indices = set() 
+
+    for gt_idx, match_info in matches.items():
+        pred_indices = match_info['pred_indices']
+        edit_distance = match_info['edit_distance']
+
+        pred_key = tuple(sorted(pred_indices))
+
+        if pred_key in final_matches:
+            if gt_idx not in processed_gt_indices:
+                final_matches[pred_key]['gt_indices'].append(gt_idx)
+                processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx],
+                'edit_distance': edit_distance
+            }
+            processed_gt_indices.add(gt_idx)
+
+    for pred_idx, gt_indices in matching_dict.items():
+        pred_key = (pred_idx,) if not isinstance(pred_idx, (list, tuple)) else tuple(sorted(pred_idx))
+
+        if pred_key in final_matches:
+            for gt_idx in gt_indices:
+                if gt_idx not in processed_gt_indices:
+                    final_matches[pred_key]['gt_indices'].append(gt_idx)
+                    processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx for gt_idx in gt_indices if gt_idx not in processed_gt_indices],
+                'edit_distance': None
+            }
+            processed_gt_indices.update(final_matches[pred_key]['gt_indices'])
+
+    return final_matches
+    
+
+
+def recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines):
+    for pred_key, info in final_matches.items():
+        gt_indices = sorted(set(info['gt_indices']))
+
+        if not gt_indices:
+            info['edit_distance'] = 1
+            continue
+
+        if len(gt_indices) > 1:
+            merged_gt_content = ''.join(norm_gt_lines[gt_idx] for gt_idx in gt_indices)
+            pred_content = norm_pred_lines[pred_key[0]] if isinstance(pred_key[0], int) else ''
+
+            try:
+                edit_distance = Levenshtein_distance(merged_gt_content, pred_content)
+                normalized_edit_distance = edit_distance / max(len(merged_gt_content), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+        else:
+            gt_idx = gt_indices[0]
+            pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+
+            try:
+                edit_distance = Levenshtein_distance(norm_gt_lines[gt_idx], pred_content)
+                normalized_edit_distance = edit_distance / max(len(norm_gt_lines[gt_idx]), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+            info['pred_content'] = pred_content
+
+
+def convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines):
+    converted_results = []
+
+    all_gt_indices = set(range(len(norm_gt_lines)))
+    all_pred_indices = set(range(len(norm_pred_lines)))
+
+    for pred_key, info in final_matches.items():
+        pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+        
+        for gt_idx in sorted(set(info['gt_indices'])):
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': list(pred_key),
+                'pred': pred_content,
+                'edit': info['edit_distance']
+            }
+            converted_results.append(result_entry)
+    
+    matched_gt_indices = set().union(*[set(info['gt_indices']) for info in final_matches.values()])
+    unmatched_gt_indices = all_gt_indices - matched_gt_indices
+    matched_pred_indices = set(idx for pred_key in final_matches.keys() for idx in pred_key if isinstance(idx, int))
+    unmatched_pred_indices = all_pred_indices - matched_pred_indices
+
+    if unmatched_pred_indices:
+        if unmatched_gt_indices:
+            distance_matrix = [
+                # [Levenshtein_distance(norm_gt_lines[gt_idx], norm_pred_lines[pred_idx]) for pred_idx in unmatched_pred_indices]
+                [Levenshtein_distance(norm_gt_lines[gt_idx], norm_pred_lines[pred_idx])/max(len(norm_gt_lines[gt_idx]), len(norm_pred_lines[pred_idx])) for pred_idx in unmatched_pred_indices]
+                for gt_idx in unmatched_gt_indices
+            ]
+
+            row_ind, col_ind = linear_sum_assignment(distance_matrix)
+
+            for i, j in zip(row_ind, col_ind):
+                gt_idx = list(unmatched_gt_indices)[i]
+                pred_idx = list(unmatched_pred_indices)[j]
+                result_entry = {
+                    'gt_idx': int(gt_idx),
+                    'gt': norm_gt_lines[gt_idx],
+                    'pred_idx': [pred_idx],
+                    'pred': norm_pred_lines[pred_idx],
+                    'edit': 1
+                }
+                converted_results.append(result_entry)
+
+            matched_gt_indices.update(list(unmatched_gt_indices)[i] for i in row_ind)
+        else:
+            result_entry = {
+                'gt_idx': "",
+                'gt': '',
+                'pred_idx': list(unmatched_pred_indices),
+                'pred': ' '.join(norm_pred_lines[pred_idx] for pred_idx in unmatched_pred_indices),
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+    else:
+        for gt_idx in unmatched_gt_indices:
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': "",
+                'pred': '',
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+
+    return converted_results

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/table_utils.py

@@ -0,0 +1,100 @@
+import re
+
+
+def markdown_to_html(markdown_table):
+    rows = [row.strip() for row in markdown_table.strip().split('\n') if row.strip()]
+    if len(rows) < 2:
+        return markdown_table
+
+    html_table = '<table>\n  <thead>\n    <tr>\n'
+    header_cells = [cell.strip() for cell in rows[0].split('|')[1:-1]]
+    for cell in header_cells:
+        html_table += f'      <th>{cell}</th>\n'
+    html_table += '    </tr>\n  </thead>\n  <tbody>\n'
+
+    for row in rows[2:]:
+        cells = [cell.strip() for cell in row.split('|')[1:-1]]
+        html_table += '    <tr>\n'
+        for cell in cells:
+            html_table += f'      <td>{cell}</td>\n'
+        html_table += '    </tr>\n'
+
+    html_table += '  </tbody>\n</table>\n'
+    return html_table
+
+
+def convert_table_str(s):
+    s = re.sub(r'<table.*?>', '<table>', s)
+    s = re.sub(r'<th', '<td', s)
+    s = re.sub(r'</th>', '</td>', s)
+    res = '\n\n'
+    temp_item = ''
+    for c in s:
+        temp_item += c
+        if c == '>' and not re.search(r'<td.*?>\$', temp_item):
+            res += temp_item + '\n'
+            temp_item = ''
+    return res + '\n'
+
+
+def find_md_table_mode(line):
+    return bool(re.search(r'-*?:', line) or re.search(r'---', line) or re.search(r':-*?', line))
+
+
+def delete_table_and_body(input_list):
+    return [line for line in input_list if not re.search(r'</?t(able|head|body)>', line)]
+
+
+def merge_table(md):
+    return convert_table_str(''.join(md))
+
+
+def replace_table_with_placeholder(input_string):
+    lines = input_string.split('\n')
+    output_lines = []
+    in_table_block = False
+    temp_block = ''
+    last_line = ''
+
+    for line in lines:
+        if '<table>' in line:
+            in_table_block = True
+            temp_block += last_line
+        elif in_table_block:
+            if not find_md_table_mode(last_line) and '</thead>' not in last_line:
+                temp_block += '\n' + last_line
+            if '</table>' in last_line:
+                if '<table>' not in line:
+                    in_table_block = False
+                    output_lines.append(merge_table(temp_block))
+                    temp_block = ''
+        else:
+            output_lines.append(last_line)
+        last_line = line
+
+    if last_line:
+        if in_table_block or '</table>' in last_line:
+            temp_block += '\n' + last_line
+            output_lines.append(merge_table(temp_block))
+        else:
+            output_lines.append(last_line)
+
+    return '\n'.join(output_lines)
+
+
+def convert_table(input_str):
+    output_str = input_str.replace('<table>', '<table border="1" >')
+    output_str = output_str.replace('<td>', '<td colspan="1" rowspan="1">')
+    return output_str
+
+
+def convert_markdown_to_html(markdown_content):
+    markdown_content = markdown_content.replace('\r', '') + '\n'
+    pattern = re.compile(r'\|\s*.*?\s*\|\n', re.DOTALL)
+    matches = pattern.findall(markdown_content)
+
+    for match in matches:
+        html_table = markdown_to_html(match)
+        markdown_content = markdown_content.replace(match, html_table, 1)
+
+    return convert_table(replace_table_with_placeholder(markdown_content))

FinixDocBench_Eval_for_Markdown/requirements.txt

@@ -0,0 +1,8 @@
+python-Levenshtein==0.25.1
+apted==1.0.3
+lxml==4.9.4
+beautifulsoup4==4.12.3
+tqdm==4.66.4
+pylatexenc==2.10
+numpy==1.26.4
+scipy==1.13.1

FinixDocBench_Eval_for_Markdown/run_eval.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+
+from finixdoc_md_eval.omnidocbench_adapter import evaluate_md_dirs
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Evaluate Markdown OCR/parsing results with text, reading-order, and table metrics."
+    )
+    parser.add_argument("--gt_dir", required=True, help="Directory containing ground-truth .md files.")
+    parser.add_argument("--pred_dir", required=True, help="Directory containing prediction .md files.")
+    parser.add_argument(
+        "--output_json",
+        default="eval_result.json",
+        help="Path to write metric results. Default: eval_result.json",
+    )
+    parser.add_argument(
+        "--allow_name_mismatch",
+        action="store_true",
+        help="Do not fail when gt/pred .md file names differ. Missing predictions are scored as empty.",
+    )
+    return parser.parse_args()
+
+
+def md_names(path):
+    return {p.name for p in Path(path).iterdir() if p.is_file() and p.suffix == ".md"}
+
+
+def validate_inputs(gt_dir, pred_dir, allow_name_mismatch=False):
+    gt_path = Path(gt_dir)
+    pred_path = Path(pred_dir)
+    if not gt_path.is_dir():
+        raise ValueError(f"GT directory does not exist: {gt_path}")
+    if not pred_path.is_dir():
+        raise ValueError(f"Prediction directory does not exist: {pred_path}")
+
+    gt_files = md_names(gt_path)
+    pred_files = md_names(pred_path)
+    if not gt_files:
+        raise ValueError(f"No .md files found in GT directory: {gt_path}")
+    if not pred_files:
+        raise ValueError(f"No .md files found in prediction directory: {pred_path}")
+
+    missing = sorted(gt_files - pred_files)
+    extra = sorted(pred_files - gt_files)
+    if not allow_name_mismatch and (missing or extra):
+        message = [
+            "GT and prediction .md file names must match.",
+            f"GT files: {len(gt_files)}",
+            f"Prediction files: {len(pred_files)}",
+        ]
+        if missing:
+            message.append(f"Missing predictions: {len(missing)}; first: {missing[0]}")
+        if extra:
+            message.append(f"Unexpected predictions: {len(extra)}; first: {extra[0]}")
+        raise ValueError(" ".join(message))
+
+    return {
+        "gt_files": len(gt_files),
+        "pred_files": len(pred_files),
+        "missing_predictions": len(missing),
+        "unexpected_predictions": len(extra),
+    }
+
+
+def rounded_metrics(metrics):
+    clean = {}
+    for key, value in metrics.items():
+        if isinstance(value, float):
+            clean[key] = None if math.isnan(value) else round(value, 6)
+        else:
+            clean[key] = value
+    clean["score"] = clean["overall"]
+    return clean
+
+
+def main():
+    args = parse_args()
+    try:
+        input_summary = validate_inputs(args.gt_dir, args.pred_dir, args.allow_name_mismatch)
+        metrics = evaluate_md_dirs(args.gt_dir, args.pred_dir)
+        result = {
+            "success": True,
+            "metrics": rounded_metrics(metrics),
+            "inputs": input_summary,
+        }
+        output_path = Path(args.output_json)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+
+        print("FinixDoc Markdown Evaluation")
+        print(f"  samples: {metrics['num_samples']}")
+        print(f"  text_block_Edit_dist: {metrics['text_block_Edit_dist']:.6f}")
+        print(f"  reading_order_Edit_dist: {metrics['reading_order_Edit_dist']:.6f}")
+        print(f"  table_TEDS: {metrics['table_TEDS']:.6f}")
+        print(f"  overall: {metrics['overall']:.6f}")
+        print(f"  result_json: {output_path}")
+    except Exception as exc:
+        result = {
+            "success": False,
+            "error": str(exc),
+        }
+        output_path = Path(args.output_json)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+        print(f"Evaluation failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

LICENSE.md

@@ -0,0 +1,47 @@
+# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+
+SPDX-License-Identifier: CC-BY-NC-SA-4.0
+
+Copyright (c) 2026 Ant Group and the FinixDocBench authors.
+
+This FinixDocBench release, including page images, Markdown ground truth, structured JSON annotations, benchmark metadata, and accompanying evaluation materials unless otherwise stated, is released under the **Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0)**.
+
+Official license deed:
+
+https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Official legal code:
+
+https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
+
+## Human-Readable Summary
+
+Under CC BY-NC-SA 4.0, you may share and adapt the licensed material for non-commercial purposes, provided that you give appropriate credit, indicate if changes were made, and distribute adaptations under the same license.
+
+This summary is provided for convenience only. If there is any inconsistency, the official Creative Commons legal code governs.
+
+## Attribution
+
+If you use this FinixDocBench release, please cite the FinixDoc technical report:
+
+```bibtex
+@misc{wang2026finixdoc,
+  title        = {FinixDoc: Rethinking Financial Document Parsing Beyond Saturated Benchmarks},
+  author       = {Hang Wang and Jin Zhang and Guoliang Xu and Pengyue Lu and Yao Li and Zijiao Zhang and Tianyu Huang and Weiqi Xiong and Yulong Wang and Chuqiao Lu and Wenkang Huang and Kai Yang and Yadong Li and Hui Li and Xingzhong Xu and Xiao Xu},
+  year         = {2026},
+  institution  = {Ant Group},
+  url          = {https://finix.alipay.com}
+}
+```
+
+## Benchmark Integrity Notice
+
+This FinixDocBench release is intended for research, benchmark evaluation, academic comparison, and reproducibility studies of OCR and document parsing systems.
+
+If you use the benchmark labels, annotations, or ground truth for model training, fine-tuning, data augmentation, prompt optimization, or any other model-improvement process, please do not report the resulting model performance as an official FinixDocBench benchmark result.
+
+The dataset is not intended for individual profiling, personal information extraction, identity inference, or automated financial, medical, insurance, legal, employment, credit, or similarly consequential decision-making.
+
+## No Warranty
+
+This FinixDocBench release is provided as-is, without warranty of any kind, express or implied, including but not limited to warranties of accuracy, completeness, merchantability, fitness for a particular purpose, and non-infringement.

README.md

@@ -0,0 +1,375 @@
+---
+license: cc-by-nc-sa-4.0
+language:
+  - zh
+  - en
+task_categories:
+  - image-to-text
+  - object-detection
+pretty_name: FinixDocBench
+size_categories:
+  - "100<n<1K"
+tags:
+  - document-parsing
+  - ocr
+  - financial-documents
+  - layout-analysis
+  - table-recognition
+  - reading-order
+  - camera-captured-documents
+  - ultra-large-documents
+  - markdown
+  - chinese
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path:
+          - metadata.jsonl
+          - track*/images/*.png
+---
+
+# FinixDocBench
+
+This repository contains a compliance-reviewed public subset of **FinixDocBench**, the financial-domain document parsing benchmark introduced in the technical report **"FinixDoc: Rethinking Financial Document Parsing Beyond Saturated Benchmarks"**.
+
+The benchmark focuses on document parsing conditions that are common in real financial workflows but underrepresented in saturated clean-document benchmarks: digitally native insurance clauses, noisy camera-captured medical receipts, ultra-long pages, and very large dense tables. The expected model outputs are page-level Markdown and, where available, structured JSON layout annotations.
+
+Project links:
+
+- Project page: https://finix.alipay.com/
+- Hugging Face dataset: https://huggingface.co/datasets/inclusionAI/FinixDocBench
+- License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+
+## Released Subset Contents
+
+This release contains **742 page samples** from the broader FinixDocBench benchmark. Track 3 is split into two directories so that ultra-long pages and large-table pages can be evaluated separately.
+
+| Track | Directory | Source type | Pages | Files per sample | Main task |
+|---|---|---|---:|---|---|
+| FinixDigital | `track1_finixdigital_242_insurance_terms/` | Digitally native insurance terms | 242 | image + Markdown + JSON | Markdown parsing and structured layout parsing |
+| FinixPhoto | `track2_finixphoto_300/` | Mobile-captured medical receipts | 300 | image + Markdown + JSON | Robust Markdown parsing and structured layout parsing |
+| FinixHuge-Long | `track3_finixhuge_100_long/` | Ultra-long financial or insurance pages | 100 | image + Markdown | Ultra-large page Markdown parsing |
+| FinixHuge-Table | `track3_finixhuge_100_table/` | Large dense table pages | 100 | image + Markdown | Ultra-large table reconstruction |
+
+The full FinixDocBench described in the technical report also includes a larger internal evaluation track, **FinixInner**, which is not included in this release because of privacy and compliance constraints. The FinixDigital package here is a 242-page insurance-terms subset of the broader FinixDigital track discussed in the report.
+
+## Repository Structure
+
+```text
+FinixDocBench/
+  README.md
+  LICENSE.md
+  CITATION.cff
+  dataset_manifest.jsonl
+  metadata.jsonl
+  track1_finixdigital_242_insurance_terms/
+    images/
+    mds/
+    jsons/
+  track2_finixphoto_300/
+    images/
+    mds/
+    jsons/
+  track3_finixhuge_100_long/
+    images/
+    mds/
+  track3_finixhuge_100_table/
+    images/
+    mds/
+  FinixDocBench_Eval_for_Markdown/
+    README.md
+    requirements.txt
+    run_eval.py
+    finixdoc_md_eval/
+```
+
+Each sample is matched by file stem. For example, `abc123.png`, `abc123.md`, and `abc123.json` describe the same page when all three files are present.
+
+The `dataset_manifest.jsonl` file provides one row per sample with relative paths, track metadata, image dimensions, and basic annotation counts. It is intended as a lightweight index for users who want to load the release programmatically.
+
+## Tasks
+
+This FinixDocBench release supports three complementary task settings.
+
+### 1. Full-Page Markdown Parsing
+
+Given a page image, a model should produce a complete page-level Markdown reconstruction. This task is available for all public tracks.
+
+The Markdown ground truth preserves text order, headings, tables, and other page-level structure. HTML `<table>` blocks are used where table structure, merged cells, or dense financial layouts need to be represented more faithfully than plain Markdown tables.
+
+### 2. Structured Layout Parsing
+
+Given a page image, a model should produce structured page elements with category labels, bounding boxes, transcribed content, and reading order. This task is available for FinixDigital and FinixPhoto, which include `jsons/` annotations.
+
+The public JSON files use pixel-space bounding boxes in the original image coordinate system. Each JSON file includes page metadata plus a `layout` list.
+
+### 3. Ultra-Large Page Processability
+
+FinixHuge-Long and FinixHuge-Table evaluate whether a system can return a syntactically valid, non-empty, page-level Markdown result for oversized documents. These pages stress page resolution, output length, table complexity, and reading-order preservation.
+
+Because FinixHuge is Markdown-only in this release, it is best evaluated with Markdown metrics plus a success-rate style processability check.
+
+## Annotation Schema
+
+FinixDigital and FinixPhoto use a unified 10-class page-element schema:
+
+```text
+page-header
+page-footer
+title
+section-header
+text
+table
+figure
+caption
+footnote
+other
+```
+
+Top-level JSON fields:
+
+| Field | Description |
+|---|---|
+| `width` | Original page image width in pixels. |
+| `height` | Original page image height in pixels. |
+| `resized_width` | Width used by the annotation or preprocessing pipeline. |
+| `resized_height` | Height used by the annotation or preprocessing pipeline. |
+| `max_pixels` | Maximum pixel budget recorded by the preprocessing pipeline. |
+| `min_pixels` | Minimum pixel budget recorded by the preprocessing pipeline. |
+| `layout` | Ordered list of page elements. |
+
+Each `layout` item contains:
+
+| Field | Description |
+|---|---|
+| `category` | One of the 10 page-element labels. |
+| `bbox` | Pixel-space bounding box `[x1, y1, x2, y2]` in the page image coordinate system. |
+| `content` | Transcribed text, Markdown structural marker, or serialized table content. This field may be absent for some `figure` elements. |
+| `order` | Reading-order index of the layout element. |
+
+Example:
+
+```json
+{
+  "width": 993,
+  "height": 1404,
+  "resized_width": 992,
+  "resized_height": 1408,
+  "max_pixels": 16777216,
+  "min_pixels": 4096,
+  "layout": [
+    {
+      "category": "section-header",
+      "bbox": [82, 364, 223, 394],
+      "content": "## 2.3 责任免除",
+      "order": 5
+    },
+    {
+      "category": "table",
+      "bbox": [337, 156, 916, 295],
+      "content": "<table>...</table>",
+      "order": 3
+    }
+  ]
+}
+```
+
+## Dataset Statistics
+
+| Track | Images | Markdown files | JSON files | Notes |
+|---|---:|---:|---:|---|
+| FinixDigital | 242 | 242 | 242 | 6,223 structured layout elements; 214 tables |
+| FinixPhoto | 300 | 300 | 300 | 8,517 structured layout elements; 224 tables |
+| FinixHuge-Long | 100 | 100 | 0 | Ultra-long page images, up to 287M pixels |
+| FinixHuge-Table | 100 | 100 | 0 | Large dense table images, up to 386M pixels |
+| **Total** | **742** | **742** | **542** | All samples have paired images and Markdown |
+
+Category counts for the structured JSON tracks:
+
+| Category | Count |
+|---|---:|
+| `text` | 10,158 |
+| `section-header` | 1,522 |
+| `figure` | 1,307 |
+| `title` | 504 |
+| `table` | 438 |
+| `caption` | 265 |
+| `page-footer` | 223 |
+| `footnote` | 204 |
+| `page-header` | 64 |
+| `other` | 55 |
+
+## Loading Examples
+
+Load the manifest with the Hugging Face `datasets` library:
+
+```python
+from datasets import load_dataset
+
+manifest = load_dataset(
+    "json",
+    data_files="dataset_manifest.jsonl",
+    split="train",
+)
+
+print(manifest[0])
+```
+
+Read a sample locally after cloning the repository:
+
+```python
+from pathlib import Path
+from PIL import Image
+import json
+
+repo = Path("FinixDocBench")
+row = manifest[0]
+
+image = Image.open(repo / row["image_path"])
+markdown = (repo / row["markdown_path"]).read_text(encoding="utf-8")
+
+annotation = None
+if row["json_path"] is not None:
+    annotation = json.loads((repo / row["json_path"]).read_text(encoding="utf-8"))
+```
+
+## Evaluation
+
+The repository includes a lightweight Markdown evaluator:
+
+```bash
+cd FinixDocBench_Eval_for_Markdown
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+Run evaluation on a track by providing a ground-truth Markdown directory and a prediction Markdown directory with matching file names:
+
+```bash
+python run_eval.py \
+  --gt_dir ../track2_finixphoto_300/mds \
+  --pred_dir /path/to/predicted_mds \
+  --output_json outputs/finixphoto_result.json
+```
+
+The Markdown evaluator reports:
+
+| Metric | Direction | Description |
+|---|---|---|
+| `text_block_Edit_dist` | Lower is better | Normalized edit distance over matched text blocks. |
+| `reading_order_Edit_dist` | Lower is better | Normalized edit distance over serialized reading-order sequences. |
+| `table_TEDS` | Higher is better | Tree-edit-distance-based table similarity, scaled to 0-100. |
+| `overall` | Higher is better | Composite score on a 0-100 scale. |
+
+The overall score is:
+
+```text
+overall = ((1 - text_block_Edit_dist) * 100
+         + (1 - reading_order_Edit_dist) * 100
+         + table_TEDS) / 3
+```
+
+For FinixHuge, users should additionally report a success rate: the fraction of pages for which the system returns a syntactically valid, non-empty page-level Markdown result without runtime failure, severe truncation, or format errors that prevent downstream evaluation.
+
+Structured JSON annotations are provided for FinixDigital and FinixPhoto. This repository currently ships the Markdown evaluator; if you report structured layout metrics, please describe the evaluator, matching rules, and coordinate convention used.
+
+## Reference Results from the Technical Report
+
+The following values are copied from the FinixDoc technical report for context. They correspond to the benchmark protocol reported in the paper and should not be treated as precomputed scores for every subset in this release unless the same split and evaluation protocol are reproduced.
+
+### FinixDigital
+
+| Model | Overall | TextEdit | TableTEDS | TableTEDS-S | ReadOrderEdit |
+|---|---:|---:|---:|---:|---:|
+| Qwen3-VL-4B | 80.18 | 0.145 | 76.04 | 81.23 | 0.210 |
+| FinixDoc-VL | 93.19 | 0.039 | 92.07 | 93.67 | 0.086 |
+| DeepSeek-OCR-2 | 82.80 | 0.139 | 90.00 | 92.32 | 0.277 |
+| FireRed-OCR | 83.10 | 0.119 | 87.10 | 89.14 | 0.259 |
+| PaddleOCR-VL-1.5 | 85.41 | 0.116 | 86.12 | 88.26 | 0.183 |
+| GLM-OCR | 86.28 | 0.121 | 89.44 | 90.99 | 0.185 |
+| Youtu-Parsing | 89.26 | 0.091 | 87.79 | 90.85 | 0.109 |
+| Dots.OCR | 90.36 | 0.058 | 89.78 | 92.26 | 0.129 |
+| MinerU 2.5 | 92.96 | 0.045 | 91.18 | 92.70 | 0.078 |
+| Qwen3.5-397B-A17B | 84.90 | 0.119 | 87.30 | 89.51 | 0.207 |
+| Kimi-K2.5 | 85.05 | 0.119 | 85.95 | 88.24 | 0.189 |
+| Qwen3-VL-235B-A22B-Instruct | 87.26 | 0.076 | 82.77 | 85.44 | 0.134 |
+
+### FinixPhoto
+
+| Model | Overall | TextEdit | TableTEDS | TableTEDS-S | ReadOrderEdit |
+|---|---:|---:|---:|---:|---:|
+| Qwen3-VL-4B | 54.28 | 0.408 | 50.13 | 63.04 | 0.465 |
+| FinixDoc-VL | 67.03 | 0.276 | 69.08 | 77.69 | 0.404 |
+| PaddleOCR-VL-1.5 | 41.28 | 0.512 | 34.54 | 46.72 | 0.595 |
+| MinerU 2.5 | 43.08 | 0.513 | 35.54 | 48.58 | 0.550 |
+| DeepSeek-OCR-2 | 43.20 | 0.459 | 30.69 | 43.52 | 0.552 |
+| GLM-OCR | 45.82 | 0.521 | 50.47 | 60.22 | 0.609 |
+| FireRed-OCR | 47.20 | 0.487 | 38.50 | 53.72 | 0.482 |
+| Dots.OCR | 52.57 | 0.399 | 44.90 | 56.92 | 0.473 |
+| Youtu-Parsing | 60.90 | 0.345 | 59.01 | 66.23 | 0.418 |
+| Qwen3.5-397B-A17B | 62.58 | 0.384 | 62.04 | 71.82 | 0.359 |
+| Qwen3-VL-235B-A22B-Instruct | 62.65 | 0.359 | 63.55 | 72.13 | 0.397 |
+| Kimi-K2.5 | 65.55 | 0.325 | 70.16 | 77.34 | 0.410 |
+
+### FinixHuge
+
+| Model | Success Rate | Overall | TextEdit | TableTEDS | TableTEDS-S | ReadOrderEdit |
+|---|---:|---:|---:|---:|---:|---:|
+| FinixDoc | 0.92 | 68.23 | 0.357 | 57.09 | 60.10 | 0.167 |
+| Qwen3-VL-235B-A22B-Instruct | 0.68 | 34.85 | 0.847 | 47.05 | 63.20 | 0.578 |
+| GLM-OCR | 0.34 | 38.06 | 0.816 | 59.39 | 62.43 | 0.636 |
+
+## Intended Uses
+
+This dataset is intended for:
+
+- Evaluating OCR and document parsing systems on financial-domain documents.
+- Testing full-page Markdown reconstruction.
+- Testing layout parsing, table parsing, bounding boxes, and reading-order recovery on FinixDigital and FinixPhoto.
+- Measuring robustness on noisy camera-captured receipt images.
+- Evaluating end-to-end processability on ultra-large document pages.
+
+## Out-of-Scope Uses
+
+This dataset is not intended for:
+
+- Individual profiling or personal information extraction.
+- Automated financial, medical, insurance, legal, employment, credit, or similarly consequential decision-making.
+- Reporting benchmark numbers after using benchmark labels or ground truth for training, fine-tuning, data augmentation, or prompt optimization.
+- Claiming complete coverage of all financial document scenarios.
+
+## Limitations
+
+FinixDocBench is an evaluation benchmark, not a comprehensive training corpus. This release covers selected high-value financial document parsing scenarios and does not include the private FinixInner track.
+
+FinixPhoto is derived from public-scenario medical receipt sources and re-annotated under the FinixDocBench schema. Prior exposure of some external models to the original public sources cannot be fully ruled out.
+
+FinixHuge emphasizes system-level processability with Markdown-only public annotations. Direct single-pass model comparisons may understate or overstate practical usability if failed pages, truncation, or invalid outputs are not reported consistently.
+
+Some page images may be very large. Users should use image loading libraries carefully and configure decompression or pixel limits intentionally when evaluating FinixHuge.
+
+## License
+
+This FinixDocBench release is distributed under the **Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0)**.
+
+See [LICENSE.md](LICENSE.md) for the human-readable license notice and the official Creative Commons license link.
+
+## Citation
+
+If you use this FinixDocBench release, please cite:
+
+```bibtex
+@misc{wang2026finixdoc,
+  title        = {FinixDoc: Rethinking Financial Document Parsing Beyond Saturated Benchmarks},
+  author       = {Hang Wang and Jin Zhang and Guoliang Xu and Pengyue Lu and Yao Li and Zijiao Zhang and Tianyu Huang and Weiqi Xiong and Yulong Wang and Chuqiao Lu and Wenkang Huang and Kai Yang and Yadong Li and Hui Li and Xingzhong Xu and Xiao Xu},
+  year         = {2026},
+  institution  = {Ant Group},
+  url          = {https://finix.alipay.com}
+}
+```
+
+## Contact
+
+For questions about the benchmark, please contact the FinixDoc authors through the project page or the Ant Group Hugging Face organization.