data preprocessing update

README.md

@@ -1,347 +1,13 @@
-# DialogZoo
-
-To replicate data construction, three steps are required:
-* Download data: ```bash scripts/download.sh```
-* Convert origin data into our unified format: ```bash scripts/convert_to_unified.sh```
+# Code directory
 ```
-{
-    # Optional values: `single` or `multi`. Indicates whether it is a single-turn or multi-turn dialogue.
-    "turn": str,
-
-    # The domains involved in the dialogue (a list because some dialogues involve multiple domains).
-    "domain": [],
-
-    # The language of the dialogue, based on the original dataset annotations (e.g., en, fr, etc.).
-    "locale": str,
-
-    # The dialogue, represented as a list where each element is a dictionary for a single turn.
-    "dialog": [
-        {
-            # The roles involved in each turn. Some datasets may have multiple roles per turn, so it's a list.
-            # For datasets without role annotations:
-            #   * Use `ROLE` for single-turn data.
-            #   * Use `ROLE1`, `ROLE2`, etc., for multi-turn data.
-            "roles": [str, ...],
-
-            # The text of the current turn.
-            "utterance": str,
-            
-            # Used for the "answer" in QA tasks.
-            "start": int,
-            "end": int,
-            "dialog_turn": int
-
-            # Rewritten text corresponding to the current turn.
-            "rewritten": str,
-
-            # Dialogue state, represented as a list where each element includes:
-            #   Domain: Some datasets constrain slot-value pairs within specific domains.
-            #   Intent: Some datasets constrain slot-value pairs within specific intents.
-            #   Slot-value pairs: A list where each element includes a slot and its corresponding values.
-            #     Slot name: A string.
-            #     Values: A list where a slot may have multiple values.
-            #       Each value includes four parts: the value itself, the normalized value, 
-            #       the character index in the current turn's text, and more.
-            #     Relation: Some slots are equal to a value, while others are greater than a value. 
-            #       Defaults to "equal" if not specified.
-            #   Requested slots: A list of slots that need to be queried but are not filled in the current state.
-            "belief_state": [
-                {
-                    # Intent
-                    "intent": str,
-                    # Slot-value pairs
-                    "informed_slot_value_table": [
-                        {
-                            # Slot name
-                            "slot": str,
-                            # Values
-                            "values": [{
-                                # Actual value
-                                "value": str,
-                                # Normalized value
-                                "cononical_value": str
-                            }, ...],
-                            # Slot-value relation
-                            "relation": str,
-                        },
-                        ...
-                    ],
-                    # Requested slots
-                    "requested_slots": [],
-                    # Domain
-                    "domain": str,
-                }, ...
-            ],
-
-            # Dialogue actions, represented as a list where each element includes:
-            #   Domain: Some datasets constrain slot-value pairs within specific domains.
-            #   Action: The actions involved in the current turn.
-            #   Slot-value pairs: Same as in dialogue state.
-            "dialog_acts": [
-                {
-                    # Action
-                    "act": str,
-                    # Slot-value pairs
-                    "slot_value_table": [
-                        {
-                            # Slot name
-                            "slot": str,
-                            # Slot-value relation
-                            "relation": str,
-                            # Values
-                            "values": [
-                                {
-                                    # Actual value
-                                    "value": str,
-                                    # Normalized value
-                                    "cononical_value": str,
-                                    # Start position
-                                    "start": int,
-                                    # End position
-                                    "end": int,
-                                },...
-                            ]
-                        },
-                        ...
-                    ],
-                    # Domain
-                    "domain": str,
-                },
-                ...
-            ],
-            
-            # Slot filling
-            "slots_to_fill": {
-                "intent": str,
-                "slot_value_table": [
-                    {
-                        "slot": str,
-                        "values": [
-                            {
-                                "value": str,
-                                "start": int,
-                                "end": int
-                            }
-                        ],
-                        "relation": str, # '=', '<=', and so on
-                    }
-                ]
-            },
-            
-            # Named entity recognition
-            "named_entity_recognition": [
-                {
-                    "type": str,
-                    "values": [
-                        {
-                            "value": str,
-                            "start": int,
-                            "end": int
-                        }, ...
-                    ]
-                }, ...
-            ],
-
-            "characters": [
-                {
-                    "value": str,
-                    "start": int,
-                    "end": int
-                }
-            ]
-            
-            # Intent detection
-            "active_intents": [str],
-
-            # Query
-            "query" {
-                ...
-            },
-            
-            # Query result
-            "querying_result": {
-               ...
-            },
-
-            # Recorded satisfied main items
-            "main_items": [],
-
-            # Aspect Sentiment Triplet Extraction task, represented as a list where each element includes three parts:
-            #   Target entity.
-            #   Related sentiment.
-            #   Words reflecting the sentiment.
-            "aspects": [
-                {
-                    # Target entity
-                    "target": {
-                        # Entity value
-                        "value": str,
-                        # Start position in the current turn's text
-                        "start": int,
-                        # End position in the current turn's text
-                        "end": int
-                    },
-                    
-                    # Category of the target entity
-                    "category": str,
-                    
-                    # Words reflecting the sentiment
-                    "opinion": {
-                        # Sentiment word
-                        "value": str,
-                        # Start position in the current turn's text
-                        "start": int,
-                        # End position in the current turn's text
-                        "end": int
-                    },
-                    # Related sentiment
-                    "sentiment": str
-                }
-            ],
-
-            "emotions": [
-                {
-                    "emotion": str,
-                    "sentiment": "positive", "negative", or "ambiguous",
-                    "evidences": [
-                        {
-                            "turn": int,
-                            "span": str,
-                            "start": int,
-                            "end": int
-                        }
-                    ],
-                    "evidence_types": [str]
-                }
-            ],
-
-            "kg_label": str,
-            
-            # Knowledge that may be required for each turn, used to select knowledge.
-            "knowledge_to_select": str,
-            
-            # SQL
-            "sql": str,
-            
-            # Rewritten text
-            "rewritten": str,
-            
-            "roles_to_select": [str],
-        },
-
-    ],
-
-    # Summary derived from the entire dialogue.
-    "summary": str,
-
-    # Entity relations determined from the entire dialogue.
-    "instance_relations": [
-        {
-            "instance1": str,
-            "instance2": str,
-            "relations": [
-                {
-                    "relation": str,
-                    "trigger": str
-                }, ...
-            ]
-        }, ...
-    ]
-    
-    # Role relations determined from the entire dialogue.
-    "role_relations": [
-        {
-            "turn": int,
-            "relation": str
-        }
-    ],
-    
-    # Used in FriendsPersona to determine a character's persona based on the entire dialogue.
-    "role_personas": [
-        {
-            "name": str,
-            "personas": [
-                {
-                    "persona": str,
-                    "sentiment": int
-                }, ...
-            ]
-        }
-    ],
-
-    # External knowledge required for the dialogue.
-    "knowledge": {
-        # `text`, `persona`, `kg`, or `schema`.
-        "type": str,
-
-        # For `text`.
-        "value": str,
-
-        # For `persona`, persona of all roles, used for personachat.
-        "value": [
-            {
-                # Role name, matching the dialogue turn.
-                "role": str,
-
-                # Persona description, which may include several sentences.
-                "description": []
-            },
-            ...
-        ]
-
-        # For `kg`.
-        "value": {
-            # `directed` or `undirected`.
-            "direction": str,
-
-            # Graph.
-            "graph": [
-                {
-                    # Source node.
-                    "source": str,
-
-                    # Target node.
-                    "target": str,
-
-                    # Relation.
-                    "relation": str
-                },
-                ...
-            ]
-        }
-
-        # For `schema`.
-        "value": {
-            ...
-        }
-
-        # For `dialogue`.
-        "value": {
-            "dialog": [],
-            "relations": []
-        }
-        
-        # For `wiki`.
-        "value": {
-            ...
-        }
-        
-        # For `sql`.
-        "value": [
-            {
-                "turn": int, 
-                "sql": str,
-                "result": ...
-            }, ...
-        ],
-        
-        # For dialogues based on specific article excerpts, this field indicates the article and section titles.
-        "value": {
-            "article title": str,
-            "section title": str
-        },
-    }
-}
-
+.
+|-- pretrain: pre-training package
+|-- utils
+|   |-- data
+|   |-- logger
+|   |-- model
+|   |-- tokenizer
+|   `-- trainer
+|-- 😀[TODO: some other tasks directories]😀
+`-- README.md
 ```
-* Linearize: ```bash scripts/convert_to_seq.sh```

src/ABSA.py

@@ -0,0 +1,41 @@
+import sys
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    ABSA_TERM_CATEGORY_SENTIMENT, ABSA_TERM_OPINION_SENTIMENT, ABSA_CATEGORY_SENTIMENT, ABSA_TERM_SENTIMENT
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+    
+)
+from preprocessor.label_funs import (
+    extract_aspects_wrapper,
+)
+import sys
+
+if __name__ == "__main__":
+    TASK = ABSA_TERM_SENTIMENT
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Extract all the aspects."
+            ),
+            # knowledge_func=concat_list_knowledge_wrapper("person 2 persona: ", " | "),
+            knowledge_func=None_knowledge,
+            label_func=extract_aspects_wrapper(" | ", ", "),
+        )
+    )
+
+    serial_proc.launch()
+
+   

src/CC.py

@@ -0,0 +1,42 @@
+import sys
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    CHIT_CHAT
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    concat_list_knowledge_wrapper,
+    
+)
+from preprocessor.label_funs import (
+    extract_turn_utterance,
+)
+import sys
+
+if __name__ == "__main__":
+    TASK = CHIT_CHAT
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Response based on the dialogue context and given self persona"
+            ),
+            knowledge_func=concat_list_knowledge_wrapper("person 2 persona: ", " | "),
+            # knowledge_func=None_knowledge,
+            label_func=extract_turn_utterance,
+            roles_to_build_example=[["person 2"]],
+        )
+    )
+
+    serial_proc.launch()
+
+   

src/CI.py

@@ -0,0 +1,43 @@
+import sys
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    CHARACTER_IDENTIFICATION
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+    
+)
+from preprocessor.label_funs import (
+    extract_characters,
+)
+from preprocessor.process_turn_funcs import introduce_mention_to_utterance_wrapper
+import sys
+
+if __name__ == "__main__":
+    TASK = CHARACTER_IDENTIFICATION
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Predict all characters mentioned in the given dialogue marked by [ mention ] tag based on the context."
+            ),
+            knowledge_func=None_knowledge,
+            # knowledge_func=None_knowledge,
+            label_func=extract_characters,
+            all_turns_process_func=introduce_mention_to_utterance_wrapper(" [ ", " ] "),
+        )
+    )
+
+    serial_proc.launch()
+
+   

src/DCRG.py

