Upload 格式转化.py

格式转化.py

@@ -0,0 +1,238 @@
+import json
+import textwrap
+
+# 1. 软约束列表（交由 LLM 判断）
+SOFT_IDS = {
+    'soft_content:language', 'soft', 'soft_content:open_ended',
+    'situation:suggestion', 'situation:role_play',
+    'situation:story_generation', 'style:open_ended'
+}
+
+
+# 辅助函数：处理比较关系的符号
+def get_op(relation):
+    return "<" if relation == "less than" else ">="
+
+
+# 辅助函数：安全获取参数
+def get_int(kwargs, key, default=1):
+    val = kwargs.get(key)
+    return int(val) if val is not None else default
+
+
+def get_str(kwargs, key, default=""):
+    val = kwargs.get(key)
+    return str(val) if val is not None else default
+
+
+# 2. 全量硬约束模板字典 (严格基于 instructions.py 源码提取)
+CODE_TEMPLATES = {
+    "detectable_format:number_highlighted_sections": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            num_highlights = 0
+            highlights = re.findall(r"\\*[^\\n\\*]*\\*", response_text)
+            double_highlights = re.findall(r"\\*\\*[^\\n\\*]*\\*\\*", response_text)
+            for highlight in highlights:
+                if highlight.strip("*").strip():
+                    num_highlights += 1
+            for highlight in double_highlights:
+                if highlight.removeprefix("**").removesuffix("**").strip():
+                    num_highlights += 1
+            return num_highlights >= {get_int(kw, 'num_highlights', 1)}"""),
+
+    "detectable_format:multiple_sections": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            spliter = {repr(get_str(kw, 'section_spliter', 'SECTION'))}
+            num_sections = {get_int(kw, 'num_sections', 2)}
+            section_splitter_patten = r"\\s?" + spliter  + r"\\s?\\d+\\s?"
+            sections = re.split(section_splitter_patten, response_text, flags=re.IGNORECASE)
+            return (len(sections) - 1) >= num_sections"""),
+
+    "punctuation:no_comma": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            import re
+            return not bool(re.search(r"\\,", response_text))"""),
+
+    "keywords:letter_frequency": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import collections
+            letter = {repr(get_str(kw, 'letter', 'a').lower())}
+            frequency = {get_int(kw, 'let_frequency', 1)}
+            letters = collections.Counter(response_text.lower())
+            return letters[letter] {get_op(kw.get('let_relation'))} frequency"""),
+
+    "length_constraints:number_sentences": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            sentences = [s for s in re.split(r'(?<=[.!?])\\s+', response_text) if s.strip()]
+            return len(sentences) {get_op(kw.get('relation'))} {get_int(kw, 'num_sentences', 1)}"""),
+
+    "detectable_format:number_placeholders": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            placeholders = re.findall(r"\\[.*?\\]", response_text)
+            return len(placeholders) >= {get_int(kw, 'num_placeholders', 1)}"""),
+
+    "detectable_format:number_bullet_lists": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            bullet_lists = re.findall(r"^\\s*\\*[^\\*].*$", response_text, flags=re.MULTILINE)
+            bullet_lists_2 = re.findall(r"^\\s*-.*$", response_text, flags=re.MULTILINE)
+            return (len(bullet_lists) + len(bullet_lists_2)) == {get_int(kw, 'num_bullets', 1)}"""),
+
+    "start_ending:constrained_response": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            options = ["My answer is yes.", "My answer is no.", "My answer is maybe."]
+            return any(opt in response_text.strip() for opt in options)"""),
+
+    "start_ending:constrained_start": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            starter = {repr(get_str(kw, 'starter', '').strip())}
+            pattern = r"^\\s*" + re.escape(starter) + r".*$"
+            return bool(re.search(pattern, response_text, flags=re.MULTILINE))"""),
+
+    "length_constraints:number_paragraphs": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            paragraphs = re.split(r"\\s?\\*\\*\\*\\s?", response_text)
+            num_paragraphs = len(paragraphs)
+            for index, paragraph in enumerate(paragraphs):
+                if not paragraph.strip():
+                    if index == 0 or index == len(paragraphs) - 1:
+                        num_paragraphs -= 1
+                    else: return False
+            return num_paragraphs == {get_int(kw, 'num_paragraphs', 1)}"""),
+
+    "keywords:existence": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            keywords = {kw.get('keywords', [])}
+            for keyword in keywords:
+                if not re.search(keyword, response_text, flags=re.IGNORECASE):
+                    return False
+            return True"""),
+
+    "keywords:frequency": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            keyword = {repr(get_str(kw, 'keyword', ''))}
+            actual_occurrences = len(re.findall(keyword, response_text, flags=re.IGNORECASE))
+            return actual_occurrences {get_op(kw.get('relation'))} {get_int(kw, 'frequency', 1)}"""),
+
+    "length_constraints:number_words": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            num_words = len(re.findall(r"\\w+", response_text))
+            return num_words {get_op(kw.get('relation'))} {get_int(kw, 'num_words', 100)}"""),
+
+    "detectable_format:json_format": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            import json
+            value = response_text.strip().removeprefix("```json").removeprefix("```Json").removeprefix("```JSON").removeprefix("```").removesuffix("```").strip()
+            try:
+                json.loads(value)
+                return True
+            except ValueError:
+                return False"""),
+
+    "keywords:forbidden_words": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            import re
+            forbidden_words = {kw.get('forbidden_words', [])}
+            for word in forbidden_words:
+                if re.search(r"\\b" + word + r"\\b", response_text, flags=re.IGNORECASE):
+                    return False
+            return True"""),
+
+    "start_ending:repeat_prompt": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            prompt_to_repeat = {repr(get_str(kw, 'prompt_to_repeat', ''))}
+            return response_text.strip().lower().startswith(prompt_to_repeat.strip().lower())"""),
+
+    "start_ending:end_phrase": lambda kw: textwrap.dedent(f"""\
+        def check(response_text):
+            end_phrase = {repr(get_str(kw, 'end_phrase', ''))}.strip().lower()
+            value = response_text.strip().strip('"').lower()
+            return value.endswith(end_phrase)"""),
+
+    "detectable_format:title": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            import re
+            titles = re.findall(r"<<[^\\n]+>>", response_text)
+            for title in titles:
+                if title.lstrip("<").rstrip(">").strip(): return True
+            return False"""),
+
+    "format:capital_letters": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            return response_text.isupper()"""),
+
+    "format:lowercase_letters": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            return response_text.islower()"""),
+
+    "detectable_format:quotation": lambda kw: textwrap.dedent("""\
+        def check(response_text):
+            val = response_text.strip()
+            return len(val) > 1 and val[0] == '"' and val[-1] == '"'"""),
+}
+
+
+def convert_dataset(input_file, output_file):
+    with open(input_file, 'r', encoding='utf-8') as fin, \
+            open(output_file, 'w', encoding='utf-8') as fout:
+
+        for line_idx, line in enumerate(fin):
+            data = json.loads(line)
+
+            converted_data = {
+                "id": line_idx + 1,
+                "conversations": [
+                    {"role": "user", "content": data['prompt']},
+                    {"role": "assistant", "content": "no"}
+                ],
+                "system": "",
+                "gemini-judge": {"constraints": []},
+                "new_query": data['prompt'],
+                "soft-constraint-fusion": {
+                    "soft_constraints": [],
+                    "final_query": data['prompt']
+                }
+            }
+
+            constraints_desc = data.get('constraint', [])
+            kwargs_list = data.get('kwargs', [])
+            id_list = data.get('instruction_id_list', [])
+
+            for i in range(len(id_list)):
+                inst_id = id_list[i]
+                desc = constraints_desc[i] if i < len(constraints_desc) else ""
+                kw = kwargs_list[i] if i < len(kwargs_list) else {}
+
+                if inst_id in SOFT_IDS:
+                    converted_data["soft-constraint-fusion"]["soft_constraints"].append(desc)
+                else:
+                    if inst_id in CODE_TEMPLATES:
+                        # 动态生成特定参数的代码
+                        code_str = CODE_TEMPLATES[inst_id](kw)
+                    else:
+                        # 极其罕见的 ID，安全回退
+                        code_str = textwrap.dedent(f"""\
+                            def check(response_text):
+                                # UNMAPPED ID: {inst_id}
+                                return False""")
+
+                    converted_data["gemini-judge"]["constraints"].append({
+                        "description": desc,
+                        "checker_code": code_str
+                    })
+
+            fout.write(json.dumps(converted_data, ensure_ascii=False) + '\n')
+
+
+if __name__ == "__main__":
+    convert_dataset('train.jsonl', 'output.jsonl')
+    print("转换完成！所有参数已被安全硬编码进独立函数中。")