import json from tqdm import tqdm import os import json import matplotlib.pyplot as plt import seaborn as sns from collections import Counter import numpy as np # def plot_distribution(data, title="Distribution of First Reason Length", bins=40, name="url", xlabel="First Reason Length", ylabel="Frequency", output_path=None): # """ # 绘制 first_reason_length 的分布图。 # 参数: # data (list): 包含 first_reason_length 的列表。 # title (str): 图表标题，默认为 "Distribution of First Reason Length"。 # bins (int): 直方图的柱子数量，默认为 20。 # """ # # 设置绘图风格 # sns.set(style="whitegrid") # # 创建直方图和核密度估计图 # plt.figure(figsize=(10, 6)) # sns.histplot(data, kde=True, bins=bins, color="skyblue", edgecolor="black") # # 添加标题和标签 # plt.title(title, fontsize=16) # plt.xlabel(xlabel, fontsize=14) # plt.ylabel(ylabel, fontsize=14) # # 显示图形 # plt.show() # # plt.savefig(f"{name}.pdf", dpi=300, bbox_inches="tight") # if output_path: # plt.savefig(f"{output_path}/{name}.png", dpi=300, bbox_inches="tight") # else: # plt.savefig(f"{name}.png", dpi=300, bbox_inches="tight") # quantiles = np.arange(0.8, 1.0, 0.03) # 0.1 到 0.9 的分位点 # quantile_values = np.quantile(data, quantiles) # 分位点对应的值 # total_count = len(data) # 数据总数 # print(f"NAME: {name}") # print("分位点统计:") # for q, value in zip(quantiles, quantile_values): # count_below = np.sum(np.array(data) <= value) # 小于等于当前分位点的数量 # percentage = count_below / total_count * 100 # 占比 # print(f"分位点 {q:.2f}: " # f"值 = {value:.2f}, " # f"数量 = {count_below}, " # f"占比 = {percentage:.2f}%") import seaborn as sns import matplotlib.pyplot as plt import numpy as np import json import os def plot_distribution(data, title="Distribution of First Reason Length", bins=40, name="url", xlabel="First Reason Length", ylabel="Frequency", output_path=None): """ 绘制 first_reason_length 的分布图，并将分位点信息保存为 JSON 文件。 参数: data (list): 包含 first_reason_length 的列表。 title (str): 图表标题，默认为 "Distribution of First Reason Length"。 bins (int): 直方图的柱子数量，默认为 40。 name (str): 输出文件的基础名。 xlabel (str): x轴标签。 ylabel (str): y轴标签。 output_path (str): 输出路径（可选），如果为 None，则保存在当前目录。 """ sns.set(style="whitegrid") plt.figure(figsize=(10, 6)) sns.histplot(data, kde=True, bins=bins, color="skyblue", edgecolor="black") plt.title(title, fontsize=16) plt.xlabel(xlabel, fontsize=14) plt.ylabel(ylabel, fontsize=14) plt.tight_layout() if output_path: os.makedirs(output_path, exist_ok=True) fig_path = os.path.join(output_path, f"{name}.png") json_path = os.path.join(output_path, f"{name}_quantiles.json") else: fig_path = f"{name}.png" json_path = f"{name}_quantiles.json" plt.savefig(fig_path, dpi=300, bbox_inches="tight") plt.show() # 分位点计算 quantiles = np.arange(0.0, 1.0, 0.03) quantile_values = np.quantile(data, quantiles) total_count = len(data) # 构造字典结构 quantile_stats = { "name": name, "quantiles": [] } for q, value in zip(quantiles, quantile_values): count_below = int(np.sum(np.array(data) <= value)) percentage = float(count_below / total_count * 100) quantile_stats["quantiles"].append({ "quantile": round(float(q), 2), "value": round(float(value), 2), "count_below": count_below, "percentage": round(percentage, 2) }) # 保存为 JSON 文件 with open(json_path, "w", encoding="utf-8") as f: json.dump(quantile_stats, f, indent=2, ensure_ascii=False) print(f"分位点统计已保存至: {json_path}") def process_and_visualize(data_list, filename): """ 统计列表中各内容的出现次数，保存为 JSON 文件，并绘制直方图。 参数: data_list (list): 输入的列表数据。 filename (str): 输出 JSON 文件的文件名（不带扩展名）。 返回: None """ # 1. 统计每个内容的出现次数 counts = Counter(data_list) # 2. 按照次数降序排序 sorted_counts = dict(sorted(counts.items(), key=lambda item: item[1], reverse=True)) # 3. 保存为 JSON 文件 json_filename = f"{filename}.json" with open(json_filename, 'w', encoding='utf-8') as json_file: json.dump(sorted_counts, json_file, ensure_ascii=False, indent=4) print(f"统计结果已保存到 {json_filename}") # 4. 绘制直方图 labels, values = zip(*sorted_counts.items()) plt.figure(figsize=(10, 6)) plt.bar(labels, values, color='skyblue') plt.xlabel('number') plt.ylabel('count') plt.title(filename) plt.xticks(rotation=45, ha='right') # 旋转标签以便显示更清晰 plt.tight_layout() # 自动调整布局以避免重叠 # 5. 保存直方图为图片文件 plot_filename = f"{filename}.png" plt.savefig(plot_filename) print(f"直方图已保存到 {plot_filename}") # 6. 显示直方图（可选） plt.show() def load_json(file_path): with open(file_path, "r", encoding="utf-8") as file: data = json.load(file) print(f"Loaded {len(data)} items from {file_path}") return data def save_json(data, file_path): with open(file_path, "w", encoding="utf-8") as file: json.dump(data, file, ensure_ascii=False, indent=4) print(f"Saved {len(data)} items to {file_path}") def find_len(id, input_str): # input_str = input_str.split(" ") input_str = input_str.split() len_error = len(input_str) > 3000 len_stats = { "output_len": len(input_str), "len_error": len_error } return len_stats def find_output_wo_ana_len(id, input_str): input_str = input_str.split() len_stats = { "output_wo_ana_len": len(input_str), "output_wo_ana_error": False } return len_stats def find_boxed(id, input_str): boxed_str = "boxed{" input_str = input_str.split("")[0] cnt_boxed = input_str.count(boxed_str) cnt_stats = { "boxed_cnt": cnt_boxed, "boxed_error": cnt_boxed != 0 } return cnt_stats def find_special_words(id, input_str): words = ["alternatively", 'wait'] input_str = input_str.lower() cnt_words = {} for word in words: cnt_words[word] = input_str.count(word) words_stats = { "words_cnt": cnt_words, # "words_error": any([cnt_words[word] > 3 for word in words]) "words_error": cnt_words["alternatively"] > 3 } return words_stats def find_lang(id, input_str): # have_chinese = ['\u4e00' <= char <= '\u9fff' for char in input_str] chinese_chars = [char for char in input_str if '\u4e00' <= char <= '\u9fff'] chinese_stats = { "count": len(chinese_chars), "chinese_chars": chinese_chars, "chinese_error": len(chinese_chars) > 0 } return chinese_stats def find_ans(id, item): # if item['metric']['acc'] == 1 and item['metric']['em'] == 0: # # if id not in format_error_data: # # format_error_data[id] = {} # ans_stats = { # "answer": item['answer'], # "ans_em_error": True, # } # else: # ans_stats = { # "answer": item['answer'], # "ans_em_error": False, # } return ans_stats def find_last_reason_len(id, input_str): last_reason_len = len(input_str.split(" ")) last_reason_stats = { "last_reason_len": last_reason_len, "last_reason_error": last_reason_len > 500 } return last_reason_stats def find_first_reason_len(id, input_str): first_reason_len = len(input_str.split(" ")) first_reason_stats = { "first_reason_len": first_reason_len, "first_reason_error": first_reason_len > 500 } return first_reason_stats def find_ans_format(id, input_str): flag = False ans_format = { "ans_format_error": flag } if not input_str.endswith("}"): flag = True elif "\n\n\n\\boxed{" not in input_str: flag = True else: flag = False # print(flag) ans_format["ans_format_error"] = flag # print(ans_format) return ans_format def find_item(id, data): for item in data: if item["id"] == id: return item if __name__ == "__main__": input_files = [ # "/opt/aps/workdir/sunshuang/deep_search/math_data/selected_data_871.json" "/opt/aps/workdir/sunshuang/deep_search/math_data/math_qwq_4524_add_prompt_token_4524.json" ] for input_file in input_files: format_error_data = [] error_ids = [] # input_file = "/opt/aps/workdir/sunshuang/deep_search/search_o1/output/output_eval_sft/qwq_sft_871_ckpt_41/eval/turn_12.json" data = load_json(input_file) search_counts = [] for id, item in tqdm(enumerate(data), total=len(data)): # 遍历数据，标记每个数据中的错误 output_text = item["output"] item["id"] = id # search_counts.append(item["search_count"]) # search_cnt = 0 item['first_reason_stats'] = find_first_reason_len(item["id"],output_text) item['last_reason_stats'] = find_last_reason_len(item["id"],output_text) # for idx, turn in enumerate(item["output"]): # for key, value in turn.items(): # # if "search" in key: # # search_cnt += 1 # # if key in ["gen", "doc_gen"]: # if # if idx == 0: # # item["first_reason_length"] = len(value.split(" ")) # item['first_reason_stats'] = find_first_reason_len(item["id"],value) # elif idx == len(item["output"]) -1: # # item["last_reason_length"] = len(value.split(" ")) # item['last_reason_stats'] = find_last_reason_len(item["id"],value) # # if idx == len(item["output"]) -1: # # value = process_string(value) # # output_text += value # item["output_text"] = output_text item['boxed_stats'] = find_boxed(item["id"], output_text) item['words_stats'] = find_special_words(item["id"], output_text) item['lang_stats'] = find_lang(item["id"], output_text) # item['ans_stats'] = find_ans(item["id"], item) item['len_stats'] = find_len(item["id"], output_text) # item['search_cnt'] = search_cnt item['ans_format_stats'] = find_ans_format(item["id"], output_text) # 筛选数据 filtered_data = [] error_data = [] # 遍历format_error_data，分别统计每个错误的数量 error_count = { "boxed_error": 0, "words_error": 0, "chinese_error": 0, # "ans_em_error": 0, "len_error": 0, "last_reason_error": 0, "first_reason_error": 0, "ans_format_error": 0 } # 收集一下first reason的长度和last reason的长度 len_first_reason_len = [] len_last_reason_len = [] len_output_len = [] len_output_wo_ana_len = [] # cnt_search = [] cnt_words_alternatively = [] cnt_words_wait = [] for item in data: len_first_reason_len.append(item['first_reason_stats']['first_reason_len']) len_last_reason_len.append(item['last_reason_stats']['last_reason_len']) # len_output_wo_ana_len.append(item['output_wo_ana_stats']['output_wo_ana_len']) len_output_len.append(item['len_stats']['output_len']) cnt_words_alternatively.append(item['words_stats']['words_cnt']['alternatively']) cnt_words_wait.append(item['words_stats']['words_cnt']['wait']) # cnt_search.append(item['search_cnt']) if item['lang_stats']['chinese_error'] or item['boxed_stats']['boxed_error'] or item['len_stats']['len_error'] or item["words_stats"]["words_error"] or item['first_reason_stats']['first_reason_error'] or item['last_reason_stats']['last_reason_error'] or item['ans_format_stats']['ans_format_error']: # 统计各个错误的数量 error_data.append(item) for key, value in item.items(): if key.endswith("_stats"): for k, v in value.items(): if k in error_count and v: error_count[k] += 1 continue filtered_data.append(item) error_count["count_overall_error"] = len(error_data) # error_count["search_count"] = sum(search_counts) / len(search_counts) error_count["alternatively_count"] = sum(cnt_words_alternatively) / len(cnt_words_alternatively) error_count["wait_count"] = sum(cnt_words_wait) / len(cnt_words_wait) error_count["first_reason_len"] = sum(len_first_reason_len) / len(len_first_reason_len) error_count["last_reason_len"] = sum(len_last_reason_len) / len(len_last_reason_len) error_count["average_len"] = sum(len_output_len) / len(len_output_len) error_count["error_ratios"] = [ {key: value / len(data)} for key, value in error_count.items() if key.endswith("_error") ] print(error_count) # 创建一个文件夹 base_dir = os.path.join(os.path.dirname(input_file), "stats_1") os.makedirs(base_dir, exist_ok=True) # 分别绘制first reason的长度分布，last reason的长度分布和output的长度分布 plot_distribution(len_first_reason_len, title="Distribution of First Reason Length", bins=40, name="first_reason_length", xlabel="First Reason Length", ylabel="Frequency", output_path=base_dir) plot_distribution(len_last_reason_len, title="Distribution of Last Reason Length", bins=40, name="last_reason_length", xlabel="Last Reason Length", ylabel="Frequency", output_path=base_dir) plot_distribution(len_output_len, title="Distribution of Output Length", bins=40, name="output_length", xlabel="Output Length", ylabel="Frequency", output_path=base_dir) # plot_distribution(search_counts, title="Distribution of Search Count", bins=40, name="search_count", xlabel="Search Count", ylabel="Frequency", output_path=base_dir) plot_distribution(cnt_words_alternatively, title="Distribution of Alternatively Count", bins=100, name="alternatively_count", xlabel="Words Count", ylabel="Frequency", output_path=base_dir) plot_distribution(cnt_words_wait, title="Distribution of Wait Count", bins=100, name="wait_count", xlabel="Words Count", ylabel="Frequency", output_path=base_dir) # 保存一下各个错误的信息 output_error_file = os.path.join(base_dir, "error_stats.json") save_json(error_count, output_error_file) # # 保存筛选后的数据 # output_filtered_file = os.path.join(base_dir, "filtered_data.json") # save_json(filtered_data, output_filtered_file) # # 保存标注后的数据 # output_tagged_file = os.path.join(base_dir, "tagged_data.json") # save_json(data, output_tagged_file) # print(f"len(filtered_data): {len(filtered_data)}")