@@ -0,0 +1,144 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DIALOGUE_CONTEXT_TO_RESPONSE_GENERATION,
+    DOCUMENT_GROUNDED_CONVERSATION,
+    MULTI_REF_SEP,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    extract_dialogue_knowledge_wrapper,
+    origin_knowledge,
+    None_knowledge,
+    extract_kg_knowledge_wrapper,
+    extract_turn_knowledge_wrapper,
+)
+from preprocessor.label_funs import (
+    extract_turn_utterance,
+)
+import sys
+
+if __name__ == "__main__":
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    TASK = DOCUMENT_GROUNDED_CONVERSATION
+
+    if len(sys.argv) <= 3:
+        based_on = "dialogue"
+    else:
+        based_on = sys.argv[3]
+
+    if len(sys.argv) < 5:
+        if based_on == "turn-document":
+            serial_proc = SerialPreprocessor(
+                SerialConfig(
+                    input_data_path,
+                    output_data_path,
+                    TASK,
+                    logger_name=TASK,
+                    task_bos_token=f"[{TASK}]",
+                    prompt_func=const_prompt_func_wrapper(
+                        "Response based on the dialogue context and given knowledge"
+                    ),
+                    # knowledge_func=extract_kg_knowledge_wrapper(": ", " | ", "; ", " "),
+                    # knowledge_func=extract_dialogue_knowledge_wrapper(": ", " | ", ", "),
+                    # knowledge_func=None_knowledge,
+                    knowledge_func=origin_knowledge,
+                    turn_knowledge_func=extract_turn_knowledge_wrapper(
+                        ": ", " | ", ", "
+                    ),
+                    label_func=extract_turn_utterance,
+                    roles_to_build_example=[["user1"], ["user2"]],
+                    # dev_and_test_roles_to_build_example=[["user2"]],
+                    roles_in_history=None,
+                    multi_ref_sep=None,
+                )
+            )
+        elif based_on == "document":
+            serial_proc = SerialPreprocessor(
+                SerialConfig(
+                    input_data_path,
+                    output_data_path,
+                    TASK,
+                    logger_name=TASK,
+                    task_bos_token=f"[{TASK}]",
+                    prompt_func=const_prompt_func_wrapper(
+                        "Response based on the dialogue context and given knowledge"
+                    ),
+                    # knowledge_func=extract_kg_knowledge_wrapper(": ", " | ", "; ", " "),
+                    knowledge_func=extract_dialogue_knowledge_wrapper(
+                        ": ", " | ", ", "
+                    ),
+                    # knowledge_func=None_knowledge,
+                    # knowledge_func=origin_knowledge,
+                    label_func=extract_turn_utterance,
+                    roles_to_build_example=[
+                        ["third-person"],
+                        ["Listener"],
+                        ["Speaker"],
+                    ],
+                    dev_and_test_roles_to_build_example=[
+                        ["third-person"],
+                        ["Listener"],
+                    ],
+                )
+            )
+        elif based_on == "None":
+            serial_proc = SerialPreprocessor(
+                SerialConfig(
+                    input_data_path,
+                    output_data_path,
+                    TASK,
+                    logger_name=TASK,
+                    task_bos_token=f"[{TASK}]",
+                    prompt_func=const_prompt_func_wrapper(
+                        "Response based on the dialogue context and given knowledge"
+                    ),
+                    knowledge_func=None_knowledge,
+                    label_func=extract_turn_utterance,
+                    roles_to_build_example=[["SYSTEM"]],
+                )
+            )
+        else:
+            serial_proc = SerialPreprocessor(
+                SerialConfig(
+                    input_data_path,
+                    output_data_path,
+                    TASK,
+                    logger_name=TASK,
+                    task_bos_token=f"[{TASK}]",
+                    prompt_func=const_prompt_func_wrapper(
+                        "Response based on the dialogue context and given knowledge"
+                    ),
+                    knowledge_func=extract_kg_knowledge_wrapper(": ", " | ", "; ", " "),
+                    # knowledge_func=extract_dialogue_knowledge_wrapper(": ", " | ", ", "),
+                    # knowledge_func=None_knowledge,
+                    label_func=extract_turn_utterance,
+                    roles_to_build_example=[["SYSTEM"], ["USER"]],
+                    dev_and_test_roles_to_build_example=[["SYSTEM"]],
+                )
+            )
+    else:
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "Response based on the dialogue context and given knowledge"
+                ),
+                # knowledge_func=extract_kg_knowledge_wrapper(": ", " | ", "; ", " "),
+                knowledge_func=extract_dialogue_knowledge_wrapper(": ", " | ", ", "),
+                label_func=extract_turn_utterance,
+                roles_to_build_example=[["SYSTEM"]],
+                roles_in_history=[["USER"]],
+                multi_ref_sep=MULTI_REF_SEP,
+            )
+        )
+
+    serial_proc.launch()

src/DS.py

@@ -0,0 +1,39 @@
+import sys
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DIALOGUE_SUMMARY,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_summary,
+)
+import sys
+
+if __name__ == "__main__":
+    TASK = DIALOGUE_SUMMARY
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Summarize the dialogue."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_summary,
+        )
+    )
+
+    serial_proc.launch()
+
+   

src/DST.py

@@ -0,0 +1,43 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DIALOGUE_STATE_TRACKING,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import None_knowledge, extract_turn_domains_wrapper
+from preprocessor.label_funs import (
+    extract_belief_state_wrapper,
+)
+import os, shutil
+
+if __name__ == "__main__":
+    TASK = DIALOGUE_STATE_TRACKING
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Generate the dialogue state based on the given dialogue context."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_belief_state_wrapper(", ", " | ", "; ", ": "),
+            roles_to_build_example=[["USER"]],
+        )
+    )
+
+    serial_proc.launch()
+
+    for split in ["train", "dev", "test"]:
+        if os.path.isfile(os.path.join(input_data_path, f"{split}_ontology.json")):
+            shutil.copyfile(
+                os.path.join(input_data_path, f"{split}_ontology.json"),
+                os.path.join(output_data_path, f"{split}_ontology.json"),
+            )

src/DT.py

@@ -0,0 +1,41 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DATA_TO_TEXT, MULTI_REF_SEP
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    extract_dict_knowledge_wrapper,
+)
+from preprocessor.label_funs import (
+    extract_turn_utterance,
+)
+import sys
+
+if __name__ == "__main__":
+    # 2. Emotion Recognition
+    TASK = DATA_TO_TEXT
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Generate the corresponding text based on the given knowledge."
+            ),
+            knowledge_func=extract_dict_knowledge_wrapper(": ", " | "),
+            label_func=extract_turn_utterance,
+            roles_in_history=[],
+            multi_ref_sep=MULTI_REF_SEP
+        )
+    )
+
+    serial_proc.launch()

src/ER.py

@@ -0,0 +1,38 @@
+import sys
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    EMOTION_RECOGNITION,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_turn_emotion_wrapper,
+)
+import sys
+
+if __name__ == "__main__":
+    # 2. Emotion Recognition
+    TASK = EMOTION_RECOGNITION
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Recognize correct emotions based on the dialogue context."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_turn_emotion_wrapper(", "),
+        )
+    )
+
+    serial_proc.launch()

src/ID.py

@@ -0,0 +1,32 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import INTENT_DETECTION, MULTI_REF_SEP
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import None_knowledge
+from preprocessor.label_funs import (
+    extract_intents_wrapper,
+)
+
+if __name__ == "__main__":
+    TASK = INTENT_DETECTION
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Detect the intent based on the given dialogue context."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_intents_wrapper(" | "),
+        )
+    )
+
+    serial_proc.launch()

src/MCQA.py

@@ -0,0 +1,41 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    MULTIPLE_CHOICE_QUESTION_ANSWERING,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    # extract_dict_knowledge_wrapper
+    extract_dialogue_knowledge_wrapper,
+    # None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_options,
+)
+
+if __name__ == "__main__":
+    TASK = MULTIPLE_CHOICE_QUESTION_ANSWERING
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    sort_or_not = len(sys.argv) > 3
+
+    prompt = "Generate the best choice."
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(prompt),
+            knowledge_func=extract_dialogue_knowledge_wrapper(": ", " | ", ", "),
+            # knowledge_func=extract_dict_knowledge_wrapper(": ", " | "),
+            label_func=extract_options,
+        )
+    )
+
+    serial_proc.launch()

src/MRC.py

@@ -0,0 +1,35 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import MACHINE_READING_COMPREHENSION, MULTI_REF_SEP
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import extract_dialogue_knowledge_wrapper
+from preprocessor.label_funs import (
+    extract_turn_utterance,
+)
+
+if __name__ == "__main__":
+    TASK = MACHINE_READING_COMPREHENSION
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Answer the question based on the given document and dialogue context."
+            ),
+            knowledge_func=extract_dialogue_knowledge_wrapper(": ", " | ", ", "),
+            label_func=extract_turn_utterance,
+            roles_in_history=[["USER"]],
+            roles_to_build_example=[["SYSTEM"]],
+            multi_ref_sep=MULTI_REF_SEP,
+        )
+    )
+
+    serial_proc.launch()

src/NLI.py

@@ -0,0 +1,33 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    NATURAL_LANGUAGE_INFERENCE,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import extract_dict_knowledge_wrapper
+from preprocessor.label_funs import (
+    extract_options,
+)
+
+if __name__ == "__main__":
+    TASK = NATURAL_LANGUAGE_INFERENCE
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper("Generate the better hypothesis."),
+            knowledge_func=extract_dict_knowledge_wrapper(": ", " | "),
+            # knowledge_func=None_knowledge,
+            label_func=extract_options,
+        )
+    )
+
+    serial_proc.launch()

src/QCR.py

@@ -0,0 +1,40 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    QUESTION_IN_CONTEXT_REWRITING,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import extract_dict_knowledge_wrapper, None_knowledge
+from preprocessor.label_funs import (
+    extrac_rewritten,
+)
+
+if __name__ == "__main__":
+    TASK = QUESTION_IN_CONTEXT_REWRITING
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    has_knowledge = len(sys.argv) > 3
+
+    kf = (
+        extract_dict_knowledge_wrapper(": ", " | ") if has_knowledge else None_knowledge
+    )
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Rewrite the user utterance of current turn based on the given dialogue context."
+            ),
+            knowledge_func=kf,
+            # knowledge_func=None_knowledge,
+            label_func=extrac_rewritten,
+        )
+    )
+
+    serial_proc.launch()

src/README.md

@@ -0,0 +1,13 @@
+# Code directory
+```
+.
+|-- pretrain: pre-training package
+|-- utils
+|   |-- data
+|   |-- logger
+|   |-- model
+|   |-- tokenizer
+|   `-- trainer
+|-- 😀[TODO: some other tasks directories]😀
+`-- README.md
+```

src/RRR.py

@@ -0,0 +1,36 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    ROLE_RELATION_RECOGNITION,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_role_relation_without_turn_wrapper,
+)
+
+if __name__ == "__main__":
+    TASK = ROLE_RELATION_RECOGNITION
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Judge the relation of two roles in the given dialogue."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_role_relation_without_turn_wrapper("; "),
+        )
+    )
+
+    serial_proc.launch()

src/SF.py

@@ -0,0 +1,36 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    SLOT_FILLING,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_slots_without_intents_wrapper,
+)
+
+if __name__ == "__main__":
+    TASK = SLOT_FILLING
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Fill all the slots based on the given utterance."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_slots_without_intents_wrapper(", ", "; "),
+        )
+    )
+
+    serial_proc.launch()

src/SP.py

@@ -0,0 +1,38 @@
+import sys
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DIALOGUE_SUMMARY,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+)
+from preprocessor.label_funs import (
+    extract_sql,
+)
+import sys
+
+if __name__ == "__main__":
+    TASK = "Semantic Parsing"
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Parse the sentence into intents and slots."
+            ),
+            knowledge_func=None_knowledge,
+            label_func=extract_sql,
+        )
+    )
+
+    serial_proc.launch()

src/T2S.py

