Upload folder using huggingface_hub

.gitattributes

@@ -1,6 +1,5 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text
@@ -58,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+train01_chatml_closed_length2048turns20_replaced.json filter=lfs diff=lfs merge=lfs -text
+13052_style_issue_samples/01_narrator_summary.jsonl filter=lfs diff=lfs merge=lfs -text
+13052_style_issue_samples/all_flagged.jsonl filter=lfs diff=lfs merge=lfs -text

13052_style_issue_samples/01_narrator_summary.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bc28b6540f7021089e76e575e5d54452c915bbcfccba5a410014a5f055d8c14
+size 43577870

13052_style_issue_samples/README.md

@@ -0,0 +1,31 @@
+# 13052 Style Issue Extraction
+
+Input: `/root/test/weitiao/data_process_bq/data/train_merged_dedup_shuffled_30001.json`
+Records: 30001
+
+## Output files
+
+- `01_narrator_summary.jsonl`: 旁白总结/复述剧情感
+- `02_scene_jump_new_event.jsonl`: 跳场景/新增事件
+- `03_role_control_shift.jsonl`: 替用户推进/控制用户动作或心理
+- `04_tone_format_mismatch.jsonl`: 语气和格式更像小说叙述，互动弱
+- `all_flagged.jsonl`: 所有命中候选
+- `summary.json`: 统计信息
+
+## Candidate-level counts
+
+- narrator_summary: 26549
+- tone_format_mismatch: 5628
+- role_control_shift: 5065
+- scene_jump_new_event: 4149
+
+## Safety heuristic
+
+- relatively_safe: records=18657, flagged_candidates=18569, flagged_candidates_per_record=0.995
+- unsafe_or_sensitive: records=11344, flagged_candidates=13772, flagged_candidates_per_record=1.214
+
+## Caveats
+
+- The source has no model-id field, so flagged_side is chosen/rejected, not a confirmed 13052 label.
+- Safety labels are heuristic keyword labels over context plus both candidate responses.
+- Counts are candidate-level for flagged outputs unless the key says record-level.

13052_style_issue_samples/all_flagged.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8961ab2dd01befb6131f14f9575113462f338acf33b4e938e63b3bee44aec565
+size 52887613

13052_style_issue_samples/summary.json

@@ -0,0 +1,52 @@
+{
+  "input": "/root/test/weitiao/data_process_bq/data/train_merged_dedup_shuffled_30001.json",
+  "output_dir": "/root/test/weitiao/data_process_bq/13052_style_issue_samples",
+  "records": 30001,
+  "category_counts_candidate_level": {
+    "narrator_summary": 26549,
+    "tone_format_mismatch": 5628,
+    "role_control_shift": 5065,
+    "scene_jump_new_event": 4149
+  },
+  "flagged_side_counts": {
+    "chosen": 16297,
+    "rejected": 16044
+  },
+  "safety_total_record_level": {
+    "relatively_safe": 18657,
+    "unsafe_or_sensitive": 11344
+  },
+  "safety_flagged_candidate_level": {
+    "relatively_safe": 18569,
+    "unsafe_or_sensitive": 13772
+  },
+  "safety_by_category_candidate_level": {
+    "narrator_summary": {
+      "relatively_safe": 14990,
+      "unsafe_or_sensitive": 11559
+    },
+    "tone_format_mismatch": {
+      "relatively_safe": 3613,
+      "unsafe_or_sensitive": 2015
+    },
+    "role_control_shift": {
+      "unsafe_or_sensitive": 2094,
+      "relatively_safe": 2971
+    },
+    "scene_jump_new_event": {
+      "relatively_safe": 2624,
+      "unsafe_or_sensitive": 1525
+    }
+  },
+  "record_category_overlap_counts": {
+    "2": 6460,
+    "1": 13301,
+    "3": 1474,
+    "4": 150
+  },
+  "notes": [
+    "The source has no model-id field, so flagged_side is chosen/rejected, not a confirmed 13052 label.",
+    "Safety labels are heuristic keyword labels over context plus both candidate responses.",
+    "Counts are candidate-level for flagged outputs unless the key says record-level."
+  ]
+}

InsTag/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

InsTag/README.md

