Upload 8 files

README.md

@@ -1,3 +1,72 @@
+# InfoChartQA:  Benchmark for Multimodal Question Answering on Infographic Charts
+🤗[Dataset](https://huggingface.co/datasets/Jietson/InfoChartQA)
+
+# Dataset 
+You can find our dataset on huggingface: 🤗[InfoChartQA Dataset](https://huggingface.co/datasets/Jietson/InfoChartQA)
+
+# Usage
+
+Each question entry is arranged as:
+
+```
+--question_id: int
+--qtype: int
+--figure_path: image
+--visual_figure_path: list of image
+--question: str
+--answer: str
+--instructions: str
+--prompt: str
+--options: list of dict ("A/B/C/D":"option_content")
+```
+
+Each question is built as:
+
+```
+image_input: figure_path, visual_figure_path_1...visual_figure_path_n (if any)
+text_iunput: prompt (if any) + question + options (if any) + instructions (if any)
+```
+
+# Evaluate
+
+You should store and evaluate model's response as:
+
+```python
+# Example code for evaluate
+def build_question(query):#to build the question
+    question = ""
+    if "prompt" in query:
+    	question = question + f"{query["prompt"]}\n"
+    question = question + f"{query["question"]}\n"
+    if "options" in query:
+        for _ in query["options"]:
+        	question = question + f"{_} {query['options'][_]}\n"
+	if "instructions" in query:
+    	question = question + query["instructions"]
+    return question
+
+with open("visual_basic.json","r",encode="utf-8") as f:
+	queries = json.load(f)
+
+for idx in range(queries):
+    question = build_question(queries[idx])
+    figure_path = [queries[idx]['figure_path']]
+    visual_figure_path = queries[idx]['visual_figure_path']
+    
+	response = model.generate(question, [figure_path, visual_figure_path])# generate model's response based on 
+    
+    queries[idx]["response"] = reponse
+
+with open("model_reponse.json","w",encode="utf-8") as f:
+	json.dump(queries, f)
+from checker import evaluate
+evaluate("model_reponse.json", "path_to_save_the_result")
+```
+
+
+
+ 
+
 ---
 dataset_info:
   features:
@@ -19,7 +88,7 @@ dataset_info:
     dtype: string
   - name: options
     list: string
-  splits:
+    splits:
   - name: info
     num_bytes: 9389294399.0
     num_examples: 55091
@@ -32,9 +101,9 @@ dataset_info:
   - name: visual_basic
     num_bytes: 1254942699.466
     num_examples: 7297
-  download_size: 20376840742
-  dataset_size: 26739208377.466
-configs:
+    download_size: 20376840742
+    dataset_size: 26739208377.466
+    configs:
 - config_name: default
   data_files:
   - split: info
@@ -45,4 +114,5 @@ configs:
     path: data/visual_metaphor-*
   - split: visual_basic
     path: data/visual_basic-*
+
 ---

eval/__init__.py

@@ -0,0 +1 @@
+from .checker import evaluate

eval/checker.py

@@ -0,0 +1,183 @@
+import json
+import os
+from collections import defaultdict
+from compare_value import compare_value
+from compare_sequence import is_sequence_match_ordered, is_sequence_match_unordered
+from compare_str import fuzzy_string_match
+from compare_multiple import multiple_choice_checker
+
+def has_more_digits_than_other_chars(s):
+    if isinstance(s, (int, float)):
+        return True
+    s = s.replace('.', '1')
+    s = s.replace(',', '1')
+    s = s.replace('$', '1')
+    s = s.replace('B', '1')
+    s = s.replace('T', '1')
+    s = s.replace('K', '1')
+    digit_count = 0
+    other_count = 0
+    for char in s:
+        if char.isdigit():
+            digit_count += 1
+        else:
+            other_count += 1
+
+    return digit_count > other_count
+
+
+def evaluate_answer(answer, response, qtype):
+    if qtype in [1, 2, 101, 102]:
+        if has_more_digits_than_other_chars(answer):
+            return "Exact Numeric", compare_value(answer, response)
+        else:
+            return "Vague String", fuzzy_string_match(answer, response)
+    elif qtype in [72, 54]:
+        return "Exact Numeric", compare_value(answer, response)
+    elif qtype in [10, 50, 51, 52, 110]:
+        return "Vague Numeric", compare_value(answer, response, eps=0.05)
+    elif qtype in [13, 103, 113]:
+        if answer.lower() in response.lower():
+            return "Exact String", True
+        return "Exact String", compare_value(answer, response)
+    elif qtype in [40, 41, 42, 43, 44]:
+        response = response.replace("\n", ",")
+        response = response.replace(" ", "")
+        answer = answer.replace(" ", "")
+        return "Vague Unordered Sequence", is_sequence_match_unordered(answer.split(","), response.split(","), fuzzy=True)
+    elif qtype in [60, 61, 70, 80, 90]:
+        return "Vague String", fuzzy_string_match(answer, response)
+    elif qtype in [71]:
+        response = response.replace("\n\n", "")
+        response = response.replace("\n", ",")
+        response = response.replace(" ", "")
+        response = response.replace("<", ",")
+        response = response.replace(">", ",")
+        if response.count(":") == 1:
+            response = response[response.find(':') + 1:]
+        answer = answer.replace(" ", "")
+        return "Vague Ordered Sequence", is_sequence_match_ordered(answer.split(","), response.split(","), fuzzy=True)
+    elif qtype in [30]:
+        for an in answer:
+            if is_sequence_match_ordered(an.split(","), response.split(","), fuzzy=True):
+                return "Vague Ordered Sequence", True
+        return "Vague Ordered Sequence", False
+    elif qtype in [202,1919810,1919811,1919812]:
+        return "Exact String", multiple_choice_checker(answer , response)
+    else:
+        print('there is no qtype',qtype)
+        return "Exact Numeric", compare_value(answer, response)
+
+
+def process_json_data(json_data):
+    results = []
+    stats = {
+        'qtype_stats': defaultdict(lambda: {'correct': 0, 'total': 0}),
+        'figure_stats': defaultdict(lambda: {'correct': 0, 'total': 0}),
+        'total_correct': 0,
+        'total_questions': 0
+    }
+
+    for key, item in json_data.items():
+        question_id = item["question_id"]
+        if 'qtype' in item:
+            qtype = item["qtype"]
+        elif 'qid' in item:
+            qtype = item["qid"]
+        else:
+            qtype = 1
+        if "response" not in item or item['response'] == 'Error!':
+            continue
+
+        answer = str(item["answer"])
+        response = str(item["response"])
+        response = response.replace(" "," ")
+
+
+        figure_path = item["figure_path"]
+        if type(figure_path) == list:
+            figure_path = figure_path[0]
+
+        eval_method, score = evaluate_answer(answer, response, qtype)
+
+        results.append({
+            "figure_path": figure_path,
+            "answer": answer,
+            "response": response,
+            "question": item["question"] if "question" in item else "",
+            "question_id": question_id,
+            "qtype": qtype,
+            "score": score,
+            "eval_method": eval_method
+        })
+
+        stats['qtype_stats'][qtype]['correct'] += score
+        stats['qtype_stats'][qtype]['total'] += 1
+
+        stats['figure_stats'][figure_path]['correct'] += score
+        stats['figure_stats'][figure_path]['total'] += 1
+
+        stats['total_correct'] += score
+        stats['total_questions'] += 1
+
+    return results, stats
+
+
+def calculate_accuracy(correct, total):
+    return round(correct / total * 100, 2) if total > 0 else 0.0
+
+
+def generate_stat_report(stats):
+    report = {}
+
+    report['overall_accuracy'] = calculate_accuracy(
+        stats['total_correct'], stats['total_questions'])
+
+    qtype_report = {}
+    for qtype, counts in stats['qtype_stats'].items():
+        qtype_report[f"qtype_{qtype}"] = {
+            'accuracy': calculate_accuracy(counts['correct'], counts['total']),
+            'correct': counts['correct'],
+            'total': counts['total']
+        }
+    report['qtype_accuracy'] = qtype_report
+
+    figure_report = {}
+    for figure_path, counts in stats['figure_stats'].items():
+        figure_report[figure_path] = {
+            'accuracy': calculate_accuracy(counts['correct'], counts['total']),
+            'correct': counts['correct'],
+            'total': counts['total']
+        }
+    report['figure_accuracy'] = figure_report
+
+    return report
+
+from copy import deepcopy
+def evaluate(input_file, output_file=None, stats_file=None):
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    with open(input_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    if type(data).__name__=='list':
+        __ = deepcopy(data)
+        data = {}
+        for _ in __:
+            data[_['question_id']] = deepcopy(_)
+    
+    
+    results, stats = process_json_data(data)
+    report = generate_stat_report(stats)
+
+    if output_file:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2, ensure_ascii=False)
+        print(f"Score save to {output_file}")
+
+    if stats_file:
+        with open(stats_file, 'w', encoding='utf-8') as f:
+            json.dump(report, f, indent=2, ensure_ascii=False)
+        print(f"Statis saved to {stats_file}")
+
+    print(f"Acc: {report['overall_accuracy']}% {stats['total_questions']}")
+
+    return results, report

eval/compare_multiple.py

@@ -0,0 +1,74 @@
+import numpy as np
+import random
+def parse_multi_choice_response(response, all_choices, index2ans):
+    """
+    Parse the prediction from the generated response.
+    Return the predicted index e.g., A, B, C, D.
+    """
+    for char in [',', '.', '!', '?', ';', ':', "'"]:
+        response = response.strip(char)
+    response = " " + response + " " # add space to avoid partial match
+
+    index_ans = True
+    ans_with_brack = False
+    candidates = []
+    for choice in all_choices:  # e.g., (A) (B) (C) (D)
+        if f'({choice})' in response:
+            candidates.append(choice)
+            ans_with_brack = True
+    if len(candidates) == 0:
+        for choice in all_choices: # e.g., A B C D
+            if f' {choice} ' in response:
+                candidates.append(choice)
+
+    # if all above doesn't get candidates, check if the content is larger than 5 tokens and try to parse the example
+    if len(candidates) == 0 and len(response.split()) > 5:
+        for index, ans in index2ans.items():
+            if ans.lower() in response.lower():
+                candidates.append(index)
+                index_ans = False # it's content ans.
+
+    # print("haha",candidates)
+    if len(candidates) == 0:  # still not get answer, randomly choose one.
+        pred_index = 'None' + str(random.randint(0,255))
+    elif len(candidates) > 1:
+        start_indexes = []
+        if index_ans:
+            if ans_with_brack:
+                for can in candidates:
+                    index = response.rfind(f'({can})')
+                    start_indexes.append(index) # -1 will be ignored anyway
+                # start_indexes = [generated_response.index(f'({can})') for can in candidates]
+            else:
+                for can in candidates:
+                    index = response.rfind(f" {can} ")
+                    start_indexes.append(index)
+        else:
+            for can in candidates:
+                index = response.lower().rfind(index2ans[can].lower())
+                start_indexes.append(index)
+        # get the last one
+        pred_index = candidates[np.argmax(start_indexes)]
+    else: # if only one candidate, use it.
+        pred_index = candidates[0]
+
+    return pred_index
+
+
+
+def multiple_choice_checker(
+        gt : str,
+        pred : str
+) -> bool:
+    if len(pred) > 50:
+        pred = pred[-10:]
+    pred = pred.split(',')
+    gt   = gt.upper().split(',')
+
+    # pred = (#)
+    jury = set([parse_multi_choice_response(_, ["A","B","C","D"] , {}) for _ in pred])
+    std  = set([parse_multi_choice_response(_, ["A", "B", "C", "D"], {}) for _ in gt])
+    # print(jury,std)
+    return jury == std
+if __name__ == "__main__":
+    print(multiple_choice_checker('B',"According to Figure 1, which details \"Iraq's bloody toll\" with a focus on the massive number of civilian and other deaths, the predominant theme is one of immense loss of life and tragedy. The graph visually represents the scale of death over several years. Let's analyze the options in this context:\n\n(A) The fear of blood: While \"bloody toll\" is in the title and red is a dominant color, the graph itself quantifies deaths. Fear of blood is a specific phobia or immediate reaction to violence, but the graph presents the aftermath and scale of death, which is broader than just the fear of blood.\n\n(B) The grief for death: Figure 1 overwhelmingly presents statistics about death. The sheer number of casualties (e.g., 113,726 civilian deaths) directly points to widespread loss. Grief is the natural and profound emotional response to such extensive death. The purpose of such a graphic is often to convey the human cost, which is closely associated with grief.\n\n(C) The amazement at quantity: The numbers are indeed shockingly large, and one might be amazed or stunned by the scale. However, \"amazement\" alone doesn't fully capture the emotional gravity of what these quantities represent – human lives lost. It's a more intellectual or initial reaction.\n\n(D) The indifference of society: Figure 1, by its nature as an informative graphic likely published to raise awareness, aims to combat indifference rather than depict it as a predominant emotion stemming from the facts. It highlights a serious issue, implicitly calling for attention and concern.\n\nConsidering the central message of Figure 1 is the staggering number of deaths and the tragic human cost of the conflict, the most predominant emotion that Figure 1 would suggest for a related Figure 2 (which would presumably depict the human aspect of this toll) is grief. The data in Figure 1 is a quantifiable representation of events that would cause widespread grief.\n\nThe final answer is $\\  B  $."))

eval/compare_sequence.py

@@ -0,0 +1,270 @@
+import json
+from typing import List, Hashable, Union
+from collections import Counter
+
+
+def is_sequence_valid(sequence: List[Union[Hashable, str]],
+                      case_sensitive: bool = False,
+                      strip_spaces: bool = True,
+                      fuzzy_duplicates: bool = False,
+                      fuzzy_threshold: float = 0.6) -> bool:
+    """
+    检查序列是否合法（无重复元素）
+
+    参数:
+        sequence: 待检查的序列
+        case_sensitive: 是否区分大小写（仅适用于字符串）
+        strip_spaces: 是否去除字符串两端空格
+        fuzzy_duplicates: 是否启用模糊查重（仅适用于字符串）
+        fuzzy_threshold: 模糊匹配阈值(0-1)
+
+    返回:
+        bool: True表示无重复（合法），False表示有重复（非法）
+
+    示例:
+        >>> is_sequence_valid(["A", "B", "C"])  # True
+        >>> is_sequence_valid(["A", "a"], case_sensitive=False)  # False
+        >>> is_sequence_valid([" apple ", "apple"])  # False
+    """
+    if not sequence:
+        return True
+
+    processed = []
+    # print(sequence)
+    for item in sequence:
+        # print(item)
+        if isinstance(item, str):
+            # 字符串预处理
+            processed_item = item
+            if not case_sensitive:
+                processed_item = processed_item.lower()
+            if strip_spaces:
+                processed_item = processed_item.strip()
+            processed.append(processed_item)
+        else:
+            processed.append(item)
+
+    # 常规检查（精确匹配）
+    # print(processed)
+    if not fuzzy_duplicates:
+        return len(processed) == len(set(processed))
+
+    # 模糊查重模式
+    for i in range(len(processed)):
+        for j in range(i + 1, len(processed)):
+            if isinstance(processed[i], str) and isinstance(processed[j], str):
+                # 使用difflib进行模糊匹配
+                from difflib import SequenceMatcher
+                similarity = SequenceMatcher(None, processed[i], processed[j]).ratio()
+                if similarity >= fuzzy_threshold:
+                    return False
+            else:
+                # 非字符串类型退化为精确匹配
+                if processed[i] == processed[j]:
+                    return False
+    return True
+
+
+def extract_answers_from_file(file_path):
+    """
+    从JSON文件中读取数据并提取answer序列
+
+    参数:
+        file_path: str - JSON文件路径
+
+    返回:
+        dict - 包含提取序列和元数据的字典
+    """
+    try:
+        # 读取JSON文件
+        with open(file_path, 'r', encoding='utf-8') as f:
+            input_data = json.load(f)
+
+        # 初始化结果字典
+        result = {
+            "sequences": [],
+            "details": []
+        }
+
+        # 遍历每个条目
+        for key, item in input_data.items():
+            # 检查answer字段是否存在
+            if 'answer' not in item:
+                continue
+
+            # 提取answer并按逗号分割成序列，去除前后空格
+            answer_sequence = [x.strip() for x in str(item['answer']).split(',')]
+
+            # 存储序列和相关信息
+            result["sequences"].append(answer_sequence)
+            result["details"].append({
+                "question_id": item.get("question_id", ""),
+                "figure_path": item.get("figure_path", ""),
+                "qtype": item.get("qtype", -1),
+                "question": item.get("question", ""),
+                "sequence_length": len(answer_sequence)
+            })
+
+        return result
+
+    except FileNotFoundError:
+        print(f"错误：文件 {file_path} 未找到")
+        return None
+    except json.JSONDecodeError:
+        print("错误：文件内容不是有效的JSON格式")
+        return None
+    except Exception as e:
+        print(f"处理文件时发生错误：{str(e)}")
+        return None
+
+
+from difflib import SequenceMatcher
+from typing import List, Union, Optional
+
+
+def fuzzy_match(s1: str, s2: str, threshold: float = 0.6) -> bool:
+    """
+    模糊字符串匹配（基于相似度阈值）
+    :param s1: 字符串1
+    :param s2: 字符串2
+    :param threshold: 相似度阈值(0-1)
+    :return: 是否匹配
+    """
+    flag = False
+    flag |= SequenceMatcher(None, s1.lower().strip(), s2.lower().strip()).ratio() >= threshold
+    flag |= s1 in s2
+    flag |= s2 in s1
+    # print(s1 , s2 , SequenceMatcher(None, s1.lower().strip(), s2.lower().strip()).ratio(),flag)
+    return flag
+
+
+def is_sequence_match_ordered(
+        seq1: List[str],
+        seq2: List[str],
+        fuzzy: bool = False,
+        threshold: float = 0.6
+) -> bool:
+    """
+    检查两个序列是否顺序完全一致
+    :param seq1: 序列1
+    :param seq2: 序列2
+    :param fuzzy: 是否启用模糊匹配
+    :param threshold: 模糊匹配阈值
+    :return: 是否匹配
+    """
+    if len(seq1) != len(seq1):
+        return False
+
+    if not is_sequence_valid(seq1, case_sensitive=True):
+        return False
+
+    if not is_sequence_valid(seq2, case_sensitive=True):
+        return False
+
+    # print(seq1 , seq2)
+    if fuzzy:
+        return all(fuzzy_match(x, y, threshold) for x, y in zip(seq1, seq2))
+    else:
+        return all(x.strip().lower() == y.strip().lower() for x, y in zip(seq1, seq2))
+
+
+def is_sequence_match_unordered(
+        seq1: List[str],
+        seq2: List[str],
+        fuzzy: bool = False,
+        threshold: float = 0.8
+) -> bool:
+    """
+    检查两个序列是否元素一致（不考虑顺序）
+    :param seq1: 序列1
+    :param seq2: 序列2
+    :param fuzzy: 是否启用模糊匹配
+    :param threshold: 模糊匹配阈值
+    :return: 是否匹配
+    """
+    if len(seq1) != len(seq2):
+        return False
+
+    seq1_processed = [s.lower().strip() for s in seq1]
+    seq2_processed = [s.lower().strip() for s in seq2]
+
+    if fuzzy:
+        # 构建双向最佳匹配
+        matched_indices = set()
+        for i, s1 in enumerate(seq1):
+            for j, s2 in enumerate(seq2):
+                if j not in matched_indices and fuzzy_match(s1, s2, threshold):
+                    matched_indices.add(j)
+                    break
+        return len(matched_indices) == len(seq1)
+    else:
+        return sorted(seq1_processed) == sorted(seq2_processed)
+
+
+# 测试用例
+if __name__ == "__main__":
+    A = "Russia, DR Congo, Ethiopia, Bangladesh, Iraq, Yemen, Pakistan, India"
+    B = "Russia: 2  \nD.R. Congo: 3  \nEthiopia: 5  \nBangladesh: 5  \nIraq: 7  \nYemen: 7  \nPakistan: 12  \nIndia: 134"
+    B = B.replace("\n", ",")
+    B = B.replace(" ", "")
+    A = A.replace(" ", "")
+    print(is_sequence_match_ordered(A.split(","), B.split(","), fuzzy=True))
+
+    # 测试数据
+    exact_ordered = ["Apple", "Banana", "Orange"]
+    exact_unordered = ["Banana", "Orange", "Apple"]
+    fuzzy_ordered = [" Apple ", "banana", "Orang"]
+    fuzzy_unordered = ["banan", "orang", " apple"]
+
+    # 精确顺序匹配测试
+    print("精确顺序匹配:")
+    print(exact_ordered, exact_ordered, is_sequence_match_ordered(exact_ordered, exact_ordered))  # True
+    print(exact_ordered, exact_unordered, is_sequence_match_ordered(exact_ordered, exact_unordered))  # False
+
+    # 精确无序匹配测试
+    print("\n精确无序匹配:")
+    print(exact_ordered, exact_unordered, is_sequence_match_unordered(exact_ordered, exact_unordered))  # True
+    print(exact_ordered, ["Apple", "Banana"], is_sequence_match_unordered(exact_ordered, ["Apple", "Banana"]))  # False
+
+    # 模糊顺序匹配测试
+    print("\n模糊顺序匹配:")
+    print(exact_ordered, fuzzy_ordered, is_sequence_match_ordered(exact_ordered, fuzzy_ordered, fuzzy=True))  # True
+    print(exact_ordered, fuzzy_unordered,
+          is_sequence_match_ordered(exact_ordered, fuzzy_unordered, fuzzy=True))  # False
+
+    # 模糊无序匹配测试
+    print("\n模糊无序匹配:")
+    print(exact_ordered, fuzzy_unordered,
+          is_sequence_match_unordered(exact_ordered, fuzzy_unordered, fuzzy=True))  # True
+    print(exact_ordered, ["App", "Banan"],
+          is_sequence_match_unordered(exact_ordered, ["App", "Banan"], fuzzy=True))  # False
+
+    answer = "Trondheim,Munich,TheHague,Muscat,RasAlKhaimah,Dubai,Taipei,Doha,Ajman,AbuDhabi"
+    response = "Trondheim,Munich,TheHague,Muscat,RasAlKhaimah,Dubai,Taipei,Doha,Ajman,AbuDhabi"
+    print(is_sequence_match_ordered(answer.split(","), response.split(","), fuzzy=True))
+
+    assert is_sequence_valid(["A", "B", "C"]) == True
+    assert is_sequence_valid(["A", "A"]) == False
+
+    # 大小写测试
+    assert is_sequence_valid(["A", "a"], case_sensitive=False) == False
+    assert is_sequence_valid(["A", "a"], case_sensitive=True) == True
+
+    # 空格处理测试
+    assert is_sequence_valid(["apple", " apple "]) == False
+    assert is_sequence_valid(["apple", " apple "], strip_spaces=False) == True
+
+    # 模糊匹配测试
+    assert is_sequence_valid(["apple", "applee"], fuzzy_duplicates=True) == False
+    assert is_sequence_valid(["apple", "aple"], fuzzy_duplicates=True, fuzzy_threshold=0.8) == False
+    assert is_sequence_valid(["apple", "orange"], fuzzy_duplicates=True) == True
+
+    # 混合类型测试
+    assert is_sequence_valid([1, "1"]) == True
+    assert is_sequence_valid([1, 1]) == False
+
+    # 边界情况
+    assert is_sequence_valid([]) == True
+    assert is_sequence_valid([None, None]) == False
+
+

eval/compare_str.py

@@ -0,0 +1,91 @@
+def is_string_match(answer, response, case_sensitive=False):
+    """
+    判断两个字符串是否匹配，支持模糊子串匹配
+    
+    参数:
+        answer: 预期字符串
+        response: 待检查字符串
+        case_sensitive: 是否区分大小写（默认不区分）
+    
+    返回:
+        bool: 是否匹配
+    """
+    if not case_sensitive:
+        answer = answer.lower()
+        response = response.lower()
+    
+    # 1. 完全一致
+    if answer == response:
+        return True
+    
+    # 2. answer是response的子串
+    if answer in response:
+        return True
+    
+    # 3. 模糊匹配：允许少量字符不匹配（简单实现）
+    # 这里使用简单的子序列检查，可以根据需求替换为更复杂的模糊匹配算法
+    len_answer = len(answer)
+    len_response = len(response)
+    
+    # answer比response长，肯定不是子串
+    if len_answer > len_response:
+        return False
+    
+    # 简单子序列检查（允许中间有少量不匹配字符）
+    i = j = 0
+    mismatch_count = 0
+    max_mismatch = max(1, len_answer // 4)  # 允许25%的字符不匹配
+    
+    while i < len_answer and j < len_response:
+        if answer[i] == response[j]:
+            i += 1
+            j += 1
+        else:
+            j += 1
+            mismatch_count += 1
+            if mismatch_count > max_mismatch:
+                return False
+    
+    return i == len_answer
+
+
+# 更强大的模糊匹配版本（使用difflib）
+from difflib import SequenceMatcher
+
+def fuzzy_string_match(answer, response, threshold=0.8, case_sensitive=False):
+    """
+    使用difflib的模糊匹配
+    
+    参数:
+        threshold: 相似度阈值(0-1)
+    """
+    if not case_sensitive:
+        answer = answer.lower()
+        response = response.lower()
+    
+    # 完全匹配
+    if answer == response:
+        return True
+    
+    # 子串匹配
+    if answer in response:
+        return True
+    
+    # 模糊匹配
+    similarity = SequenceMatcher(None, answer, response).ratio()
+    return similarity >= threshold
+
+# 在问答系统中的应用
+# qa_pairs = [
+#     {"answer": "人工智能", "response": "AI(人工智能)是未来趋势"},
+#     {"answer": "Python", "response": "我们使用python编程"},
+#     {"answer": "机器学习", "response": "深度学习是机器学习的分支"},
+#     {"answer": "42", "response": "答案是42"},
+#     {"answer": "hello", "response": "hi there"}
+# ]
+
+# print("\n问答系统匹配结果:")
+# for pair in qa_pairs:
+#     matched = fuzzy_string_match(pair["answer"], pair["response"])
+#     print(f"Answer: '{pair['answer']}' | Response: '{pair['response']}' → "
+#           f"{'匹配' if matched else '不匹配'}")

eval/compare_value.py

@@ -0,0 +1,291 @@
+import re
+from compare_str import fuzzy_string_match
+unit_map = {
+    'K': 1e3,
+    'k': 1e3,
+    'M': 1e6,  # 百万
+    'm': 1e6,  # 百万
+    'million': 1e6,  # 百万
+    'bn': 1e9,  # 百万
+    'Bn': 1e9,  # 百万
+    'b': 1e9,  # 百万
+
+    'B': 1e9,   # 十亿
+    'T': 1e12,
+    "%": 1e-2,
+    "Cr": 1e8,
+    "None": 1,
+    "Billion": 1e9
+}
+
+def extract_numbers_keep_order(text):
+    matches = []
+
+    # 1. 包含逗号的数字（不能包含小数点）
+    for m in re.finditer(r'-?(?:\d+,)+\d+', text):
+        if '.' not in m.group():
+            matches.append((m.start(), m.group()))
+
+    # 2. 小数（不能包含逗号）
+    for m in re.finditer(r'-?\d+\.\d+', text):
+        if ',' not in m.group():
+            matches.append((m.start(), m.group()))
+
+    # 3. 纯整数（不包含点或逗号，且不嵌套在已有匹配中）
+    for m in re.finditer(r'(?<![\d.,])-?\d+(?![\d.,])', text):
+        val = m.group()
+        start = m.start()
+        # 避免包含在已有匹配中
+        if '.' not in val and ',' not in val and all(not (start >= s and start < s + len(v)) for s, v in matches):
+            matches.append((start, val))
+
+    # 排序按出现顺序
+    matches.sort()
+
+    # 返回匹配值
+    return [v for _, v in matches]
+
+def get_last_number(value):
+    numbers = extract_numbers_keep_order(value)
+    if len(numbers) == 0:
+        return None
+    value = numbers[-1]
+    
+    if value.count('.') > 0:
+        if value.count('.') == 1:
+            return convert(value)
+        if only_digits_and_commas(value, '.'):
+            return convert(value.replace(".",""))
+        return value
+    elif value.count(',') > 0:
+        if only_digits_and_commas(value, ','):
+            return convert(value.replace(",",""))
+        if value.count(',') == 1:
+            return convert(value.replace(',','.'))
+        return value
+    return value
+
+def only_digits_and_commas(s, divide):
+    res1 = False
+    res2 = False
+    if divide == ",":
+        pattern = r'^\d{1,3}(,\d{3})*$'
+        if bool(re.fullmatch(r'[0-9,]+', s)):
+            res1 = True
+            if is_valid_thousand_separator(s, divide):
+                res2 = True
+    elif divide == ".":
+        pattern = r'^\d{1,3}(.\d{3})*$'
+        if bool(re.fullmatch(r'[0-9,]+', s)):
+            res1 = True
+            if is_valid_thousand_separator(s, divide):
+                res2 = True
+    return res1, res2
+    
+    
+
+def is_valid_thousand_separator_old(s, divide):
+    # 匹配是否为合法的千分位格式（例如：1,234,567）
+    if divide == ",":
+        pattern = r'^[-+]?\d{1,3}(,\d{3})*(\.(\d*))?$'
+    elif divide == ".":
+        pattern = r'^[-+]?\d{1,3}(.\d{3})*(\,(\d*))?$'
+    else:
+        return None
+    return bool(re.match(pattern, s))
+
+def convert(x):
+    x_str = str(x)
+    if x_str.replace('.', '', 1).isdigit() or (x_str.startswith('-') and x_str[1:].replace('.', '', 1).isdigit()):
+        # print("convert",x)
+        return int(float(x)) if float(x).is_integer() else float(x)
+    # print("no need to convert",x)
+    return x
+
+def contains_number(s):
+    for ch in s:
+        if is_standard_digit(ch):
+            return True
+    return False
+
+def clean(x):
+    x = str(x)
+    x = x.replace(" ","")
+    x = x.replace("$","")
+    x = x.replace("\n","")
+    return convert(x)
+def is_standard_digit(char):
+    return bool(re.match(r'^[0-9]$', char))
+def get_unit(value):
+    _v = str(value)
+    n = len(_v)
+    R , L = n , 0
+    for i in range(n - 1, -1, -1):
+        if value[i].isalpha() or value[i] == '%':
+            R = i
+            break
+    
+    # print('debugging',L , R + 1)
+    if R == n:
+        return "None"
+    for i in range(R, -1, -1):
+        if not value[i].isalpha() and value[i] != '%':
+            L = i + 1
+            break
+    if L > R:
+        return "None"
+    return value[L : R + 1]
+
+
+    
+def loose_is_digit(s):
+    for ch in s:
+        if is_standard_digit(ch) or ch == ',' or ch == '.' or ch == '+' or ch == '-':
+            continue
+        return False
+    return True
+
+def get_numeric(value):
+    _v = str(value)
+    n = len(_v)
+    L , R = -1 , n
+    
+    i = 0
+    while i < n:
+        if not is_standard_digit(value[i]) and value[i] != '+' and value[i] != '-':
+            i = i + 1
+            continue
+        j = i
+        while j < n and loose_is_digit(value[j]):
+            j = j + 1
+        L, R = i, j
+        # print("cnm",i , j,value[i:j])
+        i = j
+    if L == -1:
+        return 0
+    else:
+        return value[L : R]
+def convert_to_number(value):
+    unit_part = get_unit(value)
+    
+    value = str(value).replace("$","")
+    if is_number(value):
+        return float(value)
+    # 提取数字部分和单位部分
+    if not is_number(value[:-1]):
+        return value
+    number_part = float(value[:-1])  # 去掉最后一个字符（单位）
+    return number_part * unit_part
+
+
+def is_number(s):
+    try:
+        float(s)  # 尝试将字符串转换为浮点数
+        return True
+    except ValueError:
+        return False
+
+def is_valid_thousand_separator(s, divide):
+    # 匹配是否为合法的千分位格式（例如：1,234,567）
+
+    if divide == ",":
+        pattern = r'^[-+]?\d{1,3}(,\d{3})*(\.(\d*))?$'
+    elif divide == ".":
+        pattern = r'^[-+]?\d{1,3}(.\d{3})*(\,(\d*))?$'
+    else:
+        return False
+    return bool(re.match(pattern, s))
+
+def Convert2Number(value):
+    # print('fucker',value)
+    if value[-1] == '.':
+        value = value[:-1]
+    f = 1
+    # print('fucker',value)
+    if (value[0] == '+') or (value[0] == '-'):
+        f = 1 if (value[0] == '+') else 0
+        value = value[1:]
+    sep, comma = ',', '.'
+    # print(value,is_valid_thousand_separator(value , ','),is_valid_thousand_separator(value , '.'))
+    if ((not is_valid_thousand_separator(value , ',')) and is_valid_thousand_separator(value, '.')):
+        sep, comma = '.' , ','
+    elif (not is_valid_thousand_separator(value , ',')) and (not is_valid_thousand_separator(value, '.')):# 2018,36.8
+        value = value.split(',')[-1]
+    # print("sep check",value , sep, comma,is_valid_thousand_separator(value , ','))
+    cmx = value.replace(sep,"")
+    cmx = cmx.replace(comma,".")
+    # print(f,value)
+    if is_number(cmx):
+        return float(cmx) if f else -float(cmx)
+    else:
+        return -1145141919810
+
+# from quantulum3 import parser as PSP
+def get_unit_and_numeric(_s):
+    s = str(_s)
+    lst = s.split(' ')
+    n = len(lst)
+    for i in range(n - 1 , -1 , -1):
+        if contains_number(lst[i]):
+            # print("cmx",lst[i])
+            Answer = lst[i]
+            Answer = Answer.replace(" ","")
+            Answer = Answer.replace("$","")
+            Answer = Answer.replace("\n","")
+            # print("zst",Answer)
+            number = get_numeric(Answer)
+            unit = get_unit(Answer)
+            if unit == 'None' and i + 1 < n:
+                unit = get_unit(lst[i + 1])
+            if unit not in unit_map:
+                unit = "None"
+            return number , unit
+    return "1145141919810" , "None"
+    
+def compare_numeric_value(_answer, _response, eps = 0.001):
+    response = _response.replace('\n',' ')
+    answer = _answer.replace(' ',' ')
+    ans_number, ans_unit = get_unit_and_numeric(answer) 
+    response_number, response_unit = get_unit_and_numeric(response)
+    
+
+    # print(response_number,response_unit)
+    # print(ans_number,ans_unit,type(ans_number))
+    ans_number = Convert2Number(ans_number)
+    response_number = Convert2Number(response_number)
+
+    
+    for unit1 in [ans_unit, 'None']:
+        for unit2 in [response_unit, 'None']:
+            _ = ans_number * unit_map[unit1]
+            __ = response_number * unit_map[unit2]
+            # print(_ , __, abs((_ - __) / abs(_) ))
+            if abs((_ - __) / (0.01 + abs(_)))  < eps:
+                return True
+    # for special_case in [100 , 1000 , 1000000,1000000000]: # special case for % and B->M->k
+    for special_case in [100, 1000, 1000000, 1000000000]:
+
+        if abs(special_case * ans_number - response_number) / (0.01 + abs(special_case * ans_number)) < eps:
+            return True
+        if abs(special_case * response_number - ans_number) / (0.01 + abs(ans_number)) < eps:
+            return True
+        
+        
+    return False
+
+def compare_value(_answer, _response, eps = 0.001):
+    answer = str(_answer)
+    response = str(_response)
+    
+    # print("{ debugging }",answer , "{ debugging }",response)
+    # if answer=="0.085":
+    #     print('wxh')
+        
+    if contains_number(str(answer)):
+        return compare_numeric_value(str(answer), str(response), eps = eps)
+    else:
+        return fuzzy_string_match(answer , response)
+
+if __name__ == '__main__':
+    f = compare_value("14.200000000000001","14.2 µg/m³",0.05)
+    print(f)

eval/eval_value.py

@@ -0,0 +1,206 @@
+import json
+import re
+import os
+import shutil
+from pathlib import Path
+from compare_value import is_number, convert, convert_to_number, clean, is_valid_thousand_separator, only_digits_and_commas
+from compare_value import compare_value
+file_idx = 0
+
+
+def compare(data_chart, data_image):
+    matching_question = []
+    qid = []
+    res = []
+    path = {}
+    path_score = {}
+    for question_id, chart_data in data_chart.items():
+        if "response" not in chart_data:
+            continue
+        # 确保对应 question_id 在 data_image 中
+        if question_id in data_image:
+            image_data = data_image[question_id]
+            if "response" not in image_data or "score" not in image_data:
+                continue
+            qa = {
+                "question_id": chart_data["question_id"],
+                "qid":chart_data["qid"],
+                "figue":data_qa[chart_data["question_id"]]["figure_path"],
+                "question":data_qa[chart_data["question_id"]]["question"],
+                "answer":chart_data["answer"],
+                "response":chart_data["response"]
+            }
+            if chart_data["score"] == 0:
+                matching_question.append(qa)
+            # 检查条件
+            if chart_data["score"] == 0 and image_data["score"] == 1:
+                qid.append(chart_data["qid"])
+                
+                if data_qa[chart_data["question_id"]]["figure_path"] not in path:
+                    path[data_qa[chart_data["question_id"]]["figure_path"]] = 0
+                path[data_qa[chart_data["question_id"]]["figure_path"]] -= 1 
+                
+                
+            if chart_data["score"] == 1 and image_data["score"] == 0:
+                if data_qa[chart_data["question_id"]]["figure_path"] not in path:
+                    path[data_qa[chart_data["question_id"]]["figure_path"]] = 0
+                path[data_qa[chart_data["question_id"]]["figure_path"]] += 1 
+                
+                
+            if data_qa[chart_data["question_id"]]["figure_path"] not in path_score:
+                path_score[data_qa[chart_data["question_id"]]["figure_path"]] = {"image": 0, "chart": 0}
+            path_score[data_qa[chart_data["question_id"]]["figure_path"]]["image"] += (image_data["score"] if not image_data["score"] == -1 else 0)
+            path_score[data_qa[chart_data["question_id"]]["figure_path"]]["chart"] += (chart_data["score"] if not chart_data["score"] == -1 else 0)
+
+    # 输出结果
+    # print("Matching question IDs:", matching_question)
+    # with open("compare_res.json", "w") as f:
+    #     json.dump(matching_question, f, indent=4)
+    # print(qid)
+    path = dict(sorted(path.items(), key=lambda item: item[1]))
+    # print(path)
+   
+    path_score = dict(sorted(path_score.items(), key=lambda item: item[1]["chart"]))
+    # print(path_score)
+    # for item in path_score:
+    #     print(item,path_score[item])
+        
+        
+    easy_path_score = {k: v for k, v in path_score.items() if v['chart'] < v['image']}
+    easy_path_score = {k: path_score[k] for k in sorted(easy_path_score)}
+    even_path_score = {k: v for k, v in path_score.items() if v['chart'] == v['image']}
+    even_path_score = {k: path_score[k] for k in sorted(even_path_score)}
+    hard_path_score = {k: v for k, v in path_score.items() if v['chart'] > v['image']}
+    hard_path_score = {k: path_score[k] for k in sorted(hard_path_score)}
+    
+    res = {}
+    # 如果文件存在，读取原有数据
+    
+    # file_path = "/data/tianchi/minzhi/chartQA/code/ana/bar/simple/gemini/value.json"
+    # if Path(file_path).exists():
+    #     with open(file_path, "r") as f:
+    #         existing_data = json.load(f)
+    # else:
+    #     existing_data = {}
+
+    # # 更新数据（假设 path_score 是一个字典）
+    # print(len(existing_data))
+    # # print(existing_data)
+    # print("--------------------------------------")
+    # # print(path_score)
+    # existing_data.update(path_score)  # 或者用其他方式合并数据
+
+    # print(len(existing_data))
+    # # 写入合并后的数据
+    # with open(file_path, "w") as f:
+    #     json.dump(existing_data, f, indent=4)
+
+   
+    # # print(path_score.keys())
+    # print("-----------------")
+    
+    # global file_idx
+    # for item in easy_path_score:
+    #     print(f"/data/tianchi/minzhi/chartQA/code/CharXiv/img/bar/single/archive{file_idx}/plain_chart/"+item+".png",easy_path_score[item])
+    #     source_filepath = f"/data/tianchi/minzhi/chartQA/code/CharXiv/img/bar/single/archive{file_idx}/chart/h/"+item+".png"
+    #     target_filepath = ""
+    #     if os.path.exists(source_filepath):
+    #         print(f"           {source_filepath}")
+    #         # shutil.copy(source_filepath, target_filepath)
+    #     source_filepath = f"/data/tianchi/minzhi/chartQA/code/CharXiv/img/bar/single/archive{file_idx}/chart/v/"+item+".png"
+        # if os.path.exists(source_filepath):
+        #     print(f"           {source_filepath}")
+            # shutil.copy(source_filepath, target_filepath)
+            
+
+
+def eval_value(path):
+    print(path.split("/")[-1])
+    with open(path, 'r') as file:
+        # 解析 JSON 数据
+        data = json.load(file)
+    count = {0:0, 1:0}
+    for idx in data:
+        item = data[idx]
+        if "response" not in item:
+            continue
+        # print(item["response"])
+        if compare_value(item["answer"], item["response"]):
+            data[idx]["score"] = 1
+        else: 
+            data[idx]["score"] = 0
+        # if idx == "3":
+        #     print(item["answer"], item["response"],data[idx]["score"])
+        #     break
+        count[data[idx]["score"]] += 1
+                
+    with open(path.replace(path.split('/')[-1],"score-"+path.split('/')[-1]), 'w') as f:
+        json.dump(data, f, indent=4)      
+    print(count,count[1]/(count[0] + count[1]))
+    return count
+
+
+def analysis(chartpath, imagepath):
+    print("")
+    eval_value(chartpath)
+    eval_value(imagepath)
+    chartpath =  chartpath.replace(chartpath.split('/')[-1],"score-"+chartpath.split('/')[-1])
+    imagepath =  imagepath.replace(imagepath.split('/')[-1],"score-"+imagepath.split('/')[-1])
+    with open(chartpath, 'r') as file:
+        data_chart = json.load(file)
+    with open(imagepath, 'r') as file:
+        data_image = json.load(file)
+    # compare(data_chart, data_image)
+    # compare(data_image, data_chart, target_root = "/data/tianchi/minzhi/chartQA/code/ana/bar/simple/value/hard")
+
+
+file_idx = 3
+
+# with open(f"/data/tianchi/CharXiv/data/line/line_QA_value.json", 'r') as file:
+#     # 解析 JSON 数据
+#     data_qa = json.load(file)
+    
+# analysis("/data/tianchi/minzhi/chartQA/code/ana/bar/simple/gemini/record/bar-difference-internlm-xcomposer2-4khd-7b-chart.json",
+#          "/data/tianchi/minzhi/chartQA/code/ana/bar/simple/gemini/record/bar-difference-internlm-xcomposer2-4khd-7b-image.json")
+
+
+# model = 'gemini-2.0-flash'
+# analysis(f"/data/tianchi/CharXiv/results/{model}/{model}_line_value_plain.json",
+#          f"/data/tianchi/CharXiv/results/{model}/{model}_line_value_info.json")
+
+# analysis(f"/data/tianchi/CharXiv/results/{model}/{model}_line_difference_plain.json",
+#          f"/data/tianchi/CharXiv/results/{model}/{model}_line_difference_info.json")
+
+# file_list = ["/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/gemini-2.0-flash_label_difference_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/new_gemini-2.0-flash_label_difference_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/gemini-2.0-flash_visual_difference_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/new_gemini-2.0-flash_visual_difference_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/gemini-2.0-flash_label_value_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/new_gemini-2.0-flash_label_value_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/gemini-2.0-flash_visual_value_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/new_gemini-2.0-flash_visual_value_bar_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/line_gemini-2.0-flash_label_difference_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/line_gemini-2.0-flash_visual_difference_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/line_gemini-2.0-flash_label_value_QA.json",
+            #  "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/line_gemini-2.0-flash_visual_value_QA.json"
+            #  ]
+file_list = ["/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_flag_no-label_label_value_bar_QA.json",
+             "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_flag_origin_label_value_bar_QA.json",
+             "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_no-label_icon_value_bar_QA.json",
+             "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_no-label_label_value_bar_QA.json",
+             "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_origin_icon_value_bar_QA.json",
+             "/Users/linminzhi/Documents/chartQA/code/QA/our_bar/icon-label/record/icon-label/gemini-2.0-flash_origin_label_value_bar_QA.json"]
+for file in file_list:
+    count1 = eval_value(file)
+    # count2 = eval_value(file.replace("gemini-2.0-flash","new_gemini-2.0-flash"))
+    # count = {0:count1[0]+count2[0],1:count1[1]+count2[1]}
+    # print(count,count[1]/(count[0] + count[1]))
+    print()
+
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/hard/gemini-2.0-flash_value_bar_info_QA.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/hard/gemini-2.0-flash_value_bar_plain_QA.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/radial/gemini-2.0-flash-exp_radial_difference_bar_QA_plain.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/radial/gemini-2.0-flash-exp_radial_extreme_bar_QA_info.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/radial/gemini-2.0-flash-exp_radial_extreme_bar_QA_plain.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/radial/gemini-2.0-flash-exp_radial_value_bar_QA_info.json")
+# eval_value("/Users/linminzhi/Documents/chartQA/code/QA/our_bar/radial/gemini-2.0-flash-exp_radial_value_bar_QA_plain.json")