@@ -0,0 +1,54 @@
+import sys
+import os
+
+sys.path.append("modules/preprocess")
+
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    TEXT2SQL,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    origin_knowledge,
+    extract_schema_knowledge_wrapper,
+)
+from preprocessor.label_funs import (
+    extract_sql,
+)
+
+import shutil
+
+if __name__ == "__main__":
+    # 8. Text2SQL
+    TASK = TEXT2SQL
+    input_data_path = sys.argv[1]
+    output_data_path = sys.argv[2]
+
+    serial_proc = SerialPreprocessor(
+        SerialConfig(
+            input_data_path,
+            output_data_path,
+            TASK,
+            logger_name=TASK,
+            task_bos_token=f"[{TASK}]",
+            prompt_func=const_prompt_func_wrapper(
+                "Parse the SQL based on the given dialogue context and schema."
+            ),
+            knowledge_func=origin_knowledge,
+            turn_knowledge_func=extract_schema_knowledge_wrapper(),
+            label_func=extract_sql,
+        )
+    )
+
+    serial_proc.launch()
+
+    shutil.copyfile(
+        os.path.join(input_data_path, "tables.json"),
+        os.path.join(output_data_path, "tables.json"),
+    )
+
+    if not os.path.exists(os.path.join(output_data_path, "database")):
+        shutil.copytree(
+            os.path.join(input_data_path, "database"),
+            os.path.join(output_data_path, "database"),
+        )

src/modules/preprocess/config.py

