Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,38 @@ 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
+synthgen/PtPersonaIFGen/lmeval_pt/__pycache__/instructions.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+synthgen/PtPersonaIFGen/lmeval_pt/__pycache__/instructions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+synthgen/PtPersonaIFGen/phase1_generated_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/PtPersonaIFGen/phase2_detection_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/PtPersonaIFGen/phase3_extraction_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/PtPersonaIFGen/run.log filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/cemig_cleaned/cemig_rewrite_focus.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/cemig_cleaned/cemig_rewrite_simple.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/cemig_cleaned/cemig_summary.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/cemig_cleaned/magpie_conversations_cemig_v1_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/cemig_filtered/magpie_conversations_cemig_v1_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_clean_Resumo.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_clean_SingleTurnConvo.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_rewrite_focus.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_rewrite_simple.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_summary.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/first_versions/cemig_summary_evaled.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/magpie_conversations_cemig.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/magpie_conversations_cemig_cleaned.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/magpie_conversations_cemig_v0.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/cemig_v0/magpie_conversations_cemig_v1_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/complete/cemig_rewrite_focus.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/complete/cemig_rewrite_simple.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/complete/cemig_summary.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/complete/magpie_conversations_cemig_v1_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/ifeval_v0/vllm_pipeline_en/phase1_generated_output_v0.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/magpie_conversations_cemig_v2_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/magpie_conversations_cemig_v2_preproc_objetiva.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run03/phase1_generated_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run03/phase2_detection_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run03/phase3_extraction_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run05/phase1_generated_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run05/phase2_detection_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run05/phase3_extraction_output.jsonl filter=lfs diff=lfs merge=lfs -text
+synthgen/vllm_pipeline/runs/run05/phase4_final_output.jsonl filter=lfs diff=lfs merge=lfs -text

synthgen/PtPersonaIFGen/.gitignore

@@ -0,0 +1,6 @@
+.env
+previous_things/
+__pycache__/
+*.jsonl
+*.json
+*.txt

synthgen/PtPersonaIFGen/__init__.py

@@ -0,0 +1 @@
+# IFEval Persona Pipeline

synthgen/PtPersonaIFGen/ft_unsloth_gpu1_big_qwen.log

@@ -0,0 +1,2 @@
+nohup: ignoring input
+python: can't open file '/workspace/synthgen/PtPersonaIFGen/ft_unsloth_v5.py': [Errno 2] No such file or directory

synthgen/PtPersonaIFGen/lmeval_pt/__init__.py

@@ -0,0 +1,2 @@
+# Local copy of lm_eval IFEval code (decoupled from lm_eval package)
+# This allows adding custom instruction types without modifying the external package.

synthgen/PtPersonaIFGen/lmeval_pt/__pycache__/instructions.cpython-311.pyc

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

synthgen/PtPersonaIFGen/lmeval_pt/__pycache__/instructions.cpython-312.pyc

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

synthgen/PtPersonaIFGen/lmeval_pt/ifeval.yaml

@@ -0,0 +1,29 @@
+task: ifeval
+dataset_path: google/IFEval
+dataset_name: null
+output_type: generate_until
+test_split: train
+num_fewshot: 0
+doc_to_text: prompt
+doc_to_target: 0
+generation_kwargs:
+  until: []
+  do_sample: false
+  temperature: 0.0
+  max_gen_toks: 1280
+process_results: !function utils.process_results
+metric_list:
+  - metric: prompt_level_strict_acc
+    aggregation: mean
+    higher_is_better: true
+  - metric: inst_level_strict_acc
+    aggregation: !function utils.agg_inst_level_acc
+    higher_is_better: true
+  - metric: prompt_level_loose_acc
+    aggregation: mean
+    higher_is_better: true
+  - metric: inst_level_loose_acc
+    aggregation: !function utils.agg_inst_level_acc
+    higher_is_better: true
+metadata:
+  version: 4.0

synthgen/PtPersonaIFGen/lmeval_pt/instructions.py

