','',s)
+ # s = re.sub(r'| ',lambda x:f' | ',s)
+ # s = re.sub(r' | ',lambda x:f' | ',s)
+ res = ''
+ res += '\n\n'
+ temp_item = ''
+ for c in s:
+ temp_item += c
+ if c == '>' and not re.search(r'\$',temp_item):
+ res += temp_item+'\n'
+ temp_item = ''
+ return res+'\n'
+def merge_table(md):
+ table_temp = ''
+ for line in md:
+ table_temp += line
+ return convert_table_str(table_temp)
+def find_md_table_mode(line):
+ if re.search(r'-*?:',line) or re.search(r'---',line) or re.search(r':-*?',line):
+ return True
+ return False
+def delete_table_and_body(input_list):
+ res = []
+ for line in input_list:
+ if not re.search(r'',line):
+ res.append(line)
+ return res
+def merge_tables(input_str):
+ # Delete HTML comments
+ input_str = re.sub(r'', '', input_str)
+
+ # Use regex to find each block
+ table_blocks = re.findall(r'', input_str)
+
+ # Process each block, replace | with |
+ output_lines = []
+ for block in table_blocks:
+ block_lines = block.split('\n')
+ for i, line in enumerate(block_lines):
+ if ' | ' in line:
+ block_lines[i] = line.replace(' | ', ' | ').replace('', ' | ')
+ final_tr = delete_table_and_body(block_lines)
+ if len(final_tr) > 2:
+ output_lines.extend(final_tr) # Ignore tags, keep only table content
+
+ # Rejoin the processed strings
+ merged_output = ''.format('\n'.join(output_lines))
+
+ return "\n\n" + merged_output + "\n\n"
+
+def replace_table_with_placeholder(input_string):
+ lines = input_string.split('\n')
+ output_lines = []
+
+ in_table_block = False
+ temp_block = ""
+ last_line = ""
+
+ org_table_list = []
+ in_org_table = False
+
+ for idx, line in enumerate(lines):
+ # if not in_org_table:
+ # if "" not in last_line and in_table_block == False and temp_block != "":
+ # output_lines.append(merge_tables(temp_block))
+ # temp_block = ""
+ if "" in line:
+ # if "" not in last_line:
+ temp_block += "\n" + last_line
+ if " " in last_line:
+ if "" not in line:
+ in_table_block = False
+ output_lines.append(merge_tables(temp_block))
+ temp_block = ""
+ else:
+ output_lines.append(last_line)
+
+ last_line = line
+ # else:
+ # org_table_list.append(line)
+ # if "" in last_line:
+ temp_block += "\n" + last_line
+ output_lines.append(merge_tables(temp_block))
+ else:
+ output_lines.append(last_line)
+ # if " " in last_line:
+ # output_lines.append(merge_tables(temp_block))
+
+ return '\n'.join(output_lines)
+
+def convert_table(input_str):
+ # Replace
+ output_str = input_str.replace("", "")
+
+ # Replace |
+ output_str = output_str.replace(" | ", " | ")
+
+ return output_str
+
+def convert_markdown_to_html(markdown_content):
+ # Define a regex pattern to find Markdown tables with newlines
+ markdown_content = markdown_content.replace('\r', '')+'\n'
+ pattern = re.compile(r'\|\s*.*?\s*\|\n', re.DOTALL)
+
+ # Find all matches in the Markdown content
+ matches = pattern.findall(markdown_content)
+
+ for match in matches:
+ html_table = markdown_to_html(match)
+ markdown_content = markdown_content.replace(match, html_table, 1) # Only replace the first occurrence
+
+ res_html = convert_table(replace_table_with_placeholder(markdown_content))
+
+ return res_html
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/IoUscore_metric.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/IoUscore_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..8db4362b783d988058c9afc3bcf87304f82f364c
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/IoUscore_metric.py
@@ -0,0 +1,87 @@
+# flake8: noqa
+import os
+import re
+import ast
+import ipdb
+from vlmeval.dataset.utils.Ocrbench_v2.vqa_metric import vqa_evaluation
+
+
+def calculate_iou(box1, box2):
+
+ try:
+ box1 = [int(coordinate) for coordinate in box1]
+ box2 = [int(coordinate) for coordinate in box2]
+ except:
+ return 0
+
+ x1_inter = max(box1[0], box2[0])
+ y1_inter = max(box1[1], box2[1])
+ x2_inter = min(box1[2], box2[2])
+ y2_inter = min(box1[3], box2[3])
+ inter_area = max(0, x2_inter - x1_inter) * max(0, y2_inter - y1_inter)
+ box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+ box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+ union_area = box1_area + box2_area - inter_area
+ iou = inter_area / union_area if union_area != 0 else 0
+ return iou
+
+
+def vqa_with_position_evaluation(predict, img_metas):
+
+ score_content, score_bbox = .0, .0
+ if "answer" in predict.keys():
+ score_content = vqa_evaluation(predict["answer"], img_metas["answers"])
+ if "bbox" in predict.keys():
+ gt_bbox = img_metas["bbox"]
+ try:
+ predict_bbox_list = ast.literal_eval(predict["bbox"])
+ score_bbox = calculate_iou(predict_bbox_list, gt_bbox)
+ except:
+ score_bbox = 0
+ return 0.5 * score_content + 0.5 * score_bbox
+
+
+def extract_coordinates(text):
+ # Regex pattern to match coordinates in either (x1, y1, x2, y2) or [x1, y1, x2, y2] format
+
+ pattern = r'[\(\[]\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*[\)\]]'
+
+ matches = list(re.finditer(pattern, text))
+ coords_list = []
+ coords_set = set()
+ for match in matches:
+
+ x1, y1, x2, y2 = map(int, match.groups())
+
+ if all(0 <= n <= 1000 for n in [x1, y1, x2, y2]):
+ coords = (x1, y1, x2, y2)
+
+ if coords in coords_set:
+ coords_list = [c for c in coords_list if c != coords]
+
+ coords_list.append(coords)
+ coords_set.add(coords)
+ if coords_list:
+ last_coords = coords_list[-1]
+ return list(last_coords)
+ else:
+ return None
+
+
+if __name__ == "__main__":
+
+ print("Example for Text Grounding task.")
+ box1 = [50, 50, 150, 150]
+ box2 = [60, 60, 140, 140]
+ iou_score = calculate_iou(box1, box2)
+ print(f"IoU score: {iou_score}")
+
+ print("Example for VQA with position task.")
+ pred = {"content": "The content is Hello Buddies", "bbox": box1}
+ gt = {"content": "Hello Buddies", "bbox": box2}
+
+ vqa_score = vqa_evaluation(pred["content"], gt["content"])
+ iou_score = calculate_iou(pred["bbox"], gt["bbox"])
+
+ print(f"VQA score: {vqa_score}")
+ print(f"IoU score: {iou_score}")
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/TEDS_metric.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/TEDS_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c2680d02d59277f6bb0cec60b56ae033d20440d
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/TEDS_metric.py
@@ -0,0 +1,930 @@
+# flake8: noqa
+# 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 re
+import ast
+import json
+import ipdb
+import distance
+from apted import APTED, Config
+from itertools import product
+from apted.helpers import Tree
+from lxml import etree, html
+from collections import deque
+from vlmeval.dataset.utils.Ocrbench_v2.parallel import parallel_process
+from tqdm import tqdm
+from zss import simple_distance, Node
+import string
+from typing import Any, Callable, Optional, Sequence
+import numpy as np
+import Levenshtein
+import editdistance
+
+
+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(distance.levenshtein(*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=1, 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('' % 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 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]
+ inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]} 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
+
+
+def convert_table_to_html_str(table_row_list=[]):
+ """
+ Given a list of table rows, build the corresponding html string, which is used to compute the TEDS score.
+ We use the official code of PubTabNet to compute TEDS score, it does not consider ' | ' label.
+ We also remove unneccessary spaces within a table cell and extra '\n' as they will influence the TEDS score.
+ """
+ html_table_str = "" + '\n'
+ for data_row in table_row_list:
+ html_table_str += ""
+ for cell_str in data_row:
+ html_table_str += f"| {cell_str} | "
+ html_table_str += " "
+ html_table_str += '\n'
+ html_table_str += " "
+ html_table_str = html_table_str.replace('\n','')
+ return html_table_str
+
+
+def convert_markdown_table_to_html(markdown_table):
+ """
+ Converts a markdown table to the corresponding html string for TEDS computation.
+ """
+ # remove extra code block tokens like '```markdown' and '```
+ markdown_table = markdown_table.strip('```markdown').strip('```').strip()
+ row_str_list = markdown_table.split('\n')
+ # extra the first header row and other data rows
+ valid_row_str_list = [row_str_list[0]]+row_str_list[2:]
+ table_rows = []
+ for row_str in valid_row_str_list:
+ one_row = []
+ for cell in row_str.strip().split('|')[1:-1]:
+ if set(cell) != set(' '):
+ one_row.append(cell.strip())
+ else:
+ one_row.append(' ')
+ table_rows.append(one_row)
+ # build html string based on table rows
+ html_str = convert_table_to_html_str(table_rows)
+ return html_str
+
+
+def dict_to_html(data):
+ html = "\n"
+ for key, value in data.items():
+ if not isinstance(value, str):
+ value = str(value)
+ value_str = ' '.join(value)
+
+ html += f" | {key} | {value_str} | \n"
+ html += " "
+ return html
+
+
+def convert_str_to_dict(predict_str: str):
+ """
+ Parses the 'predict' string and returns a dictionary.
+ Missing or unparseable content is handled gracefully.
+
+ Parameters:
+ - predict_str (str): The prediction string containing the output dict.
+
+ Returns:
+ - dict: A dictionary extracted from the predict string.
+ """
+ # Remove code fences like ```python\n...\n```
+ code_fence_pattern = r'```(?:python|json)?\n(.*?)\n```'
+ match = re.search(code_fence_pattern, predict_str, re.DOTALL | re.IGNORECASE)
+ if match:
+ content = match.group(1)
+ else:
+ content = predict_str.strip()
+
+ data = {}
+ success = False
+
+ # try parsing with JSON
+ try:
+ data = json.loads(content)
+ success = True
+ except json.JSONDecodeError:
+ pass
+
+ # try parsing with ast.literal_eval
+ if not success:
+ try:
+ data = ast.literal_eval(content)
+ if isinstance(data, dict):
+ success = True
+ except (ValueError, SyntaxError):
+ pass
+
+ # try parsing with regex
+ if not success:
+ key_value_pattern = r'["\']?([\w\s]+)["\']?\s*[:=]\s*["\']?([^\n,"\'{}]+)["\']?'
+ matches = re.findall(key_value_pattern, content)
+ try:
+ for key, value in matches:
+ data[key.strip()] = value.strip()
+ except:
+ return {}
+
+ if not data:
+ return {}
+
+ try:
+ result = {k.strip(): str(v).strip() for k, v in data.items()}
+ except:
+ return {}
+ return result
+
+
+def convert_str_to_multi_dict(predict_str: str):
+ """
+ Parses the 'predict' string and returns a dictionary.
+ Handles nested dictionaries and missing or unparseable content gracefully.
+
+ Parameters:
+ - predict_str (str): The prediction string containing the output dict.
+
+ Returns:
+ - dict: A dictionary extracted from the predict string.
+ """
+ # Remove code fences like ```python\n...\n```
+ code_fence_pattern = r'```(?:python|json)?\n(.*?)\n```'
+ matches = re.findall(code_fence_pattern, predict_str, re.DOTALL | re.IGNORECASE)
+ if matches:
+ content = max(matches, key=len)
+ else:
+ content = predict_str.strip()
+
+ def strip_variable_assignment(s):
+ variable_assignment_pattern = r'^\s*\w+\s*=\s*'
+ return re.sub(variable_assignment_pattern, '', s.strip(), count=1)
+
+ content = strip_variable_assignment(content)
+
+ def remove_comments(s):
+ return re.sub(r'#.*', '', s)
+
+ content = remove_comments(content)
+
+ last_brace_pos = content.rfind('}')
+ if last_brace_pos != -1:
+ content = content[:last_brace_pos+1]
+
+ data = {}
+ success = False
+
+ # try parsing with ast.literal_eval
+ try:
+ data = ast.literal_eval(content)
+ if isinstance(data, dict):
+ success = True
+ except (ValueError, SyntaxError, TypeError):
+ pass
+
+ if not success:
+ return {}
+
+ def process_data(obj):
+ if isinstance(obj, dict):
+ return {k: process_data(v) for k, v in obj.items()}
+ elif isinstance(obj, list):
+ return [process_data(elem) for elem in obj]
+ else:
+ return obj
+
+ data = process_data(data)
+
+ return data
+
+
+def generate_combinations(input_dict):
+ """
+ Function to generate all possible combinations of values from a dictionary.
+ """
+ kie_answer = input_dict
+ if not isinstance(kie_answer, dict):
+ kie_answer = kie_answer.strip('"')
+ try:
+ kie_answer = json.loads(kie_answer)
+ except json.JSONDecodeError:
+ try:
+ kie_answer = ast.literal_eval(kie_answer)
+ if not isinstance(kie_answer, dict):
+ kie_answer = ast.literal_eval(kie_answer)
+ except (ValueError, SyntaxError):
+ print(f"Unable to parse 'answers' field: {kie_answer}")
+ return {}
+
+ # Ensure the parsed result is a dictionary.
+ if not isinstance(kie_answer, dict):
+ print("Parsed 'answers' is still not a dictionary.")
+ raise ValueError("Input could not be parsed into a dictionary.")
+
+ keys = list(kie_answer.keys())
+
+ value_lists = []
+ for single_key in keys:
+ sinlge_value = kie_answer[single_key]
+ if not isinstance(sinlge_value, list):
+ sinlge_value = [sinlge_value]
+ value_lists.append(sinlge_value)
+
+ # Compute the Cartesian product of the value lists.
+ combinations = list(product(*value_lists))
+
+ # Create a dictionary for each combination of values.
+ result = [dict(zip(keys, values)) for values in combinations]
+
+ return result
+
+ else:
+ keys = list(input_dict.keys())
+ value_lists = [input_dict[key] for key in keys]
+
+ # Compute the Cartesian product of the value lists.
+ combinations = list(product(*value_lists))
+
+ # Create a dictionary for each combination of values.
+ result = [dict(zip(keys, values)) for values in combinations]
+
+ return result
+
+
+def compute_f1_score(preds, gts, ignores=[]):
+ """Compute the F1-score for KIE task between predicted and ground truth dictionaries.
+
+ Args:
+ preds (dict): The predicted key-value pairs.
+ gts (dict): The ground truth key-value pairs.
+ ignores (list): The list of keys to ignore during evaluation.
+
+ Returns:
+ dict: A dictionary where keys are field names and values are their corresponding F1-scores.
+ """
+ # Optionally remove ignored keys from predictions and ground truths
+ keys = set(preds.keys()).union(set(gts.keys())) - set(ignores)
+ f1_scores = {}
+
+ for key in keys:
+ pred_value = preds.get(key, None)
+ gt_value = gts.get(key, None)
+
+ if pred_value:
+ pred_value = pred_value.lower().strip().replace("\n"," ").replace(" ", "")
+ if gt_value:
+ gt_value = gt_value.lower().strip().replace("\n"," ").replace(" ", "")
+
+ if pred_value is None and gt_value is None:
+ continue
+ elif pred_value is None:
+ precision = 0.0
+ recall = 0.0
+ elif gt_value is None:
+ # false positive
+ precision = 0.0
+ recall = 0.0
+ else:
+ if pred_value == gt_value:
+ # True positive
+ precision = 1.0
+ recall = 1.0
+ else:
+ precision = 0.0
+ recall = 0.0
+
+ # Compute F1-score
+ f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
+ f1_scores[key] = f1_score
+
+ if len(f1_scores) == 0:
+ return 0
+ average_f1 = sum(f1_scores.values()) / len(f1_scores)
+
+ return average_f1
+
+
+def pre_clean(text):
+ text = re.sub(r'|||', '', text)
+ text = re.sub(r'\s##(\S)', r'\1', text)
+ text = re.sub(r'\\\s', r'\\', text)
+ text = re.sub(r'\s\*\s\*\s', r'**', text)
+ text = re.sub(r'{\s', r'{', text)
+ text = re.sub(r'\s}', r'}', text)
+ text = re.sub(r'\s}', r'}', text)
+ text = re.sub(r'\\begin\s', r'\\begin', text)
+ text = re.sub(r'\\end\s', r'\\end', text)
+ text = re.sub(r'\\end{table}', r'\\end{table} \n\n', text)
+ text = text.replace('\n', ' ')
+ text = text.replace('*', ' ')
+ text = text.replace('_', ' ')
+ return text
+
+
+def get_tree(input_str):
+ tree = (Node('ROOT').addkid(Node('TITLE')))
+
+ lines = input_str.split("\n")
+ lines = [pre_clean(line) for line in lines]
+ last_title = ''
+ for line in lines:
+ if line.startswith('#'):
+ child = tree.get('ROOT')
+ line = line.replace('#', '')
+ child.addkid(Node(line))
+ last_title = line
+ else:
+ if last_title == '':
+ child = tree.get('TITLE')
+ child.addkid(Node(line))
+ else:
+ child = tree.get(last_title)
+ child.addkid(Node(line))
+ return tree
+
+def STEDS(pred_tree, ref_tree):
+ def my_distance(pred, ref):
+ if len(pred.split()) == 0 or len(ref.split()) == 0:
+ return 1
+ else:
+ return 0
+ total_distance = simple_distance(pred_tree, ref_tree, label_dist=my_distance)
+ num_of_nodes = max(len(list(pred_tree.iter())), len(list(ref_tree.iter())))
+ return 1-total_distance/num_of_nodes
+
+
+def doc_parsing_evaluation(pred, gt):
+ score = 0
+ if not isinstance(pred, str):
+ return 0
+ pred_tree = get_tree(pred)
+ gt_tree = get_tree(gt)
+ score = STEDS(pred_tree, gt_tree)
+
+ return score
+
+
+def wrap_html_table(html_table):
+ """
+ The TEDS computation from PubTabNet code requires that the input html table should have , , and tags.
+ Add them if they are missing.
+ """
+ html_table = html_table.replace('\n','')
+ # add missing tag if missing
+ if "" not in html_table:
+ html_table = html_table + " "
+ elif "" in html_table:
+ html_table = "" + html_table
+ elif "" not in html_table:
+ html_table = ""
+ else:
+ pass
+ # add and tags if missing
+ if '' not in html_table:
+ html_table = '' + html_table + ''
+ if '' not in html_table:
+ html_table = '' + html_table + ''
+ return html_table
+
+
+def get_anls(s1, s2):
+ try:
+ s1 = s1.lower()
+ s2 = s2.lower()
+ except:
+ pass
+ if s1 == s2:
+ return 1.0
+ iou = 1 - editdistance.eval(s1, s2) / max(len(s1), len(s2))
+ anls = iou
+ return anls
+
+
+def ocr_eval(references,predictions):
+ socre_=0.0
+ None_num=0
+ for idx,ref_value in enumerate(references):
+ pred_value = predictions[idx]
+ pred_values, ref_values = [], []
+ if isinstance(pred_value, str):
+ pred_values.append(pred_value)
+ else:
+ pred_values = pred_value
+ if isinstance(ref_value, str):
+ ref_values.append(ref_value)
+ else:
+ ref_values = ref_value
+
+ temp_score = 0.0
+ temp_num = len(ref_values)
+
+ for tmpidx, tmpref in enumerate(ref_values):
+ tmppred = pred_values[tmpidx] if tmpidx < len(pred_values) else pred_values[0]
+ if len(pred_values) == 1 and tmppred != "None" and "None" not in ref_values: # pred 1, and not None
+ temp_score = max(temp_score, get_anls(tmppred, tmpref))
+ temp_num = len(ref_values)
+ else:
+ if tmppred=='None' and tmpref!='None':
+ temp_score += 0.0
+ elif tmpref=='None':
+ temp_num -= 1
+ else:
+ temp_score += get_anls(tmppred, tmpref)
+ if temp_num == 0:
+ ocr_score = 0.0
+ None_num += 1
+ else:
+ ocr_score = temp_score / (temp_num)
+ socre_ += ocr_score
+ if None_num == len(references):
+ return 9999
+ else:
+ return round(socre_ / (len(references)-None_num), 5)
+
+
+def csv_eval(predictions,references,easy, pred_type='json'):
+ predictions = predictions
+ labels = references
+ def is_int(val):
+ try:
+ int(val)
+ return True
+ except ValueError:
+ return False
+
+ def is_float(val):
+ try:
+ float(val)
+ return True
+ except ValueError:
+ return False
+
+ def convert_dict_to_list(data):
+ """
+ Convert a dictionary to a list of tuples, handling both simple and nested dictionaries.
+
+ Args:
+ data (dict): The input dictionary, which might be nested or simple.
+
+ Returns:
+ list: A list of tuples generated from the input dictionary.
+ """
+ # print(data)
+ converted_list = []
+ for key, value in data.items():
+ # Check if the value is a dictionary (indicating a nested structure)
+ if isinstance(value, dict):
+ # Handle nested dictionary
+ for subkey, subvalue in value.items():
+ # converted_list.append((key, subkey, subvalue))
+ converted_list.append((key, subkey, re.sub(r'[^\d.-]', '', str(subvalue))))
+
+ else:
+ # Handle simple key-value pair
+ # converted_list.append((key, "value", value))
+ converted_list.append((key, "value", re.sub(r'[^\d.-]', '', str(value))))
+ return converted_list
+
+
+ def csv2triples(csv, separator='\\t', delimiter='\\n'):
+ lines = csv.strip().split(delimiter)
+ header = lines[0].split(separator)
+ triples = []
+ for line in lines[1:]:
+ if not line:
+ continue
+ values = line.split(separator)
+ entity = values[0]
+ for i in range(1, len(values)):
+ if i >= len(header):
+ break
+ #---------------------------------------------------------
+ temp = [entity.strip(), header[i].strip()]
+ temp = [x if len(x)==0 or x[-1] != ':' else x[:-1] for x in temp]
+ value = values[i].strip()
+ value = re.sub(r'[^\d.-]', '', str(value))
+ # value = value.replace("%","")
+ # value = value.replace("$","")
+ triples.append((temp[0], temp[1], value))
+ #---------------------------------------------------------
+ return triples
+
+ def csv2triples_noheader(csv, separator='\\t', delimiter='\\n'):
+ lines = csv.strip().split(delimiter)
+ maybe_header = [x.strip() for x in lines[0].split(separator)]
+ not_header = False
+ if len(maybe_header) > 2:
+ for c in maybe_header[1:]:
+ try:
+ num = float(c)
+ not_header = True
+ except:
+ continue
+ if not_header:
+ break
+ header = None if not_header else maybe_header
+ data_start = 0 if not_header and separator in lines[0] else 1
+ triples = []
+ for line in lines[data_start:]:
+ if not line:
+ continue
+ values = [x.strip() for x in line.split(separator)]
+ entity = values[0]
+ for i in range(1, len(values)):
+ try:
+ temp = [entity if entity[-1]!=':' else entity[:-1], ""]
+ except:
+ temp = [entity, ""]
+ if header is not None:
+ try:
+ this_header = header[i]
+ temp = [entity, this_header]
+ temp = [x if x[-1] != ':' else x[:-1] for x in temp]
+ except:
+ this_header = entity.strip()
+ value = values[i].strip()
+ value = re.sub(r'[^\d.-]', '', str(value))
+ # value = value.replace("%","")
+ # value = value.replace("$","")
+ triples.append((temp[0], temp[1], value))
+ #---------------------------------------------------------
+ return triples
+
+ def process_triplets(triplets):
+ new_triplets = []
+ for triplet in triplets:
+ new_triplet = []
+ triplet_temp = []
+ if len(triplet) > 2:
+ if is_int(triplet[2]) or is_float(triplet[2]):
+ triplet_temp = (triplet[0].lower(), triplet[1].lower(), float(triplet[2]))
+ else:
+ triplet_temp = (triplet[0].lower(), triplet[1].lower(), triplet[2].lower())
+ else:
+ triplet_temp = (triplet[0].lower(), triplet[1].lower(), "no meaning")
+ new_triplets.append(triplet_temp)
+ return new_triplets
+
+ def intersection_with_tolerance(a, b, tol_word, tol_num):
+ a = set(a)
+ b = set(b)
+ c = set()
+ for elem1 in a:
+ for elem2 in b:
+ if is_float(elem1[-1]) and is_float(elem2[-1]):
+ if ((Levenshtein.distance(''.join(elem1[:-1]),''.join(elem2[:-1])) <= tol_word) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num))or \
+ ((''.join(elem1[:-1]) in ''.join(elem2[:-1])) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num)) or \
+ ((''.join(elem2[:-1]) in ''.join(elem1[:-1])) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num)):
+ c.add(elem1)
+ else:
+ if (Levenshtein.distance(''.join([str(i) for i in elem1]),''.join([str(j) for j in elem2])) <= tol_word):
+ c.add(elem1)
+ return list(c)
+
+ def union_with_tolerance(a, b, tol_word, tol_num):
+ c = set(a) | set(b)
+ d = set(a) & set(b)
+ e = intersection_with_tolerance(a, b, tol_word, tol_num)
+ f = set(e)
+ g = c-(f-d)
+ return list(g)
+
+ def get_eval_list(pred_csv, label_csv, separator='\\t', delimiter='\\n', tol_word=3, tol_num=0.05, pred_type='json'):
+
+ if pred_type == 'json':
+ pred_triple_list=[]
+ for it in pred_csv:
+ pred_triple_temp = convert_dict_to_list(it)
+ pred_triple_pre = process_triplets(pred_triple_temp)
+ pred_triple_list.append(pred_triple_pre)
+ else:
+ pred_triple_list=[]
+ for it in pred_csv:
+ pred_triple_temp = csv2triples(it, separator=separator, delimiter=delimiter)
+ # pred_triple_temp = csv2triples_noheader(it, separator=separator, delimiter=delimiter)
+ pred_triple_pre = process_triplets(pred_triple_temp)
+ pred_triple_list.append(pred_triple_pre)
+
+ label_triple_list=[]
+ for it in label_csv:
+ label_triple_temp = convert_dict_to_list(it)
+ label_triple_pre = process_triplets(label_triple_temp)
+ label_triple_list.append(label_triple_pre)
+
+
+ intersection_list=[]
+ union_list=[]
+ sim_list=[]
+ # for each chart image
+ for pred,label in zip(pred_triple_list, label_triple_list):
+ for idx in range(len(pred)):
+ try:
+ if label[idx][1] == "value" and "value" not in pred[idx][:2]:
+ pred[idx] = (pred[idx][0], "value", pred[idx][2])
+ temp_pred_head = sorted(pred[idx][:2])
+ temp_gt_head = sorted(label[idx][:2])
+ pred[idx] = (temp_pred_head[0], temp_pred_head[1], pred[idx][2])
+ label[idx] = (temp_gt_head[0], temp_gt_head[1], label[idx][2])
+ except:
+ continue
+ intersection = intersection_with_tolerance(pred, label, tol_word = tol_word, tol_num=tol_num)
+ union = union_with_tolerance(pred, label, tol_word = tol_word, tol_num=tol_num)
+ sim = len(intersection)/len(union)
+ intersection_list.append(intersection)
+ union_list.append(union)
+ sim_list.append(sim)
+ return intersection_list, union_list, sim_list
+
+ def get_ap(predictions, labels, sim_threhold, tolerance, separator='\\t', delimiter='\\n', easy=1):
+ if tolerance == 'strict':
+ tol_word=0
+ if easy == 1:
+ tol_num=0
+ else:
+ tol_num=0.1
+
+ elif tolerance == 'slight':
+ tol_word=2
+ if easy == 1:
+ tol_num=0.05
+ else:
+ tol_num=0.3
+
+ elif tolerance == 'high':
+ tol_word= 5
+ if easy == 1:
+ tol_num=0.1
+ else:
+ tol_num=0.5
+ intersection_list, union_list, sim_list = get_eval_list(predictions, labels, separator=separator, delimiter=delimiter, tol_word=tol_word, tol_num=tol_num, pred_type=pred_type)
+ ap = len([num for num in sim_list if num >= sim_threhold])/(len(sim_list)+1e-16)
+ return ap
+
+ map_strict = 0
+ map_slight = 0
+ map_high = 0
+ s="\\t"
+ d="\\n"
+
+ for sim_threhold in np.arange (0.5, 1, 0.05):
+ map_temp_strict = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='strict', separator=s, delimiter=d, easy=easy)
+ map_temp_slight = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='slight', separator=s, delimiter=d, easy=easy)
+ map_temp_high = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='high', separator=s, delimiter=d, easy=easy)
+ map_strict += map_temp_strict/10
+ map_slight += map_temp_slight/10
+ map_high += map_temp_high/10
+
+ em = get_ap(predictions, labels, sim_threhold=1, tolerance='strict', separator=s, delimiter=d, easy=easy)
+ ap_50_strict = get_ap(predictions, labels, sim_threhold=0.5, tolerance='strict', separator=s, delimiter=d, easy=easy)
+ ap_75_strict = get_ap(predictions, labels, sim_threhold=0.75, tolerance='strict', separator=s, delimiter=d, easy=easy)
+ ap_90_strict = get_ap(predictions, labels, sim_threhold=0.90, tolerance='strict', separator=s, delimiter=d, easy=easy)
+ ap_50_slight = get_ap(predictions, labels, sim_threhold=0.5, tolerance='slight', separator=s, delimiter=d, easy=easy)
+ ap_75_slight = get_ap(predictions, labels, sim_threhold=0.75, tolerance='slight', separator=s, delimiter=d, easy=easy)
+ ap_90_slight = get_ap(predictions, labels, sim_threhold=0.90, tolerance='slight', separator=s, delimiter=d, easy=easy)
+ ap_50_high = get_ap(predictions, labels, sim_threhold=0.5, tolerance='high', separator=s, delimiter=d, easy=easy)
+ ap_75_high = get_ap(predictions, labels, sim_threhold=0.75, tolerance='high', separator=s, delimiter=d, easy=easy)
+ ap_90_high = get_ap(predictions, labels, sim_threhold=0.90, tolerance='high', separator=s, delimiter=d, easy=easy)
+
+
+ return em, map_strict, map_slight, map_high, ap_50_strict, ap_75_strict, ap_90_strict, ap_50_slight, ap_75_slight, ap_90_slight, ap_50_high, ap_75_high, ap_90_high
+
+def draw_SCRM_table(em, map_strict, map_slight, map_high, ap_50_strict, ap_75_strict, ap_90_strict, ap_50_slight, ap_75_slight, ap_90_slight, ap_50_high, ap_75_high, ap_90_high,title_ocr_socre,source_ocr_socre,x_title_ocr_socre,y_title_ocr_socre,structure_accuracy):
+
+ result=f'''
+ -----------------------------------------------------------\n
+ | Metrics | Sim_threshold | Tolerance | Value |\n
+ -----------------------------------------------------------\n
+ | | | strict | {'%.4f' % map_strict} | \n
+ | | ----------------------------\n
+ | mPrecison | 0.5:0.05:0.95 | slight | {'%.4f' % map_slight} |\n
+ | | ---------------------------\n
+ | | | high | {'%.4f' % map_high} |\n
+ -----------------------------------------------------------\n
+ | | | strict | {'%.4f' % ap_50_strict} |\n
+ | | ---------------------------\n
+ | Precison | 0.5 | slight | {'%.4f' % ap_50_slight } |\n
+ | | ---------------------------\n
+ | | | high | {'%.4f' % ap_50_high } |\n
+ -----------------------------------------------------------\n
+ | | | strict | {'%.4f' % ap_75_strict} |\n
+ | | ---------------------------\n
+ | Precison | 0.75 | slight | {'%.4f' % ap_75_slight} |\n
+ | | ---------------------------\n
+ | | | high | {'%.4f' % ap_75_high} |\n
+ -----------------------------------------------------------\n
+ | | | strict | {'%.4f' % ap_90_strict} |\n
+ | | ---------------------------\n
+ | Precison | 0.9 | slight | {'%.4f' % ap_90_slight } |\n
+ | | ---------------------------\n
+ | | | high | {'%.4f' % ap_90_high} |\n
+ -----------------------------------------------------------\n
+ |Precison(EM) | {'%.4f' % em} |\n
+ -----------------------------------------------------------\n
+ |Title(EM) | {'%.4f' % title_ocr_socre} |\n
+ -----------------------------------------------------------\n
+ |Source(EM) | {'%.4f' % source_ocr_socre} |\n
+ -----------------------------------------------------------\n
+ |X_title(EM) | {'%.4f' % x_title_ocr_socre} |\n
+ -----------------------------------------------------------\n
+ |Y_title(EM) | {'%.4f' % y_title_ocr_socre} |\n
+ -----------------------------------------------------------\n
+ |structure_acc| {'%.4f' % structure_accuracy} |\n
+ -----------------------------------------------------------\n
+
+
+ '''
+ return result
+
+
+if __name__ == '__main__':
+ import json
+ import pprint
+
+ # markdown structure for Table Parsing task
+ pred_markdown = "| 1 | august 5 , 1972 | detroit lions | l 23 - 31 | 0 - 1 |\n| 2 | august 12 , 1972 | green bay packers | l 13 - 14 | 0 - 2 |\n| 3 | august 19 , 1972 | cincinnati bengals | w 35 - 17 | 1 - 2 |\n| 4 | august 25 , 1972 | atlanta falcons | w 24 - 10 | 2 - 2 |\n| 5 | august 31 , 1972 | washington redskins | l 24 - 27 | 2 - 3 |\n| 6 | september 10 , 1972 | minnesota vikings | w 21 - 19 | 3 - 3 |"
+ true_markdown = "| week | date | opponent | result | record |\n| --- | --- | --- | --- | --- |\n| 1 | august 5 , 1972 | detroit lions | l 23 - 31 | 0 - 1 |\n| 2 | august 12 , 1972 | green bay packers | l 13 - 14 | 0 - 2 |\n| 3 | august 19 , 1972 | cincinnati bengals | w 35 - 17 | 1 - 2 |\n| 4 | august 25 , 1972 | atlanta falcons | w 24 - 10 | 2 - 2 |\n| 5 | august 31 , 1972 | washington redskins | l 24 - 27 | 2 - 3 |\n| 6 | september 10 , 1972 | minnesota vikings | w 21 - 19 | 3 - 3 |"
+ teds = TEDS(n_jobs=4)
+ pred_table_html = convert_markdown_table_to_html(pred_markdown)
+ true_table_html = convert_markdown_table_to_html(true_markdown)
+
+ scores = teds.evaluate(pred_table_html, true_table_html)
+
+ pp = pprint.PrettyPrinter()
+ pp.pprint(scores)
+
+ # dict structure for Key Information Extraction task
+ pred_dict = {
+ "company": [
+ "OLD TOWN "
+ ],
+ "date": [
+ "2024"
+ ],
+ "address": [
+ "SRI RAMPAI"
+ ],
+ "total": [
+ "30"
+ ]
+ }
+ true_dict = {
+ "company": [
+ "OLD TOWN KOPITAM SND BHD"
+ ],
+ "date": [
+ "2024/9/27"
+ ],
+ "address": [
+ "SRI RAMPAI"
+ ],
+ "total": [
+ "30"
+ ]
+ }
+ teds = TEDS(n_jobs=4)
+ pred_dict_html = dict_to_html(pred_dict)
+ true_dict_html = dict_to_html(true_dict)
+ print(pred_dict_html)
+ print(true_dict_html)
+
+ scores = teds.evaluate(pred_dict_html, true_dict_html)
+
+ pp = pprint.PrettyPrinter()
+ pp.pprint(scores)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/rrc_evaluation_funcs_1_1.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/rrc_evaluation_funcs_1_1.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e01c07f93ff0e30203df1c2a79a5033e144a373
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/rrc_evaluation_funcs_1_1.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/script.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/script.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fb78722f0773fa7736a08b868a425717f8b1f38
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/__pycache__/script.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/rrc_evaluation_funcs_1_1.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/rrc_evaluation_funcs_1_1.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c45fd5d05a2327a83fdfa1b2aa9d37407094143
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/rrc_evaluation_funcs_1_1.py
@@ -0,0 +1,456 @@
+# flake8: noqa
+#!/usr/bin/env python3
+
+#File: rrc_evaluation_funcs_1_1.py
+#Version: 1.1
+#Version info: changes for Python 3
+#Date: 2019-12-29
+#Description: File with useful functions to use by the evaluation scripts in the RRC website.
+
+import json
+import sys;
+sys.path.append('./')
+import zipfile
+import re
+import os
+import importlib
+
+def print_help():
+ sys.stdout.write('Usage: python %s.py -g= -s= [-o= -p=]' %sys.argv[0])
+ sys.exit(2)
+
+
+def load_zip_file_keys(file,fileNameRegExp=''):
+ """
+ Returns an array with the entries of the ZIP file that match with the regular expression.
+ The key's are the names or the file or the capturing group definied in the fileNameRegExp
+ """
+ try:
+ archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+ except :
+ raise Exception('Error loading the ZIP archive.')
+
+ pairs = []
+
+ for name in archive.namelist():
+ addFile = True
+ keyName = name
+ if fileNameRegExp!="":
+ m = re.match(fileNameRegExp,name)
+ if m == None:
+ addFile = False
+ else:
+ if len(m.groups())>0:
+ keyName = m.group(1)
+
+ if addFile:
+ pairs.append( keyName )
+
+ return pairs
+
+
+def load_zip_file(file,fileNameRegExp='',allEntries=False):
+ """
+ Returns an array with the contents (filtered by fileNameRegExp) of a ZIP file.
+ The key's are the names or the file or the capturing group definied in the fileNameRegExp
+ allEntries validates that all entries in the ZIP file pass the fileNameRegExp
+ """
+ try:
+ archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+ except :
+ raise Exception('Error loading the ZIP archive')
+
+ pairs = []
+ for name in archive.namelist():
+ addFile = True
+ keyName = name
+ if fileNameRegExp!="":
+ m = re.match(fileNameRegExp,name)
+ if m == None:
+ addFile = False
+ else:
+ if len(m.groups())>0:
+ keyName = m.group(1)
+
+ if addFile:
+ pairs.append( [ keyName , archive.read(name)] )
+ else:
+ if allEntries:
+ raise Exception('ZIP entry not valid: %s' %name)
+
+ return dict(pairs)
+
+def decode_utf8(raw):
+ """
+ Returns a Unicode object on success, or None on failure
+ """
+ try:
+ return raw.decode('utf-8-sig',errors = 'replace')
+ except:
+ return None
+
+def validate_lines_in_file(fileName,file_contents,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+ """
+ This function validates that all lines of the file calling the Line validation function for each line
+ """
+ utf8File = decode_utf8(file_contents)
+ if (utf8File is None) :
+ raise Exception("The file %s is not UTF-8" %fileName)
+
+ lines = utf8File.split( "\r\n" if CRLF else "\n" )
+ for line in lines:
+ line = line.replace("\r","").replace("\n","")
+ if(line != ""):
+ try:
+ validate_tl_line(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+ except Exception as e:
+ raise Exception(("Line in sample not valid. Sample: %s Line: %s Error: %s" %(fileName,line,str(e))).encode('utf-8', 'replace'))
+
+
+
+def validate_tl_line(line,LTRB=True,withTranscription=True,withConfidence=True,imWidth=0,imHeight=0):
+ """
+ Validate the format of the line. If the line is not valid an exception will be raised.
+ If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+ Posible values are:
+ LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription]
+ LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+ """
+ get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+
+
+def get_tl_line_values(line,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+ """
+ Validate the format of the line. If the line is not valid an exception will be raised.
+ If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+ Posible values are:
+ LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription]
+ LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+ Returns values from a textline. Points , [Confidences], [Transcriptions]
+ """
+ confidence = 0.0
+ transcription = "";
+ points = []
+
+ numPoints = 4;
+
+ if LTRB:
+
+ numPoints = 4;
+
+ if withTranscription and withConfidence:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+ if m == None :
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+ raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence,transcription")
+ elif withConfidence:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence")
+ elif withTranscription:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,(.*)$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,transcription")
+ else:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,?\s*$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax")
+
+ xmin = int(m.group(1))
+ ymin = int(m.group(2))
+ xmax = int(m.group(3))
+ ymax = int(m.group(4))
+ if(xmax0 and imHeight>0):
+ validate_point_inside_bounds(xmin,ymin,imWidth,imHeight);
+ validate_point_inside_bounds(xmax,ymax,imWidth,imHeight);
+
+ else:
+
+ numPoints = 8;
+
+ if withTranscription and withConfidence:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence,transcription")
+ elif withConfidence:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence")
+ elif withTranscription:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,(.*)$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,transcription")
+ else:
+ m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*$',line)
+ if m == None :
+ raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4")
+
+ points = [ float(m.group(i)) for i in range(1, (numPoints+1) ) ]
+
+ validate_clockwise_points(points)
+
+ if (imWidth>0 and imHeight>0):
+ validate_point_inside_bounds(points[0],points[1],imWidth,imHeight);
+ validate_point_inside_bounds(points[2],points[3],imWidth,imHeight);
+ validate_point_inside_bounds(points[4],points[5],imWidth,imHeight);
+ validate_point_inside_bounds(points[6],points[7],imWidth,imHeight);
+
+
+ if withConfidence:
+ try:
+ confidence = float(m.group(numPoints+1))
+ except ValueError:
+ raise Exception("Confidence value must be a float")
+
+ if withTranscription:
+ posTranscription = numPoints + (2 if withConfidence else 1)
+ transcription = m.group(posTranscription)
+ m2 = re.match(r'^\s*\"(.*)\"\s*$',transcription)
+ if m2 != None : #Transcription with double quotes, we extract the value and replace escaped characters
+ transcription = m2.group(1).replace("\\\\", "\\").replace("\\\"", "\"")
+
+ return points,confidence,transcription
+
+def get_tl_dict_values(detection,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,validNumPoints=[],validate_cw=True):
+ """
+ Validate the format of the dictionary. If the dictionary is not valid an exception will be raised.
+ If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+ Posible values:
+ {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]]}
+ {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4,"illegibility":false}
+ {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4,"dontCare":false}
+ Returns values from the dictionary. Points , [Confidences], [Transcriptions]
+ """
+ confidence = 0.0
+ transcription = "";
+ points = []
+
+ if isinstance(detection, dict) == False :
+ raise Exception("Incorrect format. Object has to be a dictionary")
+
+ if not 'points' in detection:
+ raise Exception("Incorrect format. Object has no points key)")
+
+ if isinstance(detection['points'], list) == False :
+ raise Exception("Incorrect format. Object points key have to be an array)")
+
+ num_points = len(detection['points'])
+
+ if num_points<3 :
+ raise Exception("Incorrect format. Incorrect number of points. At least 3 points are necessary. Found: " + str(num_points))
+
+ if(len(validNumPoints)>0 and num_points in validNumPoints == False ):
+ raise Exception("Incorrect format. Incorrect number of points. Only allowed 4,8 or 12 points)")
+
+ for i in range(num_points):
+ if isinstance(detection['points'][i], list) == False :
+ raise Exception("Incorrect format. Point #" + str(i+1) + " has to be an array)")
+
+ if len(detection['points'][i]) != 2 :
+ raise Exception("Incorrect format. Point #" + str(i+1) + " has to be an array with 2 objects(x,y) )")
+
+ if isinstance(detection['points'][i][0], (int,float) ) == False or isinstance(detection['points'][i][1], (int,float) ) == False :
+ raise Exception("Incorrect format. Point #" + str(i+1) + " childs have to be Integers)")
+
+ if (imWidth>0 and imHeight>0):
+ validate_point_inside_bounds(detection['points'][i][0],detection['points'][i][1],imWidth,imHeight);
+
+ points.append(float(detection['points'][i][0]))
+ points.append(float(detection['points'][i][1]))
+
+ if validate_cw :
+ validate_clockwise_points(points)
+
+ if withConfidence:
+ if not 'confidence' in detection:
+ raise Exception("Incorrect format. No confidence key)")
+
+ if isinstance(detection['confidence'], (int,float)) == False :
+ raise Exception("Incorrect format. Confidence key has to be a float)")
+
+ if detection['confidence']<0 or detection['confidence']>1 :
+ raise Exception("Incorrect format. Confidence key has to be a float between 0.0 and 1.0")
+
+ confidence = detection['confidence']
+
+ if withTranscription:
+ if not 'transcription' in detection:
+ raise Exception("Incorrect format. No transcription key)")
+
+ if isinstance(detection['transcription'], str) == False :
+ raise Exception("Incorrect format. Transcription has to be a string. Detected: " + type(detection['transcription']).__name__ )
+
+ transcription = detection['transcription']
+
+ if 'illegibility' in detection: #Ensures that if illegibility atribute is present and is True the transcription is set to ### (don't care)
+ if detection['illegibility'] == True:
+ transcription = "###"
+
+ if 'dontCare' in detection: #Ensures that if dontCare atribute is present and is True the transcription is set to ### (don't care)
+ if detection['dontCare'] == True:
+ transcription = "###"
+
+ return points,confidence,transcription
+
+def validate_point_inside_bounds(x,y,imWidth,imHeight):
+ if(x<0 or x>imWidth):
+ raise Exception("X value (%s) not valid. Image dimensions: (%s,%s)" %(xmin,imWidth,imHeight))
+ if(y<0 or y>imHeight):
+ raise Exception("Y value (%s) not valid. Image dimensions: (%s,%s) Sample: %s Line:%s" %(ymin,imWidth,imHeight))
+
+def validate_clockwise_points(points):
+ """
+ Validates that the points are in clockwise order.
+ """
+ edge = []
+ for i in range(len(points)//2):
+ edge.append( (int(points[(i+1)*2 % len(points)]) - int(points[i*2])) * (int(points[ ((i+1)*2+1) % len(points)]) + int(points[i*2+1])) )
+ if sum(edge)>0:
+ raise Exception("Points are not clockwise. The coordinates of bounding points have to be given in clockwise order. Regarding the correct interpretation of 'clockwise' remember that the image coordinate system used is the standard one, with the image origin at the upper left, the X axis extending to the right and Y axis extending downwards.")
+
+def get_tl_line_values_from_file_contents(content,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,sort_by_confidences=True):
+ """
+ Returns all points, confindences and transcriptions of a file in lists. Valid line formats:
+ xmin,ymin,xmax,ymax,[confidence],[transcription]
+ x1,y1,x2,y2,x3,y3,x4,y4,[confidence],[transcription]
+ """
+ pointsList = []
+ transcriptionsList = []
+ confidencesList = []
+
+ lines = content.split( "\r\n" if CRLF else "\n" )
+ for line in lines:
+ line = line.replace("\r","").replace("\n","")
+ if(line != "") :
+ points, confidence, transcription = get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight);
+ pointsList.append(points)
+ transcriptionsList.append(transcription)
+ confidencesList.append(confidence)
+
+ if withConfidence and len(confidencesList)>0 and sort_by_confidences:
+ import numpy as np
+ sorted_ind = np.argsort(-np.array(confidencesList))
+ confidencesList = [confidencesList[i] for i in sorted_ind]
+ pointsList = [pointsList[i] for i in sorted_ind]
+ transcriptionsList = [transcriptionsList[i] for i in sorted_ind]
+
+ return pointsList,confidencesList,transcriptionsList
+
+def get_tl_dict_values_from_array(array,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,sort_by_confidences=True,validNumPoints=[],validate_cw=True):
+ """
+ Returns all points, confindences and transcriptions of a file in lists. Valid dict formats:
+ {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4}
+ """
+ pointsList = []
+ transcriptionsList = []
+ confidencesList = []
+
+ for n in range(len(array)):
+ objectDict = array[n]
+ points, confidence, transcription = get_tl_dict_values(objectDict,withTranscription,withConfidence,imWidth,imHeight,validNumPoints,validate_cw);
+ pointsList.append(points)
+ transcriptionsList.append(transcription)
+ confidencesList.append(confidence)
+
+ if withConfidence and len(confidencesList)>0 and sort_by_confidences:
+ import numpy as np
+ sorted_ind = np.argsort(-np.array(confidencesList))
+ confidencesList = [confidencesList[i] for i in sorted_ind]
+ pointsList = [pointsList[i] for i in sorted_ind]
+ transcriptionsList = [transcriptionsList[i] for i in sorted_ind]
+
+ return pointsList,confidencesList,transcriptionsList
+
+def main_evaluation(p,default_evaluation_params_fn,validate_data_fn,evaluate_method_fn,show_result=True,per_sample=True):
+ """
+ This process validates a method, evaluates it and if it succed generates a ZIP file with a JSON entry for each sample.
+ Params:
+ p: Dictionary of parmeters with the GT/submission locations. If None is passed, the parameters send by the system are used.
+ default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+ validate_data_fn: points to a method that validates the corrct format of the submission
+ evaluate_method_fn: points to a function that evaluated the submission and return a Dictionary with the results
+ """
+
+ if (p == None):
+ p = dict([s[1:].split('=') for s in sys.argv[1:]])
+ if(len(sys.argv)<3):
+ print_help()
+
+ evalParams = default_evaluation_params_fn()
+ if 'p' in p.keys():
+ evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p']) )
+
+ resDict={'calculated':True,'Message':'','method':'{}','per_sample':'{}'}
+ try:
+ validate_data_fn(p['g'], p['s'], evalParams)
+ evalData = evaluate_method_fn(p['g'], p['s'], evalParams)
+ resDict.update(evalData)
+
+ except Exception as e:
+ resDict['Message']= str(e)
+ resDict['calculated']=False
+
+ if 'o' in p:
+ if not os.path.exists(p['o']):
+ os.makedirs(p['o'])
+
+ resultsOutputname = p['o'] + '/results.zip'
+ outZip = zipfile.ZipFile(resultsOutputname, mode='w', allowZip64=True)
+
+ del resDict['per_sample']
+ if 'output_items' in resDict.keys():
+ del resDict['output_items']
+
+ outZip.writestr('method.json',json.dumps(resDict))
+
+ if not resDict['calculated']:
+ if show_result:
+ sys.stderr.write('Error!\n'+ resDict['Message']+'\n\n')
+ if 'o' in p:
+ outZip.close()
+ return resDict
+
+ if 'o' in p:
+ if per_sample == True:
+ for k,v in evalData['per_sample'].items():
+ outZip.writestr( k + '.json',json.dumps(v))
+
+ if 'output_items' in evalData.keys():
+ for k, v in evalData['output_items'].items():
+ outZip.writestr( k,v)
+
+ outZip.close()
+
+ # if show_result:
+ # #sys.stdout.write("Calculated!")
+ # sys.stdout.write(json.dumps(resDict['method']))
+
+ return resDict
+
+
+def main_validation(default_evaluation_params_fn,validate_data_fn):
+ """
+ This process validates a method
+ Params:
+ default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+ validate_data_fn: points to a method that validates the corrct format of the submission
+ """
+ try:
+ p = dict([s[1:].split('=') for s in sys.argv[1:]])
+ evalParams = default_evaluation_params_fn()
+ if 'p' in p.keys():
+ evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p']) )
+
+ validate_data_fn(p['g'], p['s'], evalParams)
+ print ('SUCCESS')
+ sys.exit(0)
+ except Exception as e:
+ print (str(e))
+ sys.exit(101)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/__init__.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c365a8b35aa340bb9072d0feb44babd9faca4512
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/__init__.py
@@ -0,0 +1,11 @@
+from .judge_util import build_judge, DEBUG_MESSAGE
+from .multiple_choice import extract_answer_from_item, prefetch_answer
+from .vqa_eval import levenshtein_distance
+from .spatial457 import Spatial457_utils
+
+
+__all__ = [
+ 'build_judge', 'extract_answer_from_item', 'prefetch_answer',
+ 'levenshtein_distance', 'DEBUG_MESSAGE',
+ 'Spatial457_utils'
+]
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/ccocr_evaluator/ocr_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ccocr_evaluator/ocr_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c82abccc18abe7a22e9cb7daa7ec6bdb3951f9e
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ccocr_evaluator/ocr_evaluator.py
@@ -0,0 +1,106 @@
+import os
+import sys
+import json
+import re
+from collections import Counter
+
+# local import
+from .common import BaseMetric
+
+
+def token_normalize(token_text, is_lower=False, is_alphanum_only=False):
+ """
+ """
+ if is_lower:
+ token_text = token_text.lower()
+ if is_alphanum_only:
+ token_text = re.sub('[^A-Za-z0-9]+', '', token_text)
+ return token_text
+
+
+def text_normalize_and_tokenize(text, is_keep_blank=True, is_lower=True, is_alphanum_only=False):
+ text = text.replace("\t", " ").replace("\n", " ").replace("###", "").replace("***", "")
+ text = re.sub(r'\s+', ' ', text)
+ if not is_keep_blank:
+ text = text.replace(" ", "")
+ text_tokens = text.split(" ") if is_keep_blank else list(text)
+ text_token_normalized = [token_normalize(t, is_lower, is_alphanum_only) for t in text_tokens]
+ text_token_normalized = [x for x in text_token_normalized if len(x) > 0]
+ return text_token_normalized
+
+
+def evaluate_single_sample(gts, preds):
+ right_num = 0
+ gt_counter_info = dict(Counter(gts))
+ pdt_counter_info = dict(Counter(preds))
+ for gt_token, gt_count in gt_counter_info.items():
+ pred_count = pdt_counter_info.get(gt_token, 0)
+ right_num += min(gt_count, pred_count)
+ return right_num
+
+
+def calculate_metrics(response_info, gt_info, is_verbose=False):
+ """
+ """
+ macro_recall_list, macro_precision_list, macro_f1_list = [], [], []
+ total_gt_num, total_pred_num, total_right_num = 0, 0, 0
+ for file_name, fullbox_gts in gt_info.items():
+ fullbox_preds = response_info.get(file_name, [])
+ right_num = evaluate_single_sample(fullbox_gts, fullbox_preds)
+ total_right_num += right_num
+ total_gt_num += len(fullbox_gts)
+ total_pred_num += len(fullbox_preds)
+
+ macro_recall = right_num / (len(fullbox_gts) + 1e-9)
+ macro_precision = right_num / (len(fullbox_preds) + 1e-9)
+ macro_f1 = 2 * macro_recall * macro_precision / (macro_recall + macro_precision + 1e-9)
+ macro_recall_list.append(macro_recall)
+ macro_precision_list.append(macro_precision)
+ macro_f1_list.append(macro_f1)
+
+ # marco
+ final_macro_recall = sum(macro_recall_list) / (len(macro_recall_list) + 1e-9)
+ final_macro_precision = sum(macro_precision_list) / (len(macro_precision_list) + 1e-9)
+ final_macro_f1 = sum(macro_f1_list) / (len(macro_f1_list) + 1e-9)
+
+ # micro
+ recall_acc = total_right_num / (total_gt_num + 1e-9)
+ preci_acc = total_right_num / (total_pred_num + 1e-9)
+ hmean = 2 * recall_acc * preci_acc / (recall_acc + preci_acc + 1e-9)
+ vbs_eval_result = {
+ 'macro_recall': final_macro_recall, 'macro_precision': final_macro_precision, 'macro_f1_score': final_macro_f1,
+ 'micro_recall': recall_acc, 'micro_precision': preci_acc, 'mirco_f1_score': hmean
+ }
+ eval_result = vbs_eval_result if is_verbose else {'macro_f1_score': final_macro_f1, 'mirco_f1_score': hmean}
+ return eval_result
+
+
+class OcrEvaluator(BaseMetric):
+ def response_post_func(self, response_text, **kwargs):
+ return response_text
+
+ def evaluate(self, response_info, gt_info, **kwargs):
+ # hard code here
+ dataset_name = kwargs['dataset']
+ is_word_level, is_lower, is_alphanum_only = True, True, False
+ if dataset_name in ["Arabic", "Japanese", "Korean"] or "zh" in dataset_name:
+ is_word_level = False
+ if "multi_scene_ocr" in self.group_name and is_word_level:
+ is_alphanum_only = True
+ eval_config = {"word_level": is_word_level, "alphanum_only": is_alphanum_only, "lowercase": is_lower}
+
+ image_pdt_info, image_gt_info = {}, {}
+ for file_name, gt_src in gt_info.items():
+ pred_src = response_info.get(file_name, "")
+ pdt_token_list = text_normalize_and_tokenize(
+ str(pred_src).strip(), is_word_level, is_lower, is_alphanum_only)
+ gt_token_list = text_normalize_and_tokenize(
+ str(gt_src).strip(), is_word_level, is_lower, is_alphanum_only)
+ image_pdt_info[file_name] = pdt_token_list
+ image_gt_info[file_name] = gt_token_list
+ eval_result = calculate_metrics(image_pdt_info, image_gt_info, is_verbose=False)
+ return {"summary": eval_result, "metric_config": eval_config}
+
+
+if __name__ == '__main__':
+ pass
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathvista.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathvista.py
new file mode 100644
index 0000000000000000000000000000000000000000..52e138508262abd1b93bfa544120d37881d7ff5b
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathvista.py
@@ -0,0 +1,164 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_ICE():
+ example_1 = """
+Hint: Please answer the question requiring an integer answer and provide the final value,
+e.g., 1, 2, 3, at the end.\n
+Question: Which number is missing?\n
+Model response: The number missing in the sequence is 14.\n
+Extracted answer: 14
+"""
+
+ example_2 = """
+Hint: Please answer the question requiring a floating-point number with one decimal place and provide the final value,
+e.g., 1.2, 1.3, 1.4, at the end.\n
+Question: What is the fraction of females facing the camera?\n
+Model response: The fraction of females facing the camera is 0.6,
+which means that six out of ten females in the group are facing the camera.\n
+Extracted answer: 0.6
+"""
+
+ example_3 = """
+Hint: Please answer the question requiring a floating-point number with two decimal places and provide the final value,
+e.g., 1.23, 1.34, 1.45, at the end.\n
+Question: How much money does Luca need to buy a sour apple candy and a butter-scotch candy? (Unit: $)\n
+Model response: Luca needs $1.45 to buy a sour apple candy and a butterscotch candy.\n
+Extracted answer: 1.45
+"""
+
+ example_4 = """
+Hint: Please answer the question requiring a Python list as an answer and provide the final list,
+e.g., [1, 2, 3], [1.2, 1.3, 1.4], at the end.\n
+Question: Between which two years does the line graph saw its maximum peak?\n
+Model response: The line graph saw its maximum peak between 2007 and 2008.\n
+Extracted answer: [2007, 2008]
+"""
+
+ example_5 = """
+Hint: Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.\n
+Question: What fraction of the shape is blue?\n
+Choices: (A) 3/11 (B) 8/11 (C) 6/11 (D) 3/5\n
+Model response: The correct answer is (B) 8/11.\n
+Extracted answer: B
+"""
+
+ return [example_1, example_2, example_3, example_4, example_5]
+
+
+def build_mathvista_gpt4_prompt(line):
+ task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+ question = line['question']
+ prediction = str(line['prediction'])
+ prompt = task_description
+ examples = get_gpt4_ICE()
+ for example in examples:
+ prompt += example + '\n'
+ prompt += question + '\n'
+ prompt += 'Model respone: ' + prediction
+ prompt += 'Extracted answer:'
+ return prompt
+
+
+def list_to_dict(lst):
+ return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+ res = None
+ ans = line['answer']
+ response = line['prediction'] if prefetch else line['res']
+ try:
+ if line['question_type'] == 'multi_choice':
+ ans = line['answer_option']
+ choices = list_to_dict(eval(line['choices']))
+ res = can_infer(response, choices)
+ if prefetch:
+ return res
+ else:
+ if line['answer_type'] == 'integer':
+ res = int(response)
+ ans = int(line['answer'])
+ elif line['answer_type'] == 'float':
+ res = float(response)
+ ans = float(line['answer'])
+ else:
+ res = str(res)
+ ans = str(ans)
+ except ValueError:
+ pass
+
+ if res == ans:
+ return res if prefetch else True
+ else:
+ return False
+
+
+def MathVista_auxeval(model, line):
+ prompt = build_mathvista_gpt4_prompt(line)
+ log = ''
+ retry = 5
+ if post_check(line, prefetch=True):
+ res = post_check(line, prefetch=True)
+ return dict(log='Prefetch succeed', res=res)
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log=log, res=res)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='')
+
+
+def MathVista_acc(result_file):
+ data = load(result_file)
+ tot = defaultdict(lambda: 0)
+ fetch = defaultdict(lambda: 0)
+ hit = defaultdict(lambda: 0)
+ lt = len(data)
+ skill_list = []
+ for i in range(lt):
+ item = data.iloc[i]
+ cate = item['task']
+ tot['Overall'] += 1
+ try:
+ skills = eval(item['skills'])
+ except SyntaxError:
+ skills = [item['skills']]
+ for skill in skills:
+ if skill not in skill_list:
+ skill_list.append(skill)
+ tot[skill] += 1
+ tot[cate] += 1
+ if item['log'] == 'Prefetch succeed':
+ fetch['Overall'] += 1
+ fetch[cate] += 1
+ for skill in skills:
+ fetch[skill] += 1
+ if post_check(item, prefetch=False):
+ hit['Overall'] += 1
+ hit[cate] += 1
+ for skill in skills:
+ hit[skill] += 1
+
+ res = defaultdict(list)
+ for k in tot.keys():
+ res['Task&Skill'].append(k)
+ res['tot'].append(tot[k])
+ res['prefetch'].append(fetch[k])
+ res['hit'].append(hit[k])
+ res['prefetch_rate'].append(fetch[k] / tot[k] * 100)
+ res['acc'].append(hit[k] / tot[k] * 100)
+ res = pd.DataFrame(res)
+ return res
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a225d44b4a6dce7c587d04c21aba6f6f0ce0b22
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py
@@ -0,0 +1,27 @@
+from .nbbox_iou import NbboxIouTuple
+
+
+class DictNbboxIouTupleAggJaccard:
+ """Calculates the average precision IoU across the dict.
+
+ 1. Calculates the precision IoU for all sets with the same key,
+ if it appears in either pred or targets
+ 2. Calculates the total, then divides by the size of the union
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ if not isinstance(responses, dict):
+ return 0
+ all_keys = set(responses) | set(targets)
+
+ num_keys = 0
+ total_score = 0
+ for key in all_keys:
+ total_score += NbboxIouTuple.match(
+ responses.get(key, []), targets.get(key, [])
+ )
+ num_keys += 1
+
+ return total_score / num_keys
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cee6c9c6f9511cd2118951d89374cfe9614620c
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py
@@ -0,0 +1,48 @@
+import re
+from ..parsing.common.utils import extract_code_block_content
+
+
+def parse_single_letter(s):
+ # Regular expression to match (A)XXXXX, A . XXXXXXX, or A.XXXXXX
+ match = re.match(r"^\(?([A-Za-z])\)?(?:\s*\.\s*|\.)?(.*)", s)
+
+ if match:
+ # Extract and return the single letter
+ return match.group(1)
+ else:
+ # Return the original string if no match is found
+ return s
+
+
+class ExactStrMatch:
+ """Exact string matching."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Exact match between targets and responses."""
+ if not isinstance(response, str):
+ response = str(response)
+ if not isinstance(correct_answer, str):
+ correct_answer = str(correct_answer)
+
+ if len(correct_answer) == 1 and correct_answer.isalpha() and len(response) > 1:
+ # handle special case of choice letter,
+ # drop the potential parenthesis
+ response = parse_single_letter(response)
+
+ return 1 if response == correct_answer else 0
+
+
+class CodeResultExactStrMatch:
+ """Exact string matching, with the results from a results code block."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Exact match between targets and responses."""
+ correct_answer, is_code = extract_code_block_content(
+ correct_answer,
+ is_ascii_art=True,
+ should_remove_surrounding_whitespace=False,
+ )
+ # assert is_code
+ return ExactStrMatch.match(response, correct_answer)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py
new file mode 100644
index 0000000000000000000000000000000000000000..110ed84665d541dd9bc510b3c9faaad4bdd12ddc
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py
@@ -0,0 +1,14 @@
+import rapidfuzz
+
+
+class NormalizedSimilarityDamerauLevenshtein:
+ """Normalized Damerau-Levenshtein Similarity."""
+
+ @staticmethod
+ def match(response, correct_answer) -> int:
+ """Normalized indel similarityuiio do between targets and responses."""
+ if not isinstance(response, str) and isinstance(correct_answer, str):
+ return 0
+ return rapidfuzz.distance.DamerauLevenshtein.normalized_similarity(
+ response, correct_answer
+ )
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__init__.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/function_and_compare.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/function_and_compare.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a2b121ed0d13d31ad855b1dd35e49736586e0979
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/function_and_compare.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/function_and_compare.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/function_and_compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e1184b1f90e12cb98f29dc064e60ae43da80b8a
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/function_and_compare.py
@@ -0,0 +1,429 @@
+# flake8: noqa
+import re
+from typing import List
+import nltk
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+# # nltk.download("punkt")
+# nltk.data.path.append(
+# os.environ["NLTK_DATA_PATH"]
+# )
+
+# HumanCheck: True
+
+
+def check_whether_response_paragraph_number_in_range(
+ response: str, lower_bound: int, upper_bound: int
+) -> bool:
+ def clean_text(text: str) -> str:
+ return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ # use re to check the number of paragraphs
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ actual_count = len(paragraphs)
+ # print(actual_count)
+
+ return lower_bound <= actual_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_response_sentence_number_in_range(
+ response: str, lower_bound: int, upper_bound: int
+) -> bool:
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ response = clean_text(response)
+
+ # use nltk to split the response into sentences
+ sentences = nltk.sent_tokenize(response)
+ actual_count = len(sentences)
+ # print(actual_count)
+
+ return lower_bound <= actual_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_sentence_number_in_range(
+ response: str, lower_bound: int, upper_bound: int
+) -> bool:
+ def clean_text(text: str) -> str:
+ return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ # use re to check the number of paragraphs
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ for i, paragraph in enumerate(paragraphs):
+ # use nltk to split the paragraph into sentences
+ sentences = nltk.sent_tokenize(paragraph)
+ actual_count = len(sentences)
+ # print(f"paragraph {i}: {actual_count}")
+ if actual_count < lower_bound or actual_count > upper_bound:
+ return False
+
+ return True
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_sentence_number_in_range_list(
+ response: str, ranges: List[List[int]]
+) -> bool:
+ def clean_text(text: str) -> str:
+ return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ # use re to check the number of paragraphs
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ if len(paragraphs) != len(ranges):
+ return False
+
+ for i, (paragraph, range_pair) in enumerate(zip(paragraphs, ranges)):
+ lower_bound, upper_bound = range_pair
+ sentences = nltk.sent_tokenize(paragraph)
+ actual_count = len(sentences)
+ # print(f"paragraph {i}: {actual_count}")
+ if not (lower_bound <= actual_count <= upper_bound):
+ return False
+
+ return True
+
+# HumanCheck: True
+
+
+def check_whether_response_word_count_in_range(
+ response: str, lower_bound: int, upper_bound: int
+) -> bool:
+ # this line is used to filter out all non-word characters
+ response_clean = re.sub(r"[^\w\s.-]", "", response)
+ word_list = response_clean.split()
+ word_count = len(word_list)
+ # print(word_count)
+ return lower_bound <= word_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_word_count_in_range(
+ response: str, lower_bound: int, upper_bound: int
+) -> bool:
+ # Check whether the number of words in each paragraph of the response is greater than or equal to lower_bound and less than or equal to upper_bound.
+ # Here are some examples of calling this function based on constraints:
+ # If the constraint requires that the number of words in each paragraph
+ # should be between 50 and 80, then lower_bound = 50 and upper_bound = 80.
+ def clean_text(text: str) -> str:
+ return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ # use re to check the number of paragraphs
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ for i, paragraph in enumerate(paragraphs):
+ paragraph_clean = re.sub(r"[^\w\s.-]", "", paragraph)
+ word_count = len(paragraph_clean.split())
+ # print(f"paragraph {i} word count: {word_count}")
+ if not (lower_bound <= word_count <= upper_bound):
+ return False
+
+ return True
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_not_contain_certain_substrings(
+ response: str, substrings: List[str]
+) -> bool:
+ # Check whether the entire response does not contain any of the specified substrings.
+ # Here are some examples of calling this function based on constraints:
+ # If the constraint requires that the response should not contain the
+ # words "apple" and "banana", then substrings = ["apple", "banana"].
+ return all(substring not in response for substring in substrings)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_not_contain_certain_substring(
+ response: str, substring: str
+) -> bool:
+ return substring not in response
+
+# HumanCheck: True
+
+
+def check_whether_each_sentence_begin_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ # Check whether each sentence in the response starts with the specified substring.
+ # Here are some examples of calling this function based on constraints:
+ # If the constraint requires that each sentence should start with
+ # exclamation point, then substring = "!".
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ response = clean_text(response)
+
+ sentences = nltk.sent_tokenize(response)
+
+ return all(sentence.startswith(substring) for sentence in sentences)
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_begin_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ return all(paragraph.startswith(substring) for paragraph in paragraphs)
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_end_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ cleaned_response = clean_text(response)
+
+ paragraphs = [
+ p for p in re.split(
+ r"\n\s*\n",
+ cleaned_response) if p.strip()]
+
+ return all(paragraph.endswith(substring) for paragraph in paragraphs)
+
+# HumanCheck: True
+
+
+def check_whether_each_sentence_end_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ response = clean_text(response)
+
+ sentences = nltk.sent_tokenize(response)
+
+ return all(sentence.endswith(substring) for sentence in sentences)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_begin_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ return response.strip().startswith(substring)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_end_with_certain_substring(
+ response: str, substring: str
+) -> bool:
+ return response.strip().endswith(substring)
+
+# HumanCheck: True
+
+
+def check_whether_each_keyword_in_list_metioned_in_range(
+ response: str,
+ keywords: List[str],
+ lower_bound_times: int,
+ upper_bound_times: int) -> bool:
+ # should notice case like "Reddit" is counted as "Redditor"
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ response = clean_text(response)
+ response_lower = response.lower()
+
+ for keyword in keywords:
+ # use \b to match the whole word
+ pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+ matches = re.findall(pattern, response_lower)
+ if len(matches) < lower_bound_times or len(
+ matches) > upper_bound_times:
+ return False
+
+ return True
+
+# HumanCheck: True
+
+
+def check_whether_total_keyword_in_list_metioned_in_range(
+ response: str,
+ keywords: List[str],
+ lower_bound_times: int,
+ upper_bound_times: int) -> bool:
+ # should notice case like "Reddit" is counted as "Redditor"
+ def clean_text(response: str) -> str:
+ return "\n".join(line.strip()
+ for line in response.splitlines()).strip()
+
+ response = clean_text(response)
+ response_lower = response.lower()
+
+ count = 0
+ for keyword in keywords:
+ pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+ matches = re.findall(pattern, response_lower)
+ count += len(matches)
+
+ return lower_bound_times <= count <= upper_bound_times
+
+# HumanCheck: True
+
+
+def check_percentage_number_precision_in_response(
+ response: str, precision: int) -> bool:
+ # All numeric values that appear before a percentage sign (%) must be
+ # rounded and retained to two decimal places.
+ pattern = r'(\d+\.\d+|\d+)\s*%' # allow numbers and % to have spaces
+
+ matches = re.findall(pattern, response)
+
+ for num_str in matches:
+ if '.' not in num_str:
+ # no decimal point, not a float number
+ return False
+ decimal_part = num_str.split('.')[1]
+ if len(decimal_part) != precision:
+ return False
+
+ return True
+
+# HumanCheck: True
+
+
+def check_number_precision_in_response(response: str, precision: int) -> bool:
+ # Regex pattern to extract numbers, including scientific notation and
+ # percentages
+ number_pattern = r'''
+ (? bool:
+ number_pattern = r"""
+ (? bool:
+# scientific_pattern = r"(?"
+DEFAULT_VIDEO_TOKEN = " | |