@@ -0,0 +1,68 @@
+"""
+Base config supporting save and load. Refer to https://github.com/huggingface/transformers/blob/main/src/transformers/configuration_utils.py.
+Author: md
+"""
+
+from typing import Dict, Any
+import copy
+import json
+
+
+class BaseConfig(object):
+    def __init__(
+        self,
+        logger_name: str = None,
+        log_file: str = None,
+        log_mode: str = "a",
+        formatter: str = "%(asctime)s | %(levelname)s | %(message)s",
+    ) -> None:
+        """
+        params:
+        ------
+
+        logger_name: logger name
+        log_file: the file to ouput log. If `None`, output to stdout
+        log_mode: mode to write to the log file, `a` is appending.
+        formatter: logging formatter.
+        """
+        self.logger_name = logger_name
+        self.log_file = log_file
+        self.log_mode = log_mode
+        self.formatter = formatter
+
+    def to_json_string(self) -> Dict[str, Any]:
+        output = self.to_dict()
+        return json.dumps(output)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes this instance to a Python dictionary.
+
+        Returns:
+            `Dict[str, Any]`: Dictionary of all the attributes that make up this configuration instance.
+        """
+        output = copy.deepcopy(self.__dict__)
+        # if "_auto_class" in output:
+        #     del output["_auto_class"]
+
+        return output
+
+    def from_dict(self, config_dict: Dict[str, Any]) -> None:
+        self.__dict__.update(config_dict)
+
+    def save(self, save_path: str, indent: int = 4) -> None:
+        with open(save_path, "w") as writer:
+            json.dump(self.to_dict(), writer, indent=indent)
+
+    def load(self, load_path: str) -> None:
+        with open(load_path, "r") as reader:
+            self.__dict__.update(json.load(reader))
+
+
+if __name__ == "__main__":
+    config = BaseConfig()
+
+    config.from_dict({"a": 1, "b": 2, "c": "test", "d": True, "e": 3.2})
+    config.save("../../test/test1.json")
+    config.load("../../test/test1.json")
+    config.save("../../test/test2.json")

src/modules/preprocess/const.py

@@ -0,0 +1,73 @@
+"""
+Some constant variables.
+Author: md
+"""
+
+# The split names
+TRAIN_SPLIT = "train"
+DEV_SPLIT = "dev"
+TEST_SPLIT = "test"
+
+# Universal dialogue format keywords
+DIALOG = "dialog"
+ROLES = "roles"
+TARGET = "target"
+SUMMARY = "summary"
+KNOWLEDGE = "knowledge"
+UTTERANCE = "utterance"
+EMOTIONS = "emotions"
+EMOTION = "emotion"
+VALUE = "value"
+ASPECTS = "aspects"
+CATEGORY = "category"
+OPINION = "opinion"
+SENTIMENT = "sentiment"
+CHARACTERS = "characters"
+START = "start"
+END = "end"
+BELIEF_STATE = "belief_state"
+DOMAIN = "domain"
+INFORMED_SLOT_VALUE_TABLE = "informed_slot_value_table"
+SLOT = "slot"
+VALUES = "values"
+RELATION = "relation"
+KNOWLEDGE_TO_SELECT = "knowledge_to_select"
+SQL = "sql"
+SLOT_VALUE_TABLE = "slot_value_table"
+SLOTS_TO_FILL = "slots_to_fill"
+ROLE_RELATIONS = "role_relations"
+REWRITTEN = "rewritten"
+ROLES_TO_SELECT = "roles_to_select"
+ACTIVE_INTENTS = "active_intents"
+
+
+# TASK NAMES
+DIALOGUE_SUMMARY = "Dialogue Summary"
+EMOTION_RECOGNITION = "Emotion Recognition"
+DIALOGUE_CONTEXT_TO_RESPONSE_GENERATION = "Dialogue Context-to-Response Generation"
+ABSA = "ABSA"
+ABSA_TERM_OPINION_SENTIMENT = "ABSA: term opinion sentiment"
+ABSA_TERM_CATEGORY_SENTIMENT = "ABSA: term category sentiment"
+ABSA_TERM_SENTIMENT = "ABSA: term sentiment"
+ABSA_CATEGORY_SENTIMENT = "ABSA: category sentiment"
+CHARACTER_IDENTIFICATION = "Character Identification"
+DIALOGUE_STATE_TRACKING = "Dialogue State Tracking"
+DOCUMENT_GROUNDED_CONVERSATION = "Document Grounded Conversation"
+TEXT2SQL = "Text2SQL"
+SLOT_FILLING = "Slot Filling"
+ROLE_RELATION_RECOGNITION = "Role Relation Recognition"
+QUESTION_IN_CONTEXT_REWRITING = "Question in Context Rewriting"
+NATURAL_LANGUAGE_INFERENCE = "Natural Language Inference"
+MACHINE_READING_COMPREHENSION = "Machine Reading Comprehension"
+MULTIPLE_CHOICE_QUESTION_ANSWERING = "Multiple Choice Question Answering"
+INTENT_DETECTION = "Intent Detection"
+DATA_TO_TEXT = "Data-to-Text"
+CHIT_CHAT = "Chit-Chat"
+
+# Seq2Seq
+MULTI_REF_SEP = "__multi_ref_sep__"
+OPTION_LABEL = "option_label"
+CANDIDATES = "candidates"
+
+# MENTION
+MENTION = "mention"

src/modules/preprocess/logger.py

@@ -0,0 +1,30 @@
+"""
+Author: md
+"""
+import logging
+import sys
+
+
+def build_logger(
+    logger_name: str,
+    level: int,
+    log_file: str = None,
+    log_mode: str = "a",
+    formatter: str = "%(asctime)s | [%(name)s] | %(levelname)s | %(message)s",
+):
+    logger = logging.getLogger(logger_name)
+
+    logger.setLevel(level)
+
+    logger.handlers.clear()
+
+    formatter = logging.Formatter(formatter)
+    if log_file is not None:
+        handler = logging.FileHandler(log_file, log_mode)
+    else:
+        handler = logging.StreamHandler(sys.stdout)
+
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    return logger

src/modules/preprocess/preprocess.py

@@ -0,0 +1,343 @@
+from preprocessor.SerialPreprocessor import SerialConfig, SerialPreprocessor
+from const import (
+    DIALOGUE_SUMMARY,
+    EMOTION_RECOGNITION,
+    DIALOGUE_CONTEXT_TO_TEXT_GENERATION,
+    ABSA_TERM_OPINION_SENTIMENT,
+    ABSA_TERM_SENTIMENT,
+    ABSA_CATEGORY_SENTIMENT,
+    ABSA_TERM_CATEGORY_SENTIMENT,
+    CHARACTER_IDENTIFICATION,
+    DIALOGUE_STATE_TRACKING,
+    DOCUMENT_GROUNDED_CONVERSATION,
+    TEXT2SQL,
+    SLOT_FILLING,
+)
+from preprocessor.prompt_funcs import const_prompt_func_wrapper
+from preprocessor.knowledge_funcs import (
+    None_knowledge,
+    concat_list_knowledge_wrapper,
+    extract_turn_knowledge_wrapper,
+    origin_knowledge,
+    extract_schema_knowledge_wrapper,
+)
+from preprocessor.label_funs import (
+    extract_summary,
+    extract_turn_emotion_wrapper,
+    extract_turn_utterance,
+    extract_aspects_wrapper,
+    rebuild_utterance_with_characters,
+    extract_belief_state_wrapper,
+    extract_sql,
+    extract_slots_without_intents_wrapper,
+)
+import os
+
+if __name__ == "__main__":
+    # 1. Dialogue Summary
+    TASK = DIALOGUE_SUMMARY
+    input_path = r"E:\research\processed\DialogueSummary"
+    output_path = r"E:\research\seq\DialogueSummary"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "Give a summary of this dialogue."
+                ),
+                knowledge_func=None_knowledge,
+                label_func=extract_summary,
+            )
+        )
+
+        serial_proc.launch()
+
+    # 2. Emotion Recognition
+    TASK = EMOTION_RECOGNITION
+    input_path = r"E:\research\processed\EmotionRecognition"
+    output_path = r"E:\research\seq\EmotionRecognition"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given possible emotions, select the correct answer."
+                ),
+                knowledge_func=concat_list_knowledge_wrapper(
+                    "possible choices: ", " | "
+                ),
+                label_func=extract_turn_emotion_wrapper(", "),
+            )
+        )
+
+        serial_proc.launch()
+
+    # 3. Dialogue Context-to-Text Generation
+    TASK = DIALOGUE_CONTEXT_TO_TEXT_GENERATION
+    input_path = r"E:\research\processed\Dialogue-Context-to-Text Generation"
+    output_path = r"E:\research\seq\Dialogue-Context-to-Text Generation"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given dialogue context, give the response."
+                ),
+                knowledge_func=None_knowledge,
+                label_func=extract_turn_utterance,
+                roles_to_build_example=[["Listener"], ["third-person"]],
+            )
+        )
+
+        serial_proc.launch()
+
+    # 4. Aspect Sentiment Analysis
+    # 4.1 ABSA: term opinion sentiment
+    TASK = ABSA_TERM_OPINION_SENTIMENT
+    input_path = r"E:\research\processed\ABSA-term opinion sentiment\ASTE"
+    output_path = r"E:\research\seq\Aspect-based Sentiment Analysis\ASTE"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper("Give all the aspects."),
+                knowledge_func=None_knowledge,
+                label_func=extract_aspects_wrapper(" | ", ", "),
+            )
+        )
+
+        serial_proc.launch()
+
+    # 4.2 ABSA: term sentiment
+    TASK = ABSA_TERM_SENTIMENT
+    input_path = r"E:\research\processed\ABSA-term sentiment"
+    output_path = r"E:\research\seq\Aspect-based Sentiment Analysis"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper("Give all the aspects."),
+                knowledge_func=None_knowledge,
+                label_func=extract_aspects_wrapper(" | ", ", "),
+            )
+        )
+
+        serial_proc.launch()
+
+    # 4.3 ABSA: category sentiment
+    TASK = ABSA_CATEGORY_SENTIMENT
+    input_path = r"E:\research\processed\ABSA-category sentiment"
+    output_path = r"E:\research\seq\Aspect-based Sentiment Analysis"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper("Give all the aspects."),
+                knowledge_func=None_knowledge,
+                label_func=extract_aspects_wrapper(" | ", ", "),
+            )
+        )
+
+        serial_proc.launch()
+
+    # 4.4 ABSA: term category sentiment
+    TASK = ABSA_TERM_CATEGORY_SENTIMENT
+    input_path = r"E:\research\processed\ABSA-term category sentiment"
+    output_path = r"E:\research\seq\Aspect-based Sentiment Analysis"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper("Give all the aspects."),
+                knowledge_func=None_knowledge,
+                label_func=extract_aspects_wrapper(" | ", ", "),
+            )
+        )
+
+        serial_proc.launch()
+
+    # 5. Character Identification
+    TASK = CHARACTER_IDENTIFICATION
+    input_path = r"E:\research\processed\CharacterIdentification"
+    output_path = r"E:\research\seq\CharacterIdentification"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper("Generate with all characters."),
+                knowledge_func=concat_list_knowledge_wrapper("all speakers: ", " | "),
+                label_func=rebuild_utterance_with_characters,
+            )
+        )
+
+        serial_proc.launch()
+
+
+    # 6. Dialogue State Tracking
+    TASK = DIALOGUE_STATE_TRACKING
+    input_path = r"E:\research\processed\DialogueStateTracking"
+    output_path = r"E:\research\seq\DialogueStateTracking"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given dialogue context, give the dialogue state."
+                ),
+                knowledge_func=None_knowledge,
+                label_func=extract_belief_state_wrapper(", ", " | ", "; ", ": "),
+                roles_to_build_example=[["USER"]],
+            )
+        )
+
+        serial_proc.launch()
+
+    # 7. Document Grounded Conversation
+    TASK = DOCUMENT_GROUNDED_CONVERSATION
+    input_path = r"E:\research\processed\DocumentGroundedConversations"
+    output_path = r"E:\research\seq\DocumentGroundedConversation"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given dialogue context, give the response."
+                ),
+                knowledge_func=origin_knowledge,
+                turn_knowledge_func=extract_turn_knowledge_wrapper(": ", " | ", "; "),
+                label_func=extract_turn_utterance,
+            )
+        )
+
+        serial_proc.launch()
+    # 8. Text2SQL
+    TASK = TEXT2SQL
+    input_path = r"E:\research\processed\Text2SQL"
+    output_path = r"E:\research\seq\Text2SQL"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given dialogue context, give the sql."
+                ),
+                knowledge_func=origin_knowledge,
+                turn_knowledge_func=extract_schema_knowledge_wrapper(),
+                label_func=extract_sql,
+            )
+        )
+
+        serial_proc.launch()
+
+    TASK = SLOT_FILLING
+    input_path = r"E:\research\processed\SlotFilling\MultiDoGo"
+    output_path = r"E:\research\seq\SlotFilling\MultiDoGo"
+
+    for dataset in os.listdir(input_path):
+        input_data_path = os.path.join(input_path, dataset)
+        output_data_path = os.path.join(output_path, dataset)
+
+        serial_proc = SerialPreprocessor(
+            SerialConfig(
+                input_data_path,
+                output_data_path,
+                TASK,
+                logger_name=TASK,
+                task_bos_token=f"[{TASK}]",
+                prompt_func=const_prompt_func_wrapper(
+                    "With given utterance, fill the slots."
+                ),
+                knowledge_func=None_knowledge,
+                label_func=extract_slots_without_intents_wrapper(", ", " | "),
+            )
+        )
+
+        serial_proc.launch()

src/modules/preprocess/preprocessor/SerialPreprocessor.py

@@ -0,0 +1,428 @@
+"""
+Several preprocessor classes.
+Author: md
+"""
+
+from preprocessor.base import BasePreprocessorConfig, BasePreprocessor
+from const import (
+    DIALOGUE_SUMMARY,
+    DIALOGUE_CONTEXT_TO_RESPONSE_GENERATION,
+    DIALOG,
+    KNOWLEDGE,
+    UTTERANCE,
+    ROLES,
+    EMOTION_RECOGNITION,
+    VALUE,
+    ABSA,
+    CHARACTER_IDENTIFICATION,
+    DIALOGUE_STATE_TRACKING,
+    DOCUMENT_GROUNDED_CONVERSATION,
+    TEXT2SQL,
+    SLOT_FILLING,
+    ROLE_RELATION_RECOGNITION,
+    QUESTION_IN_CONTEXT_REWRITING,
+    NATURAL_LANGUAGE_INFERENCE,
+    MACHINE_READING_COMPREHENSION,
+    MULTIPLE_CHOICE_QUESTION_ANSWERING,
+    INTENT_DETECTION,
+    DATA_TO_TEXT,
+    CHIT_CHAT,
+    TRAIN_SPLIT,
+)
+from typing import Dict, List, Callable
+from copy import deepcopy
+
+
+class SerialConfig(BasePreprocessorConfig):
+    def __init__(
+        self,
+        input_dir: str,
+        output_dir: str,
+        task: str,
+        task_bos_token: str = "<s>",
+        knowledge_bos_token: str = "[EK]",
+        prompt_bos_token: str = "[C]",
+        use_role: bool = True,
+        turn_sep: str = None,
+        roles_to_build_example: List = None,
+        dev_and_test_roles_to_build_example: List = None,
+        prompt_func: Callable = None,
+        knowledge_func: Callable = None,
+        label_func: Callable = None,
+        turn_knowledge_func: Callable = None,
+        roles_in_history: List[List] = None,
+        cur_turn_process_func: Callable = None,
+        all_turns_process_func: Callable = None,
+        multi_ref_sep: str = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(input_dir, output_dir, task, *args, **kwargs)
+
+        self.use_role = use_role
+        self.turn_sep = turn_sep
+        self.roles_to_build_example = roles_to_build_example
+        self.prompt_func = prompt_func
+        self.task_bos_token = task_bos_token
+        self.knowledge_bos_token = knowledge_bos_token
+        self.prompt_bos_token = prompt_bos_token
+        self.knowledge_func = knowledge_func
+        self.label_func = label_func
+        self.turn_knowledge_func = turn_knowledge_func
+        self.roles_in_history = roles_in_history
+        self.multi_ref_sep = multi_ref_sep
+        self.dev_and_test_roles_to_build_example = dev_and_test_roles_to_build_example
+        self.cur_turn_process_func = cur_turn_process_func
+        self.all_turns_process_func = all_turns_process_func
+
+
+def concat_roles(roles):
+    return ", ".join(roles)
+
+
+def concat_dial_history(config: SerialConfig, history: List[Dict]):
+    # utterance_list = [
+    #     f"{concat_roles(turn[ROLES])}: {turn[UTTERANCE].strip()}"
+    #     if config.use_role
+    #     else turn[UTTERANCE].strip()
+    #     for turn in history
+    # ]
+
+    utterance_list = []
+    for turn in history:
+        if (
+            config.roles_in_history is not None
+            and turn[ROLES] not in config.roles_in_history
+        ):
+            continue
+
+        if config.use_role:
+            utterance_list.append(
+                f"{concat_roles(turn[ROLES])}: {turn[UTTERANCE].strip()}"
+            )
+        else:
+            utterance_list.append(turn[UTTERANCE].strip())
+
+    if not utterance_list:
+        return "None"
+
+    turn_sep = " "
+    if config.turn_sep is not None:
+        turn_sep = f" {config.turn_sep} "
+
+    return turn_sep.join(utterance_list)
+
+
+def concat_history_knowledge_prompt(
+    config: SerialConfig, history: str, knowledge: str = "", prompt: str = ""
+):
+    """Concat `history`, `knowledge` and `prompt`.
+
+    NOTE: the order is fixed now.
+    """
+    text = ""
+
+    if config.task_bos_token is not None:
+        text = f"{config.task_bos_token} "
+
+    text += history
+
+    if knowledge is not None:
+        text += f" {config.knowledge_bos_token} {knowledge}"
+
+    if prompt is not None:
+        text += f" {config.prompt_bos_token} {prompt}"
+
+    return text
+
+
+def clean(text):
+    return text.replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
+
+
+def add_prefix_to_label(prefix, split, label):
+    tgt = f"{prefix} {label}" if split == "train" else label
+    return tgt
+
+
+class SerialPreprocessor(BasePreprocessor):
+    def __init__(self, config: SerialConfig) -> None:
+        super().__init__(config)
+
+    def extract_knowledge(self, example: Dict):
+        if self.config.knowledge_func is None:
+            knowledge = None
+
+        elif (
+            KNOWLEDGE not in example
+            or not self.config.knowledge_func.__code__.co_argcount
+        ):
+            knowledge = self.config.knowledge_func()
+        else:
+            knowledge = self.config.knowledge_func(example[KNOWLEDGE][VALUE])
+
+        return knowledge
+
+    def preprocess_for_dialogue_level(self, split: str, example: Dict, knowledge: str):
+        label = self.config.label_func(example)
+        tgt = add_prefix_to_label(self.config.task_bos_token, split, label)
+
+        history = concat_dial_history(self.config, example[DIALOG])
+
+        if self.config.prompt_func is None:
+            prompt = ""
+        elif not self.config.prompt_func.__code__.co_argcount:
+            prompt = self.config.prompt_func()
+
+        src = concat_history_knowledge_prompt(self.config, history, knowledge, prompt)
+
+        return [{"src": clean(src), "tgt": clean(tgt)}]
+
+    def preprocess_for_label_level(self, split: str, example: Dict, knowledge: str):
+        label_generator = self.config.label_func(example)
+
+        examples = []
+        for turn_id, label, extra_args in label_generator:
+            tgt = add_prefix_to_label(self.config.task_bos_token, split, label)
+
+            hist = deepcopy(example[DIALOG])
+            if self.config.all_turns_process_func is not None:
+                hist[turn_id] = self.config.all_turns_process_func(
+                    hist[turn_id], *extra_args
+                )
+
+            history = concat_dial_history(self.config, hist)
+
+            if self.config.prompt_func is None:
+                prompt = ""
+            elif not self.config.prompt_func.__code__.co_argcount:
+                prompt = self.config.prompt_func()
+
+            src = concat_history_knowledge_prompt(
+                self.config, history, knowledge, prompt
+            )
+
+            examples.append({"src": clean(src), "tgt": clean(tgt)})
+
+        return examples
+
+    def get_label(
+        self, turn, include_current_turn, turn_idx, split, origin_knowledge=None
+    ):
+        # skip the roles not requiring to build examples
+        if (
+            split != TRAIN_SPLIT
+            and self.config.dev_and_test_roles_to_build_example is not None
+        ):
+            roles_to_build_example = self.config.dev_and_test_roles_to_build_example
+        else:
+            roles_to_build_example = self.config.roles_to_build_example
+        if (
+            roles_to_build_example is not None
+            and turn[ROLES] not in roles_to_build_example
+        ):
+            return None
+
+        # skip the first turn if not including current turn
+        if not include_current_turn and turn_idx == 0:
+            return None
+
+        if self.config.task != DIALOGUE_STATE_TRACKING:
+            try:
+                label = self.config.label_func(turn, split=split)
+            except:
+                label = self.config.label_func(turn, origin_knowledge, split=split)
+        else:
+            label = self.config.label_func(
+                turn, self.ontologies[split], do_train=(split == TRAIN_SPLIT)
+            )
+
+        return label
+
+    def preprocess_for_turn_level(
+        self,
+        split: str,
+        example: Dict,
+        knowledge: str,
+        include_current_turn=False,
+        origin_knowledge=None,
+    ):
+        examples = []
+        multiref = []
+        for turn_idx, turn in enumerate(example[DIALOG]):
+            label = self.get_label(
+                turn, include_current_turn, turn_idx, split, origin_knowledge
+            )
+
+            if label is None:
+                continue
+
+            multiref.append(label)
+            # requre to merge and arrive at the final consecutive label
+            if (
+                self.config.multi_ref_sep is not None
+                and split != "train"
+                and turn_idx < len(example[DIALOG]) - 1
+                and self.get_label(
+                    example[DIALOG][turn_idx + 1],
+                    include_current_turn,
+                    turn_idx + 1,
+                    split,
+                )
+                is not None
+            ):
+                continue
+
+            if self.config.multi_ref_sep is not None and split != "train":
+                label = self.config.multi_ref_sep.join(multiref)
+
+            tgt = add_prefix_to_label(self.config.task_bos_token, split, label)
+
+            end = (turn_idx + 1) if include_current_turn else turn_idx
+
+            hist = deepcopy(example[DIALOG][:end])
+            if self.config.cur_turn_process_func is not None:
+                hist[-1] = self.config.cur_turn_process_func(hist[-1])
+
+            history = concat_dial_history(self.config, hist)
+
+            if self.config.prompt_func is None:
+                prompt = ""
+            elif not self.config.prompt_func.__code__.co_argcount:
+                prompt = self.config.prompt_func()
+
+            if self.config.turn_knowledge_func is not None:
+                knowledge_to_use = self.config.turn_knowledge_func(knowledge, turn)
+            else:
+                knowledge_to_use = knowledge
+
+            src = concat_history_knowledge_prompt(
+                self.config, history, knowledge_to_use, prompt
+            )
+
+            examples.append({"src": clean(src), "tgt": clean(tgt)})
+
+            multiref = []
+
+        return examples
+
+    def preprocess_line(self, split: str, example: Dict) -> List[Dict]:
+        knowledge = self.extract_knowledge(example)
+
+        # 1. Dialogue Summary
+        if self.config.task == DIALOGUE_SUMMARY:
+            return self.preprocess_for_dialogue_level(split, example, knowledge)
+
+        # 2. Emotion Recognition
+        if self.config.task == EMOTION_RECOGNITION:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 3. Dialogue Context-to-Text Generation
+        if self.config.task == DIALOGUE_CONTEXT_TO_RESPONSE_GENERATION:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=False
+            )
+
+        # 4. ABSA
+        if self.config.task.startswith(ABSA):
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 5. Character Identification
+        if self.config.task == CHARACTER_IDENTIFICATION:
+            # return self.preprocess_for_turn_level(
+            #     split, example, knowledge, include_current_turn=True
+            # )
+            # return self.preprocess_for_dialogue_level(split, example, knowledge)
+            return self.preprocess_for_label_level(split, example, knowledge)
+
+        # 6. Dialogue State Tracking
+        if self.config.task == DIALOGUE_STATE_TRACKING:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 7. Document Grounded Conversation
+        if self.config.task == DOCUMENT_GROUNDED_CONVERSATION:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=False
+            )
+
+        # 8. Text2SQL
+        if self.config.task == TEXT2SQL:
+            seq_examples = self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+            for idx in range(len(seq_examples)):
+                seq_examples[idx]["db_id"] = knowledge["db_id"]
+
+            return seq_examples
+
+        # 9. Slot Filling
+        if self.config.task == SLOT_FILLING:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 10. Relation Recognition
+        if self.config.task == ROLE_RELATION_RECOGNITION:
+            return self.preprocess_for_dialogue_level(split, example, knowledge)
+
+        # 11. Question in Context Rewriting
+        if self.config.task == QUESTION_IN_CONTEXT_REWRITING:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 12. Natural Language Inference
+        if self.config.task == NATURAL_LANGUAGE_INFERENCE:
+            return self.preprocess_for_turn_level(
+                split,
+                example,
+                knowledge,
+                include_current_turn=True,
+                origin_knowledge=example[KNOWLEDGE][VALUE],
+            )
+
+        # 13. Machine Reading Comprehension
+        if self.config.task == MACHINE_READING_COMPREHENSION:
+            return self.preprocess_for_turn_level(split, example, knowledge)
+
+        # 14. Multiple Choice Question Answering
+        if self.config.task == MULTIPLE_CHOICE_QUESTION_ANSWERING:
+            return self.preprocess_for_turn_level(
+                split,
+                example,
+                knowledge,
+                include_current_turn=True,
+                origin_knowledge=example[KNOWLEDGE][VALUE],
+            )
+
+        # 15. Intent Detection
+        if self.config.task == INTENT_DETECTION:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 16. Data-to-Text
+        if self.config.task == DATA_TO_TEXT:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+        # 17. Chit-Chat
+        if self.config.task == CHIT_CHAT:
+            return self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=False
+            )
+
+        if self.config.task == "Semantic Parsing":
+            seq_examples = self.preprocess_for_turn_level(
+                split, example, knowledge, include_current_turn=True
+            )
+
+            return seq_examples

src/modules/preprocess/preprocessor/base.py

@@ -0,0 +1,150 @@
+"""
+Base preprocessor class.
+Author: md
+"""
+
+from config import BaseConfig
+import os
+from logger import build_logger
+import logging
+import json
+from const import TRAIN_SPLIT, DEV_SPLIT, TEST_SPLIT, DIALOGUE_STATE_TRACKING
+from typing import Dict
+import shutil
+
+
+class BasePreprocessorConfig(BaseConfig):
+    def __init__(
+        self,
+        input_dir: str,
+        output_dir: str,
+        task: str,
+        formatter="%(asctime)s | [%(name)s] | %(levelname)s | %(message)s",
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.input_dir = input_dir
+        self.output_dir = output_dir
+        self.task = task
+        self.formatter = formatter
+
+
+class BasePreprocessor(object):
+    def __init__(self, config: BasePreprocessorConfig) -> None:
+        self.config = config
+        self.logger = build_logger(
+            config.logger_name,
+            logging.INFO,
+            config.log_file,
+            config.log_mode,
+            config.formatter,
+        )
+
+        if self.config.task == DIALOGUE_STATE_TRACKING:
+            self.ontologies = {
+                split: self.load_ontology(split)
+                for split in [TRAIN_SPLIT, DEV_SPLIT, TEST_SPLIT]
+            }
+
+    def load_ontology(self, split: str) -> Dict:
+        """
+        Load the ontology file.
+        """
+        ontology_file = os.path.join(self.config.input_dir, f"{split}_ontology.json")
+        if not os.path.exists(ontology_file):
+            return None
+        return json.load(open(ontology_file, "r", encoding="utf8"))
+
+    def preprocess_line(self, split: str, example: Dict) -> Dict:
+        """
+        Every preprocessor should customize this function for all `train`, `dev` and `test` split.
+        """
+        raise NotImplementedError("The preprocess line procedure is required!")
+
+    def _preprocess_file(
+        self, start, infile, src_writer, tgt_writer, split, encoding="UTF-8"
+    ):
+        with open(infile, "r", encoding=encoding) as reader:
+            for line in reader:
+                if line.strip():
+                    example = json.loads(line)
+                    if start:
+                        start = False
+                    elif split != "train":
+                        tgt_writer.write("\n")
+                    for processed_example in self.preprocess_line(split, example):
+                        src_writer.write(f"{processed_example['src']}\n")
+                        tgt_writer.write(f"{processed_example['tgt']}")
+
+                        if "db_id" in processed_example and split != "train":
+                            tgt_writer.write(f"\t{processed_example['db_id']}")
+                        tgt_writer.write("\n")
+        return start
+
+    def preprocess(self, split: str) -> bool:
+        if not os.path.exists(self.config.output_dir):
+            os.makedirs(self.config.output_dir)
+
+        src_file = os.path.join(self.config.output_dir, f"{split}.src")
+        tgt_file = os.path.join(
+            self.config.output_dir,
+            f"{split}.tgt" if split == "train" else f"{split}.gold",
+        )
+        exist = False
+
+        with open(src_file, "w") as src_writer, open(tgt_file, "w") as tgt_writer:
+            start = True
+            for filename in os.listdir(self.config.input_dir):
+                if split not in filename or not filename.endswith(".jsonl"):
+                    continue
+
+                exist = True
+                infile = os.path.join(self.config.input_dir, filename)
+
+                self.logger.info(f"preprocessing {infile}")
+                try:
+                    start = self._preprocess_file(
+                        start, infile, src_writer, tgt_writer, split
+                    )
+                except UnicodeDecodeError:
+                    start = self._preprocess_file(
+                        start, infile, src_writer, tgt_writer, split, "ISO-8859-1"
+                    )
+
+        return exist
+
+    def launch(self) -> None:
+        self.logger.info(f"Start to preprocess: {TRAIN_SPLIT}")
+        train = self.preprocess(TRAIN_SPLIT)
+        assert train
+
+        self.logger.info(f"Start to preprocess: {DEV_SPLIT}")
+        dev = self.preprocess(DEV_SPLIT)
+        self.logger.info(f"Start to preprocess: {TEST_SPLIT}")
+        test = self.preprocess(TEST_SPLIT)
+
+        if dev and not test:
+            self.logger.info("Copy dev to test")
+            shutil.copyfile(
+                os.path.join(self.config.output_dir, "dev.src"),
+                os.path.join(self.config.output_dir, "test.src"),
+            )
+            shutil.copyfile(
+                os.path.join(self.config.output_dir, "dev.gold"),
+                os.path.join(self.config.output_dir, "test.gold"),
+            )
+
+        if test and not dev:
+            self.logger.info("Copy test to dev")
+            shutil.copyfile(
+                os.path.join(self.config.output_dir, "test.src"),
+                os.path.join(self.config.output_dir, "dev.src"),
+            )
+            shutil.copyfile(
+                os.path.join(self.config.output_dir, "test.gold"),
+                os.path.join(self.config.output_dir, "dev.gold"),
+            )
+
+        self.logger.info("Preprocess successfully!")

src/modules/preprocess/preprocessor/knowledge_funcs.py

@@ -0,0 +1,505 @@
+from typing import List, Dict, Optional, Tuple
+import random
+import difflib
+from rapidfuzz import fuzz
+import sqlite3
+import functools
+from const import KNOWLEDGE_TO_SELECT, UTTERANCE, ROLES, BELIEF_STATE, DOMAIN
+
+
+def None_knowledge():
+    return "None"
+
+
+def concat_list_knowledge_wrapper(prompt: str = "", sep: str = " | "):
+    def get_list_knowledge(str_list: List[str]):
+        return prompt + sep.join(str_list)
+
+    return get_list_knowledge
+
+
+def origin_knowledge(knowledge):
+    return knowledge
+
+
+def extract_turn_knowledge(
+    knowledge, section_prompt_op, section_sep, section_value_sep
+):
+    if isinstance(knowledge, dict):
+        sec_list = []
+        for section in sorted(knowledge.keys()):
+            sec_str = f"{section}{section_prompt_op}"
+            if isinstance(knowledge[section], str):
+                sec_str += knowledge[section]
+            elif isinstance(knowledge[section], list):
+                sec_str += section_value_sep.join(knowledge[section])
+            sec_list.append(sec_str)
+
+        return section_sep.join(sec_list)
+
+    elif isinstance(knowledge, str):
+        return knowledge
+
+    elif isinstance(knowledge, list):
+        return ";; ".join(
+            [
+                extract_turn_knowledge(
+                    sec, section_prompt_op, section_sep, section_value_sep
+                )
+                for sec in knowledge
+            ]
+        )
+
+
+def extract_turn_domains_wrapper(prompt: str = "", sep: str = ", "):
+    def extract_turn_domains(knowledge, turn):
+        bs = turn[BELIEF_STATE]
+        domains = []
+        for state in bs:
+            domain = state[DOMAIN]
+            if domain not in domains:
+                domains.append(domain)
+
+        return prompt + sep.join(domains)
+
+    return extract_turn_domains
+
+
+def extract_turn_knowledge_wrapper(section_prompt_op, section_sep, section_value_sep):
+    def extract_turn_knowledge_func(knowledge, turn):
+        return extract_turn_knowledge(
+            [knowledge[sec] for sec in turn[KNOWLEDGE_TO_SELECT]],
+            section_prompt_op,
+            section_sep,
+            section_value_sep,
+        )
+
+    return extract_turn_knowledge_func
+
+
+# Text2SQL
+EXIST = {"atis", "geo", "advising", "yelp", "restaurants", "imdb", "academic"}
+
+# fmt: off
+_stopwords = {'who', 'ourselves', 'down', 'only', 'were', 'him', 'at', "weren't", 'has', 'few', "it's", 'm', 'again',
+              'd', 'haven', 'been', 'other', 'we', 'an', 'own', 'doing', 'ma', 'hers', 'all', "haven't", 'in', 'but',
+              "shouldn't", 'does', 'out', 'aren', 'you', "you'd", 'himself', "isn't", 'most', 'y', 'below', 'is',
+              "wasn't", 'hasn', 'them', 'wouldn', 'against', 'this', 'about', 'there', 'don', "that'll", 'a', 'being',
+              'with', 'your', 'theirs', 'its', 'any', 'why', 'now', 'during', 'weren', 'if', 'should', 'those', 'be',
+              'they', 'o', 't', 'of', 'or', 'me', 'i', 'some', 'her', 'do', 'will', 'yours', 'for', 'mightn', 'nor',
+              'needn', 'the', 'until', "couldn't", 'he', 'which', 'yourself', 'to', "needn't", "you're", 'because',
+              'their', 'where', 'it', "didn't", 've', 'whom', "should've", 'can', "shan't", 'on', 'had', 'have',
+              'myself', 'am', "don't", 'under', 'was', "won't", 'these', 'so', 'as', 'after', 'above', 'each', 'ours',
+              'hadn', 'having', 'wasn', 's', 'doesn', "hadn't", 'than', 'by', 'that', 'both', 'herself', 'his',
+              "wouldn't", 'into', "doesn't", 'before', 'my', 'won', 'more', 'are', 'through', 'same', 'how', 'what',
+              'over', 'll', 'yourselves', 'up', 'mustn', "mustn't", "she's", 're', 'such', 'didn', "you'll", 'shan',
+              'when', "you've", 'themselves', "mightn't", 'she', 'from', 'isn', 'ain', 'between', 'once', 'here',
+              'shouldn', 'our', 'and', 'not', 'too', 'very', 'further', 'while', 'off', 'couldn', "hasn't", 'itself',
+              'then', 'did', 'just', "aren't"}
+# fmt: on
+
+_commonwords = {"no", "yes", "many"}
+
+
+def is_number(s: str) -> bool:
+    try:
+        float(s.replace(",", ""))
+        return True
+    except:
+        return False
+
+
+def is_stopword(s: str) -> bool:
+    return s.strip() in _stopwords
+
+
+def is_commonword(s: str) -> bool:
+    return s.strip() in _commonwords
+
+
+def is_common_db_term(s: str) -> bool:
+    return s.strip() in ["id"]
+
+
+class Match(object):
+    def __init__(self, start: int, size: int) -> None:
+        self.start = start
+        self.size = size
+
+
+def is_span_separator(c: str) -> bool:
+    return c in "'\"()`,.?! "
+
+
+def split(s: str) -> List[str]:
+    return [c.lower() for c in s.strip()]
+
+
+def prefix_match(s1: str, s2: str) -> bool:
+    i, j = 0, 0
+    for i in range(len(s1)):
+        if not is_span_separator(s1[i]):
+            break
+    for j in range(len(s2)):
+        if not is_span_separator(s2[j]):
+            break
+    if i < len(s1) and j < len(s2):
+        return s1[i] == s2[j]
+    elif i >= len(s1) and j >= len(s2):
+        return True
+    else:
+        return False
+
+
+def get_effective_match_source(s: str, start: int, end: int) -> Match:
+    _start = -1
+
+    for i in range(start, start - 2, -1):
+        if i < 0:
+            _start = i + 1
+            break
+        if is_span_separator(s[i]):
+            _start = i
+            break
+
+    if _start < 0:
+        return None
+
+    _end = -1
+    for i in range(end - 1, end + 3):
+        if i >= len(s):
+            _end = i - 1
+            break
+        if is_span_separator(s[i]):
+            _end = i
+            break
+
+    if _end < 0:
+        return None
+
+    while _start < len(s) and is_span_separator(s[_start]):
+        _start += 1
+    while _end >= 0 and is_span_separator(s[_end]):
+        _end -= 1
+
+    return Match(_start, _end - _start + 1)
+
+
+def get_matched_entries(
+    s: str, field_values: List[str], m_theta: float = 0.85, s_theta: float = 0.85
+) -> Optional[List[Tuple[str, Tuple[str, str, float, float, int]]]]:
+    if not field_values:
+        return None
+
+    if isinstance(s, str):
+        n_grams = split(s)
+    else:
+        n_grams = s
+
+    matched = dict()
+    for field_value in field_values:
+        if not isinstance(field_value, str):
+            continue
+        fv_tokens = split(field_value)
+        sm = difflib.SequenceMatcher(None, n_grams, fv_tokens)
+        match = sm.find_longest_match(0, len(n_grams), 0, len(fv_tokens))
+        if match.size > 0:
+            source_match = get_effective_match_source(
+                n_grams, match.a, match.a + match.size
+            )
+            if source_match and source_match.size > 1:
+                match_str = field_value[match.b : match.b + match.size]
+                source_match_str = s[
+                    source_match.start : source_match.start + source_match.size
+                ]
+                c_match_str = match_str.lower().strip()
+                c_source_match_str = source_match_str.lower().strip()
+                c_field_value = field_value.lower().strip()
+                if (
+                    c_match_str
+                    and not is_number(c_match_str)
+                    and not is_common_db_term(c_match_str)
+                ):
+                    if (
+                        is_stopword(c_match_str)
+                        or is_stopword(c_source_match_str)
+                        or is_stopword(c_field_value)
+                    ):
+                        continue
+                    if c_source_match_str.endswith(c_match_str + "'s"):
+                        match_score = 1.0
+                    else:
+                        if prefix_match(c_field_value, c_source_match_str):
+                            match_score = (
+                                fuzz.ratio(c_field_value, c_source_match_str) / 100
+                            )
+                        else:
+                            match_score = 0
+                    if (
+                        is_commonword(c_match_str)
+                        or is_commonword(c_source_match_str)
+                        or is_commonword(c_field_value)
+                    ) and match_score < 1:
+                        continue
+                    s_match_score = match_score
+                    if match_score >= m_theta and s_match_score >= s_theta:
+                        if field_value.isupper() and match_score * s_match_score < 1:
+                            continue
+                        matched[match_str] = (
+                            field_value,
+                            source_match_str,
+                            match_score,
+                            s_match_score,
+                            match.size,
+                        )
+
+    if not matched:
+        return None
+    else:
+        return sorted(
+            matched.items(),
+            key=lambda x: (1e16 * x[1][2] + 1e8 * x[1][3] + x[1][4]),
+            reverse=True,
+        )
+
+
+@functools.lru_cache(maxsize=1000, typed=False)
+def get_column_picklist(table_name: str, column_name: str, db_path: str) -> list:
+    fetch_sql = "SELECT DISTINCT `{}` FROM `{}`".format(column_name, table_name)
+    try:
+        conn = sqlite3.connect(db_path)
+        conn.text_factory = bytes
+        c = conn.cursor()
+        c.execute(fetch_sql)
+        picklist = set()
+        for x in c.fetchall():
+            if isinstance(x[0], str):
+                picklist.add(x[0].encode("utf-8"))
+            elif isinstance(x[0], bytes):
+                try:
+                    picklist.add(x[0].decode("utf-8"))
+                except UnicodeDecodeError:
+                    picklist.add(x[0].decode("latin-1"))
+            else:
+                picklist.add(x[0])
+        picklist = list(picklist)
+    finally:
+        conn.close()
+    return picklist
+
+
+def get_database_matches(
+    question: str,
+    table_name: str,
+    column_name: str,
+    db_path: str,
+    top_k_matches: int = 2,
+    match_threshold: float = 0.85,
+) -> List[str]:
+    picklist = get_column_picklist(
+        table_name=table_name, column_name=column_name, db_path=db_path
+    )
+    matches = []
+    if picklist and isinstance(picklist[0], str):
+        matched_entries = get_matched_entries(
+            s=question,
+            field_values=picklist,
+            m_theta=match_threshold,
+            s_theta=match_threshold,
+        )
+        if matched_entries:
+            num_values_inserted = 0
+            for _match_str, (
+                field_value,
+                _s_match_str,
+                match_score,
+                s_match_score,
+                _match_size,
+            ) in matched_entries:
+                if "name" in column_name and match_score * s_match_score < 1:
+                    continue
+                if table_name != "sqlite_sequence":  # Spider database artifact
+                    matches.append(field_value)
+                    num_values_inserted += 1
+                    if num_values_inserted >= top_k_matches:
+                        break
+    return matches
+
+
+def serialize_schema(
+    question: str,
+    db_path: str,
+    db_id: str,
+    db_column_names: Dict[str, str],
+    db_table_names: List[str],
+    schema_serialization_type: str = "peteshaw",
+    schema_serialization_randomized: bool = False,
+    schema_serialization_with_db_id: bool = True,
+    schema_serialization_with_db_content: bool = False,
+    normalize_query: bool = True,
+) -> str:
+    if schema_serialization_type == "verbose":
+        db_id_str = "Database: {db_id}. "
+        table_sep = ". "
+        table_str = "Table: {table}. Columns: {columns}"
+        column_sep = ", "
+        column_str_with_values = "{column} ({values})"
+        column_str_without_values = "{column}"
+        value_sep = ", "
+    elif schema_serialization_type == "peteshaw":
+        # see https://github.com/google-research/language/blob/master/language/nqg/tasks/spider/append_schema.py#L42
+        db_id_str = "{db_id}"
+        table_sep = ""
+        table_str = " | {table} : {columns}"
+        column_sep = " , "
+        column_str_with_values = "{column} ( {values} )"
+        column_str_without_values = "{column}"
+        value_sep = " , "
+    else:
+        raise NotImplementedError
+
+    def get_column_str(table_name: str, column_name: str) -> str:
+        column_name_str = column_name.lower() if normalize_query else column_name
+        if schema_serialization_with_db_content:
+            matches = get_database_matches(
+                question=question,
+                table_name=table_name,
+                column_name=column_name,
+                db_path=(db_path + "/" + db_id + "/" + db_id + ".sqlite"),
+            )
+            if matches:
+                return column_str_with_values.format(
+                    column=column_name_str, values=value_sep.join(matches)
+                )
+            else:
+                return column_str_without_values.format(column=column_name_str)
+        else:
+            return column_str_without_values.format(column=column_name_str)
+
+    tables = [
+        table_str.format(
+            table=table_name.lower() if normalize_query else table_name,
+            columns=column_sep.join(
+                map(
+                    lambda y: get_column_str(table_name=table_name, column_name=y[1]),
+                    filter(
+                        lambda y: y[0] == table_id,
+                        zip(
+                            db_column_names["table_id"],
+                            db_column_names["column_name"],
+                        ),
+                    ),
+                )
+            ),
+        )
+        for table_id, table_name in enumerate(db_table_names)
+    ]
+    if schema_serialization_randomized:
+        random.shuffle(tables)
+    if schema_serialization_with_db_id:
+        serialized_schema = db_id_str.format(db_id=db_id) + table_sep.join(tables)
+    else:
+        serialized_schema = table_sep.join(tables)
+    return serialized_schema
+
+
+def extract_schema_knowledge_wrapper(
+    schema_serialization_type: str = "peteshaw",
+    schema_serialization_randomized: bool = False,
+    schema_serialization_with_db_id: bool = True,
+    schema_serialization_with_db_content: bool = False,
+    normalize_query: bool = True,
+):
+    def extract_turn_schema_knowledge_func(knowledge, turn):
+        schema = knowledge["schema"]
+        db_column_names = {
+            "table_id": [table_id for table_id, _ in schema["column_names_original"]],
+            "column_name": [
+                column_name for _, column_name in schema["column_names_original"]
+            ],
+        }
+        return serialize_schema(
+            turn[UTTERANCE],
+            knowledge["db_path"],
+            knowledge["db_id"],
+            db_column_names,
+            schema["table_names_original"],
+            schema_serialization_type,
+            schema_serialization_randomized,
+            schema_serialization_with_db_id,
+            schema_serialization_with_db_content,
+            normalize_query,
+        )
+
+    return extract_turn_schema_knowledge_func
+
+
+def extract_dict_knowledge(knowledge, key_prompt_op, pair_sep):
+    pair_list = []
+    for key in knowledge:
+        pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")
+
+    if not pair_list:
+        return "None"
+
+    return pair_sep.join(pair_list)
+
+
+def extract_dict_knowledge_wrapper(key_prompt_op, pair_sep):
+    def extract_dict_knowledge_func(knowledge):
+        return extract_dict_knowledge(knowledge, key_prompt_op, pair_sep)
+
+    return extract_dict_knowledge_func
+
+
+def extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep):
+    pair_list = []
+    for key in knowledge:
+        if isinstance(knowledge[key], str):
+            pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")
+        elif isinstance(knowledge[key], list):
+            turns = []
+            for turn in knowledge[key]:
+                role_str = role_sep.join(turn[ROLES])
+                turns.append(f"{role_str}# {turn[UTTERANCE]}")
+            dial_str = " ".join(turns)
+            pair_list.append(f"{key}{key_prompt_op}{dial_str}")
+    if not pair_list:
+        return "None"
+    return pair_sep.join(pair_list)
+
+
+def extract_dialogue_knowledge_wrapper(key_prompt_op, pair_sep, role_sep):
+    def extract_dialogue_knowledge_func(knowledge):
+        return extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep)
+
+    return extract_dialogue_knowledge_func
+
+
+def extract_kg_knowledge(
+    knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
+):
+    pair_list = []
+    for key in knowledge:
+        if isinstance(knowledge[key], str):
+            pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")
+        elif isinstance(knowledge[key], list):
+            edges = []
+            for edge in knowledge[key]:
+                edges.append(inner_edge_sep.join(edge))
+            kg_str = intra_edge_sep.join(edges)
+            pair_list.append(f"{key}{key_prompt_op}{kg_str}")
+    if not pair_list:
+        return "None"
+    return pair_sep.join(pair_list)
+
+
+def extract_kg_knowledge_wrapper(
+    key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
+):
+    def extract_kg_knowledge_func(knowledge):
+        return extract_kg_knowledge(
+            knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
+        )
+
+    return extract_kg_knowledge_func

src/modules/preprocess/preprocessor/label_funs.py

@@ -0,0 +1,324 @@
+from const import (
+    SUMMARY,
+    EMOTIONS,
+    EMOTION,
+    UTTERANCE,
+    ASPECTS,
+    TARGET,
+    VALUE,
+    OPINION,
+    SENTIMENT,
+    CATEGORY,
+    CHARACTERS,
+    DIALOG,
+    START,
+    END,
+    BELIEF_STATE,
+    DOMAIN,
+    INFORMED_SLOT_VALUE_TABLE,
+    SLOT,
+    VALUES,
+    RELATION,
+    SQL,
+    SLOT_VALUE_TABLE,
+    SLOTS_TO_FILL,
+    ROLE_RELATIONS,
+    REWRITTEN,
+    ROLES_TO_SELECT,
+    ACTIVE_INTENTS,
+    TRAIN_SPLIT,
+    OPTION_LABEL,
+    CANDIDATES,
+)
+from typing import Dict
+import re
+import random
+import copy
+import json
+
+
+def extract_summary(dial: Dict, **kwargs):
+    """
+    `dial` is the full dialog.
+    """
+    return dial[SUMMARY]
+
+
+def extract_turn_emotion(turn: Dict, sep: str, **kwargs):
+    if EMOTIONS not in turn:
+        return None
+    return sep.join(map(lambda x: x[EMOTION], turn[EMOTIONS]))
+
+
+def extract_turn_emotion_wrapper(sep: str):
+    def extract_turn_emotion_func(turn: Dict, **kwargs):
+        return extract_turn_emotion(turn, sep)
+
+    return extract_turn_emotion_func
+
+
+def extract_turn_utterance(turn: Dict, **kwargs):
+    return turn[UTTERANCE]
+
+
+def extract_aspects(turn: Dict, ext_aspect_sep: str, int_aspect_sep: str):
+    if not turn[ASPECTS]:
+        return "None"
+
+    aspects = turn[ASPECTS]
+
+    tgt_seq = []
+    for aspect in aspects:
+        aspect_seq = []
+        if TARGET in aspect:
+            aspect_seq.append(aspect[TARGET][VALUE])
+        if CATEGORY in aspect:
+            aspect_seq.append(aspect[CATEGORY])
+
+        if OPINION in aspect:
+            aspect_seq.append(aspect[OPINION][VALUE])
+
+        if SENTIMENT in aspect:
+            aspect_seq.append(aspect[SENTIMENT])
+
+        tgt_seq.append(int_aspect_sep.join(aspect_seq))
+
+    return ext_aspect_sep.join(tgt_seq)
+
+
+def extract_aspects_wrapper(ext_aspect_sep: str, int_aspect_sep: str):
+    def extract_aspects_func(turn: Dict, **kwargs):
+        return extract_aspects(turn, ext_aspect_sep, int_aspect_sep)
+
+    return extract_aspects_func
+
+
+def rebuild_utterance_with_characters(turn: Dict, split):
+    if split == "train":
+        utterance = turn[UTTERANCE]
+        parts = []
+        pre = 0
+
+        for character in turn[CHARACTERS]:
+            parts.append(utterance[pre : character[START]])
+            parts.append(
+                f"[{utterance[character[START]: character[END]]} | {character[VALUE]}]"
+            )
+            pre = character[END]
+
+        parts.append(utterance[pre:])
+        return "".join(parts)
+
+    else:
+        tuples = []
+        for character in turn[CHARACTERS]:
+            tuples.append(f"{character[VALUE]}, {character[START]}, {character[END]}")
+
+        if not tuples:
+            return "None"
+        return " | ".join(tuples)
+
+
+def extract_characters(example):
+    for turn_id, turn in enumerate(example[DIALOG]):
+        if CHARACTERS not in turn:
+            continue
+
+        for character in turn[CHARACTERS]:
+            yield turn_id, character[VALUE], (character[END],)
+
+
+def extract_belief_state(
+    turn,
+    value_sep,
+    domain_sep,
+    slot_sep,
+    domain_prompt_op,
+    ontology=None,
+    do_train=True,
+):
+    domain_bs = dict()
+    bs = turn[BELIEF_STATE]
+
+    # spare_bs = {domain: {slot for slot in ontology[domain]} for domain in ontology}
+
+    for state in bs:
+        domain = state[DOMAIN]
+        if domain not in domain_bs:
+            domain_bs[domain] = dict()
+
+        if INFORMED_SLOT_VALUE_TABLE not in state:
+            continue
+
+        for svp in state[INFORMED_SLOT_VALUE_TABLE]:
+            slot = svp[SLOT]
+            values = svp[VALUES]
+            relation = svp[RELATION]
+
+            if slot not in domain_bs[domain]:
+                domain_bs[domain][slot] = {"relation": relation, "values": []}
+            domain_bs[domain][slot]["values"] += list(map(lambda x: x[VALUE], values))
+
+            # spare_bs[domain].remove(slot)
+
+    domain_bs_list = []
+    for domain in domain_bs:
+        svp_list = []
+        for slot in domain_bs[domain]:
+            val_str = value_sep.join(domain_bs[domain][slot]["values"])
+            svp_list.append(f"{slot} {domain_bs[domain][slot]['relation']} {val_str}")
+
+        # control whether to add spare slots
+        # for slot in sorted(spare_bs[domain]):
+        #     svp_list.append(f"{slot} = None")
+        if not svp_list:
+            continue
+        if do_train:
+            # shuffle for training
+            random.shuffle(svp_list)
+
+        # append a slot separator at the end to alleviate the problem of end point prediction of T5
+        svt_str = slot_sep.join(svp_list) + slot_sep
+
+        domain_bs_list.append(f"{domain}{domain_prompt_op}{svt_str.strip()}")
+
+    if not domain_bs_list:
+        return "None"
+
+    return domain_sep.join(domain_bs_list)
+
+
+def extract_belief_state_wrapper(value_sep, domain_sep, slot_sep, domain_prompt_op):
+    def extract_belief_state_func(turn, ontology, do_train=True, **kwargs):
+        return extract_belief_state(
+            turn,
+            value_sep,
+            domain_sep,
+            slot_sep,
+            domain_prompt_op,
+            ontology,
+            do_train=do_train,
+        )
+
+    return extract_belief_state_func
+
+
+def normalize(query: str) -> str:
+    def comma_fix(s):
+        # Remove spaces in front of commas
+        return s.replace(" , ", ", ")
+
+    def white_space_fix(s):
+        # Remove double and triple spaces
+        return " ".join(s.split())
+
+    def lower(s):
+        # Convert everything except text between (single or double) quotation marks to lower case
+        return re.sub(
+            r"\b(?<!['\"])(\w+)(?!['\"])\b", lambda match: match.group(1).lower(), s
+        )
+
+    def space_fix(sql: str):
+        def agg_fix(sql: str):
+            return re.sub(
+                r"(count|max|min|sum|avg)\s\(",
+                lambda match: match.group(0).replace(" ", ""),
+                sql,
+            )
+
+        def brackets_fix(sql: str):
+            sql = re.sub(r"\(\s", lambda match: match.group(0)[:-1], sql)
+            sql = re.sub(r"\s\)", lambda match: match.group(0)[1:], sql)
+
+            return sql
+
+        def double_chars_op_fix(sql: str):
+            return re.sub(
+                r"((>|<|!)\s=)",
+                lambda match: match.group(0).replace(" ", ""),
+                sql,
+            )
+
+        return double_chars_op_fix(brackets_fix(agg_fix(sql)))
+
+    return space_fix(comma_fix(white_space_fix(lower(query))))
+
+
+def extract_sql(turn, split):
+    if SQL not in turn:
+        return None
+    _normalize = normalize if split == "train" else (lambda x: x)
+    return _normalize(turn[SQL])
+
+
+def extract_slots_without_intents(turn, value_sep, slot_sep):
+    if SLOTS_TO_FILL not in turn or not turn[SLOTS_TO_FILL][SLOT_VALUE_TABLE]:
+        return "None"
+    slots = []
+    for svp in turn[SLOTS_TO_FILL][SLOT_VALUE_TABLE]:
+        slots.append(
+            svp[SLOT]
+            + " "
+            + svp[RELATION]
+            + " "
+            + value_sep.join(map(lambda x: x[VALUE], svp[VALUES]))
+        )
+
+    return (slot_sep.join(slots) + slot_sep).strip()
+
+
+def extract_slots_without_intents_wrapper(value_sep, slot_sep):
+    def extract_slots_without_intents_func(turn, **kwargs):
+        return extract_slots_without_intents(turn, value_sep, slot_sep)
+
+    return extract_slots_without_intents_func
+
+
+def extract_role_relation_without_turn(dialog, relation_sep):
+    return relation_sep.join(map(lambda x: x[RELATION], dialog[ROLE_RELATIONS]))
+
+
+def extract_role_relation_without_turn_wrapper(relation_sep):
+    def extract_role_relation_without_turn_func(dialog, **kwargs):
+        return extract_role_relation_without_turn(dialog, relation_sep)
+
+    return extract_role_relation_without_turn_func
+
+
+def extrac_rewritten(turn, **kwargs):
+    if REWRITTEN not in turn:
+        return None
+    return turn[REWRITTEN]
+
+
+def extract_options(turn, knowledge, split=None):
+    if ROLES_TO_SELECT not in turn:
+        return None
+    if split == TRAIN_SPLIT:
+        return knowledge[turn[ROLES_TO_SELECT][0]]
+    else:
+        return json.dumps(
+            {OPTION_LABEL: turn[ROLES_TO_SELECT][0], CANDIDATES: knowledge}
+        )
+
+
+# def extract_roles_wrapper(role_sep):
+#     def extract_roles_func(turn, knowledge, split=None):
+#         return extract_options(turn, know)
+
+#     return extract_roles_func
+
+
+def extract_intents(turn, intent_sep):
+    if not turn[ACTIVE_INTENTS]:
+        return "None"
+    return intent_sep.join(
+        map(lambda intent: intent.replace("_", " "), turn[ACTIVE_INTENTS])
+    )
+
+
+def extract_intents_wrapper(intent_sep):
+    def extract_intents_func(turn, **kwargs):
+        return extract_intents(turn, intent_sep)
+
+    return extract_intents_func

src/modules/preprocess/preprocessor/process_turn_funcs.py

@@ -0,0 +1,22 @@
+from const import UTTERANCE, CHARACTERS, START, END, MENTION
+
+
+def introduce_mention_to_utterance(turn, insert_index, left_bracket, right_bracket):
+    turn[UTTERANCE] = (
+        turn[UTTERANCE][:insert_index]
+        + left_bracket
+        + MENTION
+        + right_bracket
+        + turn[UTTERANCE][insert_index:]
+    )
+
+    return turn
+
+
+def introduce_mention_to_utterance_wrapper(left_bracket, right_bracket):
+    def introduce_mention_to_utterance_func(turn, insert_index, **kwargs):
+        return introduce_mention_to_utterance(
+            turn, insert_index, left_bracket, right_bracket
+        )
+
+    return introduce_mention_to_utterance_func

src/modules/preprocess/preprocessor/prompt_funcs.py

@@ -0,0 +1,5 @@
+def const_prompt_func_wrapper(const_prompt):
+    def const_prompt_func():
+        return const_prompt
+
+    return const_prompt_func

src/preprocess.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+cd preprocess
+
+INPUT=$1
+OUTPUT=$2
+
+DATA="MAMS-ACSA"
+echo "--> ${DATA}"
+# python ${DATA}.py --input_dir "${INPUT}/TaskMaster/TM-1-2019" --output_dir "${OUTPUT}/${DATA}"
+python ${DATA}.py --input_dir "${INPUT}/MAMS/data/${DATA}/raw" --output_dir "${OUTPUT}/MAMS/${DATA}"

src/preprocess/ASTE.py

@@ -0,0 +1,97 @@
+from utils import write_jsonl_file, parse, read_line_labels
+import os
+
+sent_map = {
+    "POS": "positive",
+    "NEU": "neutral",
+    "NEG": "negative",
+}
+
+
+def get_char_index(lengths, tok_ids):
+    start = lengths[tok_ids[0]] + tok_ids[0]
+    end = (
+        lengths[tok_ids[-1] + 1]
+        - lengths[tok_ids[0]]
+        + start
+        + tok_ids[-1]
+        - tok_ids[0]
+    )
+    return start, end
+
+
+def parse_aspects(utterance, aspects):
+    toks = utterance.split()
+    lengths = list(map(lambda x: len(x), toks))
+    lengths = [0] + lengths
+
+    for i in range(1, len(lengths)):
+        lengths[i] += lengths[i - 1]
+
+    parsed_aspects = []
+    for target, opinion, sentiment in aspects:
+        target_start, target_end = get_char_index(lengths, target)
+        opinion_start, opinion_end = get_char_index(lengths, opinion)
+        target_value = " ".join(toks[target[0] : target[-1] + 1])
+        opinion_value = " ".join(toks[opinion[0] : opinion[-1] + 1])
+
+        assert target_value == utterance[target_start:target_end]
+        assert opinion_value == utterance[opinion_start:opinion_end]
+
+        parsed_aspects.append(
+            {
+                "target": {
+                    "value": target_value,
+                    "start": target_start,
+                    "end": target_end,
+                },
+                "opinion": {
+                    "value": opinion_value,
+                    "start": opinion_start,
+                    "end": opinion_end,
+                },
+                "sentiment": sent_map[sentiment],
+            }
+        )
+
+    return parsed_aspects
+
+
+def reformat(args, file):
+    for domain in os.listdir(args.input_dir):
+        path = os.path.join(os.path.join(args.input_dir, domain), f"{file}.txt")
+        data = read_line_labels(path)
+
+        dials = []
+        for line in data:
+            utterance, aspects = line.strip().split("####")
+            aspects = eval(aspects)
+
+            dial = {
+                "turn": "single",
+                "locale": "en",
+                "dialog": [
+                    {
+                        "roles": ["USER"],
+                        "utterance": utterance,
+                        "aspects": parse_aspects(utterance, aspects),
+                    }
+                ],
+            }
+
+            dials.append(dial)
+
+        write_jsonl_file(
+            dials, os.path.join(os.path.join(args.output_dir, domain), f"{file}.jsonl")
+        )
+
+
+def preprocess(args):
+    reformat(args, "train")
+    reformat(args, "dev")
+    reformat(args, "test")
+
+
+if __name__ == "__main__":
+    args = parse()
+    preprocess(args)

src/preprocess/AlphaNLI.py

@@ -0,0 +1,84 @@
+from utils import read_jsonl_file, write_jsonl_file, parse, read_line_labels
+import os
+import copy
+
+label2nl = {"1": "First", "2": "Second"}
+
+
+def preprocess_for_train_and_dev(args, file):
+    data_path = os.path.join(args.input_dir, f"{file}.jsonl")
+    data = read_jsonl_file(data_path)
+
+    label_path = os.path.join(args.input_dir, f"{file}-labels.lst")
+    labels = read_line_labels(label_path)
+
+    turns = []
+    for idx, example in enumerate(data):
+        turn = {
+            "turn": "multi",
+            "locale": "en",
+            "dialog": [
+                {"roles": ["First observation"], "utterance": example["obs1"]},
+                {
+                    "roles": ["Second observation"],
+                    "utterance": example["obs2"],
+                    "roles_to_select": [f"hypothesis candidate {labels[idx]}"],
+                },
+            ],
+        }
+
+        # turn["dialog"].append(
+        #     {
+        #         "roles": ["First hypothesis"],
+        #         "utterance": example["hyp1"],
+        #     }
+        # )
+
+        # turn["dialog"].append(
+        #     {
+        #         "roles": ["Second hypothesis"],
+        #         "utterance": example["hyp2"],
+        #         "roles_to_select": [label2nl[labels[idx]] + " hypothesis"],
+        #     }
+        # )
+
+        turn["knowledge"] = {
+            "type": "text",
+            "value": {
+                "hypothesis candidate 1": example["hyp1"],
+                "hypothesis candidate 2": example["hyp2"],
+            },
+        }
+
+        # turn["roles_to_select"] = ["HYPOTHESIS " + labels[idx]]
+        turns.append(turn)
+
+        # if labels[idx] == "1":
+        #     pos_hyp = example["hyp1"]
+        #     neg_hyp = example["hyp2"]
+        # else:
+        #     pos_hyp = example["hyp2"]
+        #     neg_hyp = example["hyp1"]
+
+        # # possitive hypothesis
+        # pos_turn = copy.deepcopy(turn)
+        # pos_turn["dialog"].append({"roles": ["HYPOTHESIS"], "utterance": pos_hyp, "class_label": True})
+
+        # # negative hypothesis
+        # neg_turn = copy.deepcopy(turn)
+        # neg_turn["dialog"].append({"roles": ["HYPOTHESIS"], "utterance": neg_hyp, "class_label": False})
+
+        # turns.append(pos_turn)
+        # turns.append(neg_turn)
+
+    write_jsonl_file(turns, os.path.join(args.output_dir, f"{file}.jsonl"))
+
+
+def preprocess(args):
+    preprocess_for_train_and_dev(args, "train")
+    preprocess_for_train_and_dev(args, "dev")
+
+
+if __name__ == "__main__":
+    args = parse()
+    preprocess(args)

src/preprocess/Banking77.py

@@ -0,0 +1,32 @@
+from utils import write_jsonl_file, read_csv_file, parse
+
+
+def reformat(args, file):
+    path = args.input_dir + "/" + file + ".csv"
+    data = read_csv_file(path)
+    turns = []
+    for i in range(len(data)):
+        t = {
+            "turn": "single",
+            "locale": "en",
+            "dialog": [
+                {
+                    "roles": ["USER"],
+                    "utterance": data["text"][i],
+                    "active_intents": [data["category"][i]],
+                }
+            ],
+        }
+        turns.append(t)
+
+    write_jsonl_file(turns, args.output_dir + "/" + file + ".jsonl")
+
+
+def preprocess(args):
+    reformat(args, "train")
+    reformat(args, "test")
+
+
+if __name__ == "__main__":
+    args = parse()
+    preprocess(args)