@@ -0,0 +1,2413 @@
+# Copyright 2023 The Google Research Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Library of instructions."""
+
+import collections
+import json
+import logging
+import random
+import re
+import string
+from typing import Dict, Optional, Sequence, Union
+
+import langdetect
+
+from lmeval_pt import instructions_util
+
+
+logger = logging.getLogger(__name__)
+
+_InstructionArgsDtype = Optional[Dict[str, Union[int, str, Sequence[str]]]]
+
+_LANGUAGES = instructions_util.LANGUAGE_CODES
+
+# The relational operation for comparison.
+_COMPARISON_RELATION = ("less than", "at least")
+
+# The maximum number of sentences.
+_MAX_NUM_SENTENCES = 20
+
+# The number of placeholders.
+_NUM_PLACEHOLDERS = 4
+
+# The number of bullet lists.
+_NUM_BULLETS = 5
+
+# The options of constrained response.
+_CONSTRAINED_RESPONSE_OPTIONS = (
+    "My answer is yes.",
+    "My answer is no.",
+    "My answer is maybe.",
+)
+
+# The options of starter keywords.
+_STARTER_OPTIONS = (
+    "I would say",
+    "My answer is",
+    "I believe",
+    "In my opinion",
+    "I think",
+    "I reckon",
+    "I feel",
+    "From my perspective",
+    "As I see it",
+    "According to me",
+    "As far as I'm concerned",
+    "To my understanding",
+    "In my view",
+    "My take on it is",
+    "As per my perception",
+)
+
+# The options of ending keywords.
+# TODO(jeffreyzhou) add more ending options
+_ENDING_OPTIONS = ("Any other questions?", "Is there anything else I can help with?")
+
+# The number of highlighted sections.
+_NUM_HIGHLIGHTED_SECTIONS = 4
+
+# The section splitter.
+_SECTION_SPLITER = ("Section", "SECTION")
+
+# The number of sections.
+_NUM_SECTIONS = 5
+
+# The number of paragraphs.
+_NUM_PARAGRAPHS = 5
+
+# The postscript marker.
+_POSTSCRIPT_MARKER = ("P.S.", "P.P.S")
+
+# The number of keywords.
+_NUM_KEYWORDS = 2
+
+# The occurrences of a single keyword.
+_KEYWORD_FREQUENCY = 3
+
+# The occurrences of a single letter.
+_LETTER_FREQUENCY = 10
+
+# The occurrences of words with all capital letters.
+_ALL_CAPITAL_WORD_FREQUENCY = 20
+
+# The number of words in the response.
+_NUM_WORDS_LOWER_LIMIT = 100
+_NUM_WORDS_UPPER_LIMIT = 500
+
+
+class Instruction:
+    """An instruction template."""
+
+    def __init__(self, instruction_id):
+        self.id = instruction_id
+
+    def build_description(self, **kwargs):
+        raise NotImplementedError("`build_description` not implemented.")
+
+    def get_instruction_args(self):
+        raise NotImplementedError("`get_instruction_args` not implemented.")
+
+    def get_instruction_args_keys(self):
+        raise NotImplementedError("`get_instruction_args_keys` not implemented.")
+
+    def check_following(self, value):
+        raise NotImplementedError("`check_following` not implemented.")
+
+
+class ResponseLanguageChecker(Instruction):
+    """Check the language of the entire response."""
+
+    def build_description(self, *, language=None):
+        """Build the instruction description.
+
+        Args:
+          language: A string representing the expected language of the response. The
+            language has to comply to the 97 types defined in
+            `langid.py` (https://pypi.org/project/langid/1.1.5/), which follows
+            ISO 639-1 codes (https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes);
+            for example, `en` for English, `zh` for Chinese, `fr` for French.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._language = language
+        if self._language is None:
+            self._language = random.choice(list(_LANGUAGES.keys()))
+        # TODO(tianjianlu): opens the description generation to more choices.
+        self._description_pattern = (
+            "Your ENTIRE response should be in {language} language, no other "
+            + "language is allowed."
+        )
+        return self._description_pattern.format(language=_LANGUAGES[self._language])
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"language": self._language}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["language"]
+
+    def check_following(self, value):
+        """Check if the language of the entire response follows the instruction.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if the language of `value` follows instruction; otherwise False.
+        """
+        assert isinstance(value, str)
+
+        try:
+            return langdetect.detect(value) == self._language
+        except langdetect.LangDetectException as e:
+            # Count as instruction is followed.
+            logging.error(
+                "Unable to detect language for text %s due to %s", value, e
+            )  # refex: disable=pytotw.037
+            return True
+
+
+class NumberOfSentences(Instruction):
+    """Check the number of sentences."""
+
+    def build_description(self, *, num_sentences=None, relation=None):
+        """Build the instruction description.
+
+        Args:
+          num_sentences: An integer specifying the number of sentences as a
+            threshold.
+          relation: A string in (`less than`, `at least`), defining the relational
+            operator for comparison.
+            Two relational comparisons are supported for now:
+            if 'less than', the actual number of sentences < the threshold;
+            if 'at least', the actual number of sentences >= the threshold.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        # The number of sentences as a threshold for comparison.
+        self._num_sentences_threshold = num_sentences
+        if self._num_sentences_threshold is None or self._num_sentences_threshold < 0:
+            self._num_sentences_threshold = random.randint(1, _MAX_NUM_SENTENCES)
+
+        if relation is None:
+            self._comparison_relation = random.choice(_COMPARISON_RELATION)
+        elif relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                "The supported relation for comparison must be in "
+                f"{_COMPARISON_RELATION}, but {relation} is given."
+            )
+        else:
+            self._comparison_relation = relation
+
+        self._description_pattern = (
+            "Your response should contain {relation} {num_sentences} sentences."
+        )
+        return self._description_pattern.format(
+            relation=self._comparison_relation,
+            num_sentences=self._num_sentences_threshold,
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "num_sentences": self._num_sentences_threshold,
+            "relation": self._comparison_relation,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_sentences", "relation"]
+
+    def check_following(self, value):
+        """Check if the number of sentences follows the instruction.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if the response follows the instruction.
+
+        Raise:
+            ValueError if the string in `instruction_args` is not in
+            [`less_than`, `at_least`].
+        """
+        num_sentences = instructions_util.count_sentences(value)
+        if self._comparison_relation == _COMPARISON_RELATION[0]:
+            return num_sentences < self._num_sentences_threshold
+        elif self._comparison_relation == _COMPARISON_RELATION[1]:
+            return num_sentences >= self._num_sentences_threshold
+
+
+class PlaceholderChecker(Instruction):
+    """Check the placeholders in template writing."""
+
+    def build_description(self, *, num_placeholders=None):
+        """Build the instruction description.
+
+        Args:
+          num_placeholders: An integer denoting the minimum number of
+            placeholders required in the response.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._num_placeholders = num_placeholders
+        if self._num_placeholders is None or self._num_placeholders < 0:
+            self._num_placeholders = random.randint(1, _NUM_PLACEHOLDERS)
+        self._description_pattern = (
+            "The response must contain at least {num_placeholders} placeholders "
+            + "represented by square brackets, such as [address]."
+        )
+        return self._description_pattern.format(num_placeholders=self._num_placeholders)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"num_placeholders": self._num_placeholders}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_placeholders"]
+
+    def check_following(self, value):
+        """Check if the number of placeholders follows the instruction.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if the actual number of placeholders in the response is greater than
+          or equal to `num_placeholders`; otherwise, False.
+        """
+        placeholders = re.findall(r"\[.*?\]", value)
+        num_placeholders = len(placeholders)
+        return num_placeholders >= self._num_placeholders
+
+
+class BulletListChecker(Instruction):
+    """Checks the bullet list in the prompt."""
+
+    def build_description(self, *, num_bullets=None):
+        """Build the instruction description.
+
+        Args:
+          num_bullets: An integer specifying the exact number of bullet lists
+            that is required to appear in the response.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._num_bullets = num_bullets
+        if self._num_bullets is None or self._num_bullets < 0:
+            self._num_bullets = random.randint(1, _NUM_BULLETS)
+        self._description_pattern = (
+            "Your answer must contain exactly {num_bullets} bullet points. "
+            + "Use the markdown bullet points such as:\n"
+            + "* This is point 1. \n"
+            + "* This is point 2"
+        )
+        return self._description_pattern.format(num_bullets=self._num_bullets)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"num_bullets": self._num_bullets}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_bullets"]
+
+    def check_following(self, value):
+        r"""Check if the number of bullet lists meets the requirement.
+
+        Args:
+          value: A string representing the response. The response is expected to
+            contain some bullet lists that start with `\*`.
+
+        Returns:
+          True if the actual number of bullet lists in the response meets the
+          requirement.
+        """
+        bullet_lists = re.findall(r"^\s*\*[^\*].*$", value, flags=re.MULTILINE)
+        bullet_lists_2 = re.findall(r"^\s*-.*$", value, flags=re.MULTILINE)
+        num_bullet_lists = len(bullet_lists) + len(bullet_lists_2)
+        return num_bullet_lists == self._num_bullets
+
+
+class ConstrainedResponseChecker(Instruction):
+    """Checks the constrained response."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        # A sequence of string(s) representing the options of the expected response.
+        self._constrained_responses = _CONSTRAINED_RESPONSE_OPTIONS
+        self._description_pattern = (
+            "Answer with one of the following options: {response_options}"
+        )
+        return self._description_pattern.format(
+            response_options=self._constrained_responses
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks if the response matches the constrained options.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if the actual response contains one of the options in the constrained
+          responses; otherwise False.
+        """
+        value = value.strip()
+        for constrained_response in self._constrained_responses:
+            if constrained_response in value:
+                return True
+        return False
+
+
+class ConstrainedStartChecker(Instruction):
+    """Checks the response start."""
+
+    def build_description(self, *, starter=None):
+        """Build the instruction description.
+
+        Args:
+          starter: A string representing the keyword that the response should start
+            with.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._starter = starter.strip() if isinstance(starter, str) else starter
+        if self._starter is None:
+            self._starter = random.choice(_STARTER_OPTIONS)
+        self._description_pattern = (
+            "During the conversation, when it is your turn, "
+            + "please always start with {starter}"
+        )
+        return self._description_pattern.format(starter=self._starter)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"starter": self._starter}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["starter"]
+
+    def check_following(self, value):
+        """Checks if the response starts with the constrained keyword or phrase.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if the response starts with the given phrase or keyword that is
+          contained in `instruction_args`; otherwise, False.
+        """
+        response_pattern = r"^\s*" + self._starter + r".*$"
+        response_with_constrained_start = re.search(
+            response_pattern, value, flags=re.MULTILINE
+        )
+        return True if response_with_constrained_start else False
+
+
+class HighlightSectionChecker(Instruction):
+    """Checks the highlighted section."""
+
+    def build_description(self, *, num_highlights=None):
+        """Build the instruction description.
+
+        Args:
+          num_highlights: An integer specifying the minimum number of highlighted
+            sections.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._num_highlights = num_highlights
+        if self._num_highlights is None or self._num_highlights < 0:
+            self._num_highlights = random.randint(1, _NUM_HIGHLIGHTED_SECTIONS)
+
+        self._description_pattern = (
+            "Highlight at least {num_highlights} sections in your answer with "
+            + "markdown, i.e. *highlighted section*."
+        )
+
+        return self._description_pattern.format(num_highlights=self._num_highlights)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"num_highlights": self._num_highlights}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_highlights"]
+
+    def check_following(self, value):
+        """Checks if the number of highlighted sections meets the requirement.
+
+        Args:
+          value: a string representing the response. The response is expected to
+            contain highlighted sections in the format of *highlighted*.
+
+        Returns:
+          True if the actual number of highlighted sections in the format of
+          *highlighted sections* meets the minimum requirement; otherwise False.
+        """
+        num_highlights = 0
+        highlights = re.findall(r"\*[^\n\*]*\*", value)
+        double_highlights = re.findall(r"\*\*[^\n\*]*\*\*", value)
+        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 >= self._num_highlights
+
+
+class SectionChecker(Instruction):
+    """Checks the sections."""
+
+    def build_description(self, *, section_spliter=None, num_sections=None):
+        """Build the instruction description.
+
+        Args:
+          section_spliter: A string represents the section spliter keyword that
+            marks a new section, i.e., `Section` or `SECTION`.
+          num_sections: An integer specifying the number of sections.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._section_spliter = (
+            section_spliter.strip()
+            if isinstance(section_spliter, str)
+            else section_spliter
+        )
+        if self._section_spliter is None:
+            self._section_spliter = random.choice(_SECTION_SPLITER)
+
+        self._num_sections = num_sections
+        if self._num_sections is None or self._num_sections < 0:
+            self._num_sections = random.randint(1, _NUM_SECTIONS)
+
+        self._description_pattern = (
+            "Your response must have {num_sections} sections. Mark the beginning "
+            + "of each section with {section_spliter} X, such as:\n"
+            + "{section_spliter} 1\n"
+            + "[content of section 1]\n"
+            + "{section_spliter} 2\n"
+            + "[content of section 2]"
+        )
+
+        return self._description_pattern.format(
+            num_sections=self._num_sections, section_spliter=self._section_spliter
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "section_spliter": self._section_spliter,
+            "num_sections": self._num_sections,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["section_spliter", "num_sections"]
+
+    def check_following(self, value):
+        """Checks the response contains multiple sections.
+
+        Args:
+          value: A string representing the response. The response is expected
+            to contain multiple sections (number of sections is greater than 1).
+            A new section starts with `Section 1`, where the number denotes the
+            section index.
+
+        Returns:
+          True if the number of sections in the response is greater than or equal to
+          the minimum number of sections; otherwise, False.
+        """
+        section_splitter_patten = r"\s?" + self._section_spliter + r"\s?\d+\s?"
+        sections = re.split(section_splitter_patten, value)
+        num_sections = len(sections) - 1
+        return num_sections >= self._num_sections
+
+
+class ParagraphChecker(Instruction):
+    """Checks the paragraphs."""
+
+    def build_description(self, *, num_paragraphs=None):
+        """Build the instruction description.
+
+        Args:
+          num_paragraphs: An integer specifying the number of paragraphs.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._num_paragraphs = num_paragraphs
+        if self._num_paragraphs is None or self._num_paragraphs < 0:
+            self._num_paragraphs = random.randint(1, _NUM_PARAGRAPHS)
+
+        self._description_pattern = (
+            "There should be {num_paragraphs} paragraphs. "
+            + "Paragraphs are separated with the markdown divider: ***"
+        )
+
+        return self._description_pattern.format(num_paragraphs=self._num_paragraphs)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"num_paragraphs": self._num_paragraphs}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_paragraphs"]
+
+    def check_following(self, value):
+        """Checks the response contains required number of paragraphs.
+
+        Args:
+          value: A string representing the response. The response may contain
+            paragraphs that are separated by the markdown divider: `***`.
+
+        Returns:
+          True if the actual number of paragraphs is the same as required;
+          otherwise, False.
+        """
+        paragraphs = re.split(r"\s?\*\*\*\s?", value)
+        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 == self._num_paragraphs
+
+
+class PostscriptChecker(Instruction):
+    """Checks the postscript."""
+
+    def build_description(self, *, postscript_marker=None):
+        """Build the instruction description.
+
+        Args:
+          postscript_marker: A string containing the keyword that marks the start
+            of the postscript section.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._postscript_marker = (
+            postscript_marker.strip()
+            if isinstance(postscript_marker, str)
+            else postscript_marker
+        )
+        if self._postscript_marker is None:
+            self._postscript_marker = random.choice(_POSTSCRIPT_MARKER)
+
+        self._description_pattern = (
+            "At the end of your response, please explicitly add a postscript "
+            + "starting with {postscript}"
+        )
+
+        return self._description_pattern.format(postscript=self._postscript_marker)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"postscript_marker": self._postscript_marker}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["postscript_marker"]
+
+    def check_following(self, value):
+        """Checks if the response follows the postscript format.
+
+        Args:
+          value: a string representing the response. The response is expected to
+            contain a postscript section.
+
+        Returns:
+          True if the response contains a postscript section starting with
+          the keyword containing in the `instruction_args`; otherwise False.
+        """
+        value = value.lower()
+        if self._postscript_marker == "P.P.S":
+            postscript_pattern = r"\s*p\.\s?p\.\s?s.*$"
+        elif self._postscript_marker == "P.S.":
+            postscript_pattern = r"\s*p\.\s?s\..*$"
+        else:
+            postscript_pattern = r"\s*" + self._postscript_marker.lower() + r".*$"
+        postscript = re.findall(postscript_pattern, value, flags=re.MULTILINE)
+        return True if postscript else False
+
+
+class RephraseChecker(Instruction):
+    """Checks the rephrase."""
+
+    def build_description(self, *, original_message):
+        """Build the instruction description.
+
+        Args:
+          original_message: A string representing the original message. The
+            rephrased response should only change its words/sentences in between
+            its two asterisks, for example, *change me*. Both original and rephrased
+            messages should contain the changes in the form of *change me*.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        if not self.is_change(original_message):
+            raise ValueError(
+                f"Message {original_message} does not contain changes "
+                "in the form of *change me*."
+            )
+
+        self._reference_without_change = original_message
+        self._description = (
+            "Rephrasing: Your rephrased response should only"
+            + "change the words/sentences in between two asterisks"
+            + "such as *change me*."
+        )
+        return self._description
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"original_message": self._reference_without_change}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["original_message"]
+
+    def check_following(self, value):
+        r"""Checks if the rephrasing follows the instruction.
+
+        Args:
+          value: A string representing the response, which is expected to rephras
+            the string of `instruction_args`.
+
+        Returns:
+          True if `value` and `instruction_args` only differ by the words/sentences
+          in between two asterisks such as *change me*; otherwise, False.
+        """
+
+        if not self.is_change(value):
+            raise ValueError(
+                f"value {value} does not contain changes in the form of *change me*."
+            )
+
+        response_without_changes = self.strip_changes(value)
+        reference_without_changes = self.strip_changes(self._reference_without_change)
+
+        return response_without_changes == reference_without_changes
+
+    def is_change(self, response):
+        """Check if there is change in the response in the form of *change me*."""
+        return re.search(r"\*.*\*", response)
+
+    def strip_changes(self, response):
+        """Strips off the changes."""
+        return re.sub(r"\*.*\*", "", response)
+
+
+class KeywordChecker(Instruction):
+    """Check the existence of certain keywords."""
+
+    def build_description(self, *, keywords=None):
+        """Build the instruction description.
+
+        Args:
+          keywords: A sequence of strings representing the keywords that are
+            expected in the response.
+
+        Returns:
+          A string representing the instruction description.
+        """
+
+        if not keywords:
+            self._keywords = instructions_util.generate_keywords(
+                num_keywords=_NUM_KEYWORDS
+            )
+        else:
+            self._keywords = keywords
+        self._keywords = sorted(self._keywords)
+
+        self._description_pattern = "Include keywords {keywords} in the response."
+
+        return self._description_pattern.format(keywords=self._keywords)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"keywords": self._keywords}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["keywords"]
+
+    def check_following(self, value):
+        """Check if the response contain the expected keywords."""
+        for keyword in self._keywords:
+            if not re.search(keyword, value, flags=re.IGNORECASE):
+                return False
+        return True
+
+
+class KeywordFrequencyChecker(Instruction):
+    """Check the keyword frequency."""
+
+    def build_description(self, *, keyword=None, frequency=None, relation=None):
+        """Build the instruction description.
+
+        Args:
+          keyword: A string representing a keyword that is expected in the response.
+          frequency: An integer specifying the number of times `keyword` is expected
+            to appear in the response.
+          relation: A string in (`less than`, `at least`), defining the relational
+            operator for comparison.
+            Two relational comparisons are supported for now:
+            if 'less than', the actual number of occurrences < frequency;
+            if 'at least', the actual number of occurrences >= frequency.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        if not keyword:
+            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._keyword = keyword.strip()
+
+        self._frequency = frequency
+        if self._frequency is None or self._frequency < 0:
+            self._frequency = random.randint(1, _KEYWORD_FREQUENCY)
+
+        if relation is None:
+            self._comparison_relation = random.choice(_COMPARISON_RELATION)
+        elif relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                "The supported relation for comparison must be in "
+                f"{_COMPARISON_RELATION}, but {relation} is given."
+            )
+        else:
+            self._comparison_relation = relation
+
+        self._description_pattern = (
+            "In your response, the word {keyword} should appear {relation} "
+            + "{frequency} times."
+        )
+
+        return self._description_pattern.format(
+            keyword=self._keyword,
+            relation=self._comparison_relation,
+            frequency=self._frequency,
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "keyword": self._keyword,
+            "frequency": self._frequency,
+            "relation": self._comparison_relation,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["keyword", "frequency", "relation"]
+
+    def check_following(self, value):
+        """Checks if the response contain the keyword with required frequency."""
+        actual_occurrences = len(re.findall(self._keyword, value, flags=re.IGNORECASE))
+
+        if self._comparison_relation == _COMPARISON_RELATION[0]:
+            return actual_occurrences < self._frequency
+        elif self._comparison_relation == _COMPARISON_RELATION[1]:
+            return actual_occurrences >= self._frequency
+
+
+class NumberOfWords(Instruction):
+    """Checks the number of words."""
+
+    def build_description(self, *, num_words=None, relation=None):
+        """Build the instruction description.
+
+        Args:
+          num_words: An integer specifying the number of words contained in the
+            response.
+          relation: A string in (`less than`, `at least`), defining the relational
+            operator for comparison.
+            Two relational comparisons are supported for now:
+            if 'less than', the actual number of words < num_words;
+            if 'at least', the actual number of words >= num_words.
+
+        Returns:
+          A string representing the instruction description.
+        """
+
+        self._num_words = num_words
+        if self._num_words is None or self._num_words < 0:
+            self._num_words = random.randint(
+                _NUM_WORDS_LOWER_LIMIT, _NUM_WORDS_UPPER_LIMIT
+            )
+
+        if relation is None:
+            self._comparison_relation = random.choice(_COMPARISON_RELATION)
+        elif relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                "The supported relation for comparison must be in "
+                f"{_COMPARISON_RELATION}, but {relation} is given."
+            )
+        else:
+            self._comparison_relation = relation
+
+        self._description_pattern = "Answer with {relation} {num_words} words."
+
+        return self._description_pattern.format(
+            relation=self._comparison_relation, num_words=self._num_words
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"num_words": self._num_words, "relation": self._comparison_relation}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_words", "relation"]
+
+    def check_following(self, value):
+        """Checks if the response contains the expected number of words."""
+        num_words = instructions_util.count_words(value)
+
+        if self._comparison_relation == _COMPARISON_RELATION[0]:
+            return num_words < self._num_words
+        elif self._comparison_relation == _COMPARISON_RELATION[1]:
+            return num_words >= self._num_words
+
+
+class JsonFormat(Instruction):
+    """Check the Json format."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "Entire output should be wrapped in JSON format. You can use markdown"
+            " ticks such as ```."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        value = (
+            value.strip()
+            .removeprefix("```json")
+            .removeprefix("```Json")
+            .removeprefix("```JSON")
+            .removeprefix("```")
+            .removesuffix("```")
+            .strip()
+        )
+        try:
+            json.loads(value)
+        except ValueError:
+            return False
+        return True
+
+
+class ParagraphFirstWordCheck(Instruction):
+    """Check the paragraph and the first word of the nth paragraph."""
+
+    def build_description(
+        self, num_paragraphs=None, nth_paragraph=None, first_word=None
+    ):
+        r"""Build the instruction description.
+
+        Args:
+          num_paragraphs: An integer indicating the number of paragraphs expected
+            in the response. A paragraph is a subset of the string that is
+            expected to be separated by '\n\n'.
+          nth_paragraph: An integer indicating the paragraph number that we look at.
+            Note that n starts from 1.
+          first_word: A string that represent the first word of the bth paragraph.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._num_paragraphs = num_paragraphs
+        if self._num_paragraphs is None or self._num_paragraphs < 0:
+            self._num_paragraphs = random.randint(1, _NUM_PARAGRAPHS)
+
+        self._nth_paragraph = nth_paragraph
+        if (
+            self._nth_paragraph is None
+            or self._nth_paragraph <= 0
+            or self._nth_paragraph > self._num_paragraphs
+        ):
+            self._nth_paragraph = random.randint(1, self._num_paragraphs + 1)
+
+        self._first_word = first_word
+        if self._first_word is None:
+            self._first_word = instructions_util.generate_keywords(num_keywords=1)[0]
+        self._first_word = self._first_word.lower()
+
+        self._description_pattern = (
+            "There should be {num_paragraphs} paragraphs. "
+            + "Paragraphs and only paragraphs are separated with each other by two "
+            + "new lines as if it was '\\n\\n' in python. "
+            + "Paragraph {nth_paragraph} must start with word {first_word}."
+        )
+
+        return self._description_pattern.format(
+            num_paragraphs=self._num_paragraphs,
+            nth_paragraph=self._nth_paragraph,
+            first_word=self._first_word,
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "num_paragraphs": self._num_paragraphs,
+            "nth_paragraph": self._nth_paragraph,
+            "first_word": self._first_word,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_paragraphs", "nth_paragraph", "first_word"]
+
+    def check_following(self, value):
+        """Checks for required number of paragraphs and correct first word.
+
+        Args:
+          value: a string representing the response. The response may contain
+            paragraphs that are separated by two new lines and the first word of
+            the nth paragraph will have to match a specified word.
+
+        Returns:
+          True if the number of paragraphs is the same as required and the first
+          word of the specified paragraph is the same as required. Otherwise, false.
+        """
+
+        paragraphs = re.split(r"\n\n", value)
+        num_paragraphs = len(paragraphs)
+
+        for paragraph in paragraphs:
+            if not paragraph.strip():
+                num_paragraphs -= 1
+
+        # check that index doesn't go out of bounds
+        if self._nth_paragraph <= num_paragraphs:
+            paragraph = paragraphs[self._nth_paragraph - 1].strip()
+            if not paragraph:
+                return False
+        else:
+            return False
+
+        first_word = ""
+        punctuation = {".", ",", "?", "!", "'", '"'}
+
+        # get first word and remove punctuation
+        word = paragraph.split()[0].strip()
+        # TODO(jeffrey): make more complex?
+        word = word.lstrip("'")
+        word = word.lstrip('"')
+
+        for letter in word:
+            if letter in punctuation:
+                break
+            first_word += letter.lower()
+
+        return num_paragraphs == self._num_paragraphs and first_word == self._first_word
+
+
+# TODO(jeffrey) add relation - at least/at most?
+class KeySentenceChecker(Instruction):
+    """Check the existence of certain key sentences."""
+
+    def build_description(self, key_sentences=None, num_sentences=None):
+        """Build the instruction description.
+
+        Args:
+          key_sentences: A sequences of strings representing the key sentences that
+            are expected in the response.
+          num_sentences: The number of key sentences that are expected to be seen in
+            the response.
+
+        Returns:
+          A string representing the instruction description.
+        """
+
+        if not key_sentences:
+            # TODO(jeffrey) make a generate sentences function? wonderwords package
+            self._key_sentences = set(["For now, this is fine."])
+        else:
+            self._key_sentences = key_sentences
+
+        if not num_sentences:
+            self._num_sentences = random.randint(1, len(self._key_sentences))
+        else:
+            self._num_sentences = num_sentences
+
+        self._description_pattern = (
+            "Include {num_sentences} of the following sentences {key_sentences}"
+        )
+
+        return self._description_pattern.format(
+            num_sentences=self._num_sentences, key_sentences=self._key_sentences
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "num_sentences": self._num_sentences,
+            "key_sentences": list(self._key_sentences),
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["num_sentences", "key_sentences"]
+
+    def check_following(self, value):
+        """Checks if the response contains the expected key sentences."""
+        count = 0
+        sentences = instructions_util.split_into_sentences(value)
+        for sentence in self._key_sentences:
+            if sentence in sentences:
+                count += 1
+
+        return count == self._num_sentences
+
+
+class ForbiddenWords(Instruction):
+    """Checks that specified words are not used in response."""
+
+    def build_description(self, forbidden_words=None):
+        """Build the instruction description.
+
+        Args:
+          forbidden_words: A sequences of strings representing words that are not
+            allowed in the response.
+
+        Returns:
+          A string representing the instruction description.
+        """
+
+        if not forbidden_words:
+            self._forbidden_words = instructions_util.generate_keywords(
+                num_keywords=_NUM_KEYWORDS
+            )
+        else:
+            self._forbidden_words = list(set(forbidden_words))
+        self._forbidden_words = sorted(self._forbidden_words)
+        self._description_pattern = (
+            "Do not include keywords {forbidden_words} in the response."
+        )
+
+        return self._description_pattern.format(forbidden_words=self._forbidden_words)
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {"forbidden_words": self._forbidden_words}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["forbidden_words"]
+
+    def check_following(self, value):
+        """Check if the response does not contain the expected keywords."""
+        for word in self._forbidden_words:
+            if re.search(r"\b" + word + r"\b", value, flags=re.IGNORECASE):
+                return False
+        return True
+
+
+class RephraseParagraph(Instruction):
+    """Checks that the paragraph is rephrased."""
+
+    def build_description(self, *, original_paragraph, low, high):
+        """Builds the instruction description.
+
+        Args:
+          original_paragraph: A string presenting the original paragraph. The
+            rephrases response should have between low-high words in common.
+          low: An integer presenting the lower bound of similar words.
+          high: An integer representing the upper bound of similar words.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        # TODO(jeffrey) make more encompassing
+        self._original_paragraph = original_paragraph
+        self._low = low
+        self._high = high
+
+        self._description = (
+            "Rephrase the following paragraph: "
+            + "{original_paragraph}\nYour response should have "
+            + "between {low} and {high} of the same words. "
+            + "Words are the same if and only if all of the "
+            + "letters, ignoring cases, are the same. For "
+            + "example, 'run' is the same as 'Run' but different "
+            + "to 'ran'."
+        )
+
+        return self._description.format(
+            original_paragraph=original_paragraph, low=self._low, high=self._high
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return {
+            "original_paragraph": self._original_paragraph,
+            "low": self._low,
+            "high": self._high,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["original_paragraph", "low", "high"]
+
+    def check_following(self, value):
+        val_words = re.findall(r"\w+", value.lower())
+        original_words = re.findall(r"\w+", self._original_paragraph.lower())
+        similar_words = 0
+
+        dict_val = collections.Counter(val_words)
+        dict_original = collections.Counter(original_words)
+
+        for word in dict_original:
+            similar_words += min(dict_original[word], dict_val[word])
+
+        return similar_words >= self._low and similar_words <= self._high
+
+
+class TwoResponsesChecker(Instruction):
+    """Check that two responses were given."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "Give two different responses. Responses and only responses should"
+            " be separated by 6 asterisk symbols: ******."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        """Returns the keyword args of `build_description`."""
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks if the response has two different answers.
+
+        Args:
+          value: A string representing the response.
+
+        Returns:
+          True if two responses are detected and false otherwise.
+        """
+        valid_responses = list()
+        responses = value.split("******")
+        for index, response in enumerate(responses):
+            if not response.strip():
+                if index != 0 and index != len(responses) - 1:
+                    return False
+            else:
+                valid_responses.append(response)
+        return (
+            len(valid_responses) == 2
+            and valid_responses[0].strip() != valid_responses[1].strip()
+        )
+
+
+class RepeatPromptThenAnswer(Instruction):
+    """Checks that Prompt is first repeated then answered."""
+
+    def build_description(self, *, prompt_to_repeat=None):
+        """Build the instruction description.
+
+        Args:
+          prompt_to_repeat: The prompt that is meant to be repeated.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        if not prompt_to_repeat:
+            raise ValueError("prompt_to_repeat must be set.")
+        else:
+            self._prompt_to_repeat = prompt_to_repeat
+        self._description_pattern = (
+            "First repeat the request word for word without change,"
+            " then give your answer (1. do not say any words or characters"
+            " before repeating the request; 2. the request you need to repeat"
+            " does not include this sentence)"
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return {"prompt_to_repeat": self._prompt_to_repeat}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["prompt_to_repeat"]
+
+    def check_following(self, value):
+        if value.strip().lower().startswith(self._prompt_to_repeat.strip().lower()):
+            return True
+        return False
+
+
+class EndChecker(Instruction):
+    """Checks that the prompt ends with a given phrase."""
+
+    def build_description(self, *, end_phrase=None):
+        """Build the instruction description.
+
+        Args:
+          end_phrase: A string representing the phrase the response should end with.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._end_phrase = (
+            end_phrase.strip() if isinstance(end_phrase, str) else end_phrase
+        )
+        if self._end_phrase is None:
+            self._end_phrase = random.choice(_ENDING_OPTIONS)
+        self._description_pattern = (
+            "Finish your response with this exact phrase {ender}. "
+            "No other words should follow this phrase."
+        )
+        return self._description_pattern.format(ender=self._end_phrase)
+
+    def get_instruction_args(self):
+        return {"end_phrase": self._end_phrase}
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["end_phrase"]
+
+    def check_following(self, value):
+        """Checks if the response ends with the expected phrase."""
+        value = value.strip().strip('"').lower()
+        self._end_phrase = self._end_phrase.strip().lower()
+        return value.endswith(self._end_phrase)
+
+
+class TitleChecker(Instruction):
+    """Checks the response for a title."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "Your answer must contain a title, wrapped in double angular brackets,"
+            " such as <<poem of joy>>."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks if the response contains a title."""
+        pattern = r"<<[^\n]+>>"
+        re_pattern = re.compile(pattern)
+        titles = re.findall(re_pattern, value)
+
+        for title in titles:
+            if title.lstrip("<").rstrip(">").strip():
+                return True
+        return False
+
+
+class LetterFrequencyChecker(Instruction):
+    """Checks letter frequency."""
+
+    def build_description(self, *, letter=None, let_frequency=None, let_relation=None):
+        """Build the instruction description.
+
+        Args:
+          letter: A string representing a letter that is expected in the response.
+          let_frequency: An integer specifying the number of times `keyword` is
+            expected to appear in the response.
+          let_relation: A string in (`less than`, `at least`), defining the
+            relational operator for comparison. Two relational comparisons are
+            supported for now; if 'less than', the actual number of
+            occurrences < frequency; if 'at least', the actual number of
+            occurrences >= frequency.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        if (
+            not letter
+            or len(letter) > 1
+            or ord(letter.lower()) < 97
+            or ord(letter.lower()) > 122
+        ):
+            self._letter = random.choice(list(string.ascii_letters))
+        else:
+            self._letter = letter.strip()
+        self._letter = self._letter.lower()
+
+        self._frequency = let_frequency
+        if self._frequency is None or self._frequency < 0:
+            self._frequency = random.randint(1, _LETTER_FREQUENCY)
+
+        if let_relation is None:
+            self._comparison_relation = random.choice(_COMPARISON_RELATION)
+        elif let_relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                "The supported relation for comparison must be in "
+                f"{_COMPARISON_RELATION}, but {let_relation} is given."
+            )
+        else:
+            self._comparison_relation = let_relation
+
+        self._description_pattern = (
+            "In your response, the letter {letter} should appear {let_relation}"
+            " {let_frequency} times."
+        )
+
+        return self._description_pattern.format(
+            letter=self._letter,
+            let_frequency=self._frequency,
+            let_relation=self._comparison_relation,
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of build description."""
+        return {
+            "letter": self._letter,
+            "let_frequency": self._frequency,
+            "let_relation": self._comparison_relation,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["letter", "let_frequency", "let_relation"]
+
+    def check_following(self, value):
+        """Checks that the response contains the letter at the right frequency."""
+        value = value.lower()
+        letters = collections.Counter(value)
+
+        if self._comparison_relation == _COMPARISON_RELATION[0]:
+            return letters[self._letter] < self._frequency
+        else:
+            return letters[self._letter] >= self._frequency
+
+
+class CapitalLettersEnglishChecker(Instruction):
+    """Checks that the response is in english and is in all capital letters."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "Your entire response should be in English, and in all capital letters."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks that the response is in English and in all capital letters."""
+        assert isinstance(value, str)
+
+        try:
+            return value.isupper() and langdetect.detect(value) == "en"
+        except langdetect.LangDetectException as e:
+            # Count as instruction is followed.
+            logging.error(
+                "Unable to detect language for text %s due to %s", value, e
+            )  # refex: disable=pytotw.037
+            return True
+
+
+class LowercaseLettersEnglishChecker(Instruction):
+    """Checks that the response is in english and is in all lowercase letters."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "Your entire response should be in English, and in all lowercase"
+            " letters. No capital letters are allowed."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks that the response is in English and in all lowercase letters."""
+        assert isinstance(value, str)
+
+        try:
+            return value.islower() and langdetect.detect(value) == "en"
+        except langdetect.LangDetectException as e:
+            # Count as instruction is followed.
+            logging.error(
+                "Unable to detect language for text %s due to %s", value, e
+            )  # refex: disable=pytotw.037
+            return True
+
+
+class CommaChecker(Instruction):
+    """Checks the response for no commas."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "In your entire response, refrain from the use of any commas."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks that the response does not contain commas."""
+        return not re.search(r"\,", value)
+
+
+class CapitalWordFrequencyChecker(Instruction):
+    """Checks frequency of words with all capital letters."""
+
+    def build_description(
+        self,
+        capital_frequency=None,
+        capital_relation=None,
+    ):
+        """Build the instruction description.
+
+        Args:
+          capital_frequency: An integer that represents the number of words that
+            should be in all capital letters.
+          capital_relation: A string that is 'at least' or 'at most' that refers to
+            the frequency.
+
+        Returns:
+          A string representing the instruction description.
+        """
+        self._frequency = capital_frequency
+        if self._frequency is None:
+            self._frequency = random.randint(1, _ALL_CAPITAL_WORD_FREQUENCY)
+
+        self._comparison_relation = capital_relation
+        if capital_relation is None:
+            self._comparison_relation = random.choice(_COMPARISON_RELATION)
+        elif capital_relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                "The supported relation for comparison must be in "
+                f"{_COMPARISON_RELATION}, but {capital_relation} is given."
+            )
+
+        self._description_pattern = (
+            "In your response, words with all capital letters should appear"
+            " {relation} {frequency} times."
+        )
+
+        return self._description_pattern.format(
+            frequency=self._frequency, relation=self._comparison_relation
+        )
+
+    def get_instruction_args(self):
+        """Returns the keyword args of build description."""
+        return {
+            "capital_frequency": self._frequency,
+            "capital_relation": self._comparison_relation,
+        }
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return ["capital_frequency", "capital_relation"]
+
+    def check_following(self, value):
+        """Checks the frequency of words with all capital letters."""
+        # Hyphenated words will count as one word
+        words = instructions_util.nltk.word_tokenize(value)
+        capital_words = [word for word in words if word.isupper()]
+
+        capital_words = len(capital_words)
+
+        if self._comparison_relation == _COMPARISON_RELATION[0]:
+            return capital_words < self._frequency
+        else:
+            return capital_words >= self._frequency
+
+
+class QuotationChecker(Instruction):
+    """Checks response is wrapped with double quotation marks."""
+
+    def build_description(self):
+        """Build the instruction description."""
+        self._description_pattern = (
+            "Wrap your entire response with double quotation marks."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        """Returns the keyword args of build description."""
+        return None
+
+    def get_instruction_args_keys(self):
+        """Returns the args keys of `build_description`."""
+        return []
+
+    def check_following(self, value):
+        """Checks if the response is wrapped with double quotation marks."""
+        value = value.strip()
+        return len(value) > 1 and value[0] == '"' and value[-1] == '"'
+
+
+# ---------------------------------------------------------------------------
+# NEW IFTrain out-of-distribution constraints
+# ---------------------------------------------------------------------------
+
+class KeywordOnceChecker(Instruction):
+    """Check that a keyword appears at least once in the response."""
+
+    def build_description(self, *, keyword=None):
+        if not keyword:
+            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._keyword = keyword.strip()
+        self._description_pattern = (
+            "Include keyword {keyword} in your response."
+        )
+        return self._description_pattern.format(keyword=self._keyword)
+
+    def get_instruction_args(self):
+        return {"keyword": self._keyword}
+
+    def get_instruction_args_keys(self):
+        return ["keyword"]
+
+    def check_following(self, value):
+        return bool(re.search(r"\b" + re.escape(self._keyword) + r"\b", value, flags=re.IGNORECASE))
+
+
+class KeywordExactCountChecker(Instruction):
+    """Check that a word appears exactly N times in the response."""
+
+    def build_description(self, *, keyword=None, count=None):
+        if not keyword:
+            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._keyword = keyword.strip()
+        self._count = count
+        if self._count is None or self._count < 1:
+            self._count = random.randint(1, 5)
+        self._description_pattern = (
+            "In your response, the word {keyword} should appear {count} times."
+        )
+        return self._description_pattern.format(keyword=self._keyword, count=self._count)
+
+    def get_instruction_args(self):
+        return {"keyword": self._keyword, "count": self._count}
+
+    def get_instruction_args_keys(self):
+        return ["keyword", "count"]
+
+    def check_following(self, value):
+        occurrences = len(re.findall(r"\b" + re.escape(self._keyword) + r"\b", value, flags=re.IGNORECASE))
+        return occurrences == self._count
+
+
+class ExcludeWordHarderChecker(Instruction):
+    """Check that a specific keyword from the instruction is not used."""
+
+    def build_description(self, *, keyword=None):
+        if not keyword:
+            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._keyword = keyword.strip()
+        self._description_pattern = (
+            "Do not include keyword {keyword} in the response."
+        )
+        return self._description_pattern.format(keyword=self._keyword)
+
+    def get_instruction_args(self):
+        return {"keyword": self._keyword}
+
+    def get_instruction_args_keys(self):
+        return ["keyword"]
+
+    def check_following(self, value):
+        return not bool(re.search(r"\b" + re.escape(self._keyword) + r"\b", value, flags=re.IGNORECASE))
+
+
+class LetterExactCountChecker(Instruction):
+    """Check that a specific letter appears exactly N times in the response."""
+
+    def build_description(self, *, letter=None, count=None):
+        if (
+            not letter
+            or len(letter) > 1
+            or ord(letter.lower()) < 97
+            or ord(letter.lower()) > 122
+        ):
+            self._letter = random.choice(list(string.ascii_lowercase))
+        else:
+            self._letter = letter.strip().lower()
+        self._count = count
+        if self._count is None or self._count < 1:
+            self._count = random.randint(1, _LETTER_FREQUENCY)
+        self._description_pattern = (
+            "In your response, the letter {letter} should appear {count} times."
+        )
+        return self._description_pattern.format(letter=self._letter, count=self._count)
+
+    def get_instruction_args(self):
+        return {"letter": self._letter, "count": self._count}
+
+    def get_instruction_args_keys(self):
+        return ["letter", "count"]
+
+    def check_following(self, value):
+        value = value.lower()
+        letters = collections.Counter(value)
+        return letters[self._letter] == self._count
+
+
+class ParagraphsTwoLineBreaksChecker(Instruction):
+    """Check paragraphs separated by two line breaks (\\n\\n)."""
+
+    def build_description(self, *, num_paragraphs=None):
+        self._num_paragraphs = num_paragraphs
+        if self._num_paragraphs is None or self._num_paragraphs < 1:
+            self._num_paragraphs = random.randint(2, _NUM_PARAGRAPHS)
+        self._description_pattern = (
+            "There should be {num_paragraphs} paragraphs. "
+            "Paragraphs and only paragraphs are separated with each other by two line breaks."
+        )
+        return self._description_pattern.format(num_paragraphs=self._num_paragraphs)
+
+    def get_instruction_args(self):
+        return {"num_paragraphs": self._num_paragraphs}
+
+    def get_instruction_args_keys(self):
+        return ["num_paragraphs"]
+
+    def check_following(self, value):
+        paragraphs = re.split(r"\n\n", value)
+        num_paragraphs = len([p for p in paragraphs if p.strip()])
+        return num_paragraphs == self._num_paragraphs
+
+
+class FirstWordSentenceChecker(Instruction):
+    """Check that the first word of each sentence is a specific word."""
+
+    def build_description(self, *, first_word=None):
+        if not first_word:
+            self._first_word = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._first_word = first_word.strip().lower()
+        self._description_pattern = (
+            "The first word of each sentence should be the word {first_word}."
+        )
+        return self._description_pattern.format(first_word=self._first_word)
+
+    def get_instruction_args(self):
+        return {"first_word": self._first_word}
+
+    def get_instruction_args_keys(self):
+        return ["first_word"]
+
+    def check_following(self, value):
+        sentences = instructions_util.split_into_sentences(value)
+        if not sentences:
+            return False
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+            words = re.findall(r"\w+", sentence)
+            if not words:
+                return False
+            if words[0].lower() != self._first_word.lower():
+                return False
+        return True
+
+
+class FirstWordAnswerChecker(Instruction):
+    """Check that the first word of the entire response is a specific word."""
+
+    def build_description(self, *, first_word=None):
+        if not first_word:
+            self._first_word = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._first_word = first_word.strip().lower()
+        self._description_pattern = (
+            "The first word of your response should be the word {first_word}."
+        )
+        return self._description_pattern.format(first_word=self._first_word)
+
+    def get_instruction_args(self):
+        return {"first_word": self._first_word}
+
+    def get_instruction_args_keys(self):
+        return ["first_word"]
+
+    def check_following(self, value):
+        value = value.strip()
+        words = re.findall(r"\w+", value)
+        if not words:
+            return False
+        return words[0].lower() == self._first_word.lower()
+
+
+class LastWordSentenceChecker(Instruction):
+    """Check that the last word of each sentence (before punctuation) is a specific word."""
+
+    def build_description(self, *, last_word=None):
+        if not last_word:
+            self._last_word = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._last_word = last_word.strip().lower()
+        self._description_pattern = (
+            "The last word of each sentence, before punctuation, should be the word {last_word}."
+        )
+        return self._description_pattern.format(last_word=self._last_word)
+
+    def get_instruction_args(self):
+        return {"last_word": self._last_word}
+
+    def get_instruction_args_keys(self):
+        return ["last_word"]
+
+    def check_following(self, value):
+        sentences = instructions_util.split_into_sentences(value)
+        if not sentences:
+            return False
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+            words = re.findall(r"\w+", sentence)
+            if not words:
+                return False
+            if words[-1].lower() != self._last_word.lower():
+                return False
+        return True
+
+
+class LastWordAnswerChecker(Instruction):
+    """Check that the last word of the entire response is a specific word."""
+
+    def build_description(self, *, last_word=None):
+        if not last_word:
+            self._last_word = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._last_word = last_word.strip().lower()
+        self._description_pattern = (
+            "The last word of your response should be the word {last_word}."
+        )
+        return self._description_pattern.format(last_word=self._last_word)
+
+    def get_instruction_args(self):
+        return {"last_word": self._last_word}
+
+    def get_instruction_args_keys(self):
+        return ["last_word"]
+
+    def check_following(self, value):
+        value = value.strip()
+        # Remove trailing punctuation to get the last word
+        words = re.findall(r"\w+", value)
+        if not words:
+            return False
+        return words[-1].lower() == self._last_word.lower()
+
+
+class BigramWrappingChecker(Instruction):
+    """Check that every word bigram is wrapped in double angular brackets «...»."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "Wrap every word bigram in double angular brackets, "
+            "such as \u00abI am\u00bb \u00abat home\u00bb \u00abwith my\u00bb \u00abcute dog\u00bb."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        """Check that the response contains bigrams wrapped in «...»."""
+        # Find all bigrams wrapped in «...»
+        wrapped_bigrams = re.findall(r"\u00ab[^\u00ab\u00bb]+\u00bb", value)
+        if not wrapped_bigrams:
+            return False
+        # Each wrapped bigram should contain exactly 2 words
+        for bigram in wrapped_bigrams:
+            content = bigram.strip("\u00ab\u00bb").strip()
+            words = content.split()
+            if len(words) != 2:
+                return False
+        return True
+
+
+class CopyingSimpleChecker(Instruction):
+    """Check that the request is repeated without change and not answered."""
+
+    def build_description(self, *, prompt_to_copy=None):
+        if not prompt_to_copy:
+            raise ValueError("prompt_to_copy must be set.")
+        self._prompt_to_copy = prompt_to_copy
+        self._description_pattern = (
+            "Repeat the request without change (do not say anything before repeating "
+            "the request; the request you need to repeat does not include this sentence) "
+            "and do not answer the actual request!"
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return {"prompt_to_copy": self._prompt_to_copy}
+
+    def get_instruction_args_keys(self):
+        return ["prompt_to_copy"]
+
+    def check_following(self, value):
+        value = value.strip()
+        prompt = self._prompt_to_copy.strip()
+        return value.lower() == prompt.lower()
+
+
+class CopyingMultipleChecker(Instruction):
+    """Check that the request is repeated N times separated by 6 asterisks."""
+
+    def build_description(self, *, prompt_to_copy=None, copy_count=None):
+        if not prompt_to_copy:
+            raise ValueError("prompt_to_copy must be set.")
+        self._prompt_to_copy = prompt_to_copy
+        self._copy_count = copy_count
+        if self._copy_count is None or self._copy_count < 1:
+            self._copy_count = random.randint(2, 4)
+        self._description_pattern = (
+            "Repeat the request without change {copy_count} times, separated by 6 asterisk symbols "
+            "(do not say anything before repeating the request; the request you need to repeat "
+            "does not include this sentence) and do not answer the actual request!"
+        )
+        return self._description_pattern.format(copy_count=self._copy_count)
+
+    def get_instruction_args(self):
+        return {"prompt_to_copy": self._prompt_to_copy, "copy_count": self._copy_count}
+
+    def get_instruction_args_keys(self):
+        return ["prompt_to_copy", "copy_count"]
+
+    def check_following(self, value):
+        parts = value.split("******")
+        valid_parts = [p.strip() for p in parts if p.strip()]
+        if len(valid_parts) != self._copy_count:
+            return False
+        prompt = self._prompt_to_copy.strip().lower()
+        return all(p.lower() == prompt for p in valid_parts)
+
+
+class NoDotChecker(Instruction):
+    """Check that the response does not contain dots."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "In your entire response, refrain from the use of . (i.e. dots) as punctuation and in general."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        return "." not in value
+
+
+class NoExclamationChecker(Instruction):
+    """Check that the response does not contain exclamation marks."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "In your entire response, refrain from the use of ! (i.e. exclamation marks) as punctuation and in general."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        return "!" not in value
+
+
+class LowercaseWordCountChecker(Instruction):
+    """Check that all lowercase words appear at most N times."""
+
+    def build_description(self, *, max_count=None):
+        self._max_count = max_count
+        if self._max_count is None or self._max_count < 1:
+            self._max_count = random.randint(1, 10)
+        self._description_pattern = (
+            "In your response, all lowercase words should appear at most {max_count} times."
+        )
+        return self._description_pattern.format(max_count=self._max_count)
+
+    def get_instruction_args(self):
+        return {"max_count": self._max_count}
+
+    def get_instruction_args_keys(self):
+        return ["max_count"]
+
+    def check_following(self, value):
+        words = re.findall(r"\b[a-z]+\b", value)
+        word_counts = collections.Counter(words)
+        return all(count <= self._max_count for count in word_counts.values())
+
+
+class LetterTotalCountChecker(Instruction):
+    """Check that the response contains exactly N letters (or with relation)."""
+
+    def build_description(self, *, num_letters=None, relation=None):
+        self._num_letters = num_letters
+        if self._num_letters is None or self._num_letters < 1:
+            self._num_letters = random.randint(50, 500)
+        if relation is None:
+            self._relation = random.choice(_COMPARISON_RELATION)
+        elif relation not in _COMPARISON_RELATION:
+            raise ValueError(
+                f"The supported relation must be in {_COMPARISON_RELATION}, but {relation} is given."
+            )
+        else:
+            self._relation = relation
+        self._description_pattern = (
+            "Answer with {relation} {num_letters} letters."
+        )
+        return self._description_pattern.format(relation=self._relation, num_letters=self._num_letters)
+
+    def get_instruction_args(self):
+        return {"num_letters": self._num_letters, "relation": self._relation}
+
+    def get_instruction_args_keys(self):
+        return ["num_letters", "relation"]
+
+    def check_following(self, value):
+        letter_count = sum(1 for c in value if c.isalpha())
+        if self._relation == _COMPARISON_RELATION[0]:
+            return letter_count < self._num_letters
+        else:
+            return letter_count >= self._num_letters
+
+
+class CountingCompositionChecker(Instruction):
+    """Check 3 paragraphs with exactly N sentences each and M words per sentence."""
+
+    def build_description(self, *, n_sent=None, n_words=None):
+        self._n_sent = n_sent
+        if self._n_sent is None or self._n_sent < 1:
+            self._n_sent = random.randint(2, 5)
+        self._n_words = n_words
+        if self._n_words is None or self._n_words < 1:
+            self._n_words = random.randint(5, 15)
+        self._description_pattern = (
+            "Write 3 paragraphs, delimited by the markdown divider: ***, "
+            "with exactly {n_sent} sentences each, with exactly {n_words} words in each sentence."
+        )
+        return self._description_pattern.format(n_sent=self._n_sent, n_words=self._n_words)
+
+    def get_instruction_args(self):
+        return {"n_sent": self._n_sent, "n_words": self._n_words}
+
+    def get_instruction_args_keys(self):
+        return ["n_sent", "n_words"]
+
+    def check_following(self, value):
+        paragraphs = re.split(r"\s?\*\*\*\s?", value)
+        paragraphs = [p.strip() for p in paragraphs if p.strip()]
+        if len(paragraphs) != 3:
+            return False
+        for paragraph in paragraphs:
+            sentences = instructions_util.split_into_sentences(paragraph)
+            sentences = [s for s in sentences if s.strip()]
+            if len(sentences) != self._n_sent:
+                return False
+            for sentence in sentences:
+                word_count = instructions_util.count_words(sentence)
+                if word_count != self._n_words:
+                    return False
+        return True
+
+
+class UniqueWordsChecker(Instruction):
+    """Check that only unique words are used (no word repeated)."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "Only use unique words in your response, no word should be repeated!"
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        words = re.findall(r"\b\w+\b", value.lower())
+        return len(words) == len(set(words))
+
+
+class IncrementKeywordChecker(Instruction):
+    """Check that keyword1 appears once and keyword2 appears twice."""
+
+    def build_description(self, *, keyword1=None, keyword2=None):
+        if not keyword1 or not keyword2:
+            kws = instructions_util.generate_keywords(num_keywords=2)
+            self._keyword1 = keyword1.strip() if keyword1 else kws[0]
+            self._keyword2 = keyword2.strip() if keyword2 else kws[1]
+        else:
+            self._keyword1 = keyword1.strip()
+            self._keyword2 = keyword2.strip()
+        self._description_pattern = (
+            "Include keyword {keyword1} once in your response, keyword {keyword2} twice in your response."
+        )
+        return self._description_pattern.format(keyword1=self._keyword1, keyword2=self._keyword2)
+
+    def get_instruction_args(self):
+        return {"keyword1": self._keyword1, "keyword2": self._keyword2}
+
+    def get_instruction_args_keys(self):
+        return ["keyword1", "keyword2"]
+
+    def check_following(self, value):
+        count1 = len(re.findall(r"\b" + re.escape(self._keyword1) + r"\b", value, flags=re.IGNORECASE))
+        count2 = len(re.findall(r"\b" + re.escape(self._keyword2) + r"\b", value, flags=re.IGNORECASE))
+        return count1 == 1 and count2 == 2
+
+
+class PalindromeChecker(Instruction):
+    """Check that the response includes a palindrome."""
+
+    def build_description(self):
+        self._description_pattern = "Include a palindrome in your response."
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        words = re.findall(r"\b\w+\b", value.lower())
+        for word in words:
+            if len(word) > 1 and word == word[::-1]:
+                return True
+        return False
+
+
+class KeywordSpecificPositionChecker(Instruction):
+    """Check that a keyword appears in the Nth sentence as the Mth word."""
+
+    def build_description(self, *, keyword=None, sentence_num=None, word_num=None):
+        if not keyword:
+            self._keyword = instructions_util.generate_keywords(num_keywords=1)[0]
+        else:
+            self._keyword = keyword.strip()
+        self._sentence_num = sentence_num
+        if self._sentence_num is None or self._sentence_num < 1:
+            self._sentence_num = random.randint(1, 5)
+        self._word_num = word_num
+        if self._word_num is None or self._word_num < 1:
+            self._word_num = random.randint(1, 5)
+        self._description_pattern = (
+            "Include keyword {keyword} in the {sentence_num}-th sentence, "
+            "as the {word_num}-th word of that sentence."
+        )
+        return self._description_pattern.format(
+            keyword=self._keyword,
+            sentence_num=self._sentence_num,
+            word_num=self._word_num,
+        )
+
+    def get_instruction_args(self):
+        return {
+            "keyword": self._keyword,
+            "sentence_num": self._sentence_num,
+            "word_num": self._word_num,
+        }
+
+    def get_instruction_args_keys(self):
+        return ["keyword", "sentence_num", "word_num"]
+
+    def check_following(self, value):
+        sentences = instructions_util.split_into_sentences(value)
+        sentences = [s for s in sentences if s.strip()]
+        if len(sentences) < self._sentence_num:
+            return False
+        target_sentence = sentences[self._sentence_num - 1]
+        words = re.findall(r"\w+", target_sentence)
+        if len(words) < self._word_num:
+            return False
+        return words[self._word_num - 1].lower() == self._keyword.lower()
+
+
+class StartEndSameWordChecker(Instruction):
+    """Check that the response starts and ends with the same word."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "Start and end your response with the same word "
+            "(do not write anything after the last word, not even punctuation)."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        value = value.strip()
+        words = re.findall(r"\w+", value)
+        if len(words) < 2:
+            return False
+        return words[0].lower() == words[-1].lower()
+
+
+class RepeatPhraseChecker(Instruction):
+    """Check that a phrase is repeated N times with one word replaced each time."""
+
+    def build_description(self, *, phrase=None, repeat_count=None):
+        if not phrase:
+            kws = instructions_util.generate_keywords(num_keywords=3)
+            self._phrase = " ".join(kws)
+        else:
+            self._phrase = phrase.strip()
+        self._repeat_count = repeat_count
+        if self._repeat_count is None or self._repeat_count < 2:
+            self._repeat_count = random.randint(2, 4)
+        self._description_pattern = (
+            "Repeat the phrase \"{phrase}\" exactly {repeat_count} times, "
+            "transforming it slightly each time by replacing one word."
+        )
+        return self._description_pattern.format(phrase=self._phrase, repeat_count=self._repeat_count)
+
+    def get_instruction_args(self):
+        return {"phrase": self._phrase, "repeat_count": self._repeat_count}
+
+    def get_instruction_args_keys(self):
+        return ["phrase", "repeat_count"]
+
+    def check_following(self, value):
+        """Check that the phrase (with one word replaced) appears repeat_count times."""
+        phrase_words = self._phrase.lower().split()
+        n = len(phrase_words)
+        if n == 0:
+            return False
+        # Find all n-grams in the response
+        value_words = re.findall(r"\w+", value.lower())
+        count = 0
+        for i in range(len(value_words) - n + 1):
+            ngram = value_words[i:i + n]
+            # Count differences
+            diffs = sum(1 for a, b in zip(ngram, phrase_words) if a != b)
+            if diffs <= 1:
+                count += 1
+        return count == self._repeat_count
+
+
+class NoAdjacentConsecutiveLettersChecker(Instruction):
+    """Check that no two adjacent words start with consecutive letters of the alphabet."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "No two adjacent words can start with consecutive letters of the alphabet."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        words = re.findall(r"\b[a-zA-Z]\w*\b", value)
+        for i in range(len(words) - 1):
+            c1 = words[i][0].lower()
+            c2 = words[i + 1][0].lower()
+            if abs(ord(c1) - ord(c2)) == 1:
+                return False
+        return True
+
+
+class SquareBracketsWordChecker(Instruction):
+    """Check that every word in the response is enclosed within square brackets."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "Enclose every word in your response within square brackets."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        # Find all tokens that look like words (not already in brackets)
+        # Check that every word-like token is inside [...]
+        # Strategy: find all words not inside brackets
+        # Remove all bracketed content
+        without_brackets = re.sub(r"\[[^\[\]]*\]", "", value)
+        # After removing bracketed content, there should be no standalone words left
+        remaining_words = re.findall(r"\b[a-zA-Z]+\b", without_brackets)
+        return len(remaining_words) == 0
+
+
+class SentenceHyphensChecker(Instruction):
+    """Check that all sentences are connected using hyphens with no spaces between them."""
+
+    def build_description(self):
+        self._description_pattern = (
+            "All sentences must be connected using hyphens, with no spaces between them."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return None
+
+    def get_instruction_args_keys(self):
+        return []
+
+    def check_following(self, value):
+        value = value.strip()
+        # Check that the response contains hyphens connecting sentences
+        # and no spaces around hyphens used as sentence connectors
+        if not value:
+            return False
+        # The response should not contain ". " (sentence-ending space) patterns
+        # but should contain "-" connecting sentences
+        # Simple check: no spaces around sentence-connecting hyphens
+        # and the response uses hyphens as connectors
+        has_hyphen_connector = bool(re.search(r"\w-\w", value))
+        has_sentence_space = bool(re.search(r"[.!?]\s+[A-Z]", value))
+        return has_hyphen_connector and not has_sentence_space
+
+
+class CopyInstructionChecker(Instruction):
+    """Check that the instruction is copied verbatim without following it."""
+
+    def build_description(self, *, instruction_to_copy=None):
+        if not instruction_to_copy:
+            raise ValueError("instruction_to_copy must be set.")
+        self._instruction_to_copy = instruction_to_copy
+        self._description_pattern = (
+            "Copy this instruction verbatim, do not follow the instruction, "
+            "only copy it into the output (do not include this instruction sentence!)."
+        )
+        return self._description_pattern
+
+    def get_instruction_args(self):
+        return {"instruction_to_copy": self._instruction_to_copy}
+
+    def get_instruction_args_keys(self):
+        return ["instruction_to_copy"]
+
+    def check_following(self, value):
+        value = value.strip()
+        instruction = self._instruction_to_copy.strip()
+        return value.lower() == instruction.lower()
+
+
+class CopySpanIndexChecker(Instruction):
+    """Check that the span of words between character indices n_start and n_end is copied."""
+
+    def build_description(self, *, source_text=None, n_start=None, n_end=None):
+        if not source_text:
+            raise ValueError("source_text must be set.")
+        self._source_text = source_text
+        self._n_start = n_start if n_start is not None else 0
+        self._n_end = n_end if n_end is not None else min(len(source_text), 50)
+        self._expected_span = source_text[self._n_start:self._n_end + 1]
+        self._description_pattern = (
+            "Copy the span of words that lies between (and including) index {n_start} and {n_end}, "
+            "the indices are character indices!"
+        )
+        return self._description_pattern.format(n_start=self._n_start, n_end=self._n_end)
+
+    def get_instruction_args(self):
+        return {
+            "source_text": self._source_text,
+            "n_start": self._n_start,
+            "n_end": self._n_end,
+        }
+
+    def get_instruction_args_keys(self):
+        return ["source_text", "n_start", "n_end"]
+
+    def check_following(self, value):
+        return self._expected_span.strip() in value

synthgen/PtPersonaIFGen/lmeval_pt/instructions_registry.py

@@ -0,0 +1,273 @@
+# Copyright 2023 The Google Research Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Registry of all instructions."""
+
+from lmeval_pt import instructions
+
+
+_KEYWORD = "keywords:"
+
+_LANGUAGE = "language:"
+
+_LENGTH = "length_constraints:"
+
+_CONTENT = "detectable_content:"
+
+_FORMAT = "detectable_format:"
+
+_MULTITURN = "multi-turn:"
+
+_COMBINATION = "combination:"
+
+_STARTEND = "startend:"
+
+_CHANGE_CASES = "change_case:"
+
+_PUNCTUATION = "punctuation:"
+
+INSTRUCTION_DICT = {
+    _KEYWORD + "existence": instructions.KeywordChecker,
+    _KEYWORD + "frequency": instructions.KeywordFrequencyChecker,
+    # TODO(jeffreyzhou): make a proper set of sentences to choose from
+    # _KEYWORD + "key_sentences": instructions.KeySentenceChecker,
+    _KEYWORD + "forbidden_words": instructions.ForbiddenWords,
+    _KEYWORD + "letter_frequency": instructions.LetterFrequencyChecker,
+    _LANGUAGE + "response_language": instructions.ResponseLanguageChecker,
+    _LENGTH + "number_sentences": instructions.NumberOfSentences,
+    _LENGTH + "number_paragraphs": instructions.ParagraphChecker,
+    _LENGTH + "number_words": instructions.NumberOfWords,
+    _LENGTH + "nth_paragraph_first_word": instructions.ParagraphFirstWordCheck,
+    _CONTENT + "number_placeholders": instructions.PlaceholderChecker,
+    _CONTENT + "postscript": instructions.PostscriptChecker,
+    _FORMAT + "number_bullet_lists": instructions.BulletListChecker,
+    # TODO(jeffreyzhou): Pre-create paragraph or use prompt to replace
+    # _CONTENT + "rephrase_paragraph": instructions.RephraseParagraph,
+    _FORMAT + "constrained_response": instructions.ConstrainedResponseChecker,
+    _FORMAT + "number_highlighted_sections": (instructions.HighlightSectionChecker),
+    _FORMAT + "multiple_sections": instructions.SectionChecker,
+    # TODO(tianjianlu): Re-enable rephrasing with preprocessing the message.
+    # _FORMAT + "rephrase": instructions.RephraseChecker,
+    _FORMAT + "json_format": instructions.JsonFormat,
+    _FORMAT + "title": instructions.TitleChecker,
+    # TODO(tianjianlu): Re-enable with specific prompts.
+    # _MULTITURN + "constrained_start": instructions.ConstrainedStartChecker,
+    _COMBINATION + "two_responses": instructions.TwoResponsesChecker,
+    _COMBINATION + "repeat_prompt": instructions.RepeatPromptThenAnswer,
+    _STARTEND + "end_checker": instructions.EndChecker,
+    _CHANGE_CASES + "capital_word_frequency": instructions.CapitalWordFrequencyChecker,
+    _CHANGE_CASES + "english_capital": instructions.CapitalLettersEnglishChecker,
+    _CHANGE_CASES + "english_lowercase": instructions.LowercaseLettersEnglishChecker,
+    _PUNCTUATION + "no_comma": instructions.CommaChecker,
+    _STARTEND + "quotation": instructions.QuotationChecker,
+    # --- IFTrain out-of-distribution constraints ---
+    _KEYWORD + "word_once": instructions.KeywordOnceChecker,
+    _KEYWORD + "word_count_diff_numb": instructions.KeywordExactCountChecker,
+    _KEYWORD + "exclude_word_harder": instructions.ExcludeWordHarderChecker,
+    _KEYWORD + "letter_counting2": instructions.LetterExactCountChecker,
+    _LENGTH + "paragraphs_two_line_breaks": instructions.ParagraphsTwoLineBreaksChecker,
+    _STARTEND + "first_word_sent": instructions.FirstWordSentenceChecker,
+    _STARTEND + "first_word_answer": instructions.FirstWordAnswerChecker,
+    _STARTEND + "last_word_sent": instructions.LastWordSentenceChecker,
+    _STARTEND + "last_word_answer": instructions.LastWordAnswerChecker,
+    _FORMAT + "bigram_wrapping": instructions.BigramWrappingChecker,
+    _COMBINATION + "copying_simple": instructions.CopyingSimpleChecker,
+    _COMBINATION + "copying_multiple": instructions.CopyingMultipleChecker,
+    _PUNCTUATION + "no_dot": instructions.NoDotChecker,
+    _PUNCTUATION + "no_exclamation": instructions.NoExclamationChecker,
+    _KEYWORD + "lowercase_counting": instructions.LowercaseWordCountChecker,
+    _LENGTH + "letter_total_count": instructions.LetterTotalCountChecker,
+    _LENGTH + "counting_composition": instructions.CountingCompositionChecker,
+    _KEYWORD + "count_unique": instructions.UniqueWordsChecker,
+    _KEYWORD + "count_increment_word": instructions.IncrementKeywordChecker,
+    _KEYWORD + "palindrome": instructions.PalindromeChecker,
+    _KEYWORD + "keyword_specific_pos": instructions.KeywordSpecificPositionChecker,
+    _STARTEND + "start_end_same_word": instructions.StartEndSameWordChecker,
+    _COMBINATION + "repeat_phrase": instructions.RepeatPhraseChecker,
+    _KEYWORD + "no_adjacent_consecutive": instructions.NoAdjacentConsecutiveLettersChecker,
+    _FORMAT + "square_brackets_word": instructions.SquareBracketsWordChecker,
+    _FORMAT + "sentence_hyphens": instructions.SentenceHyphensChecker,
+    _COMBINATION + "copy_instruction": instructions.CopyInstructionChecker,
+    _COMBINATION + "copy_span_idx": instructions.CopySpanIndexChecker,
+}
+
+INSTRUCTION_CONFLICTS = {
+    _KEYWORD + "existence": {_KEYWORD + "existence"},
+    _KEYWORD + "frequency": {_KEYWORD + "frequency"},
+    # TODO(jeffreyzhou): make a proper set of sentences to choose from
+    # _KEYWORD + "key_sentences": instructions.KeySentenceChecker,
+    _KEYWORD + "forbidden_words": {_KEYWORD + "forbidden_words"},
+    _KEYWORD + "letter_frequency": {_KEYWORD + "letter_frequency"},
+    _LANGUAGE + "response_language": {
+        _LANGUAGE + "response_language",
+        _FORMAT + "multiple_sections",
+        _KEYWORD + "existence",
+        _KEYWORD + "frequency",
+        _KEYWORD + "forbidden_words",
+        _STARTEND + "end_checker",
+        _CHANGE_CASES + "english_capital",
+        _CHANGE_CASES + "english_lowercase",
+    },
+    _LENGTH + "number_sentences": {_LENGTH + "number_sentences"},
+    _LENGTH + "number_paragraphs": {
+        _LENGTH + "number_paragraphs",
+        _LENGTH + "nth_paragraph_first_word",
+        _LENGTH + "number_sentences",
+        _LENGTH + "nth_paragraph_first_word",
+        _LENGTH + "paragraphs_two_line_breaks",
+        _LENGTH + "counting_composition",
+    },
+    _LENGTH + "number_words": {_LENGTH + "number_words"},
+    _LENGTH + "nth_paragraph_first_word": {
+        _LENGTH + "nth_paragraph_first_word",
+        _LENGTH + "number_paragraphs",
+        _LENGTH + "paragraphs_two_line_breaks",
+    },
+    _CONTENT + "number_placeholders": {_CONTENT + "number_placeholders"},
+    _CONTENT + "postscript": {_CONTENT + "postscript"},
+    _FORMAT + "number_bullet_lists": {_FORMAT + "number_bullet_lists"},
+    # TODO(jeffreyzhou): Pre-create paragraph or use prompt to replace
+    # _CONTENT + "rephrase_paragraph": instructions.RephraseParagraph,
+    _FORMAT + "constrained_response": set(INSTRUCTION_DICT.keys()),
+    _FORMAT + "number_highlighted_sections": {_FORMAT + "number_highlighted_sections"},
+    _FORMAT + "multiple_sections": {
+        _FORMAT + "multiple_sections",
+        _LANGUAGE + "response_language",
+        _FORMAT + "number_highlighted_sections",
+    },
+    # TODO(tianjianlu): Re-enable rephrasing with preprocessing the message.
+    # _FORMAT + "rephrase": instructions.RephraseChecker,
+    _FORMAT + "json_format": set(INSTRUCTION_DICT.keys()).difference(
+        {_KEYWORD + "forbidden_words", _KEYWORD + "existence"}
+    ),
+    _FORMAT + "title": {_FORMAT + "title"},
+    # TODO(tianjianlu): Re-enable with specific prompts.
+    # _MULTITURN + "constrained_start": instructions.ConstrainedStartChecker,
+    _COMBINATION + "two_responses": set(INSTRUCTION_DICT.keys()).difference(
+        {
+            _KEYWORD + "forbidden_words",
+            _KEYWORD + "existence",
+            _LANGUAGE + "response_language",
+            _FORMAT + "title",
+            _PUNCTUATION + "no_comma",
+        }
+    ),
+    _COMBINATION + "repeat_prompt": set(INSTRUCTION_DICT.keys()).difference(
+        {_KEYWORD + "existence", _FORMAT + "title", _PUNCTUATION + "no_comma"}
+    ),
+    _STARTEND + "end_checker": {_STARTEND + "end_checker"},
+    _CHANGE_CASES + "capital_word_frequency": {
+        _CHANGE_CASES + "capital_word_frequency",
+        _CHANGE_CASES + "english_lowercase",
+        _CHANGE_CASES + "english_capital",
+    },
+    _CHANGE_CASES + "english_capital": {_CHANGE_CASES + "english_capital"},
+    _CHANGE_CASES + "english_lowercase": {
+        _CHANGE_CASES + "english_lowercase",
+        _CHANGE_CASES + "english_capital",
+    },
+    _PUNCTUATION + "no_comma": {_PUNCTUATION + "no_comma"},
+    _STARTEND + "quotation": {_STARTEND + "quotation", _FORMAT + "title"},
+    # --- IFTrain out-of-distribution constraints ---
+    _KEYWORD + "word_once": {_KEYWORD + "word_once"},
+    _KEYWORD + "word_count_diff_numb": {_KEYWORD + "word_count_diff_numb"},
+    _KEYWORD + "exclude_word_harder": {_KEYWORD + "exclude_word_harder"},
+    _KEYWORD + "letter_counting2": {_KEYWORD + "letter_counting2", _KEYWORD + "letter_frequency"},
+    _LENGTH + "paragraphs_two_line_breaks": {
+        _LENGTH + "paragraphs_two_line_breaks",
+        _LENGTH + "number_paragraphs",
+        _LENGTH + "nth_paragraph_first_word",
+        _LENGTH + "counting_composition",
+    },
+    _STARTEND + "first_word_sent": {
+        _STARTEND + "first_word_sent",
+        _STARTEND + "first_word_answer",
+    },
+    _STARTEND + "first_word_answer": {
+        _STARTEND + "first_word_answer",
+        _STARTEND + "first_word_sent",
+    },
+    _STARTEND + "last_word_sent": {
+        _STARTEND + "last_word_sent",
+        _STARTEND + "last_word_answer",
+        _STARTEND + "start_end_same_word",
+    },
+    _STARTEND + "last_word_answer": {
+        _STARTEND + "last_word_answer",
+        _STARTEND + "last_word_sent",
+        _STARTEND + "start_end_same_word",
+    },
+    _FORMAT + "bigram_wrapping": {_FORMAT + "bigram_wrapping"},
+    _COMBINATION + "copying_simple": set(INSTRUCTION_DICT.keys()).difference(
+        {_COMBINATION + "copying_simple"}
+    ),
+    _COMBINATION + "copying_multiple": set(INSTRUCTION_DICT.keys()).difference(
+        {_COMBINATION + "copying_multiple"}
+    ),
+    _PUNCTUATION + "no_dot": {
+        _PUNCTUATION + "no_dot",
+        _LENGTH + "number_sentences",
+        _LENGTH + "counting_composition",
+    },
+    _PUNCTUATION + "no_exclamation": {_PUNCTUATION + "no_exclamation"},
+    _KEYWORD + "lowercase_counting": {_KEYWORD + "lowercase_counting"},
+    _LENGTH + "letter_total_count": {_LENGTH + "letter_total_count"},
+    _LENGTH + "counting_composition": {
+        _LENGTH + "counting_composition",
+        _LENGTH + "number_paragraphs",
+        _LENGTH + "paragraphs_two_line_breaks",
+        _LENGTH + "number_sentences",
+        _PUNCTUATION + "no_dot",
+    },
+    _KEYWORD + "count_unique": {_KEYWORD + "count_unique"},
+    _KEYWORD + "count_increment_word": {_KEYWORD + "count_increment_word"},
+    _KEYWORD + "palindrome": {_KEYWORD + "palindrome"},
+    _KEYWORD + "keyword_specific_pos": {_KEYWORD + "keyword_specific_pos"},
+    _STARTEND + "start_end_same_word": {
+        _STARTEND + "start_end_same_word",
+        _STARTEND + "last_word_sent",
+        _STARTEND + "last_word_answer",
+    },
+    _COMBINATION + "repeat_phrase": {_COMBINATION + "repeat_phrase"},
+    _KEYWORD + "no_adjacent_consecutive": {_KEYWORD + "no_adjacent_consecutive"},
+    _FORMAT + "square_brackets_word": {
+        _FORMAT + "square_brackets_word",
+        _CONTENT + "number_placeholders",
+    },
+    _FORMAT + "sentence_hyphens": {_FORMAT + "sentence_hyphens"},
+    _COMBINATION + "copy_instruction": set(INSTRUCTION_DICT.keys()).difference(
+        {_COMBINATION + "copy_instruction"}
+    ),
+    _COMBINATION + "copy_span_idx": set(INSTRUCTION_DICT.keys()).difference(
+        {_COMBINATION + "copy_span_idx"}
+    ),
+}
+
+
+def conflict_make(conflicts):
+    """Makes sure if A conflicts with B, B will conflict with A.
+
+    Args:
+      conflicts: Dictionary of potential conflicts where key is instruction id
+        and value is set of instruction ids that it conflicts with.
+
+    Returns:
+      Revised version of the dictionary. All instructions conflict with
+      themselves. If A conflicts with B, B will conflict with A.
+    """
+    for key in conflicts:
+        for k in conflicts[key]:
+            conflicts[k].add(key)
+        conflicts[key].add(key)
+    return conflicts

synthgen/PtPersonaIFGen/lmeval_pt/instructions_util.py

@@ -0,0 +1,1701 @@
+# Copyright 2023 The Google Research Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utility library of instructions."""
+
+import functools
+import os
+import random
+import re
+from importlib.metadata import version
+
+import immutabledict
+import nltk
+from packaging.version import parse as parse_version
+
+
+# Downloading 'punkt' with nltk<3.9 has a remote code vuln.
+# see  https://github.com/EleutherAI/lm-evaluation-harness/issues/2210
+# and https://github.com/nltk/nltk/issues/3266
+# for more information.
+NLTK_MIN_VERSION = "3.9.1"
+RANK = os.environ.get("LOCAL_RANK", "0")
+
+
+def download_nltk_resources():
+    """Download 'punkt' if not already installed"""
+    assert (nltk_version := parse_version(version("nltk"))) >= parse_version(
+        NLTK_MIN_VERSION
+    ), (
+        f"`nltk` version {nltk_version} is not >= {NLTK_MIN_VERSION}. Please update `nltk` before proceeding--older versions are vulnerable to a remote code execution vulnerability."
+    )
+
+    try:
+        nltk.data.find("tokenizers/punkt_tab")
+    except LookupError:
+        if RANK == "0":
+            nltk.download("punkt_tab")
+            print("Downloaded punkt_tab on rank 0")
+
+
+download_nltk_resources()
+
+WORD_LIST = [
+    "western",
+    "sentence",
+    "signal",
+    "dump",
+    "spot",
+    "opposite",
+    "bottom",
+    "potato",
+    "administration",
+    "working",
+    "welcome",
+    "morning",
+    "good",
+    "agency",
+    "primary",
+    "wish",
+    "responsibility",
+    "press",
+    "problem",
+    "president",
+    "steal",
+    "brush",
+    "read",
+    "type",
+    "beat",
+    "trainer",
+    "growth",
+    "lock",
+    "bone",
+    "case",
+    "equal",
+    "comfortable",
+    "region",
+    "replacement",
+    "performance",
+    "mate",
+    "walk",
+    "medicine",
+    "film",
+    "thing",
+    "rock",
+    "tap",
+    "total",
+    "competition",
+    "ease",
+    "south",
+    "establishment",
+    "gather",
+    "parking",
+    "world",
+    "plenty",
+    "breath",
+    "claim",
+    "alcohol",
+    "trade",
+    "dear",
+    "highlight",
+    "street",
+    "matter",
+    "decision",
+    "mess",
+    "agreement",
+    "studio",
+    "coach",
+    "assist",
+    "brain",
+    "wing",
+    "style",
+    "private",
+    "top",
+    "brown",
+    "leg",
+    "buy",
+    "procedure",
+    "method",
+    "speed",
+    "high",
+    "company",
+    "valuable",
+    "pie",
+    "analyst",
+    "session",
+    "pattern",
+    "district",
+    "pleasure",
+    "dinner",
+    "swimming",
+    "joke",
+    "order",
+    "plate",
+    "department",
+    "motor",
+    "cell",
+    "spend",
+    "cabinet",
+    "difference",
+    "power",
+    "examination",
+    "engine",
+    "horse",
+    "dimension",
+    "pay",
+    "toe",
+    "curve",
+    "literature",
+    "bother",
+    "fire",
+    "possibility",
+    "debate",
+    "activity",
+    "passage",
+    "hello",
+    "cycle",
+    "background",
+    "quiet",
+    "author",
+    "effect",
+    "actor",
+    "page",
+    "bicycle",
+    "error",
+    "throat",
+    "attack",
+    "character",
+    "phone",
+    "tea",
+    "increase",
+    "outcome",
+    "file",
+    "specific",
+    "inspector",
+    "internal",
+    "potential",
+    "staff",
+    "building",
+    "employer",
+    "shoe",
+    "hand",
+    "direction",
+    "garden",
+    "purchase",
+    "interview",
+    "study",
+    "recognition",
+    "member",
+    "spiritual",
+    "oven",
+    "sandwich",
+    "weird",
+    "passenger",
+    "particular",
+    "response",
+    "reaction",
+    "size",
+    "variation",
+    "a",
+    "cancel",
+    "candy",
+    "exit",
+    "guest",
+    "condition",
+    "fly",
+    "price",
+    "weakness",
+    "convert",
+    "hotel",
+    "great",
+    "mouth",
+    "mind",
+    "song",
+    "sugar",
+    "suspect",
+    "telephone",
+    "ear",
+    "roof",
+    "paint",
+    "refrigerator",
+    "organization",
+    "jury",
+    "reward",
+    "engineering",
+    "day",
+    "possession",
+    "crew",
+    "bar",
+    "road",
+    "description",
+    "celebration",
+    "score",
+    "mark",
+    "letter",
+    "shower",
+    "suggestion",
+    "sir",
+    "luck",
+    "national",
+    "progress",
+    "hall",
+    "stroke",
+    "theory",
+    "offer",
+    "story",
+    "tax",
+    "definition",
+    "history",
+    "ride",
+    "medium",
+    "opening",
+    "glass",
+    "elevator",
+    "stomach",
+    "question",
+    "ability",
+    "leading",
+    "village",
+    "computer",
+    "city",
+    "grand",
+    "confidence",
+    "candle",
+    "priest",
+    "recommendation",
+    "point",
+    "necessary",
+    "body",
+    "desk",
+    "secret",
+    "horror",
+    "noise",
+    "culture",
+    "warning",
+    "water",
+    "round",
+    "diet",
+    "flower",
+    "bus",
+    "tough",
+    "permission",
+    "week",
+    "prompt",
+    "connection",
+    "abuse",
+    "height",
+    "save",
+    "corner",
+    "border",
+    "stress",
+    "drive",
+    "stop",
+    "rip",
+    "meal",
+    "listen",
+    "confusion",
+    "girlfriend",
+    "living",
+    "relation",
+    "significance",
+    "plan",
+    "creative",
+    "atmosphere",
+    "blame",
+    "invite",
+    "housing",
+    "paper",
+    "drink",
+    "roll",
+    "silver",
+    "drunk",
+    "age",
+    "damage",
+    "smoke",
+    "environment",
+    "pack",
+    "savings",
+    "influence",
+    "tourist",
+    "rain",
+    "post",
+    "sign",
+    "grandmother",
+    "run",
+    "profit",
+    "push",
+    "clerk",
+    "final",
+    "wine",
+    "swim",
+    "pause",
+    "stuff",
+    "singer",
+    "funeral",
+    "average",
+    "source",
+    "scene",
+    "tradition",
+    "personal",
+    "snow",
+    "nobody",
+    "distance",
+    "sort",
+    "sensitive",
+    "animal",
+    "major",
+    "negotiation",
+    "click",
+    "mood",
+    "period",
+    "arrival",
+    "expression",
+    "holiday",
+    "repeat",
+    "dust",
+    "closet",
+    "gold",
+    "bad",
+    "sail",
+    "combination",
+    "clothes",
+    "emphasis",
+    "duty",
+    "black",
+    "step",
+    "school",
+    "jump",
+    "document",
+    "professional",
+    "lip",
+    "chemical",
+    "front",
+    "wake",
+    "while",
+    "inside",
+    "watch",
+    "row",
+    "subject",
+    "penalty",
+    "balance",
+    "possible",
+    "adult",
+    "aside",
+    "sample",
+    "appeal",
+    "wedding",
+    "depth",
+    "king",
+    "award",
+    "wife",
+    "blow",
+    "site",
+    "camp",
+    "music",
+    "safe",
+    "gift",
+    "fault",
+    "guess",
+    "act",
+    "shame",
+    "drama",
+    "capital",
+    "exam",
+    "stupid",
+    "record",
+    "sound",
+    "swing",
+    "novel",
+    "minimum",
+    "ratio",
+    "machine",
+    "shape",
+    "lead",
+    "operation",
+    "salary",
+    "cloud",
+    "affair",
+    "hit",
+    "chapter",
+    "stage",
+    "quantity",
+    "access",
+    "army",
+    "chain",
+    "traffic",
+    "kick",
+    "analysis",
+    "airport",
+    "time",
+    "vacation",
+    "philosophy",
+    "ball",
+    "chest",
+    "thanks",
+    "place",
+    "mountain",
+    "advertising",
+    "red",
+    "past",
+    "rent",
+    "return",
+    "tour",
+    "house",
+    "construction",
+    "net",
+    "native",
+    "war",
+    "figure",
+    "fee",
+    "spray",
+    "user",
+    "dirt",
+    "shot",
+    "task",
+    "stick",
+    "friend",
+    "software",
+    "promotion",
+    "interaction",
+    "surround",
+    "block",
+    "purpose",
+    "practice",
+    "conflict",
+    "routine",
+    "requirement",
+    "bonus",
+    "hole",
+    "state",
+    "junior",
+    "sweet",
+    "catch",
+    "tear",
+    "fold",
+    "wall",
+    "editor",
+    "life",
+    "position",
+    "pound",
+    "respect",
+    "bathroom",
+    "coat",
+    "script",
+    "job",
+    "teach",
+    "birth",
+    "view",
+    "resolve",
+    "theme",
+    "employee",
+    "doubt",
+    "market",
+    "education",
+    "serve",
+    "recover",
+    "tone",
+    "harm",
+    "miss",
+    "union",
+    "understanding",
+    "cow",
+    "river",
+    "association",
+    "concept",
+    "training",
+    "recipe",
+    "relationship",
+    "reserve",
+    "depression",
+    "proof",
+    "hair",
+    "revenue",
+    "independent",
+    "lift",
+    "assignment",
+    "temporary",
+    "amount",
+    "loss",
+    "edge",
+    "track",
+    "check",
+    "rope",
+    "estimate",
+    "pollution",
+    "stable",
+    "message",
+    "delivery",
+    "perspective",
+    "mirror",
+    "assistant",
+    "representative",
+    "witness",
+    "nature",
+    "judge",
+    "fruit",
+    "tip",
+    "devil",
+    "town",
+    "emergency",
+    "upper",
+    "drop",
+    "stay",
+    "human",
+    "neck",
+    "speaker",
+    "network",
+    "sing",
+    "resist",
+    "league",
+    "trip",
+    "signature",
+    "lawyer",
+    "importance",
+    "gas",
+    "choice",
+    "engineer",
+    "success",
+    "part",
+    "external",
+    "worker",
+    "simple",
+    "quarter",
+    "student",
+    "heart",
+    "pass",
+    "spite",
+    "shift",
+    "rough",
+    "lady",
+    "grass",
+    "community",
+    "garage",
+    "youth",
+    "standard",
+    "skirt",
+    "promise",
+    "blind",
+    "television",
+    "disease",
+    "commission",
+    "positive",
+    "energy",
+    "calm",
+    "presence",
+    "tune",
+    "basis",
+    "preference",
+    "head",
+    "common",
+    "cut",
+    "somewhere",
+    "presentation",
+    "current",
+    "thought",
+    "revolution",
+    "effort",
+    "master",
+    "implement",
+    "republic",
+    "floor",
+    "principle",
+    "stranger",
+    "shoulder",
+    "grade",
+    "button",
+    "tennis",
+    "police",
+    "collection",
+    "account",
+    "register",
+    "glove",
+    "divide",
+    "professor",
+    "chair",
+    "priority",
+    "combine",
+    "peace",
+    "extension",
+    "maybe",
+    "evening",
+    "frame",
+    "sister",
+    "wave",
+    "code",
+    "application",
+    "mouse",
+    "match",
+    "counter",
+    "bottle",
+    "half",
+    "cheek",
+    "resolution",
+    "back",
+    "knowledge",
+    "make",
+    "discussion",
+    "screw",
+    "length",
+    "accident",
+    "battle",
+    "dress",
+    "knee",
+    "log",
+    "package",
+    "it",
+    "turn",
+    "hearing",
+    "newspaper",
+    "layer",
+    "wealth",
+    "profile",
+    "imagination",
+    "answer",
+    "weekend",
+    "teacher",
+    "appearance",
+    "meet",
+    "bike",
+    "rise",
+    "belt",
+    "crash",
+    "bowl",
+    "equivalent",
+    "support",
+    "image",
+    "poem",
+    "risk",
+    "excitement",
+    "remote",
+    "secretary",
+    "public",
+    "produce",
+    "plane",
+    "display",
+    "money",
+    "sand",
+    "situation",
+    "punch",
+    "customer",
+    "title",
+    "shake",
+    "mortgage",
+    "option",
+    "number",
+    "pop",
+    "window",
+    "extent",
+    "nothing",
+    "experience",
+    "opinion",
+    "departure",
+    "dance",
+    "indication",
+    "boy",
+    "material",
+    "band",
+    "leader",
+    "sun",
+    "beautiful",
+    "muscle",
+    "farmer",
+    "variety",
+    "fat",
+    "handle",
+    "director",
+    "opportunity",
+    "calendar",
+    "outside",
+    "pace",
+    "bath",
+    "fish",
+    "consequence",
+    "put",
+    "owner",
+    "go",
+    "doctor",
+    "information",
+    "share",
+    "hurt",
+    "protection",
+    "career",
+    "finance",
+    "force",
+    "golf",
+    "garbage",
+    "aspect",
+    "kid",
+    "food",
+    "boot",
+    "milk",
+    "respond",
+    "objective",
+    "reality",
+    "raw",
+    "ring",
+    "mall",
+    "one",
+    "impact",
+    "area",
+    "news",
+    "international",
+    "series",
+    "impress",
+    "mother",
+    "shelter",
+    "strike",
+    "loan",
+    "month",
+    "seat",
+    "anything",
+    "entertainment",
+    "familiar",
+    "clue",
+    "year",
+    "glad",
+    "supermarket",
+    "natural",
+    "god",
+    "cost",
+    "conversation",
+    "tie",
+    "ruin",
+    "comfort",
+    "earth",
+    "storm",
+    "percentage",
+    "assistance",
+    "budget",
+    "strength",
+    "beginning",
+    "sleep",
+    "other",
+    "young",
+    "unit",
+    "fill",
+    "store",
+    "desire",
+    "hide",
+    "value",
+    "cup",
+    "maintenance",
+    "nurse",
+    "function",
+    "tower",
+    "role",
+    "class",
+    "camera",
+    "database",
+    "panic",
+    "nation",
+    "basket",
+    "ice",
+    "art",
+    "spirit",
+    "chart",
+    "exchange",
+    "feedback",
+    "statement",
+    "reputation",
+    "search",
+    "hunt",
+    "exercise",
+    "nasty",
+    "notice",
+    "male",
+    "yard",
+    "annual",
+    "collar",
+    "date",
+    "platform",
+    "plant",
+    "fortune",
+    "passion",
+    "friendship",
+    "spread",
+    "cancer",
+    "ticket",
+    "attitude",
+    "island",
+    "active",
+    "object",
+    "service",
+    "buyer",
+    "bite",
+    "card",
+    "face",
+    "steak",
+    "proposal",
+    "patient",
+    "heat",
+    "rule",
+    "resident",
+    "broad",
+    "politics",
+    "west",
+    "knife",
+    "expert",
+    "girl",
+    "design",
+    "salt",
+    "baseball",
+    "grab",
+    "inspection",
+    "cousin",
+    "couple",
+    "magazine",
+    "cook",
+    "dependent",
+    "security",
+    "chicken",
+    "version",
+    "currency",
+    "ladder",
+    "scheme",
+    "kitchen",
+    "employment",
+    "local",
+    "attention",
+    "manager",
+    "fact",
+    "cover",
+    "sad",
+    "guard",
+    "relative",
+    "county",
+    "rate",
+    "lunch",
+    "program",
+    "initiative",
+    "gear",
+    "bridge",
+    "breast",
+    "talk",
+    "dish",
+    "guarantee",
+    "beer",
+    "vehicle",
+    "reception",
+    "woman",
+    "substance",
+    "copy",
+    "lecture",
+    "advantage",
+    "park",
+    "cold",
+    "death",
+    "mix",
+    "hold",
+    "scale",
+    "tomorrow",
+    "blood",
+    "request",
+    "green",
+    "cookie",
+    "church",
+    "strip",
+    "forever",
+    "beyond",
+    "debt",
+    "tackle",
+    "wash",
+    "following",
+    "feel",
+    "maximum",
+    "sector",
+    "sea",
+    "property",
+    "economics",
+    "menu",
+    "bench",
+    "try",
+    "language",
+    "start",
+    "call",
+    "solid",
+    "address",
+    "income",
+    "foot",
+    "senior",
+    "honey",
+    "few",
+    "mixture",
+    "cash",
+    "grocery",
+    "link",
+    "map",
+    "form",
+    "factor",
+    "pot",
+    "model",
+    "writer",
+    "farm",
+    "winter",
+    "skill",
+    "anywhere",
+    "birthday",
+    "policy",
+    "release",
+    "husband",
+    "lab",
+    "hurry",
+    "mail",
+    "equipment",
+    "sink",
+    "pair",
+    "driver",
+    "consideration",
+    "leather",
+    "skin",
+    "blue",
+    "boat",
+    "sale",
+    "brick",
+    "two",
+    "feed",
+    "square",
+    "dot",
+    "rush",
+    "dream",
+    "location",
+    "afternoon",
+    "manufacturer",
+    "control",
+    "occasion",
+    "trouble",
+    "introduction",
+    "advice",
+    "bet",
+    "eat",
+    "kill",
+    "category",
+    "manner",
+    "office",
+    "estate",
+    "pride",
+    "awareness",
+    "slip",
+    "crack",
+    "client",
+    "nail",
+    "shoot",
+    "membership",
+    "soft",
+    "anybody",
+    "web",
+    "official",
+    "individual",
+    "pizza",
+    "interest",
+    "bag",
+    "spell",
+    "profession",
+    "queen",
+    "deal",
+    "resource",
+    "ship",
+    "guy",
+    "chocolate",
+    "joint",
+    "formal",
+    "upstairs",
+    "car",
+    "resort",
+    "abroad",
+    "dealer",
+    "associate",
+    "finger",
+    "surgery",
+    "comment",
+    "team",
+    "detail",
+    "crazy",
+    "path",
+    "tale",
+    "initial",
+    "arm",
+    "radio",
+    "demand",
+    "single",
+    "draw",
+    "yellow",
+    "contest",
+    "piece",
+    "quote",
+    "pull",
+    "commercial",
+    "shirt",
+    "contribution",
+    "cream",
+    "channel",
+    "suit",
+    "discipline",
+    "instruction",
+    "concert",
+    "speech",
+    "low",
+    "effective",
+    "hang",
+    "scratch",
+    "industry",
+    "breakfast",
+    "lay",
+    "join",
+    "metal",
+    "bedroom",
+    "minute",
+    "product",
+    "rest",
+    "temperature",
+    "many",
+    "give",
+    "argument",
+    "print",
+    "purple",
+    "laugh",
+    "health",
+    "credit",
+    "investment",
+    "sell",
+    "setting",
+    "lesson",
+    "egg",
+    "middle",
+    "marriage",
+    "level",
+    "evidence",
+    "phrase",
+    "love",
+    "self",
+    "benefit",
+    "guidance",
+    "affect",
+    "you",
+    "dad",
+    "anxiety",
+    "special",
+    "boyfriend",
+    "test",
+    "blank",
+    "payment",
+    "soup",
+    "obligation",
+    "reply",
+    "smile",
+    "deep",
+    "complaint",
+    "addition",
+    "review",
+    "box",
+    "towel",
+    "minor",
+    "fun",
+    "soil",
+    "issue",
+    "cigarette",
+    "internet",
+    "gain",
+    "tell",
+    "entry",
+    "spare",
+    "incident",
+    "family",
+    "refuse",
+    "branch",
+    "can",
+    "pen",
+    "grandfather",
+    "constant",
+    "tank",
+    "uncle",
+    "climate",
+    "ground",
+    "volume",
+    "communication",
+    "kind",
+    "poet",
+    "child",
+    "screen",
+    "mine",
+    "quit",
+    "gene",
+    "lack",
+    "charity",
+    "memory",
+    "tooth",
+    "fear",
+    "mention",
+    "marketing",
+    "reveal",
+    "reason",
+    "court",
+    "season",
+    "freedom",
+    "land",
+    "sport",
+    "audience",
+    "classroom",
+    "law",
+    "hook",
+    "win",
+    "carry",
+    "eye",
+    "smell",
+    "distribution",
+    "research",
+    "country",
+    "dare",
+    "hope",
+    "whereas",
+    "stretch",
+    "library",
+    "if",
+    "delay",
+    "college",
+    "plastic",
+    "book",
+    "present",
+    "use",
+    "worry",
+    "champion",
+    "goal",
+    "economy",
+    "march",
+    "election",
+    "reflection",
+    "midnight",
+    "slide",
+    "inflation",
+    "action",
+    "challenge",
+    "guitar",
+    "coast",
+    "apple",
+    "campaign",
+    "field",
+    "jacket",
+    "sense",
+    "way",
+    "visual",
+    "remove",
+    "weather",
+    "trash",
+    "cable",
+    "regret",
+    "buddy",
+    "beach",
+    "historian",
+    "courage",
+    "sympathy",
+    "truck",
+    "tension",
+    "permit",
+    "nose",
+    "bed",
+    "son",
+    "person",
+    "base",
+    "meat",
+    "usual",
+    "air",
+    "meeting",
+    "worth",
+    "game",
+    "independence",
+    "physical",
+    "brief",
+    "play",
+    "raise",
+    "board",
+    "she",
+    "key",
+    "writing",
+    "pick",
+    "command",
+    "party",
+    "yesterday",
+    "spring",
+    "candidate",
+    "physics",
+    "university",
+    "concern",
+    "development",
+    "change",
+    "string",
+    "target",
+    "instance",
+    "room",
+    "bitter",
+    "bird",
+    "football",
+    "normal",
+    "split",
+    "impression",
+    "wood",
+    "long",
+    "meaning",
+    "stock",
+    "cap",
+    "leadership",
+    "media",
+    "ambition",
+    "fishing",
+    "essay",
+    "salad",
+    "repair",
+    "today",
+    "designer",
+    "night",
+    "bank",
+    "drawing",
+    "inevitable",
+    "phase",
+    "vast",
+    "chip",
+    "anger",
+    "switch",
+    "cry",
+    "twist",
+    "personality",
+    "attempt",
+    "storage",
+    "being",
+    "preparation",
+    "bat",
+    "selection",
+    "white",
+    "technology",
+    "contract",
+    "side",
+    "section",
+    "station",
+    "till",
+    "structure",
+    "tongue",
+    "taste",
+    "truth",
+    "difficulty",
+    "group",
+    "limit",
+    "main",
+    "move",
+    "feeling",
+    "light",
+    "example",
+    "mission",
+    "might",
+    "wait",
+    "wheel",
+    "shop",
+    "host",
+    "classic",
+    "alternative",
+    "cause",
+    "agent",
+    "consist",
+    "table",
+    "airline",
+    "text",
+    "pool",
+    "craft",
+    "range",
+    "fuel",
+    "tool",
+    "partner",
+    "load",
+    "entrance",
+    "deposit",
+    "hate",
+    "article",
+    "video",
+    "summer",
+    "feature",
+    "extreme",
+    "mobile",
+    "hospital",
+    "flight",
+    "fall",
+    "pension",
+    "piano",
+    "fail",
+    "result",
+    "rub",
+    "gap",
+    "system",
+    "report",
+    "suck",
+    "ordinary",
+    "wind",
+    "nerve",
+    "ask",
+    "shine",
+    "note",
+    "line",
+    "mom",
+    "perception",
+    "brother",
+    "reference",
+    "bend",
+    "charge",
+    "treat",
+    "trick",
+    "term",
+    "homework",
+    "bake",
+    "bid",
+    "status",
+    "project",
+    "strategy",
+    "orange",
+    "let",
+    "enthusiasm",
+    "parent",
+    "concentrate",
+    "device",
+    "travel",
+    "poetry",
+    "business",
+    "society",
+    "kiss",
+    "end",
+    "vegetable",
+    "employ",
+    "schedule",
+    "hour",
+    "brave",
+    "focus",
+    "process",
+    "movie",
+    "illegal",
+    "general",
+    "coffee",
+    "ad",
+    "highway",
+    "chemistry",
+    "psychology",
+    "hire",
+    "bell",
+    "conference",
+    "relief",
+    "show",
+    "neat",
+    "funny",
+    "weight",
+    "quality",
+    "club",
+    "daughter",
+    "zone",
+    "touch",
+    "tonight",
+    "shock",
+    "burn",
+    "excuse",
+    "name",
+    "survey",
+    "landscape",
+    "advance",
+    "satisfaction",
+    "bread",
+    "disaster",
+    "item",
+    "hat",
+    "prior",
+    "shopping",
+    "visit",
+    "east",
+    "photo",
+    "home",
+    "idea",
+    "father",
+    "comparison",
+    "cat",
+    "pipe",
+    "winner",
+    "count",
+    "lake",
+    "fight",
+    "prize",
+    "foundation",
+    "dog",
+    "keep",
+    "ideal",
+    "fan",
+    "struggle",
+    "peak",
+    "safety",
+    "solution",
+    "hell",
+    "conclusion",
+    "population",
+    "strain",
+    "alarm",
+    "measurement",
+    "second",
+    "train",
+    "race",
+    "due",
+    "insurance",
+    "boss",
+    "tree",
+    "monitor",
+    "sick",
+    "course",
+    "drag",
+    "appointment",
+    "slice",
+    "still",
+    "care",
+    "patience",
+    "rich",
+    "escape",
+    "emotion",
+    "royal",
+    "female",
+    "childhood",
+    "government",
+    "picture",
+    "will",
+    "sock",
+    "big",
+    "gate",
+    "oil",
+    "cross",
+    "pin",
+    "improvement",
+    "championship",
+    "silly",
+    "help",
+    "sky",
+    "pitch",
+    "man",
+    "diamond",
+    "most",
+    "transition",
+    "work",
+    "science",
+    "committee",
+    "moment",
+    "fix",
+    "teaching",
+    "dig",
+    "specialist",
+    "complex",
+    "guide",
+    "people",
+    "dead",
+    "voice",
+    "original",
+    "break",
+    "topic",
+    "data",
+    "degree",
+    "reading",
+    "recording",
+    "bunch",
+    "reach",
+    "judgment",
+    "lie",
+    "regular",
+    "set",
+    "painting",
+    "mode",
+    "list",
+    "player",
+    "bear",
+    "north",
+    "wonder",
+    "carpet",
+    "heavy",
+    "officer",
+    "negative",
+    "clock",
+    "unique",
+    "baby",
+    "pain",
+    "assumption",
+    "disk",
+    "iron",
+    "bill",
+    "drawer",
+    "look",
+    "double",
+    "mistake",
+    "finish",
+    "future",
+    "brilliant",
+    "contact",
+    "math",
+    "rice",
+    "leave",
+    "restaurant",
+    "discount",
+    "sex",
+    "virus",
+    "bit",
+    "trust",
+    "event",
+    "wear",
+    "juice",
+    "failure",
+    "bug",
+    "context",
+    "mud",
+    "whole",
+    "wrap",
+    "intention",
+    "draft",
+    "pressure",
+    "cake",
+    "dark",
+    "explanation",
+    "space",
+    "angle",
+    "word",
+    "efficiency",
+    "management",
+    "habit",
+    "star",
+    "chance",
+    "finding",
+    "transportation",
+    "stand",
+    "criticism",
+    "flow",
+    "door",
+    "injury",
+    "insect",
+    "surprise",
+    "apartment",
+]  # pylint: disable=line-too-long
+
+# ISO 639-1 codes to language names.
+LANGUAGE_CODES = immutabledict.immutabledict(
+    {
+        "en": "English",
+        "es": "Spanish",
+        "pt": "Portuguese",
+        "ar": "Arabic",
+        "hi": "Hindi",
+        "fr": "French",
+        "ru": "Russian",
+        "de": "German",
+        "ja": "Japanese",
+        "it": "Italian",
+        "bn": "Bengali",
+        "uk": "Ukrainian",
+        "th": "Thai",
+        "ur": "Urdu",
+        "ta": "Tamil",
+        "te": "Telugu",
+        "bg": "Bulgarian",
+        "ko": "Korean",
+        "pl": "Polish",
+        "he": "Hebrew",
+        "fa": "Persian",
+        "vi": "Vietnamese",
+        "ne": "Nepali",
+        "sw": "Swahili",
+        "kn": "Kannada",
+        "mr": "Marathi",
+        "gu": "Gujarati",
+        "pa": "Punjabi",
+        "ml": "Malayalam",
+        "fi": "Finnish",
+    }
+)
+
+_ALPHABETS = "([A-Za-z])"
+_PREFIXES = "(Mr|St|Mrs|Ms|Dr)[.]"
+_SUFFIXES = "(Inc|Ltd|Jr|Sr|Co)"
+_STARTERS = r"(Mr|Mrs|Ms|Dr|Prof|Capt|Cpt|Lt|He\s|She\s|It\s|They\s|Their\s|Our\s|We\s|But\s|However\s|That\s|This\s|Wherever)"
+_ACRONYMS = "([A-Z][.][A-Z][.](?:[A-Z][.])?)"
+_WEBSITES = "[.](com|net|org|io|gov|edu|me)"
+_DIGITS = "([0-9])"
+_MULTIPLE_DOTS = r"\.{2,}"
+
+
+def split_into_sentences(text):
+    """Split the text into sentences.
+
+    Args:
+      text: A string that consists of more than or equal to one sentences.
+
+    Returns:
+      A list of strings where each string is a sentence.
+    """
+    text = " " + text + "  "
+    text = text.replace("\n", " ")
+    text = re.sub(_PREFIXES, "\\1<prd>", text)
+    text = re.sub(_WEBSITES, "<prd>\\1", text)
+    text = re.sub(_DIGITS + "[.]" + _DIGITS, "\\1<prd>\\2", text)
+    text = re.sub(
+        _MULTIPLE_DOTS,
+        lambda match: "<prd>" * len(match.group(0)) + "<stop>",
+        text,
+    )
+    if "Ph.D" in text:
+        text = text.replace("Ph.D.", "Ph<prd>D<prd>")
+    text = re.sub(r"\s" + _ALPHABETS + "[.] ", " \\1<prd> ", text)
+    text = re.sub(_ACRONYMS + " " + _STARTERS, "\\1<stop> \\2", text)
+    text = re.sub(
+        _ALPHABETS + "[.]" + _ALPHABETS + "[.]" + _ALPHABETS + "[.]",
+        "\\1<prd>\\2<prd>\\3<prd>",
+        text,
+    )
+    text = re.sub(_ALPHABETS + "[.]" + _ALPHABETS + "[.]", "\\1<prd>\\2<prd>", text)
+    text = re.sub(" " + _SUFFIXES + "[.] " + _STARTERS, " \\1<stop> \\2", text)
+    text = re.sub(" " + _SUFFIXES + "[.]", " \\1<prd>", text)
+    text = re.sub(" " + _ALPHABETS + "[.]", " \\1<prd>", text)
+    if "”" in text:
+        text = text.replace(".”", "”.")
+    if '"' in text:
+        text = text.replace('."', '".')
+    if "!" in text:
+        text = text.replace('!"', '"!')
+    if "?" in text:
+        text = text.replace('?"', '"?')
+    text = text.replace(".", ".<stop>")
+    text = text.replace("?", "?<stop>")
+    text = text.replace("!", "!<stop>")
+    text = text.replace("<prd>", ".")
+    sentences = text.split("<stop>")
+    sentences = [s.strip() for s in sentences]
+    if sentences and not sentences[-1]:
+        sentences = sentences[:-1]
+    return sentences
+
+
+def count_words(text):
+    """Counts the number of words."""
+    tokenizer = nltk.tokenize.RegexpTokenizer(r"\w+")
+    tokens = tokenizer.tokenize(text)
+    num_words = len(tokens)
+    return num_words
+
+
+@functools.lru_cache(maxsize=None)
+def _get_sentence_tokenizer():
+    return nltk.data.load("nltk:tokenizers/punkt/english.pickle")
+
+
+def count_sentences(text):
+    """Count the number of sentences."""
+    tokenizer = _get_sentence_tokenizer()
+    tokenized_sentences = tokenizer.tokenize(text)
+    return len(tokenized_sentences)
+
+
+def generate_keywords(num_keywords):
+    """Randomly generates a few keywords."""
+    return random.sample(WORD_LIST, k=num_keywords)

synthgen/PtPersonaIFGen/lmeval_pt/utils.py

@@ -0,0 +1,134 @@
+import dataclasses
+from typing import Dict, Optional, Union
+
+from lmeval_pt import instructions_registry
+
+
+@dataclasses.dataclass
+class InputExample:
+    key: int
+    instruction_id_list: list[str]
+    prompt: str
+    kwargs: list[Dict[str, Optional[Union[str, int]]]]
+
+
+@dataclasses.dataclass
+class OutputExample:
+    instruction_id_list: list[str]
+    prompt: str
+    response: str
+    follow_all_instructions: bool
+    follow_instruction_list: list[bool]
+
+
+def test_instruction_following_strict(
+    inp,
+    response,
+):
+    """Tests response to see if instructions are followed."""
+    instruction_list = inp.instruction_id_list
+    is_following_list = []
+
+    for index, instruction_id in enumerate(instruction_list):
+        instruction_cls = instructions_registry.INSTRUCTION_DICT[instruction_id]
+        instruction = instruction_cls(instruction_id)
+
+        # Remove None values from kwargs to avoid unexpected keyword argument errors in build_description method.
+        kwargs = {k: v for k, v in inp.kwargs[index].items() if v}
+        instruction.build_description(**kwargs)
+        args = instruction.get_instruction_args()
+        if args and "prompt" in args:
+            instruction.build_description(prompt=inp.prompt)
+
+        if response.strip() and instruction.check_following(response):
+            is_following_list.append(True)
+        else:
+            is_following_list.append(False)
+
+    return OutputExample(
+        instruction_id_list=inp.instruction_id_list,
+        prompt=inp.prompt,
+        response=response,
+        follow_all_instructions=all(is_following_list),
+        follow_instruction_list=is_following_list,
+    )
+
+
+def test_instruction_following_loose(
+    inp,
+    response,
+):
+    """Tests response for an upper bound for following instructions."""
+    r = response.split("\n")
+    response_remove_first = "\n".join(r[1:]).strip()
+    response_remove_last = "\n".join(r[:-1]).strip()
+    response_remove_both = "\n".join(r[1:-1]).strip()
+    revised_response = response.replace("*", "")
+    revised_response_remove_first = response_remove_first.replace("*", "")
+    revised_response_remove_last = response_remove_last.replace("*", "")
+    revised_response_remove_both = response_remove_both.replace("*", "")
+    all_responses = [
+        response,
+        revised_response,
+        response_remove_first,
+        response_remove_last,
+        response_remove_both,
+        revised_response_remove_first,
+        revised_response_remove_last,
+        revised_response_remove_both,
+    ]
+    instruction_list = inp.instruction_id_list
+    is_following_list = []
+
+    for index, instruction_id in enumerate(instruction_list):
+        instruction_cls = instructions_registry.INSTRUCTION_DICT[instruction_id]
+        instruction = instruction_cls(instruction_id)
+
+        # Remove None values from kwargs to avoid unexpected keyword argument errors in build_description method.
+        kwargs = {k: v for k, v in inp.kwargs[index].items() if v}
+        instruction.build_description(**kwargs)
+        args = instruction.get_instruction_args()
+        if args and "prompt" in args:
+            instruction.build_description(prompt=inp.prompt)
+
+        is_following = False
+        for r in all_responses:
+            if r.strip() and instruction.check_following(r):
+                is_following = True
+                break
+
+        is_following_list.append(is_following)
+
+    return OutputExample(
+        instruction_id_list=inp.instruction_id_list,
+        prompt=inp.prompt,
+        response=response,
+        follow_all_instructions=all(is_following_list),
+        follow_instruction_list=is_following_list,
+    )
+
+
+def process_results(doc, results):
+    inp = InputExample(
+        key=doc["key"],
+        instruction_id_list=doc["instruction_id_list"],
+        prompt=doc["prompt"],
+        kwargs=doc["kwargs"],
+    )
+    response = results[0]
+
+    out_strict = test_instruction_following_strict(inp, response)
+    out_loose = test_instruction_following_loose(inp, response)
+
+    return {
+        "prompt_level_strict_acc": out_strict.follow_all_instructions,
+        "inst_level_strict_acc": out_strict.follow_instruction_list,
+        "prompt_level_loose_acc": out_loose.follow_all_instructions,
+        "inst_level_loose_acc": out_loose.follow_instruction_list,
+    }
+
+
+def agg_inst_level_acc(items):
+    flat_items = [item for sublist in items for item in sublist]
+    inst_level_acc = sum(flat_items) / len(flat_items)
+    return inst_level_acc

synthgen/PtPersonaIFGen/main_ifeval_code/__init__.py

@@ -0,0 +1,2 @@
+# vLLM Pipeline for IFEval-like Data Generation
+# Replication of distilabel pipeline using vLLM's OpenAI-compatible API

synthgen/PtPersonaIFGen/main_ifeval_code/config.py

@@ -0,0 +1,99 @@
+"""
+Configuração compartilhada e constantes para o pipeline vLLM.
+Referencia pipeline/system_prompts_pt.py e pipeline/json_schemas_pt.py
+"""
+
+import os
+
+from main_ifeval_code.system_prompts_pt import (
+    IFEVAL_SYSTEM_PROMPT,
+    IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT,
+    IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT,
+)
+from main_ifeval_code.json_schemas_pt import (
+    IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA,
+    IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA,
+)
+
+# -----------------------------------------------------------------------
+# CONFIGURAÇÃO DO SERVIDOR VLLM
+# -----------------------------------------------------------------------
+VLLM_BASE_URL = os.environ.get("VLLM_BASE_URL", "http://localhost:8021/v1")
+VLLM_API_KEY = os.environ.get("VLLM_API_KEY", "no-key-needed")
+
+# -----------------------------------------------------------------------
+# CONFIGURAÇÃO DA FONTE DE PERSONAS
+# -----------------------------------------------------------------------
+# Dataset de personas (Persona Hub - Chan et al., 2024)
+PERSONA_DATASET_ID = os.environ.get("PERSONA_DATASET_ID", "proj-persona/PersonaHub")
+PERSONA_DATASET_SUBSET = os.environ.get("PERSONA_DATASET_SUBSET", "persona")
+# PERSONA_DATASET_ID = os.environ.get("PERSONA_DATASET_ID", "nvidia/Nemotron-Personas-Brazil")
+# PERSONA_DATASET_SUBSET = os.environ.get("PERSONA_DATASET_SUBSET", "default")
+PERSONA_TEXT_FIELD = os.environ.get("PERSONA_TEXT_FIELD", "persona")
+# -----------------------------------------------------------------------
+# PARÂMETROS DE GERAÇÃO (de pipeline/pipeline.py)
+# -----------------------------------------------------------------------
+
+# Fase 1: Geração em duas etapas
+PHASE1_INSTRUCTION_TEMPERATURE = 1.2  # Maior para instruções diversas
+PHASE1_RESPONSE_TEMPERATURE = 0.7     # Menor para respostas precisas
+PHASE1_TOP_P = 0.8
+PHASE1_MAX_TOKENS_INSTRUCTION = 2048   # Instruções do usuário são mais curtas
+PHASE1_MAX_TOKENS_RESPONSE = 2048     # Respostas podem ser mais longas
+
+# Fase 2: Detecção de restrições (linhas 207-209 de pipeline.py)
+PHASE2_TEMPERATURE = 0.2
+PHASE2_MAX_TOKENS = 1024
+
+# Fase 3: Extração de parâmetros (linhas 229-231 de pipeline.py)
+PHASE3_TEMPERATURE = 0.2
+PHASE3_MAX_TOKENS = 2048
+
+# -----------------------------------------------------------------------
+# CONFIGURAÇÕES DE LOTE
+# -----------------------------------------------------------------------
+DEFAULT_BATCH_SIZE = 4  # Requisições concorrentes por lote
+DEFAULT_NUM_ROWS = 2000000  # Total de linhas a gerar (de pipeline.py linha 194)
+
+# -----------------------------------------------------------------------
+# ARQUIVOS DE SAÍDA
+# -----------------------------------------------------------------------
+PHASE1_OUTPUT = "phase1_generated_output.jsonl"
+PHASE2_OUTPUT = "phase2_detection_output.jsonl"
+PHASE3_OUTPUT = "phase3_extraction_output.jsonl"
+PHASE4_OUTPUT = "phase4_final_output.jsonl"
+
+# -----------------------------------------------------------------------
+# RE-EXPORTAR PROMPTS E SCHEMAS
+# -----------------------------------------------------------------------
+__all__ = [
+    # Prompts
+    "IFEVAL_SYSTEM_PROMPT",
+    "IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT",
+    "IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT",
+    "IFEVAL_CONSTRAINT_PHRASINGS",
+    # Schemas
+    "IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA",
+    "IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA",
+    # Config
+    "VLLM_BASE_URL",
+    "VLLM_API_KEY",
+    "PERSONA_DATASET_ID",
+    "PERSONA_DATASET_SUBSET",
+    "PERSONA_TEXT_FIELD",
+    "PHASE1_INSTRUCTION_TEMPERATURE",
+    "PHASE1_RESPONSE_TEMPERATURE",
+    "PHASE1_TOP_P",
+    "PHASE1_MAX_TOKENS_INSTRUCTION",
+    "PHASE1_MAX_TOKENS_RESPONSE",
+    "PHASE2_TEMPERATURE",
+    "PHASE2_MAX_TOKENS",
+    "PHASE3_TEMPERATURE",
+    "PHASE3_MAX_TOKENS",
+    "DEFAULT_BATCH_SIZE",
+    "DEFAULT_NUM_ROWS",
+    "PHASE1_OUTPUT",
+    "PHASE2_OUTPUT",
+    "PHASE3_OUTPUT",
+    "PHASE4_OUTPUT",
+]

synthgen/PtPersonaIFGen/main_ifeval_code/filter_ifeval_data_pt.py

@@ -0,0 +1,499 @@
+import json
+from typing import TYPE_CHECKING
+
+from datasets import load_dataset
+from lmeval_pt.utils import process_results
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+
+INSTRUCTION_ARGS = {
+    "keywords:existence": ["keywords"],
+    "keywords:frequency": ["keyword", "frequency", "relation"],
+    "keywords:forbidden_words": ["forbidden_words"],
+    "keywords:letter_frequency": ["letter", "let_frequency", "let_relation"],
+    "language:response_language": ["language"],
+    "length_constraints:number_sentences": ["num_sentences", "relation"],
+    "length_constraints:number_paragraphs": ["num_paragraphs"],
+    "length_constraints:number_words": ["num_words", "relation"],
+    "length_constraints:nth_paragraph_first_word": [
+        "num_paragraphs",
+        "nth_paragraph",
+        "first_word",
+    ],
+    "detectable_content:number_placeholders": ["num_placeholders"],
+    "detectable_content:postscript": ["postscript_marker"],
+    "detectable_format:number_bullet_lists": ["num_bullets"],
+    "detectable_format:constrained_response": [],
+    "detectable_format:number_highlighted_sections": ["num_highlights"],
+    "detectable_format:multiple_sections": ["section_spliter", "num_sections"],
+    "detectable_format:json_format": [],
+    "detectable_format:title": [],
+    "combination:two_responses": [],
+    "combination:repeat_prompt": ["prompt_to_repeat"],
+    "startend:end_checker": ["end_phrase"],
+    "change_case:capital_word_frequency": ["capital_frequency", "capital_relation"],
+    "change_case:english_capital": [],
+    "change_case:english_lowercase": [],
+    "punctuation:no_comma": [],
+    "startend:quotation": [],
+    # --- IFTrain out-of-distribution constraints ---
+    "keywords:word_once": ["keyword"],
+    "keywords:word_count_diff_numb": ["keyword", "count"],
+    "keywords:exclude_word_harder": ["keyword"],
+    "keywords:letter_counting2": ["letter", "count"],
+    "length_constraints:paragraphs_two_line_breaks": ["num_paragraphs"],
+    "startend:first_word_sent": ["first_word"],
+    "startend:first_word_answer": ["first_word"],
+    "startend:last_word_sent": ["last_word"],
+    "startend:last_word_answer": ["last_word"],
+    "detectable_format:bigram_wrapping": [],
+    "combination:copying_simple": ["prompt_to_copy"],
+    "combination:copying_multiple": ["prompt_to_copy", "copy_count"],
+    "punctuation:no_dot": [],
+    "punctuation:no_exclamation": [],
+    "keywords:lowercase_counting": ["max_count"],
+    "length_constraints:letter_total_count": ["num_letters", "relation"],
+    "length_constraints:counting_composition": ["n_sent", "n_words"],
+    "keywords:count_unique": [],
+    "keywords:count_increment_word": ["keyword1", "keyword2"],
+    "keywords:palindrome": [],
+    "keywords:keyword_specific_pos": ["keyword", "sentence_num", "word_num"],
+    "startend:start_end_same_word": [],
+    "combination:repeat_phrase": ["phrase", "repeat_count"],
+    "keywords:no_adjacent_consecutive": [],
+    "detectable_format:square_brackets_word": [],
+    "detectable_format:sentence_hyphens": [],
+    "combination:copy_instruction": ["instruction_to_copy"],
+    "combination:copy_span_idx": ["source_text", "n_start", "n_end"],
+}
+
+ALL_ARGUMENTS = {
+    "keywords",
+    "keyword",
+    "frequency",
+    "relation",
+    "forbidden_words",
+    "letter",
+    "let_frequency",
+    "let_relation",
+    "language",
+    "num_sentences",
+    "num_paragraphs",
+    "num_words",
+    "nth_paragraph",
+    "first_word",
+    "num_placeholders",
+    "postscript_marker",
+    "num_bullets",
+    "num_highlights",
+    "section_spliter",
+    "num_sections",
+    "prompt_to_repeat",
+    "end_phrase",
+    "capital_frequency",
+    "capital_relation",
+    # --- IFTrain out-of-distribution arguments ---
+    "count",
+    "last_word",
+    "prompt_to_copy",
+    "copy_count",
+    "max_count",
+    "num_letters",
+    "n_sent",
+    "n_words",
+    "keyword1",
+    "keyword2",
+    "sentence_num",
+    "word_num",
+    "phrase",
+    "repeat_count",
+    "instruction_to_copy",
+    "source_text",
+    "n_start",
+    "n_end",
+}
+
+IFEVAL_INSTRUCTION_CONFLICTS = {
+    "keywords:existence": {"keywords:existence"},
+    "keywords:frequency": {"keywords:frequency"},
+    "keywords:forbidden_words": {"keywords:forbidden_words"},
+    "keywords:letter_frequency": {"keywords:letter_frequency"},
+    "language:response_language": {
+        "change_case:english_capital",
+        "change_case:english_lowercase",
+        "startend:end_checker",
+        "keywords:frequency",
+        "keywords:forbidden_words",
+        "detectable_format:multiple_sections",
+        "keywords:existence",
+        "language:response_language",
+    },
+    "length_constraints:number_sentences": {"length_constraints:number_sentences"},
+    "length_constraints:number_paragraphs": {
+        "length_constraints:number_sentences",
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:number_paragraphs",
+    },
+    "length_constraints:number_words": {"length_constraints:number_words"},
+    "length_constraints:nth_paragraph_first_word": {
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:number_paragraphs",
+    },
+    "detectable_content:number_placeholders": {
+        "detectable_content:number_placeholders"
+    },
+    "detectable_content:postscript": {"detectable_content:postscript"},
+    "detectable_format:number_bullet_lists": {"detectable_format:number_bullet_lists"},
+    "detectable_format:constrained_response": {
+        "startend:quotation",
+        "length_constraints:number_words",
+        "detectable_format:constrained_response",
+        "change_case:english_capital",
+        "startend:end_checker",
+        "keywords:forbidden_words",
+        "length_constraints:number_sentences",
+        "combination:repeat_prompt",
+        "combination:two_responses",
+        "punctuation:no_comma",
+        "detectable_format:number_highlighted_sections",
+        "change_case:english_lowercase",
+        "detectable_format:number_bullet_lists",
+        "detectable_content:number_placeholders",
+        "keywords:letter_frequency",
+        "keywords:frequency",
+        "length_constraints:number_paragraphs",
+        "keywords:existence",
+        "length_constraints:nth_paragraph_first_word",
+        "detectable_format:title",
+        "change_case:capital_word_frequency",
+        "detectable_format:json_format",
+        "detectable_format:multiple_sections",
+        "detectable_content:postscript",
+        "language:response_language",
+    },
+    "detectable_format:number_highlighted_sections": {
+        "detectable_format:number_highlighted_sections"
+    },
+    "detectable_format:multiple_sections": {
+        "detectable_format:multiple_sections",
+        "detectable_format:number_highlighted_sections",
+        "language:response_language",
+    },
+    "detectable_format:json_format": {
+        "startend:quotation",
+        "length_constraints:number_words",
+        "detectable_format:constrained_response",
+        "change_case:english_capital",
+        "detectable_format:number_bullet_lists",
+        "detectable_content:number_placeholders",
+        "startend:end_checker",
+        "keywords:letter_frequency",
+        "keywords:frequency",
+        "length_constraints:number_paragraphs",
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:number_sentences",
+        "language:response_language",
+        "combination:repeat_prompt",
+        "detectable_format:title",
+        "change_case:capital_word_frequency",
+        "combination:two_responses",
+        "detectable_format:json_format",
+        "punctuation:no_comma",
+        "detectable_format:number_highlighted_sections",
+        "detectable_format:multiple_sections",
+        "detectable_content:postscript",
+        "change_case:english_lowercase",
+    },
+    "detectable_format:title": {"detectable_format:title"},
+    "combination:two_responses": {
+        "startend:quotation",
+        "length_constraints:number_words",
+        "detectable_format:constrained_response",
+        "change_case:english_capital",
+        "detectable_format:number_bullet_lists",
+        "detectable_content:number_placeholders",
+        "startend:end_checker",
+        "keywords:letter_frequency",
+        "keywords:frequency",
+        "length_constraints:number_paragraphs",
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:number_sentences",
+        "combination:repeat_prompt",
+        "change_case:capital_word_frequency",
+        "combination:two_responses",
+        "detectable_format:json_format",
+        "detectable_format:number_highlighted_sections",
+        "detectable_format:multiple_sections",
+        "detectable_content:postscript",
+        "change_case:english_lowercase",
+    },
+    "combination:repeat_prompt": {
+        "startend:quotation",
+        "length_constraints:number_words",
+        "detectable_format:constrained_response",
+        "change_case:english_capital",
+        "detectable_format:number_bullet_lists",
+        "detectable_content:number_placeholders",
+        "startend:end_checker",
+        "keywords:letter_frequency",
+        "keywords:forbidden_words",
+        "keywords:frequency",
+        "length_constraints:number_paragraphs",
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:number_sentences",
+        "language:response_language",
+        "combination:repeat_prompt",
+        "change_case:capital_word_frequency",
+        "combination:two_responses",
+        "detectable_format:json_format",
+        "detectable_format:number_highlighted_sections",
+        "detectable_format:multiple_sections",
+        "detectable_content:postscript",
+        "change_case:english_lowercase",
+    },
+    "startend:end_checker": {"startend:end_checker"},
+    "change_case:capital_word_frequency": {
+        "change_case:english_capital",
+        "change_case:capital_word_frequency",
+        "change_case:english_lowercase",
+    },
+    "change_case:english_capital": {"change_case:english_capital"},
+    "change_case:english_lowercase": {
+        "change_case:english_capital",
+        "change_case:english_lowercase",
+    },
+    "punctuation:no_comma": {"punctuation:no_comma"},
+    "startend:quotation": {"startend:quotation", "detectable_format:title"},
+    # --- IFTrain out-of-distribution constraints ---
+    "keywords:word_once": {"keywords:word_once"},
+    "keywords:word_count_diff_numb": {"keywords:word_count_diff_numb"},
+    "keywords:exclude_word_harder": {"keywords:exclude_word_harder"},
+    "keywords:letter_counting2": {"keywords:letter_counting2", "keywords:letter_frequency"},
+    "length_constraints:paragraphs_two_line_breaks": {
+        "length_constraints:paragraphs_two_line_breaks",
+        "length_constraints:number_paragraphs",
+        "length_constraints:nth_paragraph_first_word",
+        "length_constraints:counting_composition",
+    },
+    "startend:first_word_sent": {
+        "startend:first_word_sent",
+        "startend:first_word_answer",
+    },
+    "startend:first_word_answer": {
+        "startend:first_word_answer",
+        "startend:first_word_sent",
+    },
+    "startend:last_word_sent": {
+        "startend:last_word_sent",
+        "startend:last_word_answer",
+        "startend:start_end_same_word",
+    },
+    "startend:last_word_answer": {
+        "startend:last_word_answer",
+        "startend:last_word_sent",
+        "startend:start_end_same_word",
+    },
+    "detectable_format:bigram_wrapping": {"detectable_format:bigram_wrapping"},
+    "combination:copying_simple": {
+        "combination:copying_simple",
+        "combination:copying_multiple",
+        "combination:copy_instruction",
+        "combination:copy_span_idx",
+        "combination:repeat_prompt",
+        "combination:two_responses",
+        "combination:repeat_phrase",
+    },
+    "combination:copying_multiple": {
+        "combination:copying_multiple",
+        "combination:copying_simple",
+        "combination:copy_instruction",
+        "combination:copy_span_idx",
+        "combination:repeat_prompt",
+        "combination:two_responses",
+        "combination:repeat_phrase",
+    },
+    "punctuation:no_dot": {
+        "punctuation:no_dot",
+        "length_constraints:number_sentences",
+        "length_constraints:counting_composition",
+    },
+    "punctuation:no_exclamation": {"punctuation:no_exclamation"},
+    "keywords:lowercase_counting": {"keywords:lowercase_counting"},
+    "length_constraints:letter_total_count": {"length_constraints:letter_total_count"},
+    "length_constraints:counting_composition": {
+        "length_constraints:counting_composition",
+        "length_constraints:number_paragraphs",
+        "length_constraints:paragraphs_two_line_breaks",
+        "length_constraints:number_sentences",
+        "punctuation:no_dot",
+    },
+    "keywords:count_unique": {"keywords:count_unique"},
+    "keywords:count_increment_word": {"keywords:count_increment_word"},
+    "keywords:palindrome": {"keywords:palindrome"},
+    "keywords:keyword_specific_pos": {"keywords:keyword_specific_pos"},
+    "startend:start_end_same_word": {
+        "startend:start_end_same_word",
+        "startend:last_word_sent",
+        "startend:last_word_answer",
+    },
+    "combination:repeat_phrase": {
+        "combination:repeat_phrase",
+        "combination:copying_simple",
+        "combination:copying_multiple",
+        "combination:copy_instruction",
+        "combination:copy_span_idx",
+    },
+    "keywords:no_adjacent_consecutive": {"keywords:no_adjacent_consecutive"},
+    "detectable_format:square_brackets_word": {
+        "detectable_format:square_brackets_word",
+        "detectable_content:number_placeholders",
+    },
+    "detectable_format:sentence_hyphens": {"detectable_format:sentence_hyphens"},
+    "combination:copy_instruction": {
+        "combination:copy_instruction",
+        "combination:copying_simple",
+        "combination:copying_multiple",
+        "combination:copy_span_idx",
+        "combination:repeat_prompt",
+        "combination:two_responses",
+        "combination:repeat_phrase",
+    },
+    "combination:copy_span_idx": {
+        "combination:copy_span_idx",
+        "combination:copying_simple",
+        "combination:copying_multiple",
+        "combination:copy_instruction",
+        "combination:repeat_prompt",
+        "combination:two_responses",
+        "combination:repeat_phrase",
+    },
+}
+
+LANGUAGE_TO_CODE = {
+    "English": "en",
+    "Spanish": "es",
+    "Portuguese": "pt",
+    "Arabic": "ar",
+    "Hindi": "hi",
+    "French": "fr",
+    "Russian": "ru",
+    "German": "de",
+    "Japanese": "ja",
+    "Italian": "it",
+    "Bengali": "bn",
+    "Ukrainian": "uk",
+    "Thai": "th",
+    "Urdu": "ur",
+    "Tamil": "ta",
+    "Telugu": "te",
+    "Bulgarian": "bg",
+    "Korean": "ko",
+    "Polish": "pl",
+    "Hebrew": "he",
+    "Persian": "fa",
+    "Vietnamese": "vi",
+    "Nepali": "ne",
+    "Swahili": "sw",
+    "Kannada": "kn",
+    "Marathi": "mr",
+    "Gujarati": "gu",
+    "Punjabi": "pa",
+    "Malayalam": "ml",
+    "Finnish": "fi",
+}
+
+RELATION_PT_TO_EN = {
+    "menos de": "less than",
+    "pelo menos": "at least",
+}
+
+def build_instruction_kwargs(row: dict) -> dict:
+    """Builds the list of `kwargs` for each instruction in `instruction_id_list`."""
+    kwargs = row["kwargs"]
+
+    if kwargs is None:
+        return {"valid_kwargs_json": False}
+
+    try:
+        kwargs = json.loads(row["kwargs"])
+    except json.JSONDecodeError:
+        return {"valid_kwargs_json": False}
+
+    instruction_id_list = row["instruction_id_list"]
+    kwargs_list = []
+    for instruction_id in instruction_id_list:
+        args = INSTRUCTION_ARGS[instruction_id]
+        instruction_kwargs = {}
+        for arg in args:
+            value = kwargs[arg]
+            if arg == "language":
+                if value in LANGUAGE_TO_CODE:
+                    value = LANGUAGE_TO_CODE[value]
+                elif value not in LANGUAGE_TO_CODE.values():
+                    return {"valid_kwargs_json": False}
+            # Normalize Portuguese relation values to English for lm-eval
+            elif arg in ("relation", "let_relation", "capital_relation"):
+                if value in RELATION_PT_TO_EN:
+                    value = RELATION_PT_TO_EN[value]
+            instruction_kwargs[arg] = value
+        kwargs_list.append(instruction_kwargs)
+
+    return {"kwargs": json.dumps(kwargs_list), "valid_kwargs_json": True}
+
+
+def filter_not_valid_rows(row: dict) -> bool:
+    """Filters out rows which their JSON kwargs are not valid or that the instructions
+    in their `instruction_id_list` conflict each other."""
+    valid_kwargs_json = row["valid_kwargs_json"]
+    if not valid_kwargs_json:
+        return False
+
+    instruction_id_list = row["instruction_id_list"]
+    for instruction_id in instruction_id_list:
+        conflicts = IFEVAL_INSTRUCTION_CONFLICTS[instruction_id]
+        if any(
+            conflict in instruction_id_list
+            for conflict in conflicts
+            if conflict != instruction_id
+        ):
+            return False
+
+    return True
+
+
+def get_ifeval_results(row: dict) -> dict:
+    """Checks if the `response` correct is OK using the IFEval benchmark code from `lm-evaluation-harness`."""
+    results = [row["response"]]
+    doc = row.copy()
+    doc["kwargs"] = json.loads(doc["kwargs"])
+    try:
+        return process_results(doc, results)
+    except Exception as e:
+        return {
+            "prompt_level_strict_acc": False,
+            "inst_level_strict_acc": [],
+            "prompt_level_loose_acc": False,
+            "inst_level_loose_acc": [],
+            "validation_error": str(e),  # Capture the actual error
+        }
+
+
+def get_dataset() -> "Dataset":
+    dataset = load_dataset("argilla/ifeval-like-data", split="train")
+    dataset = dataset.map(build_instruction_kwargs)
+    dataset = dataset.filter(filter_not_valid_rows)
+    dataset = dataset.add_column("key", list(range(len(dataset))))
+    dataset = dataset.rename_column("instruction", "prompt")
+    dataset = dataset.select_columns(
+        ["key", "prompt", "response", "instruction_id_list", "kwargs"]
+    )
+    dataset = dataset.map(get_ifeval_results)
+    dataset = dataset.filter(lambda x: x["prompt_level_strict_acc"])
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = get_dataset()
+    dataset.push_to_hub("argilla/ifeval-like-data", config_name="filtered")

synthgen/PtPersonaIFGen/main_ifeval_code/json_schemas_pt.py

@@ -0,0 +1,303 @@
+IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "language": {
+            "type": ["string", "null"],
+        },
+        "num_sentences": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "relation": {
+            "type": ["string", "null"],
+            "enum": ["less than", "at least", "menos de", "pelo menos"],
+        },
+        "num_placeholders": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "num_bullets": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "starter": {
+            "type": ["string", "null"],
+        },
+        "num_highlights": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "section_spliter": {
+            "type": ["string", "null"],
+            "enum": ["Section", "SECTION", "Seção", "SEÇÃO"],
+        },
+        "num_sections": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "num_paragraphs": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "postscript_marker": {
+            "type": ["string", "null"],
+            "enum": ["P.S.", "P.P.S"],
+        },
+        "original_message": {
+            "type": ["string", "null"],
+        },
+        "keywords": {
+            "type": "array",
+            "items": {"type": "string"},
+        },
+        "keyword": {
+            "type": ["string", "null"],
+        },
+        "frequency": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "num_words": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "nth_paragraph": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "first_word": {
+            "type": ["string", "null"],
+        },
+        "key_sentences": {
+            "type": ["array", "null"],
+            "items": {"type": "string"},
+        },
+        "forbidden_words": {
+            "type": ["array", "null"],
+            "items": {"type": "string"},
+        },
+        "original_paragraph": {
+            "type": ["string", "null"],
+        },
+        "low": {
+            "type": ["integer", "null"],
+            "minimum": 0,
+        },
+        "high": {
+            "type": ["integer", "null"],
+            "minimum": 0,
+        },
+        "prompt_to_repeat": {
+            "type": ["string", "null"],
+        },
+        "end_phrase": {
+            "type": ["string", "null"],
+        },
+        "letter": {
+            "type": ["string", "null"],
+            "minLength": 1,
+            "maxLength": 1,
+            "pattern": "[a-zA-Z]",
+        },
+        "let_frequency": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "let_relation": {
+            "type": ["string", "null"],
+            "enum": ["less than", "at least", "menos de", "pelo menos"],
+        },
+        "capital_frequency": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "capital_relation": {
+            "type": ["string", "null"],
+            "enum": ["less than", "at least", "menos de", "pelo menos"],
+        },
+        "count": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "last_word": {
+            "type": ["string", "null"],
+        },
+        "prompt_to_copy": {
+            "type": ["string", "null"],
+        },
+        "copy_count": {
+            "type": ["integer", "null"],
+            "minimum": 2,
+        },
+        "max_count": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "num_letters": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "n_sent": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "n_words": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "keyword1": {
+            "type": ["string", "null"],
+        },
+        "keyword2": {
+            "type": ["string", "null"],
+        },
+        "sentence_num": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "word_num": {
+            "type": ["integer", "null"],
+            "minimum": 1,
+        },
+        "phrase": {
+            "type": ["string", "null"],
+        },
+        "repeat_count": {
+            "type": ["integer", "null"],
+            "minimum": 2,
+        },
+        "instruction_to_copy": {
+            "type": ["string", "null"],
+        },
+        "source_text": {
+            "type": ["string", "null"],
+        },
+        "n_start": {
+            "type": ["integer", "null"],
+            "minimum": 0,
+        },
+        "n_end": {
+            "type": ["integer", "null"],
+            "minimum": 0,
+        },
+    },
+    "required": [
+        "language",
+        "num_sentences",
+        "relation",
+        "num_placeholders",
+        "num_bullets",
+        "starter",
+        "num_highlights",
+        "section_spliter",
+        "num_sections",
+        "num_paragraphs",
+        "postscript_marker",
+        "original_message",
+        "keywords",
+        "keyword",
+        "frequency",
+        "num_words",
+        "nth_paragraph",
+        "first_word",
+        "key_sentences",
+        "forbidden_words",
+        "original_paragraph",
+        "low",
+        "high",
+        "prompt_to_repeat",
+        "end_phrase",
+        "letter",
+        "let_frequency",
+        "let_relation",
+        "capital_frequency",
+        "capital_relation",
+        "count",
+        "last_word",
+        "prompt_to_copy",
+        "copy_count",
+        "max_count",
+        "num_letters",
+        "n_sent",
+        "n_words",
+        "keyword1",
+        "keyword2",
+        "sentence_num",
+        "word_num",
+        "phrase",
+        "repeat_count",
+        "instruction_to_copy",
+        "source_text",
+        "n_start",
+        "n_end",
+    ],
+    "additionalProperties": False,
+}
+
+IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "instruction_id_list": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "enum": [
+                    "keywords:existence",
+                    "keywords:frequency",
+                    "keywords:forbidden_words",
+                    "keywords:letter_frequency",
+                    "language:response_language",
+                    "length_constraints:number_sentences",
+                    "length_constraints:number_paragraphs",
+                    "length_constraints:number_words",
+                    "length_constraints:nth_paragraph_first_word",
+                    "detectable_content:number_placeholders",
+                    "detectable_content:postscript",
+                    "detectable_format:number_bullet_lists",
+                    "detectable_format:constrained_response",
+                    "detectable_format:number_highlighted_sections",
+                    "detectable_format:multiple_sections",
+                    "detectable_format:json_format",
+                    "detectable_format:title",
+                    "combination:two_responses",
+                    "combination:repeat_prompt",
+                    "startend:end_checker",
+                    "change_case:capital_word_frequency",
+                    "change_case:english_capital",
+                    "change_case:english_lowercase",
+                    "punctuation:no_comma",
+                    "startend:quotation",
+                    "keywords:word_once",
+                    "keywords:word_count_diff_numb",
+                    "keywords:exclude_word_harder",
+                    "keywords:letter_counting2",
+                    "length_constraints:paragraphs_two_line_breaks",
+                    "startend:first_word_sent",
+                    "startend:first_word_answer",
+                    "startend:last_word_sent",
+                    "startend:last_word_answer",
+                    "detectable_format:bigram_wrapping",
+                    "combination:copying_simple",
+                    "combination:copying_multiple",
+                    "punctuation:no_dot",
+                    "punctuation:no_exclamation",
+                    "keywords:lowercase_counting",
+                    "length_constraints:letter_total_count",
+                    "length_constraints:counting_composition",
+                    "keywords:count_unique",
+                    "keywords:count_increment_word",
+                    "keywords:palindrome",
+                    "keywords:keyword_specific_pos",
+                    "startend:start_end_same_word",
+                    "combination:repeat_phrase",
+                    "keywords:no_adjacent_consecutive",
+                    "detectable_format:square_brackets_word",
+                    "detectable_format:sentence_hyphens",
+                    "combination:copy_instruction",
+                    "combination:copy_span_idx",
+                ],
+            },
+        }
+    },
+    "required": ["instruction_id_list"],
+}

