| |
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| from typing import Any, Dict, Iterable, List, Optional |
|
|
| import pandas as pd |
| from datasets import load_dataset |
|
|
| import math |
| import numpy as np |
| |
| |
| |
| def to_jsonable(obj: Any) -> Any: |
| """ |
| 递归把 numpy / pandas 对象转成 json 可序列化的原生 Python 类型。 |
| """ |
| |
| if obj is None or isinstance(obj, (str, int, bool)): |
| return obj |
|
|
| if isinstance(obj, float): |
| if math.isnan(obj) or math.isinf(obj): |
| return None |
| return obj |
|
|
| |
| if isinstance(obj, np.generic): |
| value = obj.item() |
| if isinstance(value, float) and (math.isnan(value) or math.isinf(value)): |
| return None |
| return value |
|
|
| |
| if isinstance(obj, np.ndarray): |
| return [to_jsonable(x) for x in obj.tolist()] |
|
|
| |
| try: |
| if pd.isna(obj): |
| return None |
| except Exception: |
| pass |
|
|
| |
| if isinstance(obj, dict): |
| return {str(k): to_jsonable(v) for k, v in obj.items()} |
|
|
| |
| if isinstance(obj, (list, tuple, set)): |
| return [to_jsonable(x) for x in obj] |
|
|
| |
| return str(obj) |
|
|
| def normalize_text(x: Any) -> str: |
| if x is None: |
| return "" |
| s = str(x) |
| s = s.replace("\r\n", "\n").replace("\r", "\n") |
| s = re.sub(r"\s+", " ", s).strip() |
| return s |
|
|
|
|
| def safe_dict(x: Any) -> Dict[str, Any]: |
| return x if isinstance(x, dict) else {} |
|
|
|
|
| def safe_list(x: Any) -> List[Any]: |
| return x if isinstance(x, list) else [] |
|
|
|
|
| def extract_prompt_text(prompt_obj: Any) -> str: |
| """ |
| 将 prompt(list[dict]) 抽取为纯文本。 |
| 例如： |
| [{"role": "user", "content": "..."}] |
| -> "..." |
| """ |
| prompt_list = safe_list(prompt_obj) |
| parts: List[str] = [] |
|
|
| for item in prompt_list: |
| if isinstance(item, dict): |
| content = item.get("content") |
| if content is not None: |
| parts.append(str(content)) |
| elif item is not None: |
| parts.append(str(item)) |
|
|
| return "\n\n".join(p.strip() for p in parts if str(p).strip()) |
|
|
|
|
| def make_dedup_key(row: Dict[str, Any]) -> str: |
| """ |
| 优先用原始题面 raw_problem 去重；若缺失，则退化到 prompt_text； |
| 再不行则对整行做稳定哈希。 |
| """ |
| raw_problem = normalize_text(row.get("problem")) |
| if raw_problem: |
| return f"problem::{raw_problem}" |
|
|
| prompt_text = normalize_text(row.get("prompt_text")) |
| if prompt_text: |
| return f"prompt::{prompt_text}" |
|
|
| stable = json.dumps(row, ensure_ascii=False, sort_keys=True) |
| return "hash::" + hashlib.sha256(stable.encode("utf-8")).hexdigest() |
|
|
|
|
| def ensure_parent_dir(path: str) -> None: |
| parent = os.path.dirname(os.path.abspath(path)) |
| if parent: |
| os.makedirs(parent, exist_ok=True) |
|
|
|
|
| |
| |
| |
|
|
| def load_from_hf(repo_id: str, split: str) -> pd.DataFrame: |
| ds = load_dataset(repo_id, split=split) |
| |
| return ds.to_pandas() |
|
|
|
|
| |
| |
| |
|
|
| def flatten_records(df: pd.DataFrame) -> pd.DataFrame: |
| rows: List[Dict[str, Any]] = [] |
|
|
| for _, rec in df.iterrows(): |
| reward_model = safe_dict(rec.get("reward_model")) |
| extra_info = safe_dict(rec.get("extra_info")) |
|
|
| row = { |
| "data_source": rec.get("data_source"), |
| "ability": rec.get("ability"), |
| "prompt_text": extract_prompt_text(rec.get("prompt")), |
| "problem": extra_info.get("raw_problem"), |
| "answer": reward_model.get("ground_truth"), |
| "style": reward_model.get("style"), |
| "source_index": extra_info.get("index"), |
| "split": extra_info.get("split"), |
| |
| "prompt": rec.get("prompt"), |
| "reward_model": reward_model, |
| "extra_info": extra_info, |
| "__index_level_0__": rec.get("__index_level_0__"), |
| } |
| row["dedup_key"] = make_dedup_key(row) |
| rows.append(row) |
|
|
| out = pd.DataFrame(rows) |
| return out |
|
|
|
|
| def deduplicate(df: pd.DataFrame) -> pd.DataFrame: |
| |
| sort_cols = [c for c in ["__index_level_0__", "source_index"] if c in df.columns] |
| if sort_cols: |
| df = df.sort_values(by=sort_cols, kind="stable").reset_index(drop=True) |
|
|
| deduped = df.drop_duplicates(subset=["dedup_key"], keep="first").reset_index(drop=True) |
| deduped.insert(0, "id", range(len(deduped))) |
| return deduped |
|
|
|
|
| |
| |
| |
|
|
| def write_jsonl(records: Iterable[Dict[str, Any]], path: str) -> None: |
| ensure_parent_dir(path) |
| with open(path, "w", encoding="utf-8") as f: |
| for row in records: |
| f.write(json.dumps(to_jsonable(row), ensure_ascii=False) + "\n") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description="下载/读取 HF 数据集，去重后导出 JSONL 和 Parquet") |
| parser.add_argument("--repo-id", default="BytedTsinghua-SIA/AIME-2024", help="Hugging Face dataset repo id") |
| parser.add_argument("--split", default="train", help="数据集 split，默认 train") |
| parser.add_argument("--save-raw-parquet", default="", help="可选：保存未去重原始 parquet") |
| parser.add_argument("--jsonl", required=True, help="输出 jsonl 路径") |
| parser.add_argument("--parquet", required=True, help="输出 parquet 路径") |
| args = parser.parse_args() |
|
|
| raw_df = load_from_hf(args.repo_id, args.split) |
|
|
| if args.save_raw_parquet: |
| ensure_parent_dir(args.save_raw_parquet) |
| raw_df.to_parquet(args.save_raw_parquet, index=False) |
|
|
| flat_df = flatten_records(raw_df) |
| dedup_df = deduplicate(flat_df) |
|
|
| |
| output_cols = [ |
| "id", |
| "problem", |
| "answer", |
| "prompt_text", |
| "data_source", |
| "ability", |
| "style", |
| "source_index", |
| "split", |
| "dedup_key", |
| "prompt", |
| "reward_model", |
| "extra_info", |
| "__index_level_0__", |
| ] |
| output_cols = [c for c in output_cols if c in dedup_df.columns] |
| final_df = dedup_df[output_cols].copy() |
|
|
| |
| records = final_df.to_dict(orient="records") |
| write_jsonl(records, args.jsonl) |
|
|
| |
| ensure_parent_dir(args.parquet) |
| final_df.to_parquet(args.parquet, index=False) |
|
|
| print(f"原始行数: {len(raw_df)}") |
| print(f"去重后行数: {len(final_df)}") |
| print(f"删除重复行数: {len(raw_df) - len(final_df)}") |
| print(f"JSONL 已写出: {args.jsonl}") |
| print(f"Parquet 已写出: {args.parquet}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