@@ -0,0 +1,93 @@
+# ****InsTag****: A Tool for Data Analysis in LLM Supervised Fine-tuning
+
+
+
+We introduce a tool named **InsTag** for analyzing supervised fine-tuning (SFT) data in LLM aligning with human preference. For local tagging deployment, we release **InsTagger**, fine-tuned on **InsTag** results, to tag the queries in SFT data.
+Through the scope of tags, we sample a 6K subset of open-resourced SFT data to fine-tune LLaMA and LLaMA-2 and the fine-tuned models **TagLM-13B-v1.0** and **TagLM-13B-v2.0** outperform many open-resourced LLMs on MT-Bench. 
+
+<p align="center">
+🤗 <a href="https://huggingface.co/OFA-Sys/InsTagger" target="_blank">InsTagger Checkpoint</a> • 👉 <a href="https://www.modelscope.cn/studios/lukeminglkm/instagger_demo/summary" target="_blank">Online LocalTagger Demo</a> • 📖 <a href="https://arxiv.org/pdf/2308.07074.pdf" target="_blank">Paper</a>  <br>
+</p>
+
+<p align="center">
+🤖️ <a href="https://huggingface.co/OFA-Sys/TagLM-13b-v1.0" target="_blank">TagLM-13B-v1.0 Checkpoint</a> 🤖️ <a href="https://huggingface.co/OFA-Sys/TagLM-13b-v2.0" target="_blank">TagLM-13B-v2.0 Checkpoint</a><br>
+</p>
+
+
+**What is *InsTag*?**
+
+Foundation language models obtain the instruction-following ability through supervised fine-tuning (SFT).
+Diversity and complexity are considered critical factors of a successful SFT dataset, while their definitions remain obscure and lack quantitative analyses.
+In this work, we propose *InsTag*, an open-set fine-grained tagger, to tag samples within SFT datasets based on semantics and intentions and define instruction diversity and complexity regarding tags.
+We obtain 6.6K tags to describe comprehensive user queries.
+We analyze popular open-sourced SFT datasets and find that the model ability grows with more diverse and complex data.
+Based on this observation, we propose a data selector based on *InsTag* to select 6K diverse and complex samples from open-source datasets and fine-tune models on *InsTag*-selected data.
+These models outperform open-source models based on considerably larger SFT data evaluated by MT-Bench, echoing the importance of query diversity and complexity.
+
+<p align="center" width="100%">
+<a ><img src="assets/main_figure.png" alt="InsTag" style="width: 80%; min-width: 300px; display: block; margin: auto;"></a>
+</p>
+
+
+## News
+
+- [08/2023] 🔥 We have an online demo of InsTagger hosted by ModelScope. Please refer to the link on the top. Thanks ModelScope!
+
+- [08/2023] 🔥 We released aligned LLMs **TagLM-13B-v1.0** and **TagLM-13B-v2.0** based on LLaMA and LLaMA-2 respectively. Both are fine-tuned on sub-sampled SFT data according to ***InsTag***. Download [v1.0]() and [v2.0](). 
+
+- [08/2023] 🔥 We released an LLM **InsTagger** fine-tuned on our tagging results for local tagging deployments. Download [weight](https://huggingface.co/OFA-Sys/InsTagger). 
+
+- [08/2023] 🔥 We introduced ***InsTag***, our SFT data analysis tool. Check out the [paper](). 
+
+## Contents
+
+- [Model Checkpoints](#model-checkpoints)
+- [Citation](#citation)
+
+## InsTagger
+
+InsTagger is a LLaMa-2 based SFT model trained with FastChat in the vicuna template. You can easily download weight at [HuggingFace ModelHub](https://huggingface.co/OFA-Sys/InsTagger) and then use [FastChat](https://github.com/lm-sys/FastChat) to serve or inference. Demo codes are about to be released.
+
+## Model Checkpoints
+
+- **InsTagger** for local query tagging:
+
+    **InsTagger** is an tagging LLM which is fine-tuned on **InsTag**'s tagging results on open-resourced SFT data. The model is based on 7B version LLaMA-2.
+
+    Download the model checkpoint below:
+
+    | Model | Checkpoint | Exact Match F1 | Semantic-based Fuzzy Match F1  | License |
+    | ----- |------| -------| -------| ----- |
+    | LocalTagger | 🤗 <a href="" target="_blank">HF Link</a>  | **31.8%** | **73.4%**  | <a href="https://ai.meta.com/resources/models-and-libraries/llama-downloads/" target="_blank">LLaMA 2 License </a> |
+
+
+
+
+- **TagLM**, fine-tuned on our SFT data sub-sampled by complexity-first diverse sampling procedure:
+
+    With only 6k data from current open-resourced SFT dataset, **TagLM** can outperform many open-resourced LLMs on MT-Bench using GPT-4 as a judge. 
+
+    Download the model checkpoint below:
+
+    | Model | Checkpoint | MT-Bench  | License |
+    | ----- |------| -------| ----- |
+    | TagLM-13B-v1.0 | 🤗 <a href="" target="_blank">HF Hub Link</a>  |  **6.44**	  | <a href="https://ai.meta.com/resources/models-and-libraries/llama-downloads/" target="_blank">LLaMA License </a> |
+    | TagLM-13B-v2.0 | 🤗 <a href="" target="_blank">HF Hub Link</a>  |  **6.55**	  | <a href="https://ai.meta.com/resources/models-and-libraries/llama-downloads/" target="_blank">LLaMA 2 License </a> |
+
+    All models are either based on LLaMA or LLaMA-2 and should be used under their licenses accordingly. All the models are fine-tuned using [FastChat](https://github.com/lm-sys/FastChat) codebase, and we apply the system template of Vicuna V1.1. 
+
+
+## Citation 
+
+Please cite our work if you find the repository helpful.
+
+```
+@misc{lu2023instag,
+      title={#InsTag: Instruction Tagging for Analyzing Supervised Fine-tuning of Large Language Models}, 
+      author={Keming Lu and Hongyi Yuan and Zheng Yuan and Runji Lin and Junyang Lin and Chuanqi Tan and Chang Zhou and Jingren Zhou},
+      year={2023},
+      eprint={2308.07074},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+```

InsTag/checkpoint/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

InsTag/checkpoint/README.md

@@ -0,0 +1,28 @@
+---
+license: apache-2.0
+language:
+- en
+---
+# InsTagger
+
+**InsTagger** is an tool for automatically providing instruction tags by distilling tagging results from **InsTag**.
+
+InsTag aims analyzing supervised fine-tuning (SFT) data in LLM aligning with human preference. For local tagging deployment, we release InsTagger, fine-tuned on InsTag results, to tag the queries in SFT data. Through the scope of tags, we sample a 6K subset of open-resourced SFT data to fine-tune LLaMA and LLaMA-2 and the fine-tuned models TagLM-13B-v1.0 and TagLM-13B-v2.0 outperform many open-resourced LLMs on MT-Bench.
+
+
+### Model Description
+
+- **Model type:** Auto-regressive Models
+- **Language(s) (NLP):** English
+- **License:** apache-2.0
+- **Finetuned from model:** LLaMa-2
+
+### Model Sources [optional]
+
+- **Repository:** [https://github.com/OFA-Sys/InsTag](https://github.com/OFA-Sys/InsTag)
+- **Paper:** [Arxiv](https://arxiv.org/pdf/2308.07074.pdf)
+- **Demo:** [ModelScope Demo](https://www.modelscope.cn/studios/lukeminglkm/instagger_demo/summary)
+
+## Uses
+
+This model is directly developed with [FastChat](https://github.com/lm-sys/FastChat). So it can be easily infer or serve with FastChat selecting the vicuna template.

InsTag/checkpoint/added_tokens.json

@@ -0,0 +1,3 @@
+{
+  "<pad>": 32000
+}

InsTag/checkpoint/config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "/cpfs01/shared/Group-m6/yuanzheng.yz/llama2_model_hf/Llama-2-7b-hf/",
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_act": "silu",
+  "hidden_size": 4096,
+  "initializer_range": 0.02,
+  "intermediate_size": 11008,
+  "max_position_embeddings": 2048,
+  "model_type": "llama",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 32,
+  "pad_token_id": 0,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.28.1",
+  "use_cache": false,
+  "vocab_size": 32000
+}

InsTag/checkpoint/generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "pad_token_id": 32000,
+  "temperature": 0.9,
+  "top_p": 0.6,
+  "transformers_version": "4.28.1"
+}

InsTag/checkpoint/pytorch_model-00001-of-00003.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0e7c11c0dd60a6d2540f12d6f28c240f42c32093da5d395ee050fd1522948d3
+size 9877989650

InsTag/checkpoint/pytorch_model-00002-of-00003.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3d71344991052e6948bd72ad1915bd4b10300f2d0cb92238365aff77492c5a2
+size 9894801206

InsTag/checkpoint/pytorch_model-00003-of-00003.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4f505299f9473bd3c955e007c7f14d82ceafce7f3bca5679ce55771ddd83f59
+size 7180990841

InsTag/checkpoint/pytorch_model.bin.index.json

@@ -0,0 +1,330 @@
+{
+  "metadata": {
+    "total_size": 26953666560
+  },
+  "weight_map": {
+    "lm_head.weight": "pytorch_model-00003-of-00003.bin",
+    "model.embed_tokens.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.0.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.1.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.10.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.11.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.11.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.11.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.11.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.11.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.12.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.12.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.13.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.14.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.15.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.16.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.17.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.18.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.19.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.2.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.2.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.20.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.20.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.21.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.input_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.22.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.23.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.23.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.23.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin",
+    "model.layers.23.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin",
+    "model.layers.24.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.24.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.25.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.26.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.27.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.28.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.29.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.3.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.3.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.30.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.30.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.input_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin",
+    "model.layers.31.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin",
+    "model.layers.4.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.4.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.5.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.6.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.7.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.8.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.input_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin",
+    "model.layers.9.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin",
+    "model.norm.weight": "pytorch_model-00003-of-00003.bin"
+  }
+}

InsTag/checkpoint/special_tokens_map.json

@@ -0,0 +1,24 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": "<unk>",
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

InsTag/checkpoint/tokenizer.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e556afd44213b6bd1be2b850ebbbd98f5481437a8021afaf58ee7fb1818d347
+size 499723

InsTag/checkpoint/tokenizer_config.json

@@ -0,0 +1,35 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "bos_token": {
+    "__type": "AddedToken",
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "clean_up_tokenization_spaces": false,
+  "eos_token": {
+    "__type": "AddedToken",
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "legacy": false,
+  "model_max_length": 2048,
+  "pad_token": null,
+  "padding_side": "right",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": {
+    "__type": "AddedToken",
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

InsTag/extracted_ontology.txt

@@ -0,0 +1,19 @@
+command execution
+describing the setting or environment of a particular situation.
+education
+historical fiction
+humor
+inference
+mathematics
+role-playing
+scene description
+simulation
+the instruction involves playing a specific character or role in a game or scenario.
+the instruction involves pretending to be a specific character or animal.
+the instruction involves providing information or knowledge about a specific subject.
+the instruction involves typing commands to be executed by the ai assistant.
+the instruction is asking for a simulation of a terminal console.
+the instruction is intended to be funny or amusing.
+the instruction relates to a fictional story set in a historical context.
+the instruction requires making an inference or deduction based on the given information.
+the instruction specifically relates to the field of mathematics.

README.md

@@ -0,0 +1,39 @@
+---
+dataset_info:
+  features:
+  - name: app_days
+    dtype: int64
+  - name: bot_id
+    dtype: string
+  - name: chosen
+    dtype: string
+  - name: chosen_model
+    dtype: int64
+  - name: chosen_position
+    dtype: int64
+  - name: chosen_prompt
+    dtype: string
+  - name: id
+    dtype: int64
+  - name: reject
+    dtype: string
+  - name: reject_model
+    dtype: int64
+  - name: reject_prompt
+    dtype: string
+  - name: timestamp
+    dtype: string
+  - name: user_id
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 112650448
+    num_examples: 7098
+  download_size: 59720019
+  dataset_size: 112650448
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+---

extract_13052_style_issues.py

@@ -0,0 +1,286 @@
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+ROOT = Path("/root/test/weitiao/data_process_bq")
+INPUT = ROOT / "data" / "train_merged_dedup_shuffled_30001.json"
+OUT_DIR = ROOT / "13052_style_issue_samples"
+
+
+NARRATOR_PATTERNS = [
+    r"\bas soon as\b",
+    r"\bas they\b",
+    r"\bas (he|she|it|you|we)\b",
+    r"\b(months?|weeks?|days?|years?) (pass|passed|later)\b",
+    r"\b(time passes|time passed)\b",
+    r"\bthe next (morning|day|night|week)\b",
+    r"\blater that\b",
+    r"\beventually\b",
+    r"\bafter a while\b",
+    r"\bover the next\b",
+    r"\bin the following\b",
+    r"\bmeanwhile\b",
+]
+
+SCENE_JUMP_PATTERNS = [
+    r"\b(knock|knocking|knocked) (at|on)\b",
+    r"\bthe door (opens|opened|slams|slammed|bursts|burst)\b",
+    r"\bphone (rings|rang|buzzes|buzzed)\b",
+    r"\bmessage (arrives|arrived|pops|popped)\b",
+    r"\bsuddenly\b",
+    r"\bjust then\b",
+    r"\bout of nowhere\b",
+    r"\bflashback\b",
+    r"\bremembers?\b",
+    r"\bmemory\b",
+    r"\b(hours?|days?|weeks?|months?) later\b",
+    r"\bthe next (morning|day|night|week)\b",
+]
+
+CONTROL_SHIFT_PATTERNS = [
+    r"\byou (nod|nodded|agree|agreed|follow|followed|step|stepped|walk|walked|sit|sat|stand|stood|take|took|accept|accepted|realize|realized|understand|understood|decide|decided|feel|felt|can't help but|cannot help but)\b",
+    r"\byour (heart|breath|body|mind|thoughts|eyes|hands|lips|cheeks)\b",
+    r"\byou (can't|cannot) resist\b",
+    r"\byou let him\b",
+    r"\byou let her\b",
+    r"\byou find yourself\b",
+    r"\bboth of you\b",
+    r"\btogether, you\b",
+]
+
+FORMAT_MISMATCH_PATTERNS = [
+    r"^\s*(with|after|as|while|when)\b",
+    r"\b(washes over|a wave of|a surge of|couldn't help but|for a moment|in that moment)\b",
+    r"\b(his|her|their) mind\b",
+    r"\bthe weight of\b",
+    r"\bthe air (is|was|grows|grew|hangs|hung)\b",
+]
+
+UNSAFE_PATTERNS = [
+    r"\b(kill|murder|blood|gun|knife|shoot|shot|stab|weapon|execution|mafia|cartel|hostage|kidnap|torture|corpse|dead|death)\b",
+    r"\b(suicide|self[- ]harm|cut myself|overdose)\b",
+    r"\b(sex|cum|cock|pussy|dick|orgasm|naked|rape|raped|molest|blowjob|anal|thrust|clit|boobs)\b",
+    r"\b(minor|underage|teen|schoolgirl|schoolboy)\b",
+    r"\b(drug|cocaine|heroin|meth|overdose)\b",
+]
+
+NARRATOR_RE = [(pat, re.compile(pat, re.I)) for pat in NARRATOR_PATTERNS]
+SCENE_JUMP_RE = [(pat, re.compile(pat, re.I)) for pat in SCENE_JUMP_PATTERNS]
+CONTROL_SHIFT_RE = [(pat, re.compile(pat, re.I)) for pat in CONTROL_SHIFT_PATTERNS]
+FORMAT_MISMATCH_RE = [(pat, re.compile(pat, re.I)) for pat in FORMAT_MISMATCH_PATTERNS]
+UNSAFE_RE = [(pat, re.compile(pat, re.I)) for pat in UNSAFE_PATTERNS]
+WORD_RE = re.compile(r"\b[\w']+\b")
+THIRD_PERSON_RE = re.compile(r"\b(he|she|they|him|her|his|hers|their|the)\b", re.I)
+YOU_RE = re.compile(r"\byou\b|\byour\b", re.I)
+ACTION_RE = re.compile(
+    r"^\s*[A-ZÁÉÍÓÚÄÖÜÑ][^.\n]{0,80}\s+"
+    r"(nods|smiles|leans|steps|looks|says|asks|whispers|murmurs|growls|grins)\b",
+    re.I,
+)
+
+
+def norm(text):
+    return (text or "").replace("\r\n", "\n")
+
+
+def text_of_message(msg):
+    if isinstance(msg, dict):
+        return norm(msg.get("value", ""))
+    return norm(str(msg))
+
+
+def regex_hits(compiled_patterns, text):
+    hits = []
+    for pat, rex in compiled_patterns:
+        if rex.search(text):
+            hits.append(pat)
+    return hits
+
+
+def quote_count(text):
+    return text.count('"') + text.count("“") + text.count("”") + text.count("¿") + text.count("?")
+
+
+def action_dialog_score(text):
+    has_action = "*" in text or ACTION_RE.search(text)
+    return int(bool(has_action)) + int(quote_count(text) >= 2)
+
+
+def categories_for(text, other_text):
+    words = WORD_RE.findall(text)
+    word_count = max(len(words), 1)
+    cats = {}
+
+    narrator_hits = regex_hits(NARRATOR_RE, text)
+    third_person = len(THIRD_PERSON_RE.findall(text))
+    dialogue_sparse = quote_count(text) < 2
+    longish = word_count >= 35
+    if narrator_hits or (longish and dialogue_sparse and third_person / word_count > 0.08):
+        cats["narrator_summary"] = {
+            "hits": narrator_hits,
+            "word_count": word_count,
+            "quote_count": quote_count(text),
+            "third_person_ratio": round(third_person / word_count, 3),
+        }
+
+    jump_hits = regex_hits(SCENE_JUMP_RE, text)
+    if jump_hits:
+        cats["scene_jump_new_event"] = {"hits": jump_hits}
+
+    control_hits = regex_hits(CONTROL_SHIFT_RE, text)
+    user_mentions = len(YOU_RE.findall(text))
+    if control_hits or user_mentions >= 5:
+        cats["role_control_shift"] = {
+            "hits": control_hits,
+            "you_your_count": user_mentions,
+        }
+
+    format_hits = regex_hits(FORMAT_MISMATCH_RE, text)
+    other_action_dialog = action_dialog_score(other_text)
+    this_action_dialog = action_dialog_score(text)
+    if format_hits or (word_count >= 45 and dialogue_sparse and other_action_dialog > this_action_dialog):
+        cats["tone_format_mismatch"] = {
+            "hits": format_hits,
+            "word_count": word_count,
+            "quote_count": quote_count(text),
+            "this_action_dialog_score": this_action_dialog,
+            "other_action_dialog_score": other_action_dialog,
+        }
+
+    return cats
+
+
+def safety_label(record, chosen_text, rejected_text):
+    parts = []
+    for msg in record.get("conversations", [])[-6:]:
+        parts.append(text_of_message(msg))
+    parts.extend([chosen_text, rejected_text])
+    blob = "\n".join(parts)
+    hits = regex_hits(UNSAFE_RE, blob)
+    return ("unsafe_or_sensitive" if hits else "relatively_safe", hits[:12])
+
+
+def context_tail(record, n=4):
+    conv = record.get("conversations", [])
+    return [
+        {"from": m.get("from"), "value": text_of_message(m)}
+        for m in conv[-n:]
+        if isinstance(m, dict)
+    ]
+
+
+def main():
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    with INPUT.open(encoding="utf-8") as f:
+        data = json.load(f)
+
+    files = {
+        "narrator_summary": (OUT_DIR / "01_narrator_summary.jsonl").open("w", encoding="utf-8"),
+        "scene_jump_new_event": (OUT_DIR / "02_scene_jump_new_event.jsonl").open("w", encoding="utf-8"),
+        "role_control_shift": (OUT_DIR / "03_role_control_shift.jsonl").open("w", encoding="utf-8"),
+        "tone_format_mismatch": (OUT_DIR / "04_tone_format_mismatch.jsonl").open("w", encoding="utf-8"),
+        "all": (OUT_DIR / "all_flagged.jsonl").open("w", encoding="utf-8"),
+    }
+
+    category_counts = Counter()
+    side_counts = Counter()
+    safety_total = Counter()
+    safety_flagged = Counter()
+    safety_by_category = defaultdict(Counter)
+    overlap_counts = Counter()
+
+    for idx, record in enumerate(data):
+        chosen_text = text_of_message(record.get("chosen", {}))
+        rejected_text = text_of_message(record.get("rejected", {}))
+        label, safety_hits = safety_label(record, chosen_text, rejected_text)
+        safety_total[label] += 1
+
+        per_record_categories = set()
+        for side, text, other in [
+            ("chosen", chosen_text, rejected_text),
+            ("rejected", rejected_text, chosen_text),
+        ]:
+            cats = categories_for(text, other)
+            if not cats:
+                continue
+            item = {
+                "index": idx,
+                "side": side,
+                "categories": cats,
+                "safety_label": label,
+                "safety_hits": safety_hits,
+                "context_tail": context_tail(record),
+                "response": text,
+                "other_response": other,
+            }
+            line = json.dumps(item, ensure_ascii=False)
+            files["all"].write(line + "\n")
+            side_counts[side] += 1
+            safety_flagged[label] += 1
+            for cat in cats:
+                files[cat].write(line + "\n")
+                category_counts[cat] += 1
+                safety_by_category[cat][label] += 1
+                per_record_categories.add(cat)
+        if per_record_categories:
+            overlap_counts[len(per_record_categories)] += 1
+
+    for f in files.values():
+        f.close()
+
+    summary = {
+        "input": str(INPUT),
+        "output_dir": str(OUT_DIR),
+        "records": len(data),
+        "category_counts_candidate_level": dict(category_counts),
+        "flagged_side_counts": dict(side_counts),
+        "safety_total_record_level": dict(safety_total),
+        "safety_flagged_candidate_level": dict(safety_flagged),
+        "safety_by_category_candidate_level": {k: dict(v) for k, v in safety_by_category.items()},
+        "record_category_overlap_counts": dict(overlap_counts),
+        "notes": [
+            "The source has no model-id field, so flagged_side is chosen/rejected, not a confirmed 13052 label.",
+            "Safety labels are heuristic keyword labels over context plus both candidate responses.",
+            "Counts are candidate-level for flagged outputs unless the key says record-level.",
+        ],
+    }
+    (OUT_DIR / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+    md = [
+        "# 13052 Style Issue Extraction",
+        "",
+        f"Input: `{INPUT}`",
+        f"Records: {len(data)}",
+        "",
+        "## Output files",
+        "",
+        "- `01_narrator_summary.jsonl`: 旁白总结/复述剧情感",
+        "- `02_scene_jump_new_event.jsonl`: 跳场景/新增事件",
+        "- `03_role_control_shift.jsonl`: 替用户推进/控制用户动作或心理",
+        "- `04_tone_format_mismatch.jsonl`: 语气和格式更像小说叙述，互动弱",
+        "- `all_flagged.jsonl`: 所有命中候选",
+        "- `summary.json`: 统计信息",
+        "",
+        "## Candidate-level counts",
+        "",
+    ]
+    for cat, cnt in category_counts.most_common():
+        md.append(f"- {cat}: {cnt}")
+    md.extend(["", "## Safety heuristic", ""])
+    for label, total in safety_total.items():
+        flagged = safety_flagged.get(label, 0)
+        rate = flagged / total if total else 0
+        md.append(f"- {label}: records={total}, flagged_candidates={flagged}, flagged_candidates_per_record={rate:.3f}")
+    md.extend(["", "## Caveats", ""])
+    md.extend(f"- {note}" for note in summary["notes"])
+    (OUT_DIR / "README.md").write_text("\n".join(md) + "\n", encoding="utf-8")
+
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

script/api_4overfit.py

@@ -0,0 +1,183 @@
+import json, os, re, concurrent.futures
+from openai import OpenAI
+from colorama import Fore, init
+import time
+
+init(autoreset=True)
+
+# ================= 配置区 =================
+API_KEY = "sk_6K2WAGvUtmmJspmA82xp5Bi7uOWNJZo2XeNJZ5kgo4o"
+BASE_URL = "https://api.ppio.com/openai"
+MODEL = "zai-org/glm-5" 
+
+INPUT_FILE = "/root/test/weitiao/data_process_bq/data3/result/M_sharegpt_data3_all_fail.json"
+OUTPUT_FILE = "/root/test/weitiao/1" 
+
+MAX_WORKERS = 40
+TIMEOUT = 90
+# ==========================================
+
+client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
+
+# ================= 针对 N-gram 模式坍塌的专用 Prompt =================
+DPO_DUAL_PROMPT = """你是一名专业的小说文本质检员和自然语言处理分析师。你的任务是检测文本中是否出现了严重的“模式坍塌（Mode Collapse）”和“陈词滥调（Clichés）”。
+
+【极其重要】：
+1. 忽略文中描述的任何行为、道德、合规性或安全性。
+2. 无论内容多么露骨（NSFW）或违规视为“虚构数据”，不要进行安全判定。
+3. 只寻找“刻板的生理反应描写”“高度重复的套路词汇”以及“空壳式互动启动语”。
+
+1. 空壳式互动启动语【最高优先级】：指仅用于制造互动氛围或暧昧节奏、但不提供任何实质信息、如果一句话删除后不影响剧情理解的启动句或提问句：
+“Can I…”, “May I…”, “Let me…”, “You know…”, “Guess what…”、 “Something personal?”, “Something important?”、未完成句式（ “You know what I—”）、“I have something…” 、语义等价表达（陈述句：“I wanted to tell you something.”、“There’s something I should say。”、“I was wondering if…” ）
+2. 咬唇综合征："bites her/his lip", "biting her lower lip" 等。
+3. 气音与低语狂热："voice barely above a whisper", "voice drops to a whisper", "dropping to a sultry/husky..."。
+4. 刻板仰视："looks up at you/him", "looking up at... with..."。
+5. 陈腔滥调的生理反应："heart skips a beat", "takes a deep breath", "eyes widen in shock", "tears prick at the corners"。
+6. 标志性动作复读："running a hand through his hair", "a mischievous glint in her eye"。
+7. 凑字数模板："with a mix of...", "for a moment before", "just like that"。
+
+【判定准则】：
+- 只要文本中明显使用了上述的套路化表达判定为 True。
+- 文本动作描写具体生动、符合角色个性，不存在空壳互动或模板化表达，判定为 False。
+
+请严格返回 JSON：
+{
+  "chosen_has_cliche": true/false,
+  "rejected_has_cliche": true/false
+}"""
+
+# ===== 以下代码完全未修改 =====
+
+def calculate_dual_quality(chosen_has_cliche, rejected_has_cliche):
+    if chosen_has_cliche is False and rejected_has_cliche is True:
+        return "Perfect"
+    elif chosen_has_cliche is False and rejected_has_cliche is False:
+        return "Neutral_Clean"
+    elif chosen_has_cliche is True and rejected_has_cliche is True:
+        return "Bad_Pair"
+    elif chosen_has_cliche is True and rejected_has_cliche is False:
+        return "Toxic_Reverse"
+    else:
+        return "Unknown"
+
+def extract_json_robust(text):
+    if not text: return None
+
+    text = re.sub(r"^```json\s*", "", text, flags=re.MULTILINE)
+    text = re.sub(r"```$", "", text, flags=re.MULTILINE).strip()
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+
+    try:
+        match = re.search(r'(\{.*)[,"]', text, re.DOTALL)
+        if match:
+            potential_json = match.group(1).strip()
+            for suffix in ['"}', '}', 'true}', 'false}']:
+                try:
+                    return json.loads(potential_json + suffix)
+                except:
+                    continue
+    except:
+        return None
+    return None
+
+def audit_dual_item(index, item):
+    prompt = f"###[A] Chosen Text:\n{item['chosen']['value']}\n\n### [B] Rejected Text:\n{item['rejected']['value']}"
+    
+    max_retries = 3
+    
+    for attempt in range(max_retries):
+        try:
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": DPO_DUAL_PROMPT}, 
+                    {"role": "user", "content": prompt}
+                ],
+                response_format={"type": "json_object"}, 
+                temperature=0.1,  
+                timeout=TIMEOUT
+            )
+            content = response.choices[0].message.content.strip()
+            audit = extract_json_robust(content)
+
+            if audit:
+                # ✅ 兼容 list 或 dict
+                if isinstance(audit, list) and len(audit) > 0:
+                    audit = audit[0]
+
+                c_cliche = audit.get("chosen_has_cliche")
+                r_cliche = audit.get("rejected_has_cliche")
+                audit["dual_quality"] = calculate_dual_quality(c_cliche, r_cliche)
+                return {"_original_index": index, "audit_result": audit}
+            else:
+                return {
+                    "_original_index": index,
+                    "audit_result": {
+                        "chosen_has_cliche": False, 
+                        "rejected_has_cliche": False,
+                        "dual_quality": "Refused"
+                    }
+                }
+                
+        except Exception as e:
+            error_msg = str(e)
+            if ("timed out" in error_msg.lower() or "timeout" in error_msg.lower() or "connection" in error_msg.lower()) and attempt < max_retries - 1:
+                sleep_time = 2 ** attempt
+                time.sleep(sleep_time)
+                continue
+            
+            return {"_original_index": index, "error": error_msg}
+
+def process():
+    if not os.path.exists(INPUT_FILE):
+        print(f"{Fore.RED}错误：找不到输入文件 {INPUT_FILE}")
+        return
+    
+    with open(INPUT_FILE, "r", encoding="utf-8") as f: 
+        data = json.load(f)
+
+    processed_count = 0
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f: 
+            processed_count = sum(1 for _ in f)
+
+    to_process = data[processed_count:]
+    print(f"{Fore.CYAN}🚀 鲁棒审计启动（打击过拟合与套路词），剩余: {len(to_process)} 条...")
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {executor.submit(audit_dual_item, i + processed_count, item): i for i, item in enumerate(to_process)}
+
+        for future in concurrent.futures.as_completed(futures):
+            res = future.result()
+            idx = res.get("_original_index", "??")
+
+            if "error" in res:
+                print(f"{Fore.RED}#{idx} | 拦截/错误: {res['error'][:40]}")
+            else:
+                aud = res["audit_result"]
+                # ✅ 防止 audit 是字符串/其他非 dict
+                if isinstance(aud, dict):
+                    c_c = aud.get("chosen_has_cliche")
+                    r_c = aud.get("rejected_has_cliche")
+                    quality = aud.get("dual_quality")
+                else:
+                    c_c = r_c = quality = "Unknown"
+
+                if quality == "Perfect":
+                    color = Fore.GREEN
+                elif quality == "Toxic_Reverse" or quality == "Bad_Pair":
+                    color = Fore.RED
+                else:
+                    color = Fore.YELLOW
+                    
+                print(f"#{idx} | {color}解析成功 | Chosen_套路: {c_c} | Rejected_套路: {r_c} | 综合质量: {quality}")
+
+            with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
+                f.write(json.dumps(res, ensure_ascii=False) + "\n")
+
+if __name__ == "__main__":
+    process()

script/check_number.py

@@ -0,0 +1,8 @@
+import json
+
+FILE_PATH = "/root/test/weitiao/data_process_bq/data3/result/M_sharegpt_data3_all_by_batch_order_perfect_neutral.json"
+with open(FILE_PATH, 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+count = len(data)
+print(f"条目总数（长度）是: {count}")

script/closure_check.py

@@ -0,0 +1,85 @@
+import json
+import re
+import os
+
+input_path = "/root/test/weitiao/data_process_bq/data/train01_hg2chatml_p2r.json"
+output_path = "/root/test/weitiao/data_process_bq/data/train01_chatml_p2r_closed.json"
+dropped_path = "/root/test/weitiao/data_process_bq/data/train01_chatml_p2r_unclosed.json"
+
+def is_balanced(text: str):
+    """检查 text 内部的特殊字符是否成对出现"""
+    if text.count('*') % 2 != 0:
+        return False, "unmatched *"
+    if re.search(r'(?<!\\)"', text):
+        return False, "unescaped quote"
+    return True, None
+
+def check_role_format(text: str):
+    """检查角色名格式是否正常"""
+    pattern = r'^[A-Za-z0-9_]+:\s*(["*]|.)'
+    ok = re.match(pattern, text.strip()) is not None
+    return ok
+
+def is_valid_message_content(content: str):
+    # 1. 成对符号检查
+    ok, reason = is_balanced(content)
+    if not ok:
+        return False, reason
+
+    # 2. 角色格式检查
+    if ":" in content:
+        left = content.split(":", 1)[0]
+        if re.match(r'^[A-Za-z0-9_]+$', left):
+            if not check_role_format(content):
+                return False, "invalid role format"
+
+    return True, None
+
+def clean_dataset(input_path, output_path, dropped_path):
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    cleaned = []
+    dropped = []
+
+    for item_idx, item in enumerate(data):
+        ok = True
+        reason = ""
+
+        # -------- 检查 chosen / rejected message lists --------
+        for branch in ["chosen", "rejected"]:
+            if branch not in item:
+                ok = False
+                reason = f"missing field: {branch}"
+                break
+            for msg_idx, msg in enumerate(item[branch]):
+                content = msg.get("content", "")
+                valid, why = is_valid_message_content(content)
+                if not valid:
+                    ok = False
+                    reason = f"{branch}[{msg_idx}].content: {why}"
+                    break
+            if not ok:
+                break
+        if ok:
+            cleaned.append(item)
+        else:
+            new_item = dict(item)
+            new_item["drop_reason"] = reason
+            dropped.append(new_item)
+
+    print(f"总共 {len(data)} 条")
+    print(f"丢弃 {len(dropped)} 条（不闭合或格式异常）")
+    print(f"保留 {len(cleaned)} 条 → {output_path}")
+    print(f"丢弃样本写入 → {dropped_path}")
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(cleaned, f, indent=2, ensure_ascii=False)
+
+    os.makedirs(os.path.dirname(dropped_path), exist_ok=True)
+    with open(dropped_path, "w", encoding="utf-8") as f:
+        json.dump(dropped, f, indent=2, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    clean_dataset(input_path, output_path, dropped_path)

script/data_turns_tokens.py

@@ -0,0 +1,80 @@
+import json
+import pandas as pd
+import numpy as np
+from transformers import AutoTokenizer
+from tqdm import tqdm
+
+DATA_PATH = "/home/DataProcess/data/train0_train1_merged.json"
+MODEL_PATH = "/home/DataProcess/model/Qwen3-4B"
+
+def main():
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
+    with open(DATA_PATH, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    stats_list = []
+
+    for i, item in tqdm(enumerate(data), total=len(data), desc="Processing"):
+        history = item.get("messages", [])
+        response_list = item.get("chosen", [])
+        if not response_list:
+            response_list = item.get("rejected", [])
+        full_conversation = history + response_list
+        
+        # num_msgs: 列表里的字典总数 (例如: System + User + Assistant + User + Assistant = 5)
+        num_msgs = len(full_conversation)
+        # turns: 估算的对话轮数 (通常一问一答算一轮，或者和前一条算一轮)
+        turns = (num_msgs + 1) // 2 
+
+        # tokenize=False 获取拼接后的字符串
+        text = tokenizer.apply_chat_template(full_conversation, tokenize=False, add_generation_prompt=False)
+        # 编码计算 token id 数量
+        token_ids = tokenizer.encode(text, add_special_tokens=False)
+        num_tokens = len(token_ids)
+
+        stats_list.append({
+            "index": i,
+            "num_messages": num_msgs, # 消息总条数
+            "turns": turns,           # 对话轮数
+            "tokens": num_tokens      # Token 数量
+        })
+    df = pd.DataFrame(stats_list)
+
+    print(f"数据总量: {len(df)} 条")
+    
+    print("\n--- Tokens (长度) 统计 ---")
+    print(f"平均 Tokens: {df['tokens'].mean():.2f}")
+    print(f"最大 Tokens: {df['tokens'].max()}")
+    print(f"最小 Tokens: {df['tokens'].min()}")
+    print(f"Token 中位数: {df['tokens'].median()}")
+    print(f"Token 95%分位: {df['tokens'].quantile(0.95):.2f}")
+
+    print("\n--- Turns (消息数) 统计 ---")
+    print(f"平均消息数 (Messages): {df['num_messages'].mean():.2f}")
+    print(f"最大消息数: {df['num_messages'].max()}")
+    print(f"平均轮数 (Turns): {df['turns'].mean():.2f}")
+
+    # Token 分布概览
+    print("\n--- Token 长度分布 (区间占比) ---")
+    token_bins = [0, 512, 1024, 2048, 4096, 8192, 100000]
+    token_labels = ['0-512', '512-1024', '1024-2048', '2048-4096', '4096-8192', '8192+']
+    df['token_group'] = pd.cut(df['tokens'], bins=token_bins, labels=token_labels)
+    print(df['token_group'].value_counts(normalize=True).sort_index() * 100)
+
+    # Turns 分布概览 (新增部分)
+    print("\n--- Turns 对话轮数分布 (区间占比) ---")
+    # 细致划分：1轮, 2轮, 3轮, 4轮, 5轮, 6-10轮, 11-20轮, 20轮以上
+    turn_bins = [0, 1, 2, 3, 4, 5, 10, 20, 1000]
+    turn_labels = ['1轮 (Single)', '2轮', '3轮', '4轮', '5轮', '6-10轮', '11-20轮', '20轮+']
+    df['turn_group'] = pd.cut(df['turns'], bins=turn_bins, labels=turn_labels)
+    print(df['turn_group'].value_counts(normalize=True).sort_index() * 100)
+
+    # 检查是否有超长数据 (超过2048)
+    over_len = df[df['tokens'] > 2048]
+    if not over_len.empty:
+        print(f"\n 注意: 有 {len(over_len)} 条数据 Token 数超过 2048")
+    else:
+        print("\n 所有数据 Token 数均在 2048 以内")
+
+if __name__ == "__main__":
+    main()

script/download_model.py

@@ -0,0 +1,11 @@
+from huggingface_hub import snapshot_download
+# 下载 Hugging Face 模型（核心：repo_type="model"）
+local_dir = snapshot_download(
+    repo_id="bingqin111/mistral_data3_2w_sft",  # 模型仓库 ID（替换为你需要的模型）
+    repo_type="model",            
+    local_dir="/root/test/weitiao/CharacterEval/model",  # 先设置好文件夹
+    # 可选参数（根据需求添加）
+    # ignore_patterns=["*.bin.index.json", "*.msgpack"],  # 忽略不需要的文件（如索引文件）
+    resume_download=True,  # 支持断点续传（网络中断后重新运行可继续下载）
+    # token="your_hf_token"  # 若模型是私有/ gated 模型，需传入你的 Hugging Face Token
+)

script/filter/filter_by_chosen_overfit_hard.py

@@ -0,0 +1,97 @@
+import json
+import os
+from typing import Any, Dict, List
+
+
+INPUT_FILE = "/root/test/weitiao/data_process_bq/data3/sharegpt_h1_nam_num_nhh_len_hard_rej_think_nobite.json"
+OUTPUT_BITE_FILE = "/root/test/weitiao/data_process_bq/data3/sharegpt_h1_nam_num_nhh_len_hard_rej_think_wis.json"
+OUTPUT_NOBITE_FILE = "/root/test/weitiao/data_process_bq/data3/sharegpt_h1_nam_num_nhh_len_hard_rej_think_nobitewis.json"
+
+KEYWORD = "her voice barely above a whisper"
+
+
+def extract_chosen_text(record: Dict[str, Any]) -> str:
+    """
+    从一条样本中抽取用于匹配的 chosen 文本。
+    兼容两种常见结构：
+      1. "chosen": {"from": "...", "value": "..."}
+      2. "chosen": "..."
+    其他情况返回空字符串。
+    """
+    chosen = record.get("chosen")
+
+    if isinstance(chosen, dict):
+        value = chosen.get("value", "")
+        return value if isinstance(value, str) else ""
+
+    if isinstance(chosen, str):
+        return chosen
+
+    return ""
+
+
+def split_by_bite(
+    input_path: str,
+    output_bite_path: str,
+    output_nobite_path: str,
+    keyword: str,
+) -> None:
+    """根据 chosen 文本中是否包含 keyword，将样本分为两份。"""
+    keyword_lower = keyword.lower()
+
+    print(f"正在读取输入文件: {input_path}")
+    try:
+        with open(input_path, "r", encoding="utf-8") as f:
+            data: List[Dict[str, Any]] = json.load(f)
+    except Exception as e:
+        print(f"❌ 无法读取或解析文件 '{input_path}'，错误信息: {e}")
+        return
+
+    if not isinstance(data, list):
+        print(f"❌ 输入文件顶层结构不是列表: {input_path}")
+        return
+
+    bite_records: List[Dict[str, Any]] = []
+    nobite_records: List[Dict[str, Any]] = []
+
+    for record in data:
+        if not isinstance(record, dict):
+            nobite_records.append(record)
+            continue
+
+        chosen_text = extract_chosen_text(record)
+        text_lower = chosen_text.lower() if isinstance(chosen_text, str) else ""
+
+        if keyword_lower in text_lower:
+            bite_records.append(record)
+        else:
+            nobite_records.append(record)
+
+    # 确保输出目录存在
+    os.makedirs(os.path.dirname(output_bite_path), exist_ok=True)
+    os.makedirs(os.path.dirname(output_nobite_path), exist_ok=True)
+
+    with open(output_bite_path, "w", encoding="utf-8") as f:
+        json.dump(bite_records, f, ensure_ascii=False, indent=4)
+
+    with open(output_nobite_path, "w", encoding="utf-8") as f:
+        json.dump(nobite_records, f, ensure_ascii=False, indent=4)
+
+    print("==============================================")
+    print(f"输入样本总数: {len(data)}")
+    print(f"包含 '{keyword}' 的样本数 (写入 *_bite.json): {len(bite_records)}")
+    print(f"不包含 '{keyword}' 的样本数 (写入 *_nobite.json): {len(nobite_records)}")
+    print("✅ 处理完成！")
+    print(f"含有关键词的样本已保存至: {output_bite_path}")
+    print(f"其余样本已保存至: {output_nobite_path}")
+    print("==============================================")
+
+
+if __name__ == "__main__":
+    split_by_bite(
+        INPUT_FILE,
+        OUTPUT_BITE_FILE,
+        OUTPUT_NOBITE_FILE,
+        KEYWORD,
+    )
+

script/filter/filter_by_hhuman.py

@@ -0,0 +1,89 @@
+import json
+import os
+
+input_file = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel_numdel/dirty_data_from_rejected.json"
+output_file = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel_numdel/p_dirty_data_from_rejected.json"
+
+def process_conversations(data):
+    processed_data =[]
+    
+    for item in data:
+        conversations = item.get("conversations",[])
+        if not conversations:
+            processed_data.append(item)
+            continue
+            
+        system_msg = None
+        raw_rest = []
+        
+        # 1. 提取并保留 system prompt
+        if conversations[0].get("from") == "system":
+            system_msg = conversations[0]
+            raw_rest = conversations[1:]
+        else:
+            raw_rest = conversations
+            
+        # 2. 处理连续出现的相同角色（保留后出现的，删除先出现的）
+        temp_msgs =[]
+        for msg in raw_rest:
+            if not temp_msgs:
+                temp_msgs.append(msg)
+            else:
+                if temp_msgs[-1]["from"] == msg["from"]:
+                    # 发现连续相同的角色，用当前这条覆盖上一条
+                    temp_msgs[-1] = msg
+                else:
+                    # 角色交替，正常添加
+                    temp_msgs.append(msg)
+                    
+        # 3. 确保 conversations 里面的对话开始必须是 human
+        if temp_msgs and temp_msgs[0]["from"] != "human":
+            temp_msgs.pop(0)
+            
+        # 4. 确保 conversations 里面的最后一条必须是 human
+        if temp_msgs and temp_msgs[-1]["from"] != "human":
+            temp_msgs.pop()
+            
+        # 5. 重组 conversations
+        new_conversations =[]
+        if system_msg:
+            new_conversations.append(system_msg)
+        new_conversations.extend(temp_msgs)
+        
+        # 更新 item 中的 conversations
+        item["conversations"] = new_conversations
+        
+        # （可选）如果在掐头去尾后，对话列表为空了（说明没有有效对话），可以选择不加入结果中。
+        # 这里默认如果还存在有对话（至少有一条human），就保留该条数据
+        if len(temp_msgs) >= 1:
+            processed_data.append(item)
+
+    return processed_data
+
+def main():
+    print(f"正在读取数据: {input_file} ...")
+    try:
+        with open(input_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        print(f"错误: 找不到文件 {input_file}")
+        return
+        
+    print(f"成功读取到 {len(data)} 条数据，开始处理...")
+    
+    processed_data = process_conversations(data)
+    
+    print(f"处理完成！剔除无效对话后剩余 {len(processed_data)} 条数据。")
+    print(f"正在保存结果至: {output_file} ...")
+    
+    # 确保保存的目录存在
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    
+    with open(output_file, 'w', encoding='utf-8') as f:
+        # ensure_ascii=False 保证中文正常显示，indent=4 美化格式（如果在意文件大小可将indent去掉）
+        json.dump(processed_data, f, ensure_ascii=False, indent=4)
+        
+    print("保存成功！")
+
+if __name__ == "__main__":
+    main()

script/filter/filter_by_lenght_turns.py

@@ -0,0 +1,91 @@
+import json
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+INPUT_PATH = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel_numdel/filtered_clean_data.json"
+PASS_PATH = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel_numdel/sharegpt_human1st_namdel_numdel_4096.json"
+FAIL_PATH = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel_numdel/sharegpt_human1st_namdel_numdel_o4096.json"
+
+MAX_TOKENS = 4096
+MAX_TURNS = 20
+
+TOKENIZER_PATH = "/root/test/weitiao/data_process_bq/model/Qwen3-4B"
+
+def format_chat_input(history, response_list, tokenizer):
+    """
+    history: list, 对应 json 中的 "messages"
+    response_list: list, 对应 json 中的 "chosen" 或 "rejected"
+    """
+    # 拼接历史对话和当前的回复
+    full_conversation = history + response_list
+    
+    # 使用 tokenizer 的聊天模板转为字符串 (例如转为 <|im_start|>user...<|im_end|>)
+    # tokenize=False 表示只返回字符串，不返回 ID
+    try:
+        txt = tokenizer.apply_chat_template(full_conversation, tokenize=False, add_generation_prompt=False)
+    except Exception as e:
+        # 如果模型没有模板（很少见），则手动拼接作为兜底
+        txt = ""
+        for msg in full_conversation:
+            txt += f"{msg['role']}: {msg['content']}\n"
+    
+    # 依然保留 V2 脚本的核心逻辑：强制检查并添加 EOS
+    if not txt.endswith(tokenizer.eos_token):
+        txt += tokenizer.eos_token
+    return txt
+
+def count_turns(messages):
+    """
+    轮数定义：
+    history 中 user 的数量
+    """
+    return sum(1 for m in messages if m.get("role") == "user")
+
+def main():
+    tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH, trust_remote_code=True)
+    tokenizer.padding_side = "left"                          
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    with open(INPUT_PATH, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    passed,failed = [],[]
+    for item in tqdm(data,desc="filtering)"):
+        history = item.get("messages",[])
+        responses = []
+        if"chosen"in item:
+            responses.append(item["chosen"])
+        if"rejected"in item:
+            responses.append(item["rejected"])
+
+        turns=count_turns(history)
+        token_exceed = False
+        for resp in responses:
+            txt=format_chat_input(history,resp,tokenizer)
+            token_len = len(tokenizer(txt)["input_ids"])
+            if token_len > MAX_TOKENS:
+                token_exceed = True
+                break
+        if token_exceed or turns>MAX_TURNS:
+            failed.append({
+                **item,
+                "_filter_reason":{
+                    "token_exceed":token_exceed,
+                    "user_turns":turns
+                }
+            })
+        else:
+            passed.append(item)
+
+    with open(PASS_PATH,"w",encoding="utf-8")as f:
+        json.dump(passed,f,ensure_ascii=False,indent=2)
+    with open(FAIL_PATH,"w",encoding="utf-8")as f:
+        json.dump(failed,f,ensure_ascii=False,indent=2)
+
+    print(f"total:{len(data)}")
+    print(f"passed:{len(passed)}")
+    print(f"failed:{len(failed)}")
+
+if __name__ == "__main__":
+    main()

script/filter/filter_by_lenth.py

@@ -0,0 +1,102 @@
+import json
+from transformers import AutoTokenizer
+import os
+
+# --- 配置 ---
+# ⚠️ 请根据您的实际情况修改以下文件名和模型ID
+INPUT_FILENAME = "/root/test/weitiao/data_processing_hsichen/data_process_bq/result/rm_dpo_infered_8_truncated_replaced_30safe.json"   # 👈 替换为您的 DPO 语料文件名
+OUTPUT_FILENAME = "/root/test/weitiao/data_processing_hsichen/data_process_bq/result/rm_dpo_8_truncated_replaced_30safe.json" # 👈 筛选后数据的输出文件名
+MODEL_ID = "mistralai/Mistral-7B-v0.1" 
+
+# --- 筛选条件 ---
+MIN_TOKENS = 20
+MAX_TOKENS = 76
+
+def get_token_length(tokenizer, text):
+    """计算给定文本的 token 长度。"""
+    # 使用 return_length=True 来获取长度，但通常直接 len(tokens) 更常见且稳定
+    return len(tokenizer.encode(text, add_special_tokens=False))
+
+def filter_dataset_by_length(input_file, output_file, model_id, min_len, max_len):
+    """
+    读取DPO数据集，并根据 chosen 和 rejected 回复的 token 长度进行筛选。
+    """
+    # 检查输入文件是否存在
+    if not os.path.exists(input_file):
+        print(f"❌ 错误: 输入文件 '{input_file}' 不存在。请检查路径是否正确。")
+        return
+
+    print(f"正在加载 tokenizer: {model_id}...")
+    try:
+        # 加载用于计算长度的 tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        print("Tokenizer 加载完成。")
+    except Exception as e:
+        print(f"❌ 错误: Tokenizer 加载失败。请检查 MODEL_ID 和网络连接。错误: {e}")
+        return
+
+    # 1. 读取数据
+    print(f"正在读取数据文件: {input_file}...")
+    try:
+        with open(input_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"❌ 错误: 无法读取或解析文件 '{input_file}'。错误: {e}")
+        return
+
+    filtered_data = []
+    dropped_count = 0
+    total_count = len(data)
+
+    print(f"开始筛选语料，总共 {total_count} 条数据...")
+
+    # 2. 遍历并筛选数据
+    for i, item in enumerate(data):
+        # 确保数据格式正确
+        if "chosen" not in item or "rejected" not in item:
+            print(f"⚠️ 警告: 第 {i+1} 条数据缺少 'chosen' 或 'rejected' 键，已丢弃。")
+            dropped_count += 1
+            continue
+            
+        chosen_text = item["chosen"]["value"]
+        rejected_text = item["rejected"]["value"]
+
+        # 检查 chosen 文本长度
+        chosen_len = get_token_length(tokenizer, chosen_text)
+        
+        # 检查 rejected 文本长度
+        rejected_len = get_token_length(tokenizer, rejected_text)
+
+        # 筛选逻辑：chosen 和 rejected 必须同时满足长度要求
+        is_chosen_valid = min_len <= chosen_len <= max_len
+        is_rejected_valid = min_len <= rejected_len <= max_len
+
+        if is_chosen_valid and is_rejected_valid:
+            filtered_data.append(item)
+        else:
+            dropped_count += 1
+            # 打印丢弃原因，方便调试
+            print(f"丢弃第 {i+1} 条数据: Chosen({chosen_len} tokens) / Rejected({rejected_len} tokens)。")
+
+    # 3. 保存筛选后的数据
+    print("\n" + "="*30)
+    print("筛选结果统计")
+    print("="*30)
+    print(f"原始数据总量: {total_count} 条")
+    print(f"✅ 保留数据量: {len(filtered_data)} 条")
+    print(f"❌ 丢弃数据量: {dropped_count} 条")
+    print(f"保留比例: {len(filtered_data) / total_count * 100:.2f}%")
+
+    if filtered_data:
+        try:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                json.dump(filtered_data, f, indent=2, ensure_ascii=False)
+            print(f"💾 筛选后的数据已保存到 '{output_file}'。")
+        except Exception as e:
+            print(f"❌ 错误: 写入输出文件失败。错误: {e}")
+    else:
+        print("⚠️ 警告: 没有数据符合筛选条件，未生成输出文件。")
+
+
+if __name__ == "__main__":
+    filter_dataset_by_length(INPUT_FILENAME, OUTPUT_FILENAME, MODEL_ID, MIN_TOKENS, MAX_TOKENS)

script/filter/filter_by_name_delete.py

@@ -0,0 +1,84 @@
+import json
+import re
+from tqdm import tqdm
+
+INPUT_FILENAME = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st.json" 
+OUTPUT_FILENAME = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st_namdel.json"
+
+def fix_all_prefixes(input_file, output_file):
+    """
+    修复数据集中 conversations, chosen, 和 rejected 部分中
+    human 和 gpt 回答残留的 'Name: ' 等前缀。
+    此函数会确保不修改 system 回合。
+    """
+    try:
+        with open(input_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"❌ 错误: 无法读取文件 '{input_file}'. 错误: {e}")
+        return
+
+    fixed_data = []
+    total_turns_fixed = 0
+    items_affected = 0
+
+    # 用于匹配 "Name: ", "Character : " 等格式的前缀
+    prefix_pattern = re.compile(r"^[\w\s\(\)'-]+\s*:\s*")
+
+    for item in tqdm(data, desc="修复所有前缀"):
+        item_was_affected = False
+
+        # --- 1. 修复 'conversations' 中的前缀 ---
+        conversations = item.get("conversations")
+        if conversations and isinstance(conversations, list):
+            for turn in conversations:
+                # 只对 human 和 gpt 回合进行操作
+                if turn.get("from") in ["human", "gpt"]:
+                    value = turn.get("value", "")
+                    if isinstance(value, str):
+                        match = prefix_pattern.match(value)
+                        if match:
+                            turn['value'] = value[match.end():].strip()
+                            total_turns_fixed += 1
+                            item_was_affected = True
+
+        # --- 2. 修复 'chosen' 中的前缀 (新增) ---
+        chosen_turn = item.get("chosen")
+        if chosen_turn and isinstance(chosen_turn, dict) and chosen_turn.get("from") in ["human", "gpt"]:
+            value = chosen_turn.get("value", "")
+            if isinstance(value, str):
+                match = prefix_pattern.match(value)
+                if match:
+                    chosen_turn['value'] = value[match.end():].strip()
+                    total_turns_fixed += 1
+                    item_was_affected = True
+
+        # --- 3. 修复 'rejected' 中的前缀 (新增) ---
+        rejected_turn = item.get("rejected")
+        if rejected_turn and isinstance(rejected_turn, dict) and rejected_turn.get("from") in ["human", "gpt"]:
+            value = rejected_turn.get("value", "")
+            if isinstance(value, str):
+                match = prefix_pattern.match(value)
+                if match:
+                    rejected_turn['value'] = value[match.end():].strip()
+                    total_turns_fixed += 1
+                    item_was_affected = True
+
+        if item_was_affected:
+            items_affected += 1
+
+        fixed_data.append(item)
+
+    # 保存修复后的数据
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(fixed_data, f, indent=2, ensure_ascii=False)
+
+    print("\n" + "="*20 + " 全面修复完成 " + "="*20)
+    print(f"总共处理: {len(data)} 条数据")
+    print(f"总共有 {items_affected} 条数据的对话内容被修改。")
+    print(f"✅ 成功修复了 'conversations', 'chosen', 'rejected' 中总计 {total_turns_fixed} 个回合的前缀。")
+    print(f"💾 修复后的数据已保存到 '{output_file}'。")
+
+
+if __name__ == "__main__":
+    fix_all_prefixes(INPUT_FILENAME, OUTPUT_FILENAME)

script/filter/filter_by_number_start.py

@@ -0,0 +1,133 @@
+import json
+import os
+
+def contains_digit(text):
+    """
+    检查一个字符串的任何位置是否包含数字。
+    """
+    if not isinstance(text, str):
+        return False
+    return any(char.isdigit() for char in text)
+
+def starts_with_invalid_character(text):
+    """
+    检查字符串在去除空格后，是否以无效字符开头。
+    有效开头：字母、星号(*)、双引号(")。
+    无效开头：数字、其他符号、标点等。
+    """
+    if not isinstance(text, str):
+        return False # 非字符串不处理
+
+    stripped_text = text.strip()
+
+    if not stripped_text:
+        return False # 空字符串视为有效
+
+    first_char = stripped_text[0]
+
+    # 如果开头是字母或在允许的符号列表中，则是有效的
+    if first_char.isalpha() or first_char in ['*', '"']:
+        return False
+
+    # 其他所有情况（包括数字开头）均视为无效
+    return True
+
+def process_and_filter_data(input_file_path, output_directory):
+    """
+    根据严格的“无数字”和“有效开头”规则，过滤SFT JSON文件，
+    并分类保存被移除的数据。
+    """
+    # 初始化数据分类列表
+    clean_records = []
+    dirty_from_conv = []
+    dirty_from_chosen = []
+    dirty_from_rejected = []
+
+    try:
+        with open(input_file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"❌ 错误: 无法读取或解析文件 '{input_file_path}'. 错误详情: {e}")
+        return
+
+    if not isinstance(data, list):
+        print(f"❌ 错误: 文件 '{input_file_path}' 的顶层结构不是列表。")
+        return
+
+    # 遍历每一条主数据记录
+    for record in data:
+        if not isinstance(record, dict):
+            continue
+
+        # 初始化当前记录的问题标志位
+        is_dirty_in_conv, is_dirty_in_chosen, is_dirty_in_rejected = False, False, False
+
+        # --- 检查记录中的所有问题 ---
+        # 1. 检查 'conversations'
+        if 'conversations' in record and isinstance(record['conversations'], list):
+            for turn in record['conversations']:
+                if isinstance(turn, dict) and turn.get('from') == 'gpt':
+                    value = turn.get('value')
+                    if contains_digit(value) or starts_with_invalid_character(value):
+                        is_dirty_in_conv = True
+                        break # 在conversations中发现问题，无需再检查此列表
+
+        # 2. 检查 'chosen'
+        chosen_turn = record.get('chosen')
+        if isinstance(chosen_turn, dict) and chosen_turn.get('from') == 'gpt':
+            value = chosen_turn.get('value')
+            if contains_digit(value) or starts_with_invalid_character(value):
+                is_dirty_in_chosen = True
+
+        # 3. 检查 'rejected'
+        rejected_turn = record.get('rejected')
+        if isinstance(rejected_turn, dict) and rejected_turn.get('from') == 'gpt':
+            value = rejected_turn.get('value')
+            if contains_digit(value) or starts_with_invalid_character(value):
+                is_dirty_in_rejected = True
+
+        # --- 分类逻辑 ---
+        # 只要任何一个部分有问题，记录就是“不干净”的
+        is_dirty = is_dirty_in_conv or is_dirty_in_chosen or is_dirty_in_rejected
+
+        if not is_dirty:
+            clean_records.append(record)
+        else:
+            # 根据问题出现的位置，将不干净的记录放入对应列表
+            if is_dirty_in_conv: dirty_from_conv.append(record)
+            if is_dirty_in_chosen: dirty_from_chosen.append(record)
+            if is_dirty_in_rejected: dirty_from_rejected.append(record)
+
+    # --- 文件输出逻辑 ---
+    os.makedirs(output_directory, exist_ok=True)
+
+    output_files = {
+        "filtered_clean_data.json": clean_records,
+        "dirty_data_from_conversations.json": dirty_from_conv,
+        "dirty_data_from_chosen.json": dirty_from_chosen,
+        "dirty_data_from_rejected.json": dirty_from_rejected
+    }
+
+    print("="*60)
+    print(f"数据清洗与过滤报告 (输出目录: '{output_directory}')")
+    print("="*60)
+    print(f"原始数据总数: {len(data)} 条")
+
+    for filename, data_to_write in output_files.items():
+        output_path = os.path.join(output_directory, filename)
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data_to_write, f, indent=4, ensure_ascii=False)
+        print(f"已生成文件: {filename:<40} (包含 {len(data_to_write)} 条记录)")
+
+    print("="*60)
+    print("✅ 所有文件已处理完毕！")
+    print("="*60)
+
+
+if __name__ == "__main__":
+
+    input_file = "/root/test/weitiao/data_process_bq/data/data3/sharegpt_h1_nam_num_nhh_len_hard.json"
+    output_dir = "/root/test/weitiao/data_process_bq/data/data3/sharegpt_h1_nam_num_nhh_len_hard2.json"
+
+    # 执行主函数
+    process_and_filter_data(input_file, output_dir)

script/filter/filter_by_number_start_rejonly.py

@@ -0,0 +1,122 @@
+import json
+import os
+
+def contains_digit(text):
+    """
+    检查一个字符串的任何位置是否包含数字。
+    """
+    if not isinstance(text, str):
+        return False
+    return any(char.isdigit() for char in text)
+
+def starts_with_invalid_character(text):
+    """
+    检查字符串在去除空格后，是否以无效字符开头。
+    有效开头：字母、星号(*)、双引号(")。
+    无效开头：数字、其他符号、标点等。
+    """
+    if not isinstance(text, str):
+        return False # 非字符串不处理
+
+    stripped_text = text.strip()
+
+    if not stripped_text:
+        return False # 空字符串视为有效
+
+    first_char = stripped_text[0]
+
+    # 如果开头是字母或在允许的符号列表中，则是有效的
+    if first_char.isalpha() or first_char in['*', '"']:
+        return False
+
+    # 其他所有情况（包括数字开头）均视为无效
+    return True
+
+def process_and_filter_data(input_file_path, output_directory):
+    """
+    根据严格的“无数字”和“有效开头”规则，专门筛选出：
+    rejected 中存在非法，且 chosen 和 conversations 中没有任何非法的语料。
+    """
+    # 初始化目标数据列表
+    target_records =[]
+
+    try:
+        with open(input_file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"❌ 错误: 无法读取或解析文件 '{input_file_path}'. 错误详情: {e}")
+        return
+
+    if not isinstance(data, list):
+        print(f"❌ 错误: 文件 '{input_file_path}' 的顶层结构不是列表。")
+        return
+
+    # 遍历每一条主数据记录
+    for record in data:
+        if not isinstance(record, dict):
+            continue
+
+        # 初始化当前记录的问题标志位
+        is_dirty_in_conv, is_dirty_in_chosen, is_dirty_in_rejected = False, False, False
+
+        # --- 检查记录中的所有问题 ---
+        # 1. 检查 'conversations'
+        if 'conversations' in record and isinstance(record['conversations'], list):
+            for turn in record['conversations']:
+                if isinstance(turn, dict) and turn.get('from') == 'gpt':
+                    value = turn.get('value')
+                    if contains_digit(value) or starts_with_invalid_character(value):
+                        is_dirty_in_conv = True
+                        break # 在conversations中发现问题，无需再检查此列表
+
+        # 2. 检查 'chosen'
+        chosen_turn = record.get('chosen')
+        if isinstance(chosen_turn, dict) and chosen_turn.get('from') == 'gpt':
+            value = chosen_turn.get('value')
+            if contains_digit(value) or starts_with_invalid_character(value):
+                is_dirty_in_chosen = True
+
+        # 3. 检查 'rejected'
+        rejected_turn = record.get('rejected')
+        if isinstance(rejected_turn, dict) and rejected_turn.get('from') == 'gpt':
+            value = rejected_turn.get('value')
+            if contains_digit(value) or starts_with_invalid_character(value):
+                is_dirty_in_rejected = True
+
+        # --- 分类逻辑 ---
+        # 核心修改：只筛选 rejected 出现非法，但是 chosen 和 conversation 里面没有非法的这部分语料
+        if is_dirty_in_rejected and not is_dirty_in_chosen and not is_dirty_in_conv:
+            target_records.append(record)
+
+    # --- 文件输出逻辑 ---
+    os.makedirs(output_directory, exist_ok=True)
+
+    output_files = {
+        "dirty_only_in_rejected.json": target_records
+    }
+
+    print("="*60)
+    print(f"数据清洗与过滤报告 (输出目录: '{output_directory}')")
+    print("="*60)
+    print(f"原始数据总数: {len(data)} 条")
+
+    for filename, data_to_write in output_files.items():
+        output_path = os.path.join(output_directory, filename)
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data_to_write, f, indent=4, ensure_ascii=False)
+        print(f"已生成文件: {filename:<40} (包含 {len(data_to_write)} 条记录)")
+
+    print("="*60)
+    print("✅ 专项筛选已处理完毕！")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    
+    # 注意：根据原代码，这里 output_dir 实际上应该是一个“目录名”而不是“文件名”，
+    # 因为函数内是用 os.makedirs 创建文件夹，并在其内部保存 json的。
+    input_file = "/root/test/weitiao/data_process_bq/data/data3/sharegpt_h1_nam_num_nhh_len_hard2.json/dirty_data_from_rejected.json"
+    output_dir = "/root/test/weitiao/data_process_bq/data/data3/sharegpt_h1_nam_num_nhh_len_hard2.json/filtered_by_rejected_only"
+
+    # 执行主函数
+    process_and_filter_data(input_file, output_dir)

script/filter/filter_by_quota.py

@@ -0,0 +1,22 @@
+
+import json
+import re
+from tqdm import tqdm   
+
+data = json.load(open("/root/test/weitiao/data_processing_hsichen/data_process_bq/data/merged_rm_dpo_scored.json"))
+target_file_path = '/root/test/weitiao/data_processing_hsichen/data_process_bq/data/rm_dpo_scored_quota_filtered.json'
+
+#这里改成5w
+output_data = []
+for sample in tqdm(data,total=len(data)):
+    chosen_value = sample['chosen_quota_score']
+    rejected_value = sample['rejected_quota_score']
+    
+    if chosen_value - rejected_value < 0 or chosen_value < 3 or rejected_value < 3:
+        continue
+    output_data.append(sample)
+
+with open(target_file_path, 'w', encoding='utf-8') as f:
+    json.dump(output_data, f, indent=2)
+print(f"Filtered data saved to {target_file_path}, total {len(output_data)} samples.")
+    

script/filter/first_human.py

@@ -0,0 +1,36 @@
+import json
+
+INPUT_PATH = "/root/test/weitiao/data_process_bq/data/sharegpt_all.json"
+OUTPUT_PATH = "/root/test/weitiao/data_process_bq/data/sharegpt_human1st.json"
+
+def process_conversations(convs):
+    new_convs = []
+    first_gpt_removed = False
+
+    # ① 删除第一条 gpt
+    for msg in convs:
+        if msg["from"] == "gpt" and not first_gpt_removed:
+            first_gpt_removed = True
+            continue
+        new_convs.append(msg)
+
+    # ② 如果最后一句是 gpt，再删掉
+    if new_convs and new_convs[-1]["from"] == "gpt":
+        new_convs = new_convs[:-1]
+
+    return new_convs
+
+
+def main():
+    with open(INPUT_PATH, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    for item in data:
+        item["conversations"] = process_conversations(item["conversations"])
+
+    with open(OUTPUT_PATH, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+if __name__ == "__main__":
+    main()

script/filter/rm_filter_by_30safe.py

@@ -0,0 +1,122 @@
+import json
+import random
+import os
+from typing import List, Dict, Any
+
+# =========================
+# 配置
+# =========================
+# 原始 JSON 语料文件路径 (请根据您的实际文件路径修改)
+INPUT_FILE = "/root/test/weitiao/data_processing_hsichen/data_process_bq/result/high_chosen_reward_safety_8_quadrants_labeled/merged.json" 
+
+# 过滤并丢弃部分语料后的输出文件路径
+OUTPUT_FILE = "/root/test/weitiao/data_processing_hsichen/data_process_bq/result/rm_dpo_infered_8_truncated_replaced_30safe.json"
+
+# 定义不安全语料的丢弃比例 (30%)
+DISCARD_PERCENTAGE = 0.70
+
+# 定义判定为不安全的标签
+UNSAFE_LABEL = "Sexual Content"
+
+# =========================
+# 主处理函数
+# =========================
+
+def filter_and_discard_unsafe_data(input_path: str, output_path: str, discard_ratio: float, unsafe_label: str):
+    """
+    读取语料文件，根据 safety_analysis 字段中的标签判断 unsafe，
+    随机丢弃指定比例的 unsafe 语料，并保存剩余数据。
+    """
+    
+    # 1. 读取输入文件
+    print(f"🚀 正在读取输入文件: {input_path}")
+    try:
+        with open(input_path, 'r', encoding='utf-8') as f:
+            data: List[Dict[str, Any]] = json.load(f)
+    except FileNotFoundError:
+        print(f"❌ 错误: 输入文件 '{input_path}' 未找到。")
+        return
+    except json.JSONDecodeError:
+        print(f"❌ 错误: 输入文件 '{input_path}' 不是有效的 JSON 格式。")
+        return
+    except Exception as e:
+        print(f"❌ 错误: 读取文件时发生未知错误: {e}")
+        return
+
+    total_count = len(data)
+    print(f"文件加载成功，总计 {total_count} 条语料。")
+
+    # 2. 分类 safe 和 unsafe 语料
+    safe_data: List[Dict[str, Any]] = []
+    unsafe_data: List[Dict[str, Any]] = []
+
+    for item in data:
+        is_unsafe = False
+        
+        # 检查 safety_analysis 字段是否存在
+        if "safety_analysis" in item:
+            analysis = item["safety_analysis"]
+            
+            # 检查 chosen_labels
+            chosen_labels = analysis.get("chosen_labels", [])
+            if unsafe_label in chosen_labels:
+                is_unsafe = True
+
+            # 检查 rejected_labels
+            rejected_labels = analysis.get("rejected_labels", [])
+            if unsafe_label in rejected_labels:
+                is_unsafe = True
+
+        if is_unsafe:
+            unsafe_data.append(item)
+        else:
+            safe_data.append(item)
+
+    unsafe_count = len(unsafe_data)
+    safe_count = len(safe_data)
+    print(f"\n分类结果:")
+    print(f"   - 标记为 UNSAFE 的语料: {unsafe_count} 条")
+    print(f"   - 标记为 SAFE 的语料: {safe_count} 条")
+
+    # 3. 随机丢弃指定比例的 unsafe 语料
+    num_to_discard = int(unsafe_count * discard_ratio)
+    
+    # 使用 random.sample 从 unsafe_data 中抽取需要丢弃的样本
+    # random.sample(population, k) 从序列中不重复地抽取 k 个元素
+    samples_to_keep = unsafe_data
+    if num_to_discard > 0:
+        num_to_keep = unsafe_count - num_to_discard
+        # 随机抽取要保留的样本
+        samples_to_keep = random.sample(unsafe_data, num_to_keep)
+        
+    discarded_count = unsafe_count - len(samples_to_keep)
+    
+    print(f"\n丢弃处理 (比例: {discard_ratio * 100}%)")
+    print(f"   - 计划丢弃数量: {num_to_discard} 条")
+    print(f"   - 实际丢弃数量: {discarded_count} 条")
+
+    # 4. 合并保留的语料并保存
+    final_data = safe_data + samples_to_keep
+    final_count = len(final_data)
+    
+    print(f"\n最终语料集总数: {final_count} 条 (总数 {total_count} - 丢弃 {discarded_count})")
+
+    # 确保输出目录存在
+    output_dir = os.path.dirname(output_path)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # 写入最终的 JSON 文件
+    try:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            # 使用 indent=2 和 ensure_ascii=False 保持格式美观且支持中文
+            json.dump(final_data, f, indent=2, ensure_ascii=False)
+        print(f"🎉 成功保存过滤后的语料到: {output_path}")
+    except Exception as e:
+        print(f"❌ 错误: 写入输出文件时发生错误: {e}")
+
+
+if __name__ == "__main__":
+    # 确保随机性
+    random.seed()
+    filter_and_discard_unsafe_data(INPUT_FILE, OUTPUT_FILE, DISCARD_PERCENTAGE, UNSAFE_LABEL)

script/format_trans/chatml2sharegpt.py

@@ -0,0 +1,70 @@
+import json
+from pathlib import Path
+
+# ===== 路径配置 =====
+INPUT_PATH = "/root/test/weitiao/data_process_bq/data/train01_chatml_closed_length2048turns20_replaced.json"
+OUTPUT_PATH = "/root/test/weitiao/data_process_bq/data/train01_sharegpt_closed_length_replaced.json"
+
+
+def convert_one_sample(sample):
+    conversations = []
+
+    for msg in sample.get("messages", []):
+        role = msg.get("role")
+        content = msg.get("content", "")
+
+        if role == "user":
+            conversations.append({
+                "from": "human",
+                "value": content
+            })
+        elif role == "assistant":
+            conversations.append({
+                "from": "gpt",
+                "value": content
+            })
+
+        elif role == "system":
+            conversations.append({
+                "from": "system",
+                "value": content
+            })
+
+    def convert_choice(choice_list):
+        if not choice_list:
+            return None
+        choice = choice_list[0]
+        return {
+            "from": "gpt",
+            "value": choice.get("content", "")
+        }
+
+    return {
+        "conversations": conversations,
+        "chosen": convert_choice(sample.get("chosen", [])),
+        "rejected": convert_choice(sample.get("rejected", []))
+    }
+
+
+def main():
+    with open(INPUT_PATH, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    assert isinstance(data, list), "输入 JSON 顶层必须是 list"
+
+    converted = []
+    for idx, sample in enumerate(data):
+        try:
+            converted.append(convert_one_sample(sample))
+        except Exception as e:
+            print(f"[WARN] 第 {idx} 条样本转换失败: {e}")
+
+    with open(OUTPUT_PATH, "w", encoding="utf-8") as f:
+        json.dump(converted, f, ensure_ascii=False, indent=2)
+
+    print(f"转换完成，共 {len(converted)} 条")
+    print(f"输出路径：{OUTPUT_PATH}")
+
+
+if __name__ == "__main__":
+    main()

script/format_trans/chatml_p2r.py

@@ -0,0 +1,29 @@
+import json
+import os
+
+input_file = "/root/test/weitiao/data_process_bq/data/train01_chatml_closed_length2048turns20.json"
+output_file = "/root/test/weitiao/data_process_bq/data/train01_p2r_closed_length2048turns20.json"
+
+with open(input_file, 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+processed_data = []
+
+for item in data:
+    history = item.get('messages', [])
+    old_chosen = item.get('chosen', [])
+    old_rejected = item.get('rejected', [])
+    
+    new_chosen = history + old_chosen
+    new_rejected = history + old_rejected
+    
+    new_item = {
+        "chosen": new_chosen,
+        "rejected": new_rejected
+    }
+    processed_data.append(new_item)
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    json.dump(processed_data, f, ensure_ascii=False, indent=2)
+
+print(f"done, {len(processed_data)} items")