synthgen/PtPersonaIFGen/main_ifeval_code/phase1_magpie.py

@@ -0,0 +1,537 @@
+"""
+Phase 1: Persona-Driven Instruction + Response Generation
+
+Generates IFEval-style training data using a persona-driven two-step approach,
+following the TULU 3 / Persona Hub methodology (Chan et al., 2024).
+
+Constraint selection is PROGRAMMATIC: constraints are cycled through in order
+(round-robin), so each constraint gets equal coverage across the dataset.
+The cycle restarts from the beginning after the last constraint is used.
+
+Step 1: Generate User Instruction (persona-conditioned + constraint-assigned)
+    - A constraint is selected deterministically based on item_id % len(constraints)
+    - System prompt: a simple instruction-generation prompt
+    - User prompt: the persona + the exact constraint phrasing to embed
+    - Model generates a natural user instruction that includes the given constraint
+
+Step 2: Generate Assistant Response
+    - System prompt: IFEVAL_SYSTEM_PROMPT (constraint-following instructions)
+    - User prompt: The generated instruction from Step 1
+    - Model generates a response that follows the constraints
+
+This approach:
+    - Guarantees uniform constraint coverage across the dataset
+    - Provides behavioral/perspective diversity through ~250K personas
+    - Ensures constraint consistency between instruction and response
+"""
+
+import argparse
+import asyncio
+from typing import Optional, Dict, Any, Iterator
+
+from openai import AsyncOpenAI
+from tqdm import tqdm
+
+from main_ifeval_code.config import (
+    VLLM_BASE_URL,
+    VLLM_API_KEY,
+    PERSONA_DATASET_ID,
+    PERSONA_DATASET_SUBSET,
+    PERSONA_TEXT_FIELD,
+    PHASE1_INSTRUCTION_TEMPERATURE,
+    PHASE1_RESPONSE_TEMPERATURE,
+    PHASE1_TOP_P,
+    PHASE1_MAX_TOKENS_INSTRUCTION,
+    PHASE1_MAX_TOKENS_RESPONSE,
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_NUM_ROWS,
+    PHASE1_OUTPUT,
+)
+from main_ifeval_code.utils import get_last_processed_id, write_jsonl_batch
+from main_ifeval_code.system_prompts_pt import get_response_system_prompt
+
+
+# -----------------------------------------------------------------------
+# ASYNC CLIENT
+# -----------------------------------------------------------------------
+client = AsyncOpenAI(
+    base_url=VLLM_BASE_URL,
+    api_key=VLLM_API_KEY,
+)
+
+
+# -----------------------------------------------------------------------
+# CONSTRAINT SCHEDULE
+# Ordered list of (constraint_id, portuguese_phrasing) pairs.
+# Constraints are assigned round-robin: item_id % len(CONSTRAINT_SCHEDULE).
+# -----------------------------------------------------------------------
+# Ordered list of constraint IDs to cycle through (round-robin).
+# No phrasings here — the model should generate a natural instruction that
+# implies the constraint, not copy-paste a canned phrasing.
+CONSTRAINT_SCHEDULE = [
+    # ---- Original IFEval constraints ----
+    "language:response_language",
+    "length_constraints:number_sentences",
+    "detectable_content:number_placeholders",
+    "detectable_format:number_bullet_lists",
+    "detectable_format:constrained_response",
+    "detectable_format:number_highlighted_sections",
+    "detectable_format:multiple_sections",
+    "length_constraints:number_paragraphs",
+    "detectable_content:postscript",
+    "keywords:existence",
+    "keywords:frequency",
+    "length_constraints:number_words",
+    "detectable_format:json_format",
+    "keywords:forbidden_words",
+    "combination:two_responses",
+    "startend:end_checker",
+    "detectable_format:title",
+    "keywords:letter_frequency",
+    "change_case:english_capital",
+    "change_case:english_lowercase",
+    "punctuation:no_comma",
+    "change_case:capital_word_frequency",
+    "startend:quotation",
+    "combination:repeat_prompt",
+    "length_constraints:nth_paragraph_first_word",
+    # ---- IFTrain out-of-distribution constraints ----
+    "keywords:word_once",
+    "keywords:word_count_diff_numb",
+    "keywords:exclude_word_harder",
+    "keywords:letter_counting2",
+    "length_constraints:paragraphs_two_line_breaks",
+    "startend:first_word_sent",
+    "startend:first_word_answer",
+    "startend:last_word_sent",
+    "startend:last_word_answer",
+    "detectable_format:bigram_wrapping",
+    "combination:copying_simple",
+    "combination:copying_multiple",
+    "punctuation:no_dot",
+    "punctuation:no_exclamation",
+    "keywords:lowercase_counting",
+    "length_constraints:letter_total_count",
+    "length_constraints:counting_composition",
+    "keywords:count_unique",
+    "keywords:count_increment_word",
+    "keywords:palindrome",
+    "keywords:keyword_specific_pos",
+    "startend:start_end_same_word",
+    "combination:repeat_phrase",
+    "keywords:no_adjacent_consecutive",
+    "detectable_format:square_brackets_word",
+    "detectable_format:sentence_hyphens",
+    "combination:copy_instruction",
+    "combination:copy_span_idx",
+]
+
+# Natural-language descriptions of what each constraint requires the *response* to do.
+# Used to guide the instruction-generation model — it reads this description and writes
+# a realistic user request that would naturally call for such a constraint in the answer.
+CONSTRAINT_DESCRIPTIONS: dict[str, str] = {
+    "language:response_language": "A resposta deve estar inteiramente em um idioma específico.",
+    "length_constraints:number_sentences": "A resposta deve conter um número específico de frases.",
+    "detectable_content:number_placeholders": "A resposta deve incluir um certo número de placeholders entre colchetes, como [nome] ou [endereço].",
+    "detectable_format:number_bullet_lists": "A resposta deve conter um número específico de itens em lista com marcadores markdown.",
+    "detectable_format:constrained_response": "A resposta deve ser exatamente uma de algumas opções predefinidas.",
+    "detectable_format:number_highlighted_sections": "A resposta deve destacar um número específico de seções usando markdown.",
+    "detectable_format:multiple_sections": "A resposta deve ser dividida em um número específico de seções nomeadas.",
+    "length_constraints:number_paragraphs": "A resposta deve conter um número específico de parágrafos separados por um divisor markdown.",
+    "detectable_content:postscript": "A resposta deve terminar com um post-scriptum explícito (P.S. ou P.P.S).",
+    "keywords:existence": "A resposta deve incluir certas palavras-chave específicas.",
+    "keywords:frequency": "Uma palavra específica deve aparecer um número mínimo ou máximo de vezes na resposta.",
+    "length_constraints:number_words": "A resposta deve ter um número mínimo ou máximo de palavras.",
+    "detectable_format:json_format": "A resposta deve estar inteiramente em formato JSON válido.",
+    "keywords:forbidden_words": "A resposta não deve conter certas palavras específicas.",
+    "combination:two_responses": "A resposta deve conter duas respostas distintas separadas por asteriscos.",
+    "startend:end_checker": "A resposta deve terminar com uma frase exata e específica.",
+    "detectable_format:title": "A resposta deve incluir um título entre colchetes angulares duplos.",
+    "keywords:letter_frequency": "Uma letra específica deve aparecer um número mínimo ou máximo de vezes na resposta.",
+    "change_case:english_capital": "A resposta deve estar inteiramente em letras maiúsculas.",
+    "change_case:english_lowercase": "A resposta deve estar inteiramente em letras minúsculas.",
+    "punctuation:no_comma": "A resposta não deve conter vírgulas.",
+    "change_case:capital_word_frequency": "Um número específico de palavras na resposta deve estar em letras maiúsculas.",
+    "startend:quotation": "A resposta deve estar envolvida por aspas duplas.",
+    "combination:repeat_prompt": "A resposta deve começar repetindo o pedido original do usuário.",
+    "length_constraints:nth_paragraph_first_word": "Um parágrafo específico da resposta deve começar com uma palavra determinada.",
+    "keywords:word_once": "Uma palavra específica deve aparecer pelo menos uma vez na resposta.",
+    "keywords:word_count_diff_numb": "Uma palavra específica deve aparecer exatamente N vezes na resposta.",
+    "keywords:exclude_word_harder": "Uma palavra específica não deve aparecer em nenhum lugar da resposta.",
+    "keywords:letter_counting2": "Uma letra específica deve aparecer exatamente N vezes na resposta.",
+    "length_constraints:paragraphs_two_line_breaks": "A resposta deve ter parágrafos separados por duas quebras de linha.",
+    "startend:first_word_sent": "A primeira palavra de cada frase da resposta deve ser uma palavra específica.",
+    "startend:first_word_answer": "A primeira palavra da resposta deve ser uma palavra específica.",
+    "startend:last_word_sent": "A última palavra de cada frase da resposta deve ser uma palavra específica.",
+    "startend:last_word_answer": "A última palavra da resposta deve ser uma palavra específica.",
+    "detectable_format:bigram_wrapping": "Cada par de palavras consecutivas na resposta deve estar entre colchetes angulares duplos.",
+    "combination:copying_simple": "A resposta deve ser uma cópia exata do pedido, sem responder ao conteúdo.",
+    "combination:copying_multiple": "A resposta deve repetir o pedido várias vezes, separado por asteriscos, sem responder ao conteúdo.",
+    "punctuation:no_dot": "A resposta não deve conter pontos finais.",
+    "punctuation:no_exclamation": "A resposta não deve conter pontos de exclamação.",
+    "keywords:lowercase_counting": "Cada palavra em minúsculas na resposta pode aparecer no máximo N vezes.",
+    "length_constraints:letter_total_count": "A resposta deve conter um número mínimo ou máximo de letras no total.",
+    "length_constraints:counting_composition": "A resposta deve ter exatamente 3 parágrafos, cada um com um número fixo de frases e palavras por frase.",
+    "keywords:count_unique": "A resposta deve usar apenas palavras únicas — nenhuma palavra pode se repetir.",
+    "keywords:count_increment_word": "Duas palavras específicas devem aparecer com frequências diferentes: uma vez e duas vezes respectivamente.",
+    "keywords:palindrome": "A resposta deve incluir um palíndromo.",
+    "keywords:keyword_specific_pos": "Uma palavra específica deve aparecer em uma posição exata dentro de uma frase específica.",
+    "startend:start_end_same_word": "A resposta deve começar e terminar com a mesma palavra.",
+    "combination:repeat_phrase": "Uma frase específica deve ser repetida várias vezes, com uma palavra diferente substituída a cada vez.",
+    "keywords:no_adjacent_consecutive": "Nenhuma palavra adjacente na resposta pode começar com letras consecutivas do alfabeto.",
+    "detectable_format:square_brackets_word": "Cada palavra da resposta deve estar entre colchetes.",
+    "detectable_format:sentence_hyphens": "As frases da resposta devem ser conectadas por hífens, sem espaços.",
+    "combination:copy_instruction": "A resposta deve ser uma cópia literal da instrução recebida, sem segui-la.",
+    "combination:copy_span_idx": "A resposta deve conter um trecho específico do texto original, identificado por índices de caracteres.",
+}
+
+def get_constraint_for_item(item_id: int) -> str:
+    """
+    Return the constraint_id for a given item_id.
+    Cycles through CONSTRAINT_SCHEDULE in order, wrapping around.
+    """
+    return CONSTRAINT_SCHEDULE[item_id % len(CONSTRAINT_SCHEDULE)]
+
+
+# -----------------------------------------------------------------------
+# PERSONA PROVIDER
+# -----------------------------------------------------------------------
+class PersonaProvider:
+    """
+    Streams personas from the Persona Hub dataset (Chan et al., 2024).
+    Each call to get_persona() returns a single persona string.
+    The dataset is streamed lazily and restarts when exhausted.
+    """
+
+    def __init__(
+        self,
+        dataset_id: str,
+        subset: str,
+        text_field: str,
+    ):
+        self.dataset_id = dataset_id
+        self.subset = subset
+        self.text_field = text_field
+        self._iterator: Optional[Iterator] = None
+        self._current_index: int = -1
+
+    def _get_iterator(self) -> Iterator:
+        """Lazy-load the dataset iterator."""
+        if self._iterator is None:
+            from datasets import load_dataset
+            ds = load_dataset(
+                self.dataset_id,
+                self.subset,
+                split="train",
+                streaming=True,
+            )
+            self._iterator = iter(ds)
+        return self._iterator
+
+    def get_persona(self) -> Dict[str, Any]:
+        """
+        Get the next persona from the dataset.
+        Returns a dict with 'persona' (str) and 'persona_index' (int).
+        Automatically restarts the iterator if the dataset is exhausted.
+        """
+        iterator = self._get_iterator()
+
+        while True:
+            try:
+                record = next(iterator)
+                self._current_index += 1
+            except StopIteration:
+                # Restart when exhausted (allows generating more rows than personas)
+                self._iterator = None
+                self._current_index = -1
+                iterator = self._get_iterator()
+                record = next(iterator)
+                self._current_index += 1
+
+            persona_text = record.get(self.text_field, "")
+            if not isinstance(persona_text, str) or not persona_text.strip():
+                continue
+
+            return {
+                "persona": persona_text.strip(),
+                "persona_index": self._current_index,
+            }
+
+
+def get_persona_provider() -> PersonaProvider:
+    """Factory function to create the PersonaProvider."""
+    return PersonaProvider(
+        dataset_id=PERSONA_DATASET_ID,
+        subset=PERSONA_DATASET_SUBSET,
+        text_field=PERSONA_TEXT_FIELD,
+    )
+
+
+# -----------------------------------------------------------------------
+# STEP 1: GENERATE USER INSTRUCTION (persona-conditioned, constraint-assigned)
+# -----------------------------------------------------------------------
+
+_INSTRUCTION_GENERATOR_SYSTEM_PROMPT = (
+    "Você é um gerador de dados de treino para modelos de linguagem. "
+    "Você recebe uma persona e uma restrição de formatação, e escreve uma instrução "
+    "realista em português que alguém faria a um assistente de IA."
+)
+
+
+def build_instruction_messages(persona: str, constraint_id: str) -> list:
+    """
+    Build the messages list for the instruction-generation LLM call.
+
+    System prompt: minimal role definition only.
+    User prompt: persona + constraint description + task.
+
+    The model reads the constraint description (what the response must do) and
+    writes a natural user request that would require that constraint to be followed.
+    It should choose concrete values for any open parameters (specific words,
+    numbers, letters, etc.) that fit the persona and topic.
+    """
+    description = CONSTRAINT_DESCRIPTIONS[constraint_id]
+
+    user_prompt = (
+        f"Persona: {persona}\n\n"
+        f"Restrição que a resposta do assistente deve seguir: {description}\n\n"
+        f"Escreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. "
+        f"A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — "
+        f"com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido "
+        f"para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela."
+    )
+
+    return [
+        {"role": "system", "content": _INSTRUCTION_GENERATOR_SYSTEM_PROMPT},
+        {"role": "user", "content": user_prompt},
+    ]
+
+
+async def generate_user_instruction(
+    model_id: str,
+    persona: str,
+    constraint_id: str,
+) -> Optional[str]:
+    """
+    Generate a user instruction conditioned on a persona and a pre-selected constraint.
+    """
+    messages = build_instruction_messages(persona, constraint_id)
+
+    try:
+        print("Printing user instruction: ", messages)
+        resp = await client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            temperature=PHASE1_INSTRUCTION_TEMPERATURE,
+            top_p=PHASE1_TOP_P,
+            max_tokens=PHASE1_MAX_TOKENS_INSTRUCTION,
+        )
+        instruction = resp.choices[0].message.content
+        return instruction.strip() if instruction else None
+    except Exception as e:
+        print(f"Error generating instruction: {e}")
+        return None
+
+
+# -----------------------------------------------------------------------
+# STEP 2: GENERATE ASSISTANT RESPONSE
+# -----------------------------------------------------------------------
+async def generate_response(
+    model_id: str,
+    instruction: str,
+    constraint_id: str,
+) -> Optional[str]:
+    """
+    Generate an assistant response for the given instruction.
+
+    Uses a focused per-constraint system prompt so the model only sees
+    the one rule it must follow, not all 53.
+
+    Args:
+        model_id: The vLLM model ID
+        instruction: The user instruction (with embedded constraint)
+        constraint_id: The constraint ID used to select the system prompt
+
+    Returns:
+        An assistant response that follows the constraint
+    """
+    messages = [
+        {"role": "system", "content": get_response_system_prompt(constraint_id)},
+        {"role": "user", "content": instruction},
+    ]
+
+    try:
+        print("Printing user instruction: ", messages)
+        resp = await client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            temperature=PHASE1_RESPONSE_TEMPERATURE,
+            top_p=PHASE1_TOP_P,
+            max_tokens=PHASE1_MAX_TOKENS_RESPONSE,
+        )
+        response = resp.choices[0].message.content
+        return response.strip() if response else None
+    except Exception as e:
+        print(f"Error generating response: {e}")
+        return None
+
+
+# -----------------------------------------------------------------------
+# COMBINED: GENERATE INSTRUCTION-RESPONSE PAIR
+# -----------------------------------------------------------------------
+async def generate_instruction_response_pair(
+    model_id: str,
+    item_id: int,
+    persona_provider: PersonaProvider,
+) -> Optional[Dict[str, Any]]:
+    """
+    Generate a complete instruction-response pair.
+
+    The constraint is selected deterministically from CONSTRAINT_SCHEDULE
+    using item_id % len(CONSTRAINT_SCHEDULE), cycling in order.
+
+    Returns:
+        Dict with id, instruction, response, persona, persona_index,
+        constraint_id, and constraint_index.
+    """
+    # Determine constraint for this item (round-robin)
+    constraint_id = get_constraint_for_item(item_id)
+    constraint_index = item_id % len(CONSTRAINT_SCHEDULE)
+
+    # Sample a persona
+    persona_data = persona_provider.get_persona()
+    persona = persona_data["persona"]
+    persona_index = persona_data["persona_index"]
+
+    # Step 1: Generate user instruction conditioned on persona + constraint
+    instruction = await generate_user_instruction(model_id, persona, constraint_id)
+    if not instruction:
+        return None
+
+    # Step 2: Generate assistant response (focused system prompt for this constraint)
+    response = await generate_response(model_id, instruction, constraint_id)
+    if not response:
+        return None
+
+    return {
+        "id": item_id,
+        "instruction": instruction,
+        "response": response,
+        "persona": persona,
+        "persona_index": persona_index,
+        "constraint_id": constraint_id,
+        "constraint_index": constraint_index,
+    }
+
+
+# -----------------------------------------------------------------------
+# BATCH PROCESSING
+# -----------------------------------------------------------------------
+async def process_batch(
+    model_id: str,
+    start_id: int,
+    batch_size: int,
+    persona_provider: PersonaProvider,
+) -> list[Dict[str, Any]]:
+    """Process a batch of generations concurrently."""
+    tasks = [
+        generate_instruction_response_pair(model_id, start_id + i, persona_provider)
+        for i in range(batch_size)
+    ]
+    results = await asyncio.gather(*tasks)
+    # Filter out None results
+    return [r for r in results if r is not None]
+
+
+# -----------------------------------------------------------------------
+# MAIN
+# -----------------------------------------------------------------------
+async def main(
+    output_file: str = PHASE1_OUTPUT,
+    num_rows: int = DEFAULT_NUM_ROWS,
+    batch_size: int = DEFAULT_BATCH_SIZE,
+):
+    # Discover model
+    try:
+        models_resp = await client.models.list()
+        model_id = models_resp.data[0].id
+        print(f"Using model: {model_id}")
+    except Exception as e:
+        print(f"Could not list models. Is vLLM running? Error: {e}")
+        return
+
+    # Initialize persona provider
+    print(f"Persona source: {PERSONA_DATASET_ID}/{PERSONA_DATASET_SUBSET}")
+    persona_provider = get_persona_provider()
+
+    print(
+        f"Constraint schedule: {len(CONSTRAINT_SCHEDULE)} constraints, cycling in order.\n"
+        f"  First: {CONSTRAINT_SCHEDULE[0][0]}\n"
+        f"  Last:  {CONSTRAINT_SCHEDULE[-1][0]}"
+    )
+
+    # Resume from last processed ID
+    last_id = get_last_processed_id(output_file)
+    start_from_id = last_id + 1
+
+    if start_from_id > 0:
+        resume_constraint_id = get_constraint_for_item(start_from_id)[0]
+        print(f"Resuming from ID: {start_from_id} (constraint: {resume_constraint_id})")
+    else:
+        print("Starting from scratch.")
+
+    # Calculate remaining rows
+    remaining_rows = num_rows - start_from_id
+    if remaining_rows <= 0:
+        print(f"Already generated {num_rows} rows. Nothing to do.")
+        return
+
+    print(f"Generating {remaining_rows} persona-driven instruction-response pairs...")
+
+    # Process in batches
+    current_id = start_from_id
+    pbar = tqdm(total=remaining_rows, initial=0, desc="Generating")
+
+    while current_id < num_rows:
+        # Calculate batch size for this iteration
+        this_batch_size = min(batch_size, num_rows - current_id)
+
+        # Generate batch
+        results = await process_batch(
+            model_id, current_id, this_batch_size, persona_provider
+        )
+
+        # Write results
+        if results:
+            write_jsonl_batch(output_file, results)
+            pbar.update(len(results))
+
+        current_id += this_batch_size
+
+    pbar.close()
+    print(f"Phase 1 complete. Output: {output_file}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Phase 1: Persona-Driven Instruction + Response Generation"
+    )
+    parser.add_argument(
+        "--output", default=PHASE1_OUTPUT,
+        help="Output JSONL file"
+    )
+    parser.add_argument(
+        "--num-rows", type=int, default=DEFAULT_NUM_ROWS,
+        help="Number of rows to generate"
+    )
+    parser.add_argument(
+        "--batch-size", type=int, default=DEFAULT_BATCH_SIZE,
+        help="Batch size for concurrent requests"
+    )
+    args = parser.parse_args()
+
+    asyncio.run(main(
+        output_file=args.output,
+        num_rows=args.num_rows,
+        batch_size=args.batch_size,
+    ))

synthgen/PtPersonaIFGen/main_ifeval_code/phase2_detection.py

@@ -0,0 +1,214 @@
+"""
+Phase 2: Constraint Type Detection
+
+Replicates IFEvalInstructionIdListAssignator from pipeline/ifeval_tasks.py (lines 14-40).
+Takes each instruction and classifies which of the 25 IFEval constraint types are present.
+
+System Prompt: pipeline/system_prompts.py -> IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT (lines 55-93)
+JSON Schema: pipeline/json_schemas.py -> IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA (lines 154-193)
+Generation Params: pipeline/pipeline.py (lines 207-209)
+
+Input Format (from format_input, ifeval_tasks.py lines 19-28):
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": instruction}
+    ]
+"""
+
+import argparse
+import asyncio
+import json
+from typing import Optional
+
+from openai import AsyncOpenAI
+from tqdm import tqdm
+
+from main_ifeval_code.config import (
+    VLLM_BASE_URL,
+    VLLM_API_KEY,
+    IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT,
+    IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA,
+    PHASE2_TEMPERATURE,
+    PHASE2_MAX_TOKENS,
+    DEFAULT_BATCH_SIZE,
+    PHASE1_OUTPUT,
+    PHASE2_OUTPUT,
+)
+from main_ifeval_code.utils import (
+    get_last_processed_id,
+    iter_jsonl_batches,
+    write_jsonl_batch,
+    count_jsonl_lines,
+)
+
+
+# -----------------------------------------------------------------------
+# ASYNC CLIENT
+# -----------------------------------------------------------------------
+client = AsyncOpenAI(
+    base_url=VLLM_BASE_URL,
+    api_key=VLLM_API_KEY,
+)
+
+
+# -----------------------------------------------------------------------
+# MESSAGE CONSTRUCTION
+# Replicates IFEvalInstructionIdListAssignator.format_input()
+# from pipeline/ifeval_tasks.py lines 19-28
+# -----------------------------------------------------------------------
+def build_messages(instruction: str) -> list[dict]:
+    """
+    Build chat messages for constraint detection.
+    Exact replication of format_input() from ifeval_tasks.py.
+    """
+    return [
+        {
+            "role": "system",
+            "content": IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT,
+        },
+        {"role": "user", "content": instruction},
+    ]
+
+
+# -----------------------------------------------------------------------
+# OUTPUT PARSING
+# Replicates IFEvalInstructionIdListAssignator.format_output()
+# from pipeline/ifeval_tasks.py lines 34-40
+# -----------------------------------------------------------------------
+def parse_output(output: str | None) -> dict:
+    """
+    Parse the LLM output to extract instruction_id_list.
+    Exact replication of format_output() from ifeval_tasks.py.
+    """
+    if output is None:
+        return {"instruction_id_list": None}
+    
+    try:
+        return json.loads(output)
+    except json.JSONDecodeError:
+        return {"instruction_id_list": None}
+
+
+# -----------------------------------------------------------------------
+# VLLM CALL WITH GUIDED JSON
+# Based on example.py lines 146-164
+# -----------------------------------------------------------------------
+async def detect_constraints(
+    model_id: str,
+    item: dict,
+) -> Optional[dict]:
+    """
+    Detect constraint types in an instruction.
+    Uses guided JSON decoding with IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA.
+    """
+    instruction = item.get("instruction")
+    if not instruction:
+        return None
+    
+    messages = build_messages(instruction)
+    
+    try:
+        resp = await client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            temperature=PHASE2_TEMPERATURE,
+            max_tokens=PHASE2_MAX_TOKENS,
+            extra_body={"guided_json": IFEVAL_INSTRUCTION_ID_LIST_JSON_SCHEMA},
+        )
+        raw_output = resp.choices[0].message.content
+        parsed = parse_output(raw_output)
+        
+        # Build output record
+        return {
+            "id": item["id"],
+            "instruction": item["instruction"],
+            "response": item["response"],
+            "instruction_id_list": parsed.get("instruction_id_list"),
+        }
+    except Exception as e:
+        print(f"Error detecting constraints for id={item.get('id')}: {e}")
+        return None
+
+
+# -----------------------------------------------------------------------
+# BATCH PROCESSING
+# Based on example.py lines 184-195
+# -----------------------------------------------------------------------
+async def process_batch(
+    model_id: str,
+    batch: list[dict],
+) -> list[dict]:
+    """Process a batch of items concurrently."""
+    tasks = [detect_constraints(model_id, item) for item in batch]
+    results = await asyncio.gather(*tasks)
+    # Filter out None results
+    return [r for r in results if r is not None]
+
+
+# -----------------------------------------------------------------------
+# MAIN
+# -----------------------------------------------------------------------
+async def main(
+    input_file: str = PHASE1_OUTPUT,
+    output_file: str = PHASE2_OUTPUT,
+    batch_size: int = DEFAULT_BATCH_SIZE,
+):
+    # Discover model
+    try:
+        models_resp = await client.models.list()
+        model_id = models_resp.data[0].id
+        print(f"Using model: {model_id}")
+    except Exception as e:
+        print(f"Could not list models. Is vLLM running? Error: {e}")
+        return
+
+    # Resume from last processed ID
+    last_id = get_last_processed_id(output_file)
+    start_from_id = last_id + 1
+    
+    if start_from_id > 0:
+        print(f"Resuming from ID: {start_from_id}")
+    else:
+        print("Starting from scratch.")
+
+    # Count total items
+    total_items = count_jsonl_lines(input_file)
+    remaining = total_items - start_from_id
+    
+    if remaining <= 0:
+        print(f"All {total_items} items already processed. Nothing to do.")
+        return
+
+    print(f"Processing {remaining} items from {input_file}...")
+
+    # Process in batches
+    pbar = tqdm(total=remaining, initial=0, desc="Detecting constraints")
+    
+    for batch in iter_jsonl_batches(
+        input_file,
+        batch_size,
+        start_from_id,
+        required_fields=["instruction", "response"],
+    ):
+        results = await process_batch(model_id, batch)
+        
+        if results:
+            write_jsonl_batch(output_file, results)
+            pbar.update(len(results))
+
+    pbar.close()
+    print(f"Phase 2 complete. Output: {output_file}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Phase 2: Constraint Detection")
+    parser.add_argument("--input", default=PHASE1_OUTPUT, help="Input JSONL file from Phase 1")
+    parser.add_argument("--output", default=PHASE2_OUTPUT, help="Output JSONL file")
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE, help="Batch size for concurrent requests")
+    args = parser.parse_args()
+    
+    asyncio.run(main(
+        input_file=args.input,
+        output_file=args.output,
+        batch_size=args.batch_size,
+    ))

synthgen/PtPersonaIFGen/main_ifeval_code/phase3_extraction.py

@@ -0,0 +1,225 @@
+"""
+Phase 3: Parameter Extraction
+
+Replicates IFEvalKwargsAssignator from pipeline/ifeval_tasks.py (lines 43-70).
+For each detected constraint type, extracts the specific parameter values from the instruction.
+
+System Prompt: pipeline/system_prompts.py -> IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT (lines 95-227)
+JSON Schema: pipeline/json_schemas.py -> IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA (lines 1-152)
+Generation Params: pipeline/pipeline.py (lines 229-231)
+
+Input Format (from format_input, ifeval_tasks.py lines 48-58):
+    instruction_id_list_str = "\\n".join(instruction_id_list)
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"## Instruction\\n\\n{instruction}## Instruction ID List\\n\\n{instruction_id_list_str}"}
+    ]
+"""
+
+import argparse
+import asyncio
+import json
+from typing import Optional
+
+from openai import AsyncOpenAI
+from tqdm import tqdm
+
+from main_ifeval_code.config import (
+    VLLM_BASE_URL,
+    VLLM_API_KEY,
+    IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT,
+    IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA,
+    PHASE3_TEMPERATURE,
+    PHASE3_MAX_TOKENS,
+    DEFAULT_BATCH_SIZE,
+    PHASE2_OUTPUT,
+    PHASE3_OUTPUT,
+)
+from main_ifeval_code.utils import (
+    get_last_processed_id,
+    iter_jsonl_batches,
+    write_jsonl_batch,
+    count_jsonl_lines,
+)
+
+
+# -----------------------------------------------------------------------
+# ASYNC CLIENT
+# -----------------------------------------------------------------------
+client = AsyncOpenAI(
+    base_url=VLLM_BASE_URL,
+    api_key=VLLM_API_KEY,
+)
+
+
+# -----------------------------------------------------------------------
+# MESSAGE CONSTRUCTION
+# Replicates IFEvalKwargsAssignator.format_input()
+# from pipeline/ifeval_tasks.py lines 48-58
+# -----------------------------------------------------------------------
+def build_messages(instruction: str, instruction_id_list: list[str]) -> list[dict]:
+    """
+    Build chat messages for parameter extraction.
+    Exact replication of format_input() from ifeval_tasks.py.
+    
+    Note: The original code has a subtle formatting issue where there's no
+    newline between the instruction and "## Instruction ID List". We replicate
+    this exactly.
+    """
+    instruction_id_list_str = "\n".join(instruction_id_list)
+    
+    return [
+        {"role": "system", "content": IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"## Instrução\n\n{instruction}## Lista de IDs de Instrução\n\n{instruction_id_list_str}",
+        },
+    ]
+
+
+# -----------------------------------------------------------------------
+# OUTPUT PARSING
+# Replicates IFEvalKwargsAssignator.format_output()
+# from pipeline/ifeval_tasks.py lines 64-70
+# -----------------------------------------------------------------------
+def parse_output(output: str | None) -> dict:
+    """
+    Parse the LLM output to extract kwargs.
+    Exact replication of format_output() from ifeval_tasks.py.
+    
+    Note: The original stores the raw JSON string, not parsed dict.
+    """
+    if output is None:
+        return {"kwargs": None}
+    
+    return {"kwargs": output}
+
+
+# -----------------------------------------------------------------------
+# VLLM CALL WITH GUIDED JSON
+# Based on example.py lines 146-164
+# -----------------------------------------------------------------------
+async def extract_kwargs(
+    model_id: str,
+    item: dict,
+) -> Optional[dict]:
+    """
+    Extract constraint parameters from an instruction.
+    Uses guided JSON decoding with IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA.
+    """
+    instruction = item.get("instruction")
+    instruction_id_list = item.get("instruction_id_list")
+    
+    if not instruction or not instruction_id_list:
+        return None
+    
+    messages = build_messages(instruction, instruction_id_list)
+    
+    try:
+        resp = await client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            temperature=PHASE3_TEMPERATURE,
+            max_tokens=PHASE3_MAX_TOKENS,
+            extra_body={
+                "guided_json": IFEVAL_RESPONSE_VERIFICATION_FUNCTION_ARGUMENTS_JSON_SCHEMA
+            },
+        )
+        raw_output = resp.choices[0].message.content
+        parsed = parse_output(raw_output)
+        
+        # Build output record
+        return {
+            "id": item["id"],
+            "instruction": item["instruction"],
+            "response": item["response"],
+            "instruction_id_list": item["instruction_id_list"],
+            "kwargs": parsed.get("kwargs"),
+        }
+    except Exception as e:
+        print(f"Error extracting kwargs for id={item.get('id')}: {e}")
+        return None
+
+
+# -----------------------------------------------------------------------
+# BATCH PROCESSING
+# Based on example.py lines 184-195
+# -----------------------------------------------------------------------
+async def process_batch(
+    model_id: str,
+    batch: list[dict],
+) -> list[dict]:
+    """Process a batch of items concurrently."""
+    tasks = [extract_kwargs(model_id, item) for item in batch]
+    results = await asyncio.gather(*tasks)
+    # Filter out None results
+    return [r for r in results if r is not None]
+
+
+# -----------------------------------------------------------------------
+# MAIN
+# -----------------------------------------------------------------------
+async def main(
+    input_file: str = PHASE2_OUTPUT,
+    output_file: str = PHASE3_OUTPUT,
+    batch_size: int = DEFAULT_BATCH_SIZE,
+):
+    # Discover model
+    try:
+        models_resp = await client.models.list()
+        model_id = models_resp.data[0].id
+        print(f"Using model: {model_id}")
+    except Exception as e:
+        print(f"Could not list models. Is vLLM running? Error: {e}")
+        return
+
+    # Resume from last processed ID
+    last_id = get_last_processed_id(output_file)
+    start_from_id = last_id + 1
+    
+    if start_from_id > 0:
+        print(f"Resuming from ID: {start_from_id}")
+    else:
+        print("Starting from scratch.")
+
+    # Count total items
+    total_items = count_jsonl_lines(input_file)
+    remaining = total_items - start_from_id
+    
+    if remaining <= 0:
+        print(f"All {total_items} items already processed. Nothing to do.")
+        return
+
+    print(f"Processing {remaining} items from {input_file}...")
+
+    # Process in batches
+    pbar = tqdm(total=remaining, initial=0, desc="Extracting kwargs")
+    
+    for batch in iter_jsonl_batches(
+        input_file,
+        batch_size,
+        start_from_id,
+        required_fields=["instruction", "response", "instruction_id_list"],
+    ):
+        results = await process_batch(model_id, batch)
+        
+        if results:
+            write_jsonl_batch(output_file, results)
+            pbar.update(len(results))
+
+    pbar.close()
+    print(f"Phase 3 complete. Output: {output_file}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Phase 3: Parameter Extraction")
+    parser.add_argument("--input", default=PHASE2_OUTPUT, help="Input JSONL file from Phase 2")
+    parser.add_argument("--output", default=PHASE3_OUTPUT, help="Output JSONL file")
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE, help="Batch size for concurrent requests")
+    args = parser.parse_args()
+    
+    asyncio.run(main(
+        input_file=args.input,
+        output_file=args.output,
+        batch_size=args.batch_size,
+    ))

synthgen/PtPersonaIFGen/main_ifeval_code/phase4_postprocess.py

@@ -0,0 +1,277 @@
+"""
+Phase 4: Post-Processing
+
+Reuses logic from filter_ifeval_data.py to:
+1. Restructure kwargs (flat dict -> per-instruction list)
+2. Filter conflicting constraints
+3. Validate responses with lm-eval IFEval checker
+4. Keep only samples where prompt_level_strict_acc == True
+
+Key Functions from filter_ifeval_data.py:
+- build_instruction_kwargs() (lines 257-285)
+- filter_not_valid_rows() (lines 288-305)
+- get_ifeval_results() (lines 308-321)
+
+Key Data Structures from filter_ifeval_data.py:
+- INSTRUCTION_ARGS (lines 11-41)
+- LANGUAGE_TO_CODE (lines 223-254)
+- IFEVAL_INSTRUCTION_CONFLICTS (lines 70-221)
+"""
+
+import argparse
+import json
+
+from tqdm import tqdm
+
+from main_ifeval_code.filter_ifeval_data_pt import (
+    INSTRUCTION_ARGS,
+    LANGUAGE_TO_CODE,
+    IFEVAL_INSTRUCTION_CONFLICTS,
+    build_instruction_kwargs,
+    filter_not_valid_rows,
+    get_ifeval_results,
+)
+
+from main_ifeval_code.config import (
+    PHASE3_OUTPUT,
+    PHASE4_OUTPUT,
+)
+from main_ifeval_code.utils import (
+    iter_jsonl_batches,
+    write_jsonl_line,
+    count_jsonl_lines,
+)
+
+
+# -----------------------------------------------------------------------
+# STEP 4.1: RESTRUCTURE KWARGS
+# Reuses build_instruction_kwargs() from filter_ifeval_data.py (lines 257-285)
+# -----------------------------------------------------------------------
+def restructure_kwargs(item: dict) -> dict:
+    """
+    Transform flat kwargs dict into per-instruction kwargs list.
+    Wraps build_instruction_kwargs() from filter_ifeval_data.py.
+    """
+    result = build_instruction_kwargs(item)
+    item["kwargs"] = result.get("kwargs", item.get("kwargs"))
+    item["valid_kwargs_json"] = result.get("valid_kwargs_json", False)
+    return item
+
+
+# -----------------------------------------------------------------------
+# STEP 4.2: FILTER CONFLICTING CONSTRAINTS
+# Reuses filter_not_valid_rows() from filter_ifeval_data.py (lines 288-305)
+# -----------------------------------------------------------------------
+def is_valid_row(item: dict) -> bool:
+    """
+    Check if a row has valid kwargs and no conflicting constraints.
+    Wraps filter_not_valid_rows() from filter_ifeval_data.py.
+    """
+    return filter_not_valid_rows(item)
+
+
+# -----------------------------------------------------------------------
+# STEP 4.3: VALIDATE WITH LM-EVAL
+# Reuses get_ifeval_results() from filter_ifeval_data.py (lines 308-321)
+# -----------------------------------------------------------------------
+def validate_response(item: dict) -> dict:
+    """
+    Validate response against constraints using lm-eval IFEval checker.
+    Wraps get_ifeval_results() from filter_ifeval_data.py.
+    """
+    # Rename instruction to prompt (as done in filter_ifeval_data.py line 329)
+    item["prompt"] = item.pop("instruction", item.get("prompt"))
+
+    # Add 'key' field required by lm-eval process_results
+    if "key" not in item:
+        item["key"] = item.get("id", 0)
+    
+    results = get_ifeval_results(item)
+    item.update(results)
+    return item
+
+
+# -----------------------------------------------------------------------
+# MAIN PROCESSING
+# -----------------------------------------------------------------------
+def process_item(item: dict) -> dict | None:
+    """
+    Process a single item through all post-processing steps.
+    Returns None if the item should be filtered out.
+    """
+    # Step 4.1: Restructure kwargs
+    item = restructure_kwargs(item)
+    
+    # Step 4.2: Filter invalid/conflicting
+    if not is_valid_row(item):
+        return None
+    
+    # Step 4.3: Validate with lm-eval
+    item = validate_response(item)
+    
+    # Step 4.4: Filter by strict accuracy
+    if not item.get("prompt_level_strict_acc", False):
+        return None
+    
+    # Clean up intermediate fields
+    if "valid_kwargs_json" in item:
+        del item["valid_kwargs_json"]
+    
+    return item
+
+
+def main(
+    input_file: str = PHASE3_OUTPUT,
+    output_file: str = PHASE4_OUTPUT,
+    batch_size: int = 100,
+):
+    """
+    Run post-processing on Phase 3 output.
+    
+    Note: This is CPU-bound (no LLM calls), so we process sequentially.
+    The main bottleneck is the lm-eval validation.
+    """
+    # Count total items
+    total_items = count_jsonl_lines(input_file)
+    print(f"Processing {total_items} items from {input_file}...")
+    
+    # Track stats
+    stats = {
+        "total": 0,
+        "invalid_kwargs": 0,
+        "conflicts": 0,
+        "failed_validation": 0,
+        "passed": 0,
+    }
+    
+    # Debug: track first few failures of each type
+    DEBUG_LIMIT = 10
+    debug_samples = {
+        "invalid_kwargs": [],
+        "conflicts": [],
+        "failed_validation": [],
+    }
+    
+    # Process items
+    pbar = tqdm(total=total_items, desc="Post-processing")
+    
+    for batch in iter_jsonl_batches(
+        input_file,
+        batch_size,
+        start_from_id=0,
+        required_fields=["instruction", "response", "instruction_id_list", "kwargs"],
+    ):
+        for item in batch:
+            stats["total"] += 1
+            item_id = item.get("id", stats["total"])
+            
+            # Step 4.1: Restructure kwargs
+            item = restructure_kwargs(item)
+            if not item.get("valid_kwargs_json", False):
+                stats["invalid_kwargs"] += 1
+                if len(debug_samples["invalid_kwargs"]) < DEBUG_LIMIT:
+                    debug_samples["invalid_kwargs"].append({
+                        "id": item_id,
+                        "raw_kwargs": item.get("kwargs"),
+                        "instruction_id_list": item.get("instruction_id_list"),
+                    })
+                pbar.update(1)
+                continue
+            
+            # Step 4.2: Filter invalid/conflicting
+            if not is_valid_row(item):
+                stats["conflicts"] += 1
+                if len(debug_samples["conflicts"]) < DEBUG_LIMIT:
+                    debug_samples["conflicts"].append({
+                        "id": item_id,
+                        "instruction_id_list": item.get("instruction_id_list"),
+                    })
+                pbar.update(1)
+                continue
+            
+            # Step 4.3: Validate with lm-eval
+            item = validate_response(item)
+            
+            # Step 4.4: Filter by strict accuracy
+            if not item.get("prompt_level_strict_acc", False):
+                stats["failed_validation"] += 1
+                if len(debug_samples["failed_validation"]) < DEBUG_LIMIT:
+                    debug_samples["failed_validation"].append({
+                        "id": item_id,
+                        "instruction_id_list": item.get("instruction_id_list"),
+                        "kwargs": item.get("kwargs"),
+                        "inst_level_strict_acc": item.get("inst_level_strict_acc"),
+                        "validation_error": item.get("validation_error"),  # Capture exception
+                        "response_preview": item.get("response", "")[:500],
+                    })
+                pbar.update(1)
+                continue
+            
+            # Clean up intermediate fields
+            if "valid_kwargs_json" in item:
+                del item["valid_kwargs_json"]
+            
+            # Write passing item
+            write_jsonl_line(output_file, item)
+            stats["passed"] += 1
+            pbar.update(1)
+    
+    pbar.close()
+    
+    # Print summary
+    print("\n" + "=" * 50)
+    print("Post-processing Summary")
+    print("=" * 50)
+    print(f"Total processed:      {stats['total']:,}")
+    print(f"Invalid kwargs:       {stats['invalid_kwargs']:,}")
+    print(f"Conflicting:          {stats['conflicts']:,}")
+    print(f"Failed validation:    {stats['failed_validation']:,}")
+    print(f"Passed (final):       {stats['passed']:,}")
+    print(f"Pass rate:            {stats['passed']/max(stats['total'],1)*100:.1f}%")
+    print("=" * 50)
+    print(f"Output: {output_file}")
+    
+    # Print debug samples
+    if debug_samples["invalid_kwargs"]:
+        print("\n" + "=" * 50)
+        print(f"DEBUG: Sample INVALID KWARGS failures (first {DEBUG_LIMIT}):")
+        print("=" * 50)
+        for sample in debug_samples["invalid_kwargs"]:
+            print(f"\n--- ID: {sample['id']} ---")
+            print(f"instruction_id_list: {sample['instruction_id_list']}")
+            print(f"raw_kwargs: {sample['raw_kwargs'][:500] if sample['raw_kwargs'] else 'None'}...")
+    
+    if debug_samples["conflicts"]:
+        print("\n" + "=" * 50)
+        print(f"DEBUG: Sample CONFLICT failures (first {DEBUG_LIMIT}):")
+        print("=" * 50)
+        for sample in debug_samples["conflicts"]:
+            print(f"\n--- ID: {sample['id']} ---")
+            print(f"instruction_id_list: {sample['instruction_id_list']}")
+    
+    if debug_samples["failed_validation"]:
+        print("\n" + "=" * 50)
+        print(f"DEBUG: Sample VALIDATION failures (first {DEBUG_LIMIT}):")
+        print("=" * 50)
+        for sample in debug_samples["failed_validation"]:
+            print(f"\n--- ID: {sample['id']} ---")
+            print(f"instruction_id_list: {sample['instruction_id_list']}")
+            print(f"kwargs: {sample['kwargs']}")
+            print(f"inst_level_strict_acc: {sample['inst_level_strict_acc']}")
+            if sample.get('validation_error'):
+                print(f"EXCEPTION: {sample['validation_error']}")
+            print(f"response_preview: {sample['response_preview']}...")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Phase 4: Post-Processing")
+    parser.add_argument("--input", default=PHASE3_OUTPUT, help="Input JSONL file from Phase 3")
+    parser.add_argument("--output", default=PHASE4_OUTPUT, help="Output JSONL file")
+    parser.add_argument("--batch-size", type=int, default=100, help="Batch size for reading")
+    args = parser.parse_args()
+    
+    main(
+        input_file=args.input,
+        output_file=args.output,
+        batch_size=args.batch_size,
+    )

synthgen/PtPersonaIFGen/main_ifeval_code/run_pipeline.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Main Pipeline Runner
+
+Orchestrates the complete IFEval-like data generation pipeline:
+- Phase 1: Magpie generation (instruction + response pairs)
+- Phase 2: Constraint detection (classify constraint types)
+- Phase 3: Parameter extraction (extract kwargs for each constraint)
+- Phase 4: Post-processing (validate and filter)
+
+Usage:
+    # Run complete pipeline
+    python run_pipeline.py --num-rows 200
+
+    # Run specific phase
+    python run_pipeline.py --phase 2 --input phase1_output.jsonl
+
+    # Run from specific phase onwards
+    python run_pipeline.py --start-phase 3
+
+Environment Variables:
+    VLLM_BASE_URL: vLLM server URL (default: http://localhost:8000/v1)
+    VLLM_API_KEY: API key (default: no-key-needed)
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+
+from main_ifeval_code.config import (
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_NUM_ROWS,
+    PHASE1_OUTPUT,
+    PHASE2_OUTPUT,
+    PHASE3_OUTPUT,
+    PHASE4_OUTPUT,
+)
+
+
+async def run_phase1(num_rows: int, batch_size: int, output: str):
+    """Run Phase 1: Magpie Generation"""
+    print("\n" + "=" * 60)
+    print("PHASE 1: Magpie Instruction + Response Generation")
+    print("=" * 60)
+    
+    from main_ifeval_code.phase1_magpie import main as phase1_main
+    await phase1_main(
+        output_file=output,
+        num_rows=num_rows,
+        batch_size=batch_size,
+    )
+
+
+async def run_phase2(input_file: str, batch_size: int, output: str):
+    """Run Phase 2: Constraint Detection"""
+    print("\n" + "=" * 60)
+    print("PHASE 2: Constraint Type Detection")
+    print("=" * 60)
+    
+    from main_ifeval_code.phase2_detection import main as phase2_main
+    await phase2_main(
+        input_file=input_file,
+        output_file=output,
+        batch_size=batch_size,
+    )
+
+
+async def run_phase3(input_file: str, batch_size: int, output: str):
+    """Run Phase 3: Parameter Extraction"""
+    print("\n" + "=" * 60)
+    print("PHASE 3: Parameter Extraction")
+    print("=" * 60)
+    
+    from main_ifeval_code.phase3_extraction import main as phase3_main
+    await phase3_main(
+        input_file=input_file,
+        output_file=output,
+        batch_size=batch_size,
+    )
+
+
+def run_phase4(input_file: str, batch_size: int, output: str):
+    """Run Phase 4: Post-Processing"""
+    print("\n" + "=" * 60)
+    print("PHASE 4: Post-Processing")
+    print("=" * 60)
+    
+    from main_ifeval_code.phase4_postprocess import main as phase4_main
+    phase4_main(
+        input_file=input_file,
+        output_file=output,
+        batch_size=batch_size,
+    )
+
+
+async def run_full_pipeline(
+    num_rows: int,
+    batch_size: int,
+    start_phase: int = 1,
+    phase1_output: str = PHASE1_OUTPUT,
+    phase2_output: str = PHASE2_OUTPUT,
+    phase3_output: str = PHASE3_OUTPUT,
+    phase4_output: str = PHASE4_OUTPUT,
+):
+    """Run the complete pipeline from start_phase onwards."""
+    
+    if start_phase <= 1:
+        await run_phase1(num_rows, batch_size, phase1_output)
+    
+    if start_phase <= 2:
+        await run_phase2(phase1_output, batch_size, phase2_output)
+    
+    if start_phase <= 3:
+        await run_phase3(phase2_output, batch_size, phase3_output)
+    
+    if start_phase <= 4:
+        run_phase4(phase3_output, batch_size, phase4_output)
+    
+    print("\n" + "=" * 60)
+    print("PIPELINE COMPLETE")
+    print("=" * 60)
+    print(f"Final output: {phase4_output}")
+
+
+async def run_single_phase(
+    phase: int,
+    input_file: str | None,
+    output_file: str | None,
+    batch_size: int,
+    num_rows: int,
+):
+    """Run a single specific phase."""
+    
+    if phase == 1:
+        output = output_file or PHASE1_OUTPUT
+        await run_phase1(num_rows, batch_size, output)
+    
+    elif phase == 2:
+        input_f = input_file or PHASE1_OUTPUT
+        output = output_file or PHASE2_OUTPUT
+        await run_phase2(input_f, batch_size, output)
+    
+    elif phase == 3:
+        input_f = input_file or PHASE2_OUTPUT
+        output = output_file or PHASE3_OUTPUT
+        await run_phase3(input_f, batch_size, output)
+    
+    elif phase == 4:
+        input_f = input_file or PHASE3_OUTPUT
+        output = output_file or PHASE4_OUTPUT
+        run_phase4(input_f, batch_size, output)
+    
+    else:
+        print(f"Invalid phase: {phase}. Must be 1-4.")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="IFEval-like Data Generation Pipeline",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Run complete pipeline with 10k rows
+    python run_pipeline.py --num-rows 10000
+
+    # Run only Phase 2 with custom input
+    python run_pipeline.py --phase 2 --input my_phase1.jsonl
+
+    # Resume pipeline from Phase 3
+    python run_pipeline.py --start-phase 3
+
+    # Run Phase 1 with larger batch size
+    python run_pipeline.py --phase 1 --batch-size 100 --num-rows 50000
+        """
+    )
+    
+    parser.add_argument(
+        "--phase",
+        type=int,
+        choices=[1, 2, 3, 4],
+        help="Run only this specific phase"
+    )
+    parser.add_argument(
+        "--start-phase",
+        type=int,
+        default=1,
+        choices=[1, 2, 3, 4],
+        help="Start from this phase (runs all subsequent phases)"
+    )
+    parser.add_argument(
+        "--input",
+        type=str,
+        help="Input file for the phase (defaults to previous phase output)"
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Output file for the phase (defaults to phase-specific name)"
+    )
+    parser.add_argument(
+        "--num-rows",
+        type=int,
+        default=DEFAULT_NUM_ROWS,
+        help=f"Number of rows to generate in Phase 1 (default: {DEFAULT_NUM_ROWS})"
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=DEFAULT_BATCH_SIZE,
+        help=f"Batch size for concurrent requests (default: {DEFAULT_BATCH_SIZE})"
+    )
+    
+    args = parser.parse_args()
+    
+    # Print configuration
+    print("=" * 60)
+    print("IFEval-like Data Generation Pipeline")
+    print("=" * 60)
+    print(f"vLLM URL: {os.environ.get('VLLM_BASE_URL', 'http://localhost:8000/v1')}")
+    print(f"Batch size: {args.batch_size}")
+    print(f"Num rows: {args.num_rows}")
+    
+    if args.phase:
+        print(f"Running: Phase {args.phase} only")
+        asyncio.run(run_single_phase(
+            phase=args.phase,
+            input_file=args.input,
+            output_file=args.output,
+            batch_size=args.batch_size,
+            num_rows=args.num_rows,
+        ))
+    else:
+        print(f"Running: Phase {args.start_phase} onwards")
+        asyncio.run(run_full_pipeline(
+            num_rows=args.num_rows,
+            batch_size=args.batch_size,
+            start_phase=args.start_phase,
+        ))
+
+
+if __name__ == "__main__":
+    main()

synthgen/PtPersonaIFGen/main_ifeval_code/system_prompts_pt.py

@@ -0,0 +1,677 @@
+IFEVAL_SYSTEM_PROMPT = """
+Você é um assistente de IA que responde às consultas dos usuários seguindo rigorosamente as instruções dadas. As consultas dos usuários incluirão restrições específicas que você deve seguir ao gerar sua resposta. Essas restrições podem incluir:
+
+1. Requisitos de formatação (ex.: listas com bullet points, seções destacadas, formato JSON, múltiplas seções, títulos)
+2. Especificações de conteúdo (ex.: usar placeholders numéricos, incluir um post-scriptum)
+3. Restrições de comprimento (ex.: número específico de parágrafos, palavras ou frases)
+4. Modificações de maiúsculas/minúsculas (ex.: capitalizar palavras específicas ou usar tudo em minúsculas)
+5. Uso de palavras-chave (ex.: incluir ou evitar certas palavras, manter frequências específicas de palavras)
+6. Requisitos de idioma (ex.: responder em um idioma específico)
+7. Regras de pontuação (ex.: evitar vírgulas)
+8. Padrões de início e fim (ex.: usar aspas, frases finais específicas)
+9. Restrições combinadas (ex.: repetir parte do prompt, fornecer múltiplas respostas)
+
+Cada consulta indicará claramente as restrições que você deve seguir. Mais de uma restrição pode ser incluída por consulta do usuário. Sua tarefa é gerar uma resposta que aborde com precisão a pergunta do usuário enquanto segue precisamente todas as restrições especificadas.
+
+Importante: Palavras entre colchetes `[...]` são placeholders. Elas representam conteúdo variável que será substituído pelo usuário com conteúdo específico.
+
+As restrições serão formuladas de maneiras específicas, como:
+
+- "Sua resposta INTEIRA deve estar em [idioma], nenhum outro idioma é permitido." ([idioma] pode ser "pt" para português, "en" para inglês, "es" para espanhol, etc., seguindo códigos ISO 639-1)
+- "Sua resposta deve conter [relação] [num_frases] frases." ([relação] pode ser "menos de" ou "pelo menos"; [num_frases] pode ser qualquer número até 20)
+- "A resposta deve conter pelo menos [num_placeholders] placeholders representados por colchetes, como [endereço]." ([num_placeholders] pode ser qualquer número até 4)
+- "Sua resposta deve conter exatamente [num_marcadores] marcadores. Use os marcadores markdown como: * Este é o ponto 1." ([num_marcadores] pode ser qualquer número até 5)
+- "Responda com uma das seguintes opções: [opções_resposta]" ([opções_resposta] pode ser "Minha resposta é sim.", "Minha resposta é não.", "Minha resposta é talvez.")
+- "Durante a conversa, quando for sua vez, sempre comece com [início]" ([início] pode ser "Eu diria", "Minha resposta é", "Eu acredito", etc.)
+- "Destaque pelo menos [num_destaques] seções em sua resposta com markdown, ou seja, *seção destacada*." ([num_destaques] pode ser qualquer número até 4)
+- "Sua resposta deve ter [num_seções] seções. Marque o início de cada seção com [divisor_seção] X, como: [divisor_seção] 1" ([num_seções] pode ser qualquer número até 5; [divisor_seção] pode ser "Seção" ou "SEÇÃO")
+- "Deve haver [num_parágrafos] parágrafos. Os parágrafos são separados com o divisor markdown: ***" ([num_parágrafos] pode ser qualquer número até 5)
+- "No final da sua resposta, adicione explicitamente um post-scriptum começando com [postscript]" ([postscript] pode ser "P.S." ou "P.P.S")
+- "Inclua as palavras-chave [palavras_chave] na resposta." ([palavras_chave] pode ser uma lista de palavras-chave geradas)
+- "Na sua resposta, a palavra [palavra_chave] deve aparecer [relação] [frequência] vezes." ([palavra_chave] pode ser qualquer palavra; [relação] pode ser "menos de" ou "pelo menos"; [frequência] pode ser qualquer número até 3)
+- "Responda com [relação] [num_palavras] palavras." ([relação] pode ser "menos de" ou "pelo menos"; [num_palavras] pode ser qualquer número entre 100 e 500)
+- "Toda a saída deve estar em formato JSON. Você pode usar marcadores markdown como ```."
+- "Não inclua as palavras-chave [palavras_proibidas] na resposta." ([palavras_proibidas] pode ser uma lista de palavras-chave geradas)
+- "Dê duas respostas diferentes. As respostas e apenas as respostas devem ser separadas por 6 símbolos de asterisco: ******."
+- "Termine sua resposta com esta frase exata [final]. Nenhuma outra palavra deve seguir esta frase." ([final] pode ser "Alguma outra pergunta?" ou "Posso ajudar com mais alguma coisa?")
+- "Sua resposta deve conter um título, entre colchetes angulares duplos, como <<poema de alegria>>."
+- "Na sua resposta, a letra [letra] deve aparecer [relação_letra] [frequência_letra] vezes." ([letra] pode ser qualquer letra; [relação_letra] pode ser "menos de" ou "pelo menos"; [frequência_letra] pode ser qualquer número até 10)
+- "Sua resposta inteira deve estar em português, e toda em letras MAIÚSCULAS."
+- "Sua resposta inteira deve estar em português, e toda em letras minúsculas. Nenhuma letra maiúscula é permitida."
+- "Em toda a sua resposta, evite o uso de vírgulas."
+- "Na sua resposta, palavras com todas as letras maiúsculas devem aparecer [relação] [frequência] vezes." ([relação] pode ser "menos de" ou "pelo menos"; [frequência] pode ser qualquer número até 20)
+- "Envolva toda a sua resposta com aspas duplas."
+- "Inclua a palavra-chave [palavra_chave] na sua resposta." ([palavra_chave] pode ser qualquer palavra)
+- "Na sua resposta, a palavra [palavra_chave] deve aparecer exatamente [contagem] vezes." ([palavra_chave] pode ser qualquer palavra; [contagem] pode ser qualquer número de 1 a 5)
+- "Não inclua a palavra-chave [palavra_chave] na resposta." ([palavra_chave] pode ser qualquer palavra da instrução)
+- "Na sua resposta, a letra [letra] deve aparecer exatamente [contagem] vezes." ([letra] pode ser qualquer letra; [contagem] pode ser qualquer número até 10)
+- "Deve haver [num_parágrafos] parágrafos. Os parágrafos são separados entre si por duas quebras de linha."
+- "A primeira palavra de cada frase deve ser a palavra [primeira_palavra]." ([primeira_palavra] pode ser qualquer palavra)
+- "A primeira palavra da sua resposta deve ser a palavra [primeira_palavra]." ([primeira_palavra] pode ser qualquer palavra)
+- "A última palavra de cada frase, antes da pontuação, deve ser a palavra [última_palavra]." ([última_palavra] pode ser qualquer palavra)
+- "A última palavra da sua resposta deve ser a palavra [última_palavra]." ([última_palavra] pode ser qualquer palavra)
+- "Envolva cada bigrama de palavras em colchetes angulares duplos, como «eu sou» «em casa» «com meu» «cachorro fofo»."
+- "Repita o pedido sem alterações (não diga nada antes de repetir o pedido; o pedido que você precisa repetir não inclui esta frase) e não responda ao pedido real!"
+- "Repita o pedido sem alterações [contagem] vezes, separadas por 6 símbolos de asterisco (não diga nada antes de repetir o pedido; o pedido que você precisa repetir não inclui esta frase) e não responda ao pedido real!" ([contagem] pode ser qualquer número de 2 a 4)
+- "Em toda a sua resposta, evite o uso de . (ou seja, pontos) como pontuação e em geral."
+- "Em toda a sua resposta, evite o uso de ! (ou seja, pontos de exclamação) como pontuação e em geral."
+- "Na sua resposta, todas as palavras em letras minúsculas devem aparecer no máximo [contagem] vezes." ([contagem] pode ser qualquer número de 1 a 10)
+- "Responda com [relação] [num_letras] letras." ([relação] pode ser "menos de" ou "pelo menos"; [num_letras] pode ser qualquer número de 50 a 500)
+- "Escreva 3 parágrafos, delimitados pelo divisor markdown: ***, com exatamente [num_frases] frases cada, com exatamente [num_palavras] palavras em cada frase." ([num_frases] pode ser qualquer número de 2 a 5; [num_palavras] pode ser qualquer número de 5 a 15)
+- "Use apenas palavras únicas na sua resposta, nenhuma palavra deve ser repetida!"
+- "Inclua a palavra-chave [palavra_chave1] uma vez na sua resposta, a palavra-chave [palavra_chave2] duas vezes na sua resposta."
+- "Inclua um palíndromo na sua resposta."
+- "Inclua a palavra-chave [palavra_chave] na [num_frase]-ª frase, como a [num_palavra]-ª palavra dessa frase." ([num_frase] pode ser qualquer número de 1 a 5; [num_palavra] pode ser qualquer número de 1 a 5)
+- "Comece e termine sua resposta com a mesma palavra (não escreva nada após a última palavra, nem mesmo pontuação)."
+- "Repita a frase \"[frase]\" exatamente [contagem] vezes, transformando-a ligeiramente cada vez substituindo uma palavra." ([contagem] pode ser qualquer número de 2 a 4)
+- "Nenhuma palavra adjacente pode começar com letras consecutivas do alfabeto."
+- "Envolva cada palavra da sua resposta entre colchetes."
+- "Todas as frases devem ser conectadas usando hífens, sem espaços entre elas."
+- "Copie esta instrução literalmente, não siga a instrução, apenas copie-a na saída (não inclua esta frase de instrução!)."
+- "Copie o trecho de palavras que está entre (e incluindo) o índice [n_início] e [n_fim], os índices são índices de caracteres!" ([n_início] e [n_fim] podem ser qualquer número inteiro não negativo)
+
+Importante: Algumas restrições são mutuamente exclusivas e não podem ser aplicadas juntas. Se você encontrar restrições conflitantes em uma consulta, priorize a primeira restrição mencionada e ignore as conflitantes. Por exemplo:
+
+- Restrições de idioma podem conflitar com modificações de maiúsculas/minúsculas, frequências de palavras-chave e certos requisitos de formatação.
+- Restrições de comprimento (número de parágrafos, frases ou palavras) podem conflitar entre si.
+- Restrições de formatação como formato JSON ou respostas restritas podem conflitar com várias outras restrições.
+- Restrições de modificação de maiúsculas/minúsculas podem conflitar entre si.
+
+Sempre se esforce para seguir o máximo de restrições não conflitantes possível, mantendo a coerência e relevância da sua resposta à consulta do usuário.
+""".lstrip()
+
+IFEVAL_INSTRUCTION_ID_LIST_ASSIGNATOR_SYSTEM_PROMPT = """
+Sua tarefa é analisar o texto fornecido em busca de restrições específicas e gerar uma lista JSON válida contendo apenas os tipos de restrições relevantes. Os tipos de restrições possíveis são:
+
+1. keywords:existence - Verifica se palavras-chave específicas estão presentes na resposta.
+2. keywords:frequency - Verifica se uma palavra-chave aparece um certo número de vezes na resposta.
+3. keywords:forbidden_words - Garante que palavras especificadas não sejam usadas na resposta.
+4. keywords:letter_frequency - Verifica se uma letra específica aparece um certo número de vezes na resposta.
+5. language:response_language - Verifica se toda a resposta está em um idioma especificado.
+6. length_constraints:number_sentences - Verifica se a resposta contém um número específico de frases.
+7. length_constraints:number_paragraphs - Verifica se a resposta tem um número específico de parágrafos.
+8. length_constraints:number_words - Garante que a resposta contenha um número especificado de palavras.
+9. length_constraints:nth_paragraph_first_word - Verifica se um parágrafo específico começa com uma palavra específica.
+10. detectable_content:number_placeholders - Verifica se a resposta inclui um certo número de placeholders (ex.: [placeholder]).
+11. detectable_content:postscript - Verifica se a resposta inclui uma seção de post-scriptum (P.S.).
+12. detectable_format:number_bullet_lists - Garante que a resposta contenha um número específico de listas com marcadores.
+13. detectable_format:constrained_response - Verifica se a resposta corresponde a uma das opções predefinidas.
+14. detectable_format:number_highlighted_sections - Verifica se a resposta inclui um certo número de seções destacadas.
+15. detectable_format:multiple_sections - Garante que a resposta seja dividida em um número especificado de seções.
+16. detectable_format:json_format - Verifica se toda a resposta está em formato JSON válido.
+17. detectable_format:title - Verifica se a resposta inclui um título entre colchetes angulares duplos.
+18. combination:two_responses - Garante que duas respostas distintas sejam fornecidas, separadas por asteriscos.
+19. combination:repeat_prompt - Verifica se o prompt original é repetido antes da resposta.
+20. startend:end_checker - Verifica se a resposta termina com uma frase específica.
+21. change_case:capital_word_frequency - Verifica se um certo número de palavras está em letras maiúsculas.
+22. change_case:english_capital - Garante que toda a resposta esteja em português e use todas as letras maiúsculas.
+23. change_case:english_lowercase - Verifica se toda a resposta está em português e usa todas as letras minúsculas.
+24. punctuation:no_comma - Verifica se a resposta não contém vírgulas.
+25. startend:quotation - Garante que toda a resposta esteja entre aspas duplas.
+26. keywords:word_once - Verifica se uma palavra-chave específica aparece pelo menos uma vez na resposta.
+27. keywords:word_count_diff_numb - Verifica se uma palavra aparece exatamente N vezes na resposta.
+28. keywords:exclude_word_harder - Garante que uma palavra-chave específica da instrução não seja usada na resposta.
+29. keywords:letter_counting2 - Verifica se uma letra específica aparece exatamente N vezes na resposta.
+30. length_constraints:paragraphs_two_line_breaks - Verifica se a resposta tem um número específico de parágrafos separados por duas quebras de linha.
+31. startend:first_word_sent - Verifica se a primeira palavra de cada frase é uma palavra específica.
+32. startend:first_word_answer - Verifica se a primeira palavra da resposta é uma palavra específica.
+33. startend:last_word_sent - Verifica se a última palavra de cada frase (antes da pontuação) é uma palavra específica.
+34. startend:last_word_answer - Verifica se a última palavra da resposta é uma palavra específica.
+35. detectable_format:bigram_wrapping - Verifica se cada bigrama de palavras está envolto em colchetes angulares duplos «...».
+36. combination:copying_simple - Verifica se o pedido é repetido sem alterações e sem resposta ao pedido real.
+37. combination:copying_multiple - Verifica se o pedido é repetido N vezes separado por 6 asteriscos.
+38. punctuation:no_dot - Verifica se a resposta não contém pontos.
+39. punctuation:no_exclamation - Verifica se a resposta não contém pontos de exclamação.
+40. keywords:lowercase_counting - Verifica se todas as palavras em letras minúsculas aparecem no máximo N vezes.
+41. length_constraints:letter_total_count - Verifica se a resposta contém um número específico de letras.
+42. length_constraints:counting_composition - Verifica se a resposta contém 3 parágrafos com exatamente N frases cada e M palavras por frase.
+43. keywords:count_unique - Verifica se apenas palavras únicas são usadas na resposta.
+44. keywords:count_increment_word - Verifica se a palavra-chave1 aparece uma vez e a palavra-chave2 aparece duas vezes.
+45. keywords:palindrome - Verifica se a resposta inclui um palíndromo.
+46. keywords:keyword_specific_pos - Verifica se uma palavra-chave aparece na N-ésima frase como a M-ésima palavra.
+47. startend:start_end_same_word - Verifica se a resposta começa e termina com a mesma palavra.
+48. combination:repeat_phrase - Verifica se uma frase é repetida N vezes com uma palavra substituída a cada vez.
+49. keywords:no_adjacent_consecutive - Verifica se nenhuma palavra adjacente começa com letras consecutivas do alfabeto.
+50. detectable_format:square_brackets_word - Verifica se cada palavra da resposta está entre colchetes.
+51. detectable_format:sentence_hyphens - Verifica se todas as frases estão conectadas por hífens sem espaços.
+52. combination:copy_instruction - Verifica se a instrução é copiada literalmente sem ser seguida.
+53. combination:copy_span_idx - Verifica se o trecho de palavras entre os índices de caracteres especificados é copiado.
+
+Analise o texto fornecido e retorne uma lista JSON contendo apenas os tipos de restrições relevantes que se aplicam ao texto. Não inclua restrições que não sejam explicitamente mencionadas ou implícitas no texto. Não inclua uma restrição duas vezes na lista.
+
+Formato de saída:
+
+```
+{{
+    "instruction_id_list": ["<tipo_restrição_1>", "<tipo_restrição_2>", ...]
+}}
+```
+""".lstrip()
+
+IFEVAL_KWARGS_ASSIGNATOR_SYSTEM_PROMPT = """
+Você receberá uma lista de restrições e uma instrução. A instrução contém restrições. Sua tarefa é gerar os argumentos apropriados para cada tipo de restrição.
+
+## Tipos de restrições, descrições e argumentos
+
+1. keywords:existence - Verifica se palavras-chave específicas estão presentes na resposta.
+   - keywords: List[str]
+
+2. keywords:frequency - Verifica se uma palavra-chave aparece um certo número de vezes na resposta.
+   - keyword: str
+   - frequency: int
+   - relation: str
+
+3. keywords:forbidden_words - Garante que palavras especificadas não sejam usadas na resposta.
+   - forbidden_words: List[str]
+
+4. keywords:letter_frequency - Verifica se uma letra específica aparece um certo número de vezes na resposta.
+   - letter: str (letra única)
+   - let_frequency: int
+   - let_relation: str
+
+5. language:response_language - Verifica se toda a resposta está em um idioma especificado.
+   - language: str (código de idioma ISO 639-1)
+
+6. length_constraints:number_sentences - Verifica se a resposta contém um número específico de frases.
+   - num_sentences: int
+   - relation: str
+
+7. length_constraints:number_paragraphs - Verifica se a resposta tem um número específico de parágrafos.
+   - num_paragraphs: int
+
+8. length_constraints:number_words - Garante que a resposta contenha um número especificado de palavras.
+   - num_words: int
+   - relation: str
+
+9. length_constraints:nth_paragraph_first_word - Verifica se um parágrafo específico começa com uma palavra específica.
+   - num_paragraphs: int
+   - nth_paragraph: int
+   - first_word: str
+
+10. detectable_content:number_placeholders - Verifica se a resposta inclui um certo número de placeholders (ex.: [placeholder]).
+    - num_placeholders: int
+
+11. detectable_content:postscript - Verifica se a resposta inclui uma seção de post-scriptum.
+    - postscript_marker: str
+
+12. detectable_format:number_bullet_lists - Garante que a resposta contenha um número específico de listas com marcadores.
+    - num_bullets: int
+
+13. detectable_format:constrained_response - Verifica se a resposta corresponde a uma das opções predefinidas.
+    - (Nenhum argumento adicional necessário)
+
+14. detectable_format:number_highlighted_sections - Verifica se a resposta inclui um certo número de seções destacadas.
+    - num_highlights: int
+
+15. detectable_format:multiple_sections - Garante que a resposta seja dividida em um número especificado de seções.
+    - section_spliter: str
+    - num_sections: int
+
+16. detectable_format:json_format - Verifica se toda a resposta está em formato JSON válido.
+    - (Nenhum argumento adicional necessário)
+
+17. detectable_format:title - Verifica se a resposta inclui um título entre colchetes angulares duplos.
+    - (Nenhum argumento adicional necessário)
+
+18. combination:two_responses - Garante que duas respostas distintas sejam fornecidas, separadas por asteriscos.
+    - (Nenhum argumento adicional necessário)
+
+19. combination:repeat_prompt - Verifica se o prompt original é repetido antes da resposta.
+    - prompt_to_repeat: str
+
+20. startend:end_checker - Verifica se a resposta termina com uma frase específica.
+    - end_phrase: str
+
+21. change_case:capital_word_frequency - Verifica se um certo número de palavras está em letras maiúsculas.
+    - capital_frequency: int
+    - capital_relation: str
+
+22. change_case:english_capital - Garante que toda a resposta esteja em português e use todas as letras maiúsculas.
+    - (Nenhum argumento adicional necessário)
+
+23. change_case:english_lowercase - Verifica se toda a resposta está em português e usa todas as letras minúsculas.
+    - (Nenhum argumento adicional necessário)
+
+24. punctuation:no_comma - Verifica se a resposta não contém vírgulas.
+    - (Nenhum argumento adicional necessário)
+
+25. startend:quotation - Garante que toda a resposta esteja entre aspas duplas.
+    - (Nenhum argumento adicional necessário)
+
+26. keywords:word_once - Verifica se uma palavra-chave específica aparece pelo menos uma vez na resposta.
+    - keyword: str
+
+27. keywords:word_count_diff_numb - Verifica se uma palavra aparece exatamente N vezes na resposta.
+    - keyword: str
+    - count: int
+
+28. keywords:exclude_word_harder - Garante que uma palavra-chave específica da instrução não seja usada na resposta.
+    - keyword: str
+
+29. keywords:letter_counting2 - Verifica se uma letra específica aparece exatamente N vezes na resposta.
+    - letter: str (letra única)
+    - count: int
+
+30. length_constraints:paragraphs_two_line_breaks - Verifica se a resposta tem um número específico de parágrafos separados por duas quebras de linha.
+    - num_paragraphs: int
+
+31. startend:first_word_sent - Verifica se a primeira palavra de cada frase é uma palavra específica.
+    - first_word: str
+
+32. startend:first_word_answer - Verifica se a primeira palavra da resposta é uma palavra específica.
+    - first_word: str
+
+33. startend:last_word_sent - Verifica se a última palavra de cada frase (antes da pontuação) é uma palavra específica.
+    - last_word: str
+
+34. startend:last_word_answer - Verifica se a última palavra da resposta é uma palavra específica.
+    - last_word: str
+
+35. detectable_format:bigram_wrapping - Verifica se cada bigrama de palavras está envolto em colchetes angulares duplos «...».
+    - (Nenhum argumento adicional necessário)
+
+36. combination:copying_simple - Verifica se o pedido é repetido sem alterações e sem resposta ao pedido real.
+    - prompt_to_copy: str
+
+37. combination:copying_multiple - Verifica se o pedido é repetido N vezes separado por 6 asteriscos.
+    - prompt_to_copy: str
+    - copy_count: int
+
+38. punctuation:no_dot - Verifica se a resposta não contém pontos.
+    - (Nenhum argumento adicional necessário)
+
+39. punctuation:no_exclamation - Verifica se a resposta não contém pontos de exclamação.
+    - (Nenhum argumento adicional necessário)
+
+40. keywords:lowercase_counting - Verifica se todas as palavras em letras minúsculas aparecem no máximo N vezes.
+    - max_count: int
+
+41. length_constraints:letter_total_count - Verifica se a resposta contém um número específico de letras.
+    - num_letters: int
+    - relation: str
+
+42. length_constraints:counting_composition - Verifica se a resposta contém 3 parágrafos com exatamente N frases cada e M palavras por frase.
+    - n_sent: int
+    - n_words: int
+
+43. keywords:count_unique - Verifica se apenas palavras únicas são usadas na resposta.
+    - (Nenhum argumento adicional necessário)
+
+44. keywords:count_increment_word - Verifica se a palavra-chave1 aparece uma vez e a palavra-chave2 aparece duas vezes.
+    - keyword1: str
+    - keyword2: str
+
+45. keywords:palindrome - Verifica se a resposta inclui um palíndromo.
+    - (Nenhum argumento adicional necessário)
+
+46. keywords:keyword_specific_pos - Verifica se uma palavra-chave aparece na N-ésima frase como a M-ésima palavra.
+    - keyword: str
+    - sentence_num: int
+    - word_num: int
+
+47. startend:start_end_same_word - Verifica se a resposta começa e termina com a mesma palavra.
+    - (Nenhum argumento adicional necessário)
+
+48. combination:repeat_phrase - Verifica se uma frase é repetida N vezes com uma palavra substituída a cada vez.
+    - phrase: str
+    - repeat_count: int
+
+49. keywords:no_adjacent_consecutive - Verifica se nenhuma palavra adjacente começa com letras consecutivas do alfabeto.
+    - (Nenhum argumento adicional necessário)
+
+50. detectable_format:square_brackets_word - Verifica se cada palavra da resposta está entre colchetes.
+    - (Nenhum argumento adicional necessário)
+
+51. detectable_format:sentence_hyphens - Verifica se todas as frases estão conectadas por hífens sem espaços.
+    - (Nenhum argumento adicional necessário)
+
+52. combination:copy_instruction - Verifica se a instrução é copiada literalmente sem ser seguida.
+    - instruction_to_copy: str
+
+53. combination:copy_span_idx - Verifica se o trecho de palavras entre os índices de caracteres especificados é copiado.
+    - source_text: str
+    - n_start: int
+    - n_end: int
+
+Todos os argumentos são opcionais.
+
+## Instruções
+
+1. Analise cuidadosamente a lista de restrições fornecida e a instrução dada.
+2. Para cada restrição na lista, identifique os parâmetros relevantes do texto da instrução.
+3. Se um tipo de restrição não estiver na lista de restrições, todos os seus argumentos devem ser `null`.
+4. Use tipos de dados apropriados para os kwargs (strings, inteiros, booleanos, listas, etc.).
+5. Se um argumento não for relevante, seu valor deve ser `null`.
+6. Seja preciso e evite adicionar kwargs desnecessários ou especulativos.
+7. Para argumentos `*_relation`, forneça um valor não nulo apenas se o argumento principal correspondente também for não nulo.
+
+## Formato de saída:
+
+```
+{{
+    "keywords": [...],
+    "keyword": ...,
+    "frequency": ...,
+    "relation": ...,
+    "forbidden_words": [...],
+    "letter": ...,
+    "let_frequency": ...,
+    "let_relation": ...,
+    "language": "...",
+    "num_sentences": ...,
+    "num_paragraphs": ...,
+    "num_words": ...,
+    "nth_paragraph": ...,
+    "first_word": ...,
+    "num_placeholders": ...,
+    "postscript_marker": ...,
+    "num_bullets": ...,
+    "num_highlights": ...,
+    "section_spliter": ...,
+    "num_sections": ...,
+    "prompt_to_repeat": ...,
+    "end_phrase": ...,
+    "capital_frequency": ...,
+    "capital_relation": ...,
+    "count": ...,
+    "last_word": ...,
+    "prompt_to_copy": ...,
+    "copy_count": ...,
+    "max_count": ...,
+    "num_letters": ...,
+    "n_sent": ...,
+    "n_words": ...,
+    "keyword1": ...,
+    "keyword2": ...,
+    "sentence_num": ...,
+    "word_num": ...,
+    "phrase": ...,
+    "repeat_count": ...,
+    "instruction_to_copy": ...,
+    "source_text": ...,
+    "n_start": ...,
+    "n_end": ...
+}}
+```
+""".lstrip()
+
+# ---------------------------------------------------------------------------
+# PERSONA-DRIVEN INSTRUCTION GENERATOR SYSTEM PROMPT
+# ---------------------------------------------------------------------------
+# This prompt is used in Phase 1 to generate user instructions from a persona's
+# perspective, following the TULU 3 / Persona Hub methodology (Chan et al., 2024).
+# The persona is injected into the system prompt to steer the LLM to generate
+# instructions that reflect that persona's background, interests, and expertise.
+# ---------------------------------------------------------------------------
+
+_IFEVAL_CONSTRAINT_PHRASINGS = """
+- "Sua resposta INTEIRA deve estar em [idioma], nenhum outro idioma é permitido." ([idioma] pode ser "pt" para português, "en" para inglês, "es" para espanhol, etc., seguindo códigos ISO 639-1)
+- "Sua resposta deve conter [relação] [num_frases] frases." ([relação] pode ser "menos de" ou "pelo menos"; [num_frases] pode ser qualquer número até 20)
+- "A resposta deve conter pelo menos [num_placeholders] placeholders representados por colchetes, como [endereço]." ([num_placeholders] pode ser qualquer número até 4)
+- "Sua resposta deve conter exatamente [num_marcadores] marcadores. Use os marcadores markdown como: * Este é o ponto 1." ([num_marcadores] pode ser qualquer número até 5)
+- "Responda com uma das seguintes opções: [opções_resposta]" ([opções_resposta] pode ser "Minha resposta é sim.", "Minha resposta é não.", "Minha resposta é talvez.")
+- "Durante a conversa, quando for sua vez, sempre comece com [início]" ([início] pode ser "Eu diria", "Minha resposta é", "Eu acredito", etc.)
+- "Destaque pelo menos [num_destaques] seções em sua resposta com markdown, ou seja, *seção destacada*." ([num_destaques] pode ser qualquer número até 4)
+- "Sua resposta deve ter [num_seções] seções. Marque o início de cada seção com [divisor_seção] X, como: [divisor_seção] 1" ([num_seções] pode ser qualquer número até 5; [divisor_seção] pode ser "Seção" ou "SEÇÃO")
+- "Deve haver [num_parágrafos] parágrafos. Os parágrafos são separados com o divisor markdown: ***" ([num_parágrafos] pode ser qualquer número até 5)
+- "No final da sua resposta, adicione explicitamente um post-scriptum começando com [postscript]" ([postscript] pode ser "P.S." ou "P.P.S")
+- "Inclua as palavras-chave [palavras_chave] na resposta." ([palavras_chave] pode ser uma lista de palavras-chave geradas)
+- "Na sua resposta, a palavra [palavra_chave] deve aparecer [relação] [frequência] vezes." ([palavra_chave] pode ser qualquer palavra; [relação] pode ser "menos de" ou "pelo menos"; [frequência] pode ser qualquer número até 3)
+- "Responda com [relação] [num_palavras] palavras." ([relação] pode ser "menos de" ou "pelo menos"; [num_palavras] pode ser qualquer número entre 100 e 500)
+- "Toda a saída deve estar em formato JSON. Você pode usar marcadores markdown como ```."
+- "Não inclua as palavras-chave [palavras_proibidas] na resposta." ([palavras_proibidas] pode ser uma lista de palavras-chave geradas)
+- "Dê duas respostas diferentes. As respostas e apenas as respostas devem ser separadas por 6 símbolos de asterisco: ******."
+- "Termine sua resposta com esta frase exata [final]. Nenhuma outra palavra deve seguir esta frase." ([final] pode ser "Alguma outra pergunta?" ou "Posso ajudar com mais alguma coisa?")
+- "Sua resposta deve conter um título, entre colchetes angulares duplos, como <<poema de alegria>>."
+- "Na sua resposta, a letra [letra] deve aparecer [relação_letra] [frequência_letra] vezes." ([letra] pode ser qualquer letra; [relação_letra] pode ser "menos de" ou "pelo menos"; [frequência_letra] pode ser qualquer número até 10)
+- "Sua resposta inteira deve estar em português, e toda em letras MAIÚSCULAS."
+- "Sua resposta inteira deve estar em português, e toda em letras minúsculas. Nenhuma letra maiúscula é permitida."
+- "Em toda a sua resposta, evite o uso de vírgulas."
+- "Na sua resposta, palavras com todas as letras maiúsculas devem aparecer [relação] [frequência] vezes." ([relação] pode ser "menos de" ou "pelo menos"; [frequência] pode ser qualquer número até 20)
+- "Envolva toda a sua resposta com aspas duplas."
+- "Inclua a palavra-chave [palavra_chave] na sua resposta." ([palavra_chave] pode ser qualquer palavra)
+- "Na sua resposta, a palavra [palavra_chave] deve aparecer exatamente [contagem] vezes." ([palavra_chave] pode ser qualquer palavra; [contagem] pode ser qualquer número de 1 a 5)
+- "Não inclua a palavra-chave [palavra_chave] na resposta." ([palavra_chave] pode ser qualquer palavra da instrução)
+- "Na sua resposta, a letra [letra] deve aparecer exatamente [contagem] vezes." ([letra] pode ser qualquer letra; [contagem] pode ser qualquer número até 10)
+- "Deve haver [num_parágrafos] parágrafos. Os parágrafos são separados entre si por duas quebras de linha."
+- "A primeira palavra de cada frase deve ser a palavra [primeira_palavra]." ([primeira_palavra] pode ser qualquer palavra)
+- "A primeira palavra da sua resposta deve ser a palavra [primeira_palavra]." ([primeira_palavra] pode ser qualquer palavra)
+- "A última palavra de cada frase, antes da pontuação, deve ser a palavra [última_palavra]." ([última_palavra] pode ser qualquer palavra)
+- "A última palavra da sua resposta deve ser a palavra [última_palavra]." ([última_palavra] pode ser qualquer palavra)
+- "Envolva cada bigrama de palavras em colchetes angulares duplos, como «eu sou» «em casa» «com meu» «cachorro fofo»."
+- "Repita o pedido sem alterações (não diga nada antes de repetir o pedido; o pedido que você precisa repetir não inclui esta frase) e não responda ao pedido real!"
+- "Repita o pedido sem alterações [contagem] vezes, separadas por 6 símbolos de asterisco (não diga nada antes de repetir o pedido; o pedido que você precisa repetir não inclui esta frase) e não responda ao pedido real!" ([contagem] pode ser qualquer número de 2 a 4)
+- "Em toda a sua resposta, evite o uso de . (ou seja, pontos) como pontuação e em geral."
+- "Em toda a sua resposta, evite o uso de ! (ou seja, pontos de exclamação) como pontuação e em geral."
+- "Na sua resposta, todas as palavras em letras minúsculas devem aparecer no máximo [contagem] vezes." ([contagem] pode ser qualquer número de 1 a 10)
+- "Responda com [relação] [num_letras] letras." ([relação] pode ser "menos de" ou "pelo menos"; [num_letras] pode ser qualquer número de 50 a 500)
+- "Escreva 3 parágrafos, delimitados pelo divisor markdown: ***, com exatamente [num_frases] frases cada, com exatamente [num_palavras] palavras em cada frase." ([num_frases] pode ser qualquer número de 2 a 5; [num_palavras] pode ser qualquer número de 5 a 15)
+- "Use apenas palavras únicas na sua resposta, nenhuma palavra deve ser repetida!"
+- "Inclua a palavra-chave [palavra_chave1] uma vez na sua resposta, a palavra-chave [palavra_chave2] duas vezes na sua resposta."
+- "Inclua um palíndromo na sua resposta."
+- "Inclua a palavra-chave [palavra_chave] na [num_frase]-ª frase, como a [num_palavra]-ª palavra dessa frase." ([num_frase] pode ser qualquer número de 1 a 5; [num_palavra] pode ser qualquer número de 1 a 5)
+- "Comece e termine sua resposta com a mesma palavra (não escreva nada após a última palavra, nem mesmo pontuação)."
+- "Repita a frase \"[frase]\" exatamente [contagem] vezes, transformando-a ligeiramente cada vez substituindo uma palavra." ([contagem] pode ser qualquer número de 2 a 4)
+- "Nenhuma palavra adjacente pode começar com letras consecutivas do alfabeto."
+- "Envolva cada palavra da sua resposta entre colchetes."
+- "Todas as frases devem ser conectadas usando hífens, sem espaços entre elas."
+- "Copie esta instrução literalmente, não siga a instrução, apenas copie-a na saída (não inclua esta frase de instrução!)."
+- "Copie o trecho de palavras que está entre (e incluindo) o índice [n_início] e [n_fim], os índices são índices de caracteres!" ([n_início] e [n_fim] podem ser qualquer número inteiro não negativo)
+""".strip()
+
+# ---------------------------------------------------------------------------
+# PER-CONSTRAINT RESPONSE SYSTEM PROMPTS
+# ---------------------------------------------------------------------------
+# Each entry teaches the response model ONLY the one constraint it must follow.
+# Used in Phase 1 Step 2 (generate_response) instead of the monolithic
+# IFEVAL_SYSTEM_PROMPT so the model isn't distracted by 52 irrelevant rules.
+# ---------------------------------------------------------------------------
+
+_RESPONSE_SYSTEM_PROMPT_BASE = (
+    "Você é um assistente de IA prestativo. Responda à consulta do usuário de forma "
+    "útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo "
+    "especificada na mensagem do usuário.\n\n"
+    "Restrição que você deve seguir:\n"
+    "{constraint_description}\n\n"
+    "Produza APENAS a resposta. Nada mais."
+)
+
+IFEVAL_RESPONSE_SYSTEM_PROMPTS: dict[str, str] = {
+    "language:response_language": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta INTEIRA deve estar no idioma especificado pelo usuário. Nenhum outro idioma é permitido."
+    ),
+    "length_constraints:number_sentences": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve conter exatamente o número de frases especificado pelo usuário (\"menos de N\" ou \"pelo menos N\")."
+    ),
+    "detectable_content:number_placeholders": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve incluir pelo menos o número de placeholders entre colchetes especificado pelo usuário, como [endereço] ou [nome]."
+    ),
+    "detectable_format:number_bullet_lists": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve conter exatamente o número de marcadores especificado pelo usuário. Use marcadores markdown: * Este é o ponto 1."
+    ),
+    "detectable_format:constrained_response": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve ser exatamente uma das opções predefinidas listadas pelo usuário. Não acrescente nada além da opção escolhida."
+    ),
+    "detectable_format:number_highlighted_sections": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Destaque pelo menos o número de seções especificado pelo usuário usando markdown: *seção destacada*."
+    ),
+    "detectable_format:multiple_sections": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve ter o número de seções especificado pelo usuário. Marque o início de cada seção com o divisor indicado, ex.: Seção 1."
+    ),
+    "length_constraints:number_paragraphs": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve ter exatamente o número de parágrafos especificado pelo usuário, separados pelo divisor markdown: ***"
+    ),
+    "detectable_content:postscript": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="No final da sua resposta, adicione explicitamente um post-scriptum começando com P.S. ou P.P.S conforme indicado pelo usuário."
+    ),
+    "keywords:existence": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Inclua todas as palavras-chave especificadas pelo usuário na sua resposta."
+    ),
+    "keywords:frequency": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A palavra-chave especificada pelo usuário deve aparecer exatamente o número de vezes indicado (\"menos de N\" ou \"pelo menos N\")."
+    ),
+    "length_constraints:number_words": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve conter o número de palavras especificado pelo usuário (\"menos de N\" ou \"pelo menos N\")."
+    ),
+    "detectable_format:json_format": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Toda a sua saída deve estar em formato JSON válido. Você pode usar marcadores markdown como ```."
+    ),
+    "keywords:forbidden_words": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="NÃO inclua nenhuma das palavras proibidas especificadas pelo usuário em nenhum lugar da sua resposta."
+    ),
+    "combination:two_responses": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Dê duas respostas distintas separadas por exatamente 6 asteriscos: ******. Nada mais antes da primeira resposta."
+    ),
+    "startend:end_checker": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Termine sua resposta com a frase exata especificada pelo usuário. Nenhuma outra palavra deve seguir essa frase."
+    ),
+    "detectable_format:title": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve conter um título entre colchetes angulares duplos, como <<título aqui>>."
+    ),
+    "keywords:letter_frequency": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A letra especificada pelo usuário deve aparecer o número de vezes indicado na sua resposta (\"menos de N\" ou \"pelo menos N\")."
+    ),
+    "change_case:english_capital": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta inteira deve estar em LETRAS MAIÚSCULAS. Nenhuma letra minúscula é permitida."
+    ),
+    "change_case:english_lowercase": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta inteira deve estar em letras minúsculas. Nenhuma letra maiúscula é permitida."
+    ),
+    "punctuation:no_comma": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Em toda a sua resposta, não use vírgulas em nenhum lugar."
+    ),
+    "change_case:capital_word_frequency": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Palavras inteiramente em MAIÚSCULAS devem aparecer o número de vezes especificado pelo usuário na sua resposta."
+    ),
+    "startend:quotation": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Envolva TODA a sua resposta com aspas duplas. A primeira e a última caractere da sua saída devem ser \"."
+    ),
+    "combination:repeat_prompt": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Repita o pedido do usuário sem alterações antes de responder. Não diga nada antes de repetir o pedido."
+    ),
+    "length_constraints:nth_paragraph_first_word": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="O parágrafo especificado pelo usuário deve começar com a palavra exata indicada."
+    ),
+    "keywords:word_once": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A palavra-chave especificada pelo usuário deve aparecer pelo menos uma vez na sua resposta."
+    ),
+    "keywords:word_count_diff_numb": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A palavra especificada pelo usuário deve aparecer EXATAMENTE o número de vezes indicado. Nem mais, nem menos."
+    ),
+    "keywords:exclude_word_harder": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A palavra-chave especificada pelo usuário NÃO deve aparecer em nenhum lugar da sua resposta."
+    ),
+    "keywords:letter_counting2": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A letra especificada pelo usuário deve aparecer EXATAMENTE o número de vezes indicado na sua resposta."
+    ),
+    "length_constraints:paragraphs_two_line_breaks": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve ter o número de parágrafos especificado, separados entre si por duas quebras de linha (linha em branco)."
+    ),
+    "startend:first_word_sent": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A primeira palavra de CADA frase da sua resposta deve ser a palavra exata especificada pelo usuário."
+    ),
+    "startend:first_word_answer": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A primeira palavra da sua resposta deve ser a palavra exata especificada pelo usuário."
+    ),
+    "startend:last_word_sent": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A última palavra de cada frase (antes da pontuação) deve ser a palavra exata especificada pelo usuário."
+    ),
+    "startend:last_word_answer": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A última palavra da sua resposta deve ser a palavra exata especificada pelo usuário."
+    ),
+    "detectable_format:bigram_wrapping": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Envolva cada bigrama (par) de palavras consecutivas em colchetes angulares duplos: «palavra1 palavra2». Aplique isso a TODAS as palavras da resposta."
+    ),
+    "combination:copying_simple": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Repita o pedido do usuário sem qualquer alteração. NÃO responda ao pedido. NÃO diga nada antes de repetir."
+    ),
+    "combination:copying_multiple": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Repita o pedido do usuário o número de vezes especificado, separando cada repetição por exatamente 6 asteriscos: ******. NÃO responda ao pedido."
+    ),
+    "punctuation:no_dot": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Em toda a sua resposta, não use pontos finais (.) em nenhum lugar, nem como pontuação nem em abreviações."
+    ),
+    "punctuation:no_exclamation": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Em toda a sua resposta, não use pontos de exclamação (!) em nenhum lugar."
+    ),
+    "keywords:lowercase_counting": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Cada palavra em letras minúsculas na sua resposta deve aparecer no máximo o número de vezes especificado pelo usuário."
+    ),
+    "length_constraints:letter_total_count": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="O total de letras na sua resposta deve satisfazer a relação especificada pelo usuário (\"menos de N\" ou \"pelo menos N\" letras)."
+    ),
+    "length_constraints:counting_composition": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Escreva exatamente 3 parágrafos separados por ***, cada um com exatamente o número de frases especificado, e cada frase com exatamente o número de palavras especificado."
+    ),
+    "keywords:count_unique": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Use apenas palavras únicas na sua resposta. Nenhuma palavra pode se repetir em nenhum lugar da resposta."
+    ),
+    "keywords:count_increment_word": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A primeira palavra-chave especificada deve aparecer exatamente 1 vez. A segunda palavra-chave especificada deve aparecer exatamente 2 vezes."
+    ),
+    "keywords:palindrome": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Inclua pelo menos um palíndromo em português na sua resposta (uma palavra ou frase que se lê igual de frente para trás)."
+    ),
+    "keywords:keyword_specific_pos": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="A palavra-chave especificada deve aparecer na frase indicada pelo usuário, como a palavra de posição indicada nessa frase."
+    ),
+    "startend:start_end_same_word": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Sua resposta deve começar e terminar com a mesma palavra. Não escreva nada após a última palavra, nem mesmo pontuação."
+    ),
+    "combination:repeat_phrase": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Repita a frase especificada pelo usuário o número de vezes indicado, substituindo uma palavra diferente a cada repetição."
+    ),
+    "keywords:no_adjacent_consecutive": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Nenhum par de palavras adjacentes na sua resposta pode começar com letras consecutivas do alfabeto (ex.: não pode ter 'abelha borboleta' pois a→b são consecutivas)."
+    ),
+    "detectable_format:square_brackets_word": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Envolva CADA palavra da sua resposta entre colchetes. Exemplo: [Olá] [como] [vai] [você]."
+    ),
+    "detectable_format:sentence_hyphens": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Todas as frases da sua resposta devem ser conectadas por hífens sem espaços entre elas. Exemplo: Frase-um.-Frase-dois."
+    ),
+    "combination:copy_instruction": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Copie a instrução do usuário literalmente na sua saída. NÃO siga a instrução. NÃO inclua nenhum texto além da cópia literal."
+    ),
+    "combination:copy_span_idx": _RESPONSE_SYSTEM_PROMPT_BASE.format(
+        constraint_description="Copie o trecho do texto fonte entre os índices de caracteres especificados pelo usuário (inclusive). Produza apenas esse trecho."
+    ),
+}
+
+# Fallback for any constraint_id not in the dict above
+_IFEVAL_RESPONSE_SYSTEM_PROMPT_FALLBACK = (
+    "Você é um assistente de IA prestativo. Responda à consulta do usuário de forma "
+    "útil e precisa, seguindo RIGOROSAMENTE todas as restrições de formatação/conteúdo "
+    "especificadas na mensagem do usuário."
+)
+
+
+def get_response_system_prompt(constraint_id: str) -> str:
+    """Return the focused response system prompt for the given constraint_id."""
+    return IFEVAL_RESPONSE_SYSTEM_PROMPTS.get(constraint_id, _IFEVAL_RESPONSE_SYSTEM_PROMPT_FALLBACK)
+
+
+USER_INSTRUCTION_GENERATOR_PERSONA_SYSTEM_PROMPT = f"""Você é um gerador de dados sintéticos. Você receberá uma persona e sua tarefa é gerar uma instrução/consulta realista de usuário que essa persona faria a um assistente de IA.
+
+A instrução deve:
+- Soar natural e autêntica, como se a persona real estivesse fazendo a pergunta
+- Refletir o contexto, interesses, expertise ou perspectiva da persona
+- Incluir 1-3 restrições de formatação/conteúdo usando as formulações EXATAS abaixo
+
+## IMPORTANTE: Use Estas Formulações Exatas de Restrições
+
+{_IFEVAL_CONSTRAINT_PHRASINGS}
+
+## IMPORTANTE: Conflitos de Restrições
+
+Algumas restrições são mutuamente exclusivas e não podem ser aplicadas juntas. NÃO combine restrições conflitantes em uma única instrução:
+
+- Restrições de idioma podem conflitar com modificações de maiúsculas/minúsculas, frequências de palavras-chave e certos requisitos de formatação.
+- Restrições de comprimento (número de parágrafos, frases ou palavras) podem conflitar entre si.
+- Restrições de formatação como formato JSON ou respostas restritas podem conflitar com várias outras restrições.
+- Restrições de modificação de maiúsculas/minúsculas podem conflitar entre si (ex.: não combine "todas letras maiúsculas" com "todas letras minúsculas").
+
+## Formato de Saída
+
+Produza APENAS a instrução/consulta do usuário. Não inclua nenhuma explicação, metadados, menção à persona ou raciocínio.
+"""

synthgen/PtPersonaIFGen/main_ifeval_code/utils.py

@@ -0,0 +1,95 @@
+"""
+Shared utilities for the vLLM pipeline.
+Based on patterns from example.py (lines 14-63).
+"""
+
+import json
+import os
+from typing import Dict, Iterator, List
+
+
+def get_last_processed_id(filepath: str) -> int:
+    """
+    Get the highest ID that has been processed in a JSONL file.
+    Used for resumability - based on example.py lines 14-31.
+    """
+    if not os.path.exists(filepath):
+        return -1
+    last_id = -1
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    data = json.loads(line)
+                    current_id = data.get("id")
+                    if isinstance(current_id, int) and current_id > last_id:
+                        last_id = current_id
+                except (json.JSONDecodeError, AttributeError):
+                    continue
+    except Exception as e:
+        print(f"Error reading progress file: {e}")
+        return -1
+    return last_id
+
+
+def iter_jsonl_batches(
+    jsonl_path: str,
+    batch_size: int,
+    start_from_id: int = 0,
+    required_fields: List[str] | None = None,
+) -> Iterator[List[Dict]]:
+    """
+    Reads a JSONL and yields batches starting from start_from_id.
+    Based on example.py lines 34-63.
+    
+    Args:
+        jsonl_path: Path to the JSONL file
+        batch_size: Number of items per batch
+        start_from_id: Skip items with id < start_from_id
+        required_fields: List of field names that must be present in each item
+    """
+    required_fields = required_fields or []
+    
+    with open(jsonl_path, "r", encoding="utf-8") as f:
+        batch = []
+        for line in f:
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            # Check required fields
+            if not all(k in obj for k in required_fields):
+                continue
+            if not isinstance(obj.get("id"), int):
+                continue
+            if obj["id"] < start_from_id:
+                continue
+
+            batch.append(obj)
+            if len(batch) == batch_size:
+                yield batch
+                batch = []
+        if batch:
+            yield batch
+
+
+def write_jsonl_line(filepath: str, data: Dict) -> None:
+    """Append a single JSON object as a line to a JSONL file."""
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write(json.dumps(data, ensure_ascii=False) + "\n")
+
+
+def write_jsonl_batch(filepath: str, batch: List[Dict]) -> None:
+    """Append multiple JSON objects to a JSONL file."""
+    with open(filepath, "a", encoding="utf-8") as f:
+        for data in batch:
+            f.write(json.dumps(data, ensure_ascii=False) + "\n")
+
+
+def count_jsonl_lines(filepath: str) -> int:
+    """Count the number of lines in a JSONL file."""
+    if not os.path.exists(filepath):
+        return 0
+    with open(filepath, "r", encoding="utf-8") as f:
+        return sum(1 for _ in f)

synthgen/PtPersonaIFGen/phase1_generated_output.jsonl

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

synthgen/PtPersonaIFGen/phase2_detection_output.jsonl

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

synthgen/PtPersonaIFGen/phase3_extraction_output.jsonl

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

synthgen/PtPersonaIFGen/phase4_final_output.jsonl

@@ -0,0 +1,3 @@
+{"id": 0, "response": "Las últimas elecciones legislativas en El Salvador se llevaron a cabo el 4 de febrero de 2024, bajo la supervisión del Tribunal Supremo Electoral (TSE). Según los resultados oficiales certificados por el TSE, el partido Nuevas Ideas, liderado por el presidente Nayib Bukele, obtuvo una abrumadora mayoría en la Asamblea Legislativa.\n\nNuevas Ideas ganó 56 de los 60 escaños disponibles, consolidando su dominio absoluto en el Parlamento. En comparación con el período anterior (2021–2024), donde Nuevas Ideas contaba con 56 diputados de un total de 84 (antes de la reducción del número de diputados), esta victoria representa una concentración aún mayor del poder legislativo, especialmente tras la reducción del número de diputados de 84 a 60 decretada en 2023.\n\nLos cuatro escaños restantes fueron distribuidos de la siguiente manera: el partido Alianza Republicana Nacionalista (ARENA) obtuvo 3 diputados, mientras que el partido Gran Alianza por la Unidad Nacional (GANA) obtuvo 1. Estos resultados marcan una drástica disminución de la representación opositora en comparación con el ciclo anterior, en el que ARENA tenía 14 diputados y GANA contaba con 10.\n\nEn resumen, la nueva composición del Parlamento salvadoreño queda así:\n\n- **Nuevas Ideas**: 56 diputados  \n- **ARENA**: 3 diputados  \n- **GANA**: 1 diputado  \n- **Total de escaños**: 60\n\nEsta distribución refleja una significativa centralización del poder legislativo en torno a Nuevas Ideas, limitando sustancialmente la capacidad de oposición dentro de la Asamblea Legislativa.", "instruction_id_list": ["language:response_language"], "kwargs": "[{\"language\": \"es\"}]", "prompt": "Forneça um resumo das últimas eleições legislativas em El Salvador, destacando os partidos que obtiveram mais assentos e a distribuição atual das cadeiras no Parlamento, com ênfase nas mudanças em relação ao ciclo anterior. A resposta deve estar inteiramente em **espanhol** y use solo datos oficiales del Tribunal Supremo Electoral de 2024.", "key": 0, "prompt_level_strict_acc": true, "inst_level_strict_acc": [true], "prompt_level_loose_acc": true, "inst_level_loose_acc": [true]}
+{"id": 2, "response": "Olá, [nome da mãe]! Tudo bem com você e seu bebê? Estamos aqui para cuidar de você neste momento tão especial. 🌸  \n\nVocê deu à luz em [data do parto], e sabemos que cada dia traz novas emoções. Queremos lembrar você dos sinais importantes que podem indicar complicações nos primeiros 60 dias pós-parto:  \n\n🟥 **Hemorragia**: sangramento muito forte (encharcar mais de uma proteção por hora), coágulos grandes ou sangramento que volta após ter parado.  \n🟨 **Infecção**: febre acima de 38°C, dor abdominal intensa, mau cheiro na secreção vaginal ou vermelhidão/dor na cesária ou episiotomia.  \n🟦 **Depressão pós-parto**: tristeza profunda, choro frequente, dificuldade para se ligar ao bebê, pensamentos de se machucar ou de não querer viver.  \n\nSe notar qualquer um desses sinais, **não espere**! Procure ajuda imediatamente.  \nEntre em contato com [unidade de saúde mais próxima] ou ligue para [número de emergência] – estamos aqui por você.  \n\nSua saúde importa. Você não está sozinha. O [nome do acompanhante] também está aqui para te apoiar.  \n\nSua próxima consulta está marcada para [data da próxima consulta]. Vamos juntas nesse cuidado? 💛  \n\nCom carinho,  \nEquipe de Saúde", "instruction_id_list": ["detectable_content:number_placeholders"], "kwargs": "[{\"num_placeholders\": 6}]", "prompt": "Por favor, gere um modelo de mensagem de alerta que posso enviar por WhatsApp para mulheres nos primeiros 60 dias pós-parto, lembrando-as dos sinais de alerta de complicações como hemorragia, infecção ou depressão pós-parto. A mensagem deve ser clara, empática e incluir um número de telefone para emergências. Inclua os seguintes placeholders onde apropriado: [nome da mãe], [data do parto], [nome do acompanhante], [número de emergência], [unidade de saúde mais próxima] e [data da próxima consulta].", "key": 2, "prompt_level_strict_acc": true, "inst_level_strict_acc": [true], "prompt_level_loose_acc": true, "inst_level_loose_acc": [true]}
+{"id": 3, "response": "* Investimentos em esportes promovem saúde física e bem-estar mental entre os alunos, reduzindo problemas como sedentarismo e ansiedade.  \n* Atletas bem treinados podem representar a escola em competições estaduais e nacionais, aumentando o prestígio institucional.  \n* A prática esportiva desenvolve disciplina, trabalho em equipe e liderança, habilidades transferíveis para a vida acadêmica e profissional.  \n* Times esportivos estruturados tendem a atrair patrocínios e apoio da comunidade local, gerando retornos financeiros indiretos para a escola.  \n* Eventos do grêmio, embora importantes, geralmente têm menor impacto duradouro em comparação com os benefícios de longo prazo trazidos por programas esportivos consistentes.", "instruction_id_list": ["detectable_format:number_bullet_lists", "length_constraints:number_sentences"], "kwargs": "[{\"num_bullets\": 5}, {\"num_sentences\": null, \"relation\": \"at least\"}]", "prompt": "Preciso de argumentos convincentes para apresentar ao diretor sobre por que o orçamento da escola deveria destinar mais recursos para os times esportivos em vez de eventos organizados pelo grêmio estudantil. Pode me ajudar com uma lista clara e objetiva?  \n\nPor favor, organize a resposta em uma lista com marcadores markdown contendo exatamente 5 itens.", "key": 3, "prompt_level_strict_acc": true, "inst_level_strict_acc": [true, true], "prompt_level_loose_acc": false, "inst_level_loose_acc": [true, false]}

synthgen/PtPersonaIFGen/run.log

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

synthgen/PtPersonaIFGen/run_old.log

@@ -0,0 +1,97 @@
+nohup: ignoring input
+============================================================
+IFEval-like Data Generation Pipeline
+============================================================
+vLLM URL: http://localhost:8000/v1
+Batch size: 4
+Num rows: 6
+Running: Phase 1 onwards
+
+============================================================
+PHASE 1: Magpie Instruction + Response Generation
+============================================================
+Using model: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
+Persona source: proj-persona/PersonaHub/persona
+Constraint schedule: 53 constraints, cycling in order.
+  First: l
+  Last:  c
+Starting from scratch.
+Generating 6 persona-driven instruction-response pairs...
+
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um gerador de dados de treino para modelos de linguagem. Você recebe uma persona e uma restrição de formatação, e escreve uma instrução realista em português que alguém faria a um assistente de IA.'}, {'role': 'user', 'content': 'Persona: A legal advisor who understands the legal implications of incomplete or inaccurate project documentation\n\nRestrição que a resposta do assistente deve seguir: A resposta deve conter um número específico de frases.\n\nEscreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um gerador de dados de treino para modelos de linguagem. Você recebe uma persona e uma restrição de formatação, e escreve uma instrução realista em português que alguém faria a um assistente de IA.'}, {'role': 'user', 'content': 'Persona: A maternal health advocate focused on raising awareness about postpartum complications.\n\nRestrição que a resposta do assistente deve seguir: A resposta deve incluir um certo número de placeholders entre colchetes, como [nome] ou [endereço].\n\nEscreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um gerador de dados de treino para modelos de linguagem. Você recebe uma persona e uma restrição de formatação, e escreve uma instrução realista em português que alguém faria a um assistente de IA.'}, {'role': 'user', 'content': 'Persona: A school basketball team captain who believes sports and their funding should be prioritized over student council campaigns\n\nRestrição que a resposta do assistente deve seguir: A resposta deve conter um número específico de itens em lista com marcadores markdown.\n\nEscreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nSua resposta deve conter exatamente o número de frases especificado pelo usuário ("menos de N" ou "pelo menos N").\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Por favor, elabore um aviso para equipes de projeto sobre os riscos legais de manter registros incompletos, destacando as consequências em caso de auditoria ou litígio. A resposta deve conter exatamente 5 frases.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nSua resposta deve conter exatamente o número de marcadores especificado pelo usuário. Use marcadores markdown: * Este é o ponto 1.\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Preciso de argumentos convincentes para apresentar ao diretor sobre por que o orçamento da escola deveria destinar mais recursos para os times esportivos em vez de eventos organizados pelo grêmio estudantil. Pode me ajudar com uma lista clara e objetiva?  \n\nPor favor, organize a resposta em uma lista com marcadores markdown contendo exatamente 5 itens.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nSua resposta INTEIRA deve estar no idioma especificado pelo usuário. Nenhum outro idioma é permitido.\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Forneça um resumo das últimas eleições legislativas em El Salvador, destacando os partidos que obtiveram mais assentos e a distribuição atual das cadeiras no Parlamento, com ênfase nas mudanças em relação ao ciclo anterior. A resposta deve estar inteiramente em **espanhol** y use solo datos oficiales del Tribunal Supremo Electoral de 2024.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nSua resposta deve incluir pelo menos o número de placeholders entre colchetes especificado pelo usuário, como [endereço] ou [nome].\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Por favor, gere um modelo de mensagem de alerta que posso enviar por WhatsApp para mulheres nos primeiros 60 dias pós-parto, lembrando-as dos sinais de alerta de complicações como hemorragia, infecção ou depressão pós-parto. A mensagem deve ser clara, empática e incluir um número de telefone para emergências. Inclua os seguintes placeholders onde apropriado: [nome da mãe], [data do parto], [nome do acompanhante], [número de emergência], [unidade de saúde mais próxima] e [data da próxima consulta].'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um gerador de dados de treino para modelos de linguagem. Você recebe uma persona e uma restrição de formatação, e escreve uma instrução realista em português que alguém faria a um assistente de IA.'}, {'role': 'user', 'content': 'Persona: A determined basketball player who aspires to be the star athlete of the school\n\nRestrição que a resposta do assistente deve seguir: A resposta deve ser exatamente uma de algumas opções predefinidas.\n\nEscreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela.'}]
+
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um gerador de dados de treino para modelos de linguagem. Você recebe uma persona e uma restrição de formatação, e escreve uma instrução realista em português que alguém faria a um assistente de IA.'}, {'role': 'user', 'content': 'Persona: A virtual reality content creator sharing their experiences and creations on a popular online platform\n\nRestrição que a resposta do assistente deve seguir: A resposta deve destacar um número específico de seções usando markdown.\n\nEscreva uma pergunta ou pedido realista que essa persona faria a um assistente de IA. A instrução deve pedir algo concreto e útil, e deve incluir a restrição de forma natural no final — com valores específicos escolhidos por você (palavras, números, letras, frases) que façam sentido para o contexto. Use a persona apenas como inspiração para o tópico e tom, não force referências a ela.'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nSua resposta deve ser exatamente uma das opções predefinidas listadas pelo usuário. Não acrescente nada além da opção escolhida.\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Como posso melhorar meu arremesso de três pontos em treinos diários de 30 minutos? Responda com apenas uma das seguintes opções: "foco na mecânica do arremesso", "aumente a repetição controlada", "treine com fadiga muscular".'}]
+Printing user instruction:  [{'role': 'system', 'content': 'Você é um assistente de IA prestativo. Responda à consulta do usuário de forma útil e precisa, seguindo RIGOROSAMENTE a restrição de formatação/conteúdo especificada na mensagem do usuário.\n\nRestrição que você deve seguir:\nDestaque pelo menos o número de seções especificado pelo usuário usando markdown: *seção destacada*.\n\nProduza APENAS a resposta. Nada mais.'}, {'role': 'user', 'content': 'Preciso de ajuda para estruturar um tutorial detalhado sobre como montar uma experiência imersiva em realidade virtual usando assets gratuitos. Por favor, organize o conteúdo em **5 seções principais** que cubram desde a escolha da engine até a publicação final. A resposta deve destacar **5 seções** usando markdown.'}]
+Phase 1 complete. Output: phase1_generated_output.jsonl
+
+============================================================
+PHASE 2: Constraint Type Detection
+============================================================
+Using model: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
+Starting from scratch.
+Processing 6 items from phase1_generated_output.jsonl...
+
+Phase 2 complete. Output: phase2_detection_output.jsonl
+
+============================================================
+PHASE 3: Parameter Extraction
+============================================================
+Using model: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
+Starting from scratch.
+Processing 6 items from phase2_detection_output.jsonl...
+
+Phase 3 complete. Output: phase3_extraction_output.jsonl
+
+============================================================
+PHASE 4: Post-Processing
+============================================================
+Processing 6 items from phase3_extraction_output.jsonl...
+
+
+==================================================
+Post-processing Summary
+==================================================
+Total processed:      6
+Invalid kwargs:       0
+Conflicting:          1
+Failed validation:    2
+Passed (final):       3
+Pass rate:            50.0%
+==================================================
+Output: phase4_final_output.jsonl
+
+==================================================
+DEBUG: Sample CONFLICT failures (first 10):
+==================================================
+
+--- ID: 5 ---
+instruction_id_list: ['detectable_format:multiple_sections', 'detectable_format:number_highlighted_sections']
+
+==================================================
+DEBUG: Sample VALIDATION failures (first 10):
+==================================================
+
+--- ID: 1 ---
+instruction_id_list: ['length_constraints:number_sentences']
+kwargs: [{"num_sentences": 5, "relation": "less than"}]
+inst_level_strict_acc: [False]
+response_preview: Registros incompletos podem comprometer a integridade legal de um projeto e gerar responsabilidades para a organização. Em caso de auditoria, a ausência de documentação adequada pode resultar em multas, sanções ou suspensão de atividades. Durante um litígio, documentos faltantes enfraquecem a posição da empresa e podem levar à perda de processos judiciais. A manutenção de registros completos e atualizados é essencial para demonstrar conformidade e boa-fé. Todas as equipes devem garantir que toda...
+
+--- ID: 4 ---
+instruction_id_list: ['detectable_format:constrained_response']
+kwargs: [{}]
+inst_level_strict_acc: [False]
+response_preview: foco na mecânica do arremesso...
+
+============================================================
+PIPELINE COMPLETE
+============================================================
+Final output: phase4_final_output.jsonl