first commit

README.md

@@ -1,10 +1,76 @@
----
-title: T5nyllama
-emoji: 👀
-colorFrom: yellow
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Lightweight English Text Editing Assistant (t5nyllama)
+This repository houses the source code for t5nyllama, a lightweight English text editing assistant designed to provide a simple and efficient way to enhance your writing.
+
+**Huggingface Spaces:**
+https://huggingface.co/spaces/letheviet/t5nyllama
+
+**How it Works:**
+
+t5nyllama uses a two-step approach:
+
+1. **Text Generation:** The core of the assistant is a TinyLlama model, specifically fine-tuned for text editing. This model is designed to improve the flow and clarity of your text, making it more polished and engaging. However, TinyLlama is **relatively small and not particularly adept at complex grammar correction.** 
+
+2. **Grammar Correction:** To address this limitation, we employ a powerful Flan-T5 model for a second pass. This model takes the output of the TinyLlama model and carefully analyzes it for grammatical errors. It then suggests corrections, ensuring your final text is grammatically sound and ready for publication.
+
+**Key Features:**
+
+* **Lightweight and Efficient:** The TinyLlama model is quantized to 4-bit precision, minimizing memory usage and computational demands, making it suitable for resource-constrained environments.
+* **Focused on Text Improvement:** TinyLlama excels at refining the overall quality of your writing, making it more readable and engaging.
+* **Enhanced Grammar Accuracy:** The Flan-T5 model provides a robust final check for grammatical errors, ensuring your text is free from mistakes.
+
+
+**Design Principles:**
+
+* **Local Application:**  Prioritizes offline functionality, allowing you to edit text without requiring an internet connection.
+* **Lightweight Design:**  Minimizes resource consumption, making the application suitable for a wide range of devices and systems.
+
+## Installation
+
+**1. Clone the Repository:**
+```shell
+git clone https://github.com/LETHEVIET/t5nyllama.git
+```
+
+**2. Install Dependencies:**
+```shell
+pip3 install -r requirements.txt
+python3 -m spacy download en_core_web_sm
+python3 download_dependencies.py
+```
+
+**3. Run the Application:**
+```shell
+python3 app.py
+```
+
+## Docker Deployment
+
+**1. Build Docker Image:**
+```shell
+docker build . -t t5nyllama
+```
+
+**2. Run Docker Image:**
+```shell
+docker run -p 7860:7860 t5nyllama 
+```
+
+## Fine-Tuning TinyLlama
+
+The fine-tuning script follows the UnslothAI example for fine-tuning Tiny Llama. Please install dependencies from [unsloth](https://github.com/unslothai/unsloth) before running the script.
+
+```shell
+python finetuning_tinyllama.py
+```
+
+## References
+
+* **Unsloth Fast Fine-Tuning LLM:** https://github.com/unslothai/unsloth
+* **Dataset Card for CoEdIT: Text Editing via Instruction Tuning :** https://huggingface.co/datasets/grammarly/coedit
+* **Grammar-Synthesis-Large: FLAN-t5:** https://huggingface.co/pszemraj/flan-t5-large-grammar-synthesis
+* **ALLECS: A Lightweight Language Error Correction System:** https://github.com/nusnlp/ALLECS 
+* **Python Bindings for llama.cpp:** https://github.com/abetlen/llama-cpp-python
+* **Gradio: Build Machine Learning Web Apps — in Python:** https://github.com/gradio-app/gradio
+## Demo
+
+[Include a GIF or screenshot demonstrating the application's functionality.]

app.py

@@ -0,0 +1,318 @@
+import gradio as gr
+import errant
+import spacy
+import os
+import json
+import nltk
+from utils import get_random_prompt, instruction_prompts
+from llama_cpp import Llama
+from transformers import pipeline
+import config
+
+# Load necessary models and resources
+nlp = spacy.load("en_core_web_sm")
+annotator = errant.load('en', nlp)
+errant_path = os.path.join(os.path.dirname("./"), 'errant_verbose.json')
+errant_verbose = json.load(open(errant_path, "r"))
+sent_detector = nltk.data.load('tokenizers/punkt/english.pickle')
+
+# Load text editor (TinyLlama)
+text_editor = Llama(
+    model_path="./texteditor-model/coedit-tinyllama-chat-bnb-4bit-unsloth.Q4_K_M.gguf",
+    verbose=False
+)
+print("text editor is loaded!")
+
+# Load grammar corrector (Flan-T5)
+grammar_corrector = pipeline(
+    'text2text-generation',
+    'pszemraj/flan-t5-large-grammar-synthesis',
+)
+print("grammar corrector is loaded!")
+
+def correcting_text(src: str) -> str:
+    """
+    Corrects grammatical errors in the given text using the grammar corrector model.
+
+    Args:
+        src: The text to be corrected.
+
+    Returns:
+        The grammatically corrected text.
+    """
+    lines = src.split('\n')
+    sentences = []
+    line_idx = []
+    for l_idx, line in enumerate(lines):
+        if len(line) == 0:
+            continue
+        l_sents = sent_detector.tokenize(line)
+        for sent in l_sents:
+            sentences.append(sent)
+            line_idx.append(l_idx)
+
+    num_iter = (len(sentences) + config.BATCH_SIZE - 1) // config.BATCH_SIZE
+    final_outs = []
+    out_lines = ["" for _ in lines]
+    for i in range(num_iter):
+        start = i * config.BATCH_SIZE
+        end = min((i + 1) * config.BATCH_SIZE, len(sentences))
+        
+        final_outs += grammar_corrector(sentences[start:end], max_length=128, num_beams=5, early_stopping=True)
+        
+
+    for i in range(len(final_outs)):
+        out_lines[line_idx[i]] += final_outs[i]["generated_text"] + " " 
+
+    return "\n".join(out_lines)
+
+def annotate_text(src: str, tag: str, analyze: bool = True) -> list:
+    """
+    Annotates the text with edits based on the provided tag using the Errant library.
+    original code from: https://github.com/nusnlp/ALLECS
+    Args:
+        src: The source text.
+        tag: The target text.
+        analyze: Whether to analyze and provide detailed information about edits.
+
+    Returns:
+        A list of tuples representing the edits, where each tuple is:
+        - (edit_text, edit_type)
+    """
+    out = {"edits": []}
+    out['source'] = src
+    src_doc = annotator.parse(src)
+    tag_doc = annotator.parse(tag)
+    cur_edits = annotator.annotate(src_doc, tag_doc)
+
+        
+    for e in cur_edits:
+        out["edits"].append((e.o_start, e.o_end, e.type, e.c_str))
+    result = []
+    last_pos = 0
+    if analyze:
+        tokens = out['source']
+        if isinstance(tokens, str):
+            tokens = tokens.split(' ')
+        edits = out['edits']
+        offset = 0
+        for edit in edits:
+            if isinstance(edit, dict):
+                e_start = edit['start']
+                e_end = edit['end']
+                e_type = edit['type']
+                e_rep = edit['cor']
+            elif isinstance(edit, tuple):
+                e_start = edit[0]
+                e_end = edit[1]
+                e_type = edit[2]
+                e_rep = edit[3]
+            else:
+                raise ValueError("Data type {} is not supported."\
+                        .format(type(edit)))
+
+            e_rep = e_rep.strip()
+            op_type = e_type[0]
+            pos_type = e_type[2:]
+            errant_info = errant_verbose[pos_type]
+            title = errant_info["title"]
+            
+            result.append((' '.join(tokens[last_pos:e_start + offset]), None))
+            
+            ori_str = ' '.join(tokens[e_start + offset:e_end + offset]).strip()
+            if pos_type == "ORTH":
+                # check if it's a casing issue
+                if ori_str.lower() == e_rep.lower():
+                    if e_rep[0].isupper() and ori_str[0].islower():
+                        msg = "<b>{ori}</b> should be capitalized."
+                    elif e_rep[0].islower() and ori_str[0].isupper():
+                        msg = "<b>{ori}</b> should not be capitalized."
+                    else:
+                        msg = "The casing of the word <b>{ori}</b> is wrong."
+                # then it should be a spacing issue
+                else:
+                    if len(ori_str) - 1 == len(e_rep):
+                        msg = "The word <b>{ori}</b> should not be written separately."
+                    elif len(ori_str) + 1 == len(e_rep):
+                        msg = "The word <b>{ori}</b> should be separated into <b>{cor}</b>."
+                    else:
+                        msg = "The word <b>{ori}</b> has orthography error."
+            else:
+                if op_type in errant_info:
+                    msg = errant_info[op_type]
+                else:
+                    msg = errant_verbose["Default"][op_type]
+            
+            msg = '<p>' + msg.format(ori=ori_str, cor=e_rep) + '</p>'
+
+            e_cor =  e_rep.split()
+            len_cor = len(e_cor)
+            tokens[e_start + offset:e_end + offset] = e_cor
+            last_pos = e_start + offset + len_cor 
+            offset = offset - (e_end - e_start) + len_cor
+            result.append((e_rep, pos_type))
+        out = ' '.join(tokens)
+        result.append((' '.join(tokens[last_pos:]), None))
+    print(result)
+    return result
+
+def choices2promts() -> list:
+    """
+    Returns a list of available instructions for text editing.
+
+    Returns:
+        A list of instruction names.
+    """
+    return instruction_prompts.keys()
+
+with gr.Blocks() as demo: 
+
+    def turn_off_legend(msg: str) -> gr.update:
+        """
+        Turns off the legend in the highlighted text component.
+
+        Args:
+            msg: The text input.
+
+        Returns:
+            A Gradio update object to hide the legend.
+        """
+        return gr.update(show_legend=False)
+
+    def turn_on_legend(annotate: bool) -> gr.update:
+        """
+        Turns on the legend in the highlighted text component if annotate is True.
+
+        Args:
+            annotate: Whether to show annotations.
+
+        Returns:
+            A Gradio update object to show or hide the legend.
+        """
+        if annotate:
+            return gr.update(show_legend=True)
+        else:
+            return gr.update(show_legend=False)
+
+    def bot(task: str, text: str, post_check: bool, annotate: bool) -> tuple:
+        """
+        Processes the user input and returns the edited text along with annotations.
+
+        Args:
+            task: The chosen instruction for editing.
+            text: The text to be edited.
+            post_check: Whether to check for grammatical errors after text generation.
+            annotate: Whether to show annotations.
+
+        Yields:
+            Tuples of (edited text, annotation type) to update the interface.
+        """
+        response = ""
+        if task == "Grammar Error Correction":
+            yield [("Processing ...", None)], "Checking Grammar ..."
+            response = correcting_text(text)
+        else:
+            instruction = get_random_prompt(task)
+            prompt = instruction + ": " + text
+            print(prompt)
+            output = text_editor.create_chat_completion(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are an English writing assistant, editing the text of user input and response based on user instructions. Please do not provide explanations, but respond only with the edited text. Also, if the instruction is not provided, correct the grammar of the text. Finally, if the instruction is not for editing text, correct the grammar of the text.",
+                    },
+                    {"role": "user", "content": f"{prompt}"},
+                ],
+                temperature=0.0,
+                stream=True,
+            )
+
+            response = ""
+            for chunk in output:
+                delta = chunk["choices"][0]["delta"]
+                if "role" in delta:
+                    pass
+                elif "content" in delta:
+                    response+=delta['content']
+                    res = [(response, None), ]
+                    print(res)
+                    yield res, "Generating output ..."
+            
+            if post_check:
+                yield [(response, None)], "Checking Grammar ..."
+                response = correcting_text(response)
+
+        print(response)
+
+        if annotate:
+            e_edit = annotate_text(text, response)
+        else:
+            e_edit = [(response, None)]
+        
+        yield e_edit, "Done."
+
+    def handle_highlight_selection():
+        """
+        Handles the selection event of the highlighted text component.
+
+        This function is not implemented in the original code.
+        """
+        # print("hi")
+        return
+
+    gr.Markdown("# English Text Editing Application using T5 and Tiny Llama")
+    gr.Markdown("> source code: https://github.com/LETHEVIET/t5nyllama")
+    with gr.Row() as row:
+        with gr.Column(scale=1) as col1:
+            instruction = gr.Dropdown(
+                choices=choices2promts(),
+                value="Grammar Error Correction",
+                multiselect=False,
+                label="Choose your instruction",
+                interactive=True,
+                scale=0
+            )
+
+            with gr.Row() as row2:
+                clear = gr.Button("Clear", scale=-1)
+                submit = gr.Button("submit", scale=-1)
+                
+            info_msg = gr.Textbox(
+                label="Information",
+                scale=1,
+                lines=3,
+                value="Therefore careful analysis of a product has to be made before select a solution for testing and implementation.",
+            )
+
+            post_check = gr.Checkbox(label="Check grammaticality after text generation.", value=True)
+            annotate = gr.Checkbox(label="Highlight different", value=True)
+        with gr.Column(scale=2) as col2:
+            msg = gr.Textbox(
+                label="Input",
+                scale=3,
+                value="Therefore careful analysis of a product has to be made before select a solution for testing and implementation.",
+            )
+
+            result = gr.HighlightedText(
+                label="Result",
+                combine_adjacent=True,
+                show_legend=False,
+                scale=3
+            )
+        
+    res_msg = gr.Textbox(
+        scale=0,
+        visible=False,
+        label="Ouput",
+    )
+    
+    msg.submit(turn_off_legend, msg, result).then(bot, [instruction, msg, post_check, annotate], [result, info_msg]).then(turn_on_legend, annotate, result)
+
+    clear.click(lambda: None, None, result, queue=False)
+
+    submit.click(turn_off_legend, msg, result).then(bot, [instruction, msg, post_check, annotate], [result, info_msg]).then(turn_on_legend, annotate, result)
+
+    result.select(handle_highlight_selection, [], [])
+
+if __name__ == "__main__":
+    demo.launch(server_port=7860)

config.py

@@ -0,0 +1 @@
+BATCH_SIZE = 4

dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY . .
+
+RUN apt-get update && apt-get -y upgrade
+RUN apt-get install -y build-essential
+RUN pip3 install --upgrade pip setuptools
+RUN pip3 install -r requirements.txt
+RUN python3 -m spacy download en_core_web_sm
+RUN python3 download_dependencies.py
+
+CMD ["python3", "app.py"]

download_dependencies.py

@@ -0,0 +1,8 @@
+import gdown
+import nltk
+
+id = "1TnPssg0CkWQ_thuAH8cY3hdB2J18A0Kl"
+output = "texteditor-model/coedit-tinyllama-chat-bnb-4bit-unsloth.Q4_K_M.gguf"
+gdown.download(id=id, output=output)
+
+nltk.download('punkt')

errant_verbose.json

@@ -0,0 +1,86 @@
+{
+    "Default": {
+        "M": "<b>{cor}</b> should be inserted here, considering the context.",
+        "R": "<b>{cor} is more appropriate than <b>{ori}</b> in this context.",
+        "U": "<b>{ori}</b> is unnecessary/incorrect in this context."
+    },
+    "ADJ": {
+        "title": "Adjective"
+    },
+    "ADJ:FORM": {
+        "title": "Adjective Form"
+    },
+    "ADV": {
+        "title": "Adverb"
+    },
+    "CONJ": {
+        "title": "Conjunction"
+    },
+    "CONTR": {
+        "title": "Contraction"
+    },
+    "DET": {
+        "title": "Determiner"
+    },
+    "NOUN": {
+        "title": "Noun"
+    },
+    "NOUN:POSS": {
+        "title": "Possessive Noun"
+    },
+    "OTHER": {
+        "title": ""
+    },
+    "PART": {
+        "title": "Particle"
+    },
+    "PREP": {
+        "title": "Preposition"
+    },
+    "PRON": {
+        "title": "Pronoun"
+    },
+    "PUNCT": {
+        "title": "Punctuation"
+    },
+    "VERB": {
+        "title": "Verb"
+    },
+    "VERB:FORM": {
+        "title": "Verb Form"
+    },
+    "VERB:TENSE": {
+        "title": "Verb Tense"
+    },
+    "MORPH": {
+        "title": "Morphology",
+        "R": "The word form of <b>{cor}</b> is more appropriate than <b>{ori}</b> here."
+    },
+    "NOUN:INFL": {
+        "title": "Noun Inflection",
+        "R": "<b>{ori}</b> is wrong and should be written as <b>{cor}</b>."
+    },
+    "NOUN:NUM": {
+        "title": "Noun Number",
+        "R": "The noun number of <b>{ori}</b> is wrong and should be written as <b>{cor}</b>."
+    },
+    "ORTH": {
+        "title": "Orthography"
+    },
+    "SPELL": {
+        "title": "Spelling",
+        "R": "<b>{ori}</b> is not the correct spelling of <b>{cor}</b>."
+    },
+    "VERB:INFL": {
+        "title": "Verb Inflection",
+        "R": "<b>{ori}</b> is wrong and should be written as <b>{cor}</b>."
+    },
+    "VERB:SVA": {
+        "title": "Subject-Verb Agreement",
+        "R": "The form of <b>{ori}</b> does not follow the subject-verb agreement."
+    },
+    "WO": {
+        "title": "Word Order",
+        "R": "The word order of '<b>{ori}</b>' is wrong."
+    }
+}

finetuning_tinyllama.py

@@ -0,0 +1,160 @@
+from unsloth import FastLanguageModel
+import torch
+
+# Define model parameters
+max_seq_length = 4096  # Choose any! We auto support RoPE Scaling internally!
+dtype = None  # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
+load_in_4bit = True  # Use 4bit quantization to reduce memory usage. Can be False.
+
+# Load the model and tokenizer
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/tinyllama-chat-bnb-4bit",  # "unsloth/tinyllama" for 16bit loading
+    max_seq_length=max_seq_length,
+    dtype=dtype,
+    load_in_4bit=load_in_4bit,
+    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
+)
+
+# Apply PEFT (Parameter-Efficient Fine-Tuning)
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=32,  # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                    "gate_proj", "up_proj", "down_proj",],
+    lora_alpha=32,
+    lora_dropout=0,  # Currently only supports dropout = 0
+    bias="none",  # Currently only supports bias = "none"
+    use_gradient_checkpointing=False,  # @@@ IF YOU GET OUT OF MEMORY - set to True @@@
+    random_state=3407,
+    use_rslora=False,  # We support rank stabilized LoRA
+    loftq_config=None,  # And LoftQ
+)
+
+# Data preparation
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import datasets
+
+# Load the dataset
+train = datasets.load_dataset("grammarly/coedit", split="train").to_pandas()
+val = datasets.load_dataset("grammarly/coedit", split="validation").to_pandas()
+
+# Data cleaning and preparation
+data = pd.concat([train, val])
+data[['instruction', 'input']] = data['src'].str.split(': ', n=1, expand=True)
+data = data.rename(columns={"tgt": "output"})
+data = data.drop(columns=["_id", "src"])
+
+# Stratify based on task for balanced splits
+stratify_col = data['task']
+
+# Split the data into train and test sets
+train_df, test_df = train_test_split(
+    data,
+    test_size=0.2,
+    random_state=42,
+    stratify=stratify_col
+)
+
+def formatting_prompts_func(examples, tokenizer):
+    """
+    Formats the examples into the desired chat format for training.
+
+    Args:
+        examples: A dictionary of examples from the dataset.
+        tokenizer: The tokenizer used for processing text.
+
+    Returns:
+        A dictionary containing the formatted text for each example.
+    """
+    instructions = examples["instruction"]
+    inputs = examples["input"]
+    outputs = examples["output"]
+    texts = []
+    for instruction, input, output in zip(instructions, inputs, outputs):
+        message = [
+            {"role": "user", "content": instruction + ": " + input},
+            {"role": "assistant", "content": output},
+        ]
+        text = tokenizer.apply_chat_template(
+            message, tokenize=False, add_generation_prompt=False)
+        texts.append(text)
+    return {"text": texts, }
+
+# Create datasets from pandas DataFrames
+train_ds = datasets.Dataset.from_pandas(train_df)
+test_ds = datasets.Dataset.from_pandas(test_df)
+
+# Map the formatting function to the datasets for chat format conversion
+train_ds = train_ds.map(formatting_prompts_func, fn_kwargs={"tokenizer": tokenizer}, batched=True,)
+test_ds = test_ds.map(formatting_prompts_func, fn_kwargs={"tokenizer": tokenizer}, batched=True,)
+
+print(train_ds[0]['text'])
+
+# Fine-tuning with trl
+from trl import SFTTrainer
+from transformers import TrainingArguments
+
+# Define training arguments
+trainer = SFTTrainer(
+    model=model,
+    tokenizer=tokenizer,
+    train_dataset=train_ds,
+    eval_dataset=test_ds,
+    dataset_text_field="text",
+    max_seq_length=max_seq_length,
+    dataset_num_proc=10,
+    packing=False,  # Can make training 5x faster for short sequences.
+    args=TrainingArguments(
+        per_device_train_batch_size=8,
+        per_device_eval_batch_size=8,
+        gradient_accumulation_steps=4,
+        warmup_steps=5,
+        num_train_epochs=2,
+        learning_rate=2e-4,
+        fp16=not torch.cuda.is_bf16_supported(),
+        bf16=torch.cuda.is_bf16_supported(),
+        logging_steps=1,
+        save_steps=100,
+        save_total_limit=4,  # Limit the total number of checkpoints
+        evaluation_strategy="steps",
+        eval_steps=100,
+        optim="adamw_8bit",
+        weight_decay=0.01,
+        lr_scheduler_type="linear",
+        seed=3407,
+        output_dir="outputs",
+        load_best_model_at_end=True,
+        save_strategy="steps",
+    ),
+)
+
+# Print GPU information
+gpu_stats = torch.cuda.get_device_properties(0)
+start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
+max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)
+print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.")
+print(f"{start_gpu_memory} GB of memory reserved.")
+
+# Train the model
+trainer_stats = trainer.train()
+
+# Print memory usage statistics
+used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
+used_memory_for_lora = round(used_memory - start_gpu_memory, 3)
+used_percentage = round(used_memory / max_memory * 100, 3)
+lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)
+print(f"{trainer_stats.metrics['train_runtime']} seconds used for training.")
+print(f"{round(trainer_stats.metrics['train_runtime'] / 60, 2)} minutes used for training.")
+print(f"Peak reserved memory = {used_memory} GB.")
+print(f"Peak reserved memory for training = {used_memory_for_lora} GB.")
+print(f"Peak reserved memory % of max memory = {used_percentage} %.")
+print(f"Peak reserved memory for training % of max memory = {lora_percentage} %.")
+
+# Save the trained model and tokenizer
+print("Saving model to local")
+model.save_pretrained("coedit-tinyllama-chat-bnb-4bit")  # Local saving
+tokenizer.save_pretrained("coedit-tinyllama-chat-bnb-4bit")
+
+# Evaluate the model (Optional)
+#trainer.evaluate()

requirements.txt

@@ -0,0 +1,9 @@
+spacy
+transformers
+gradio
+errant
+nltk
+llama-cpp-python
+gdown
+tensorflow
+tf-keras

utils.py

@@ -0,0 +1,193 @@
+GEC = [
+    "Fix grammar",
+    "Fix grammar in this sentence",
+    "Fix grammar in the sentence",
+    "Fix grammar errors",
+    "Fix grammatical errors",
+    "Fix grammaticality",
+    "Fix all grammatical errors",
+    "Fix grammatical errors in this sentence",
+    "Fix grammar errors in this sentence",
+    "Fix grammatical mistakes in this sentence",
+    "Fix grammaticality in this sentence",
+    "Fix grammaticality of the sentence",
+    "Fix disfluencies in the sentence",
+    "Make the sentence grammatical",
+    "Make the sentence fluent",
+    "Fix errors in this text",
+    "Update to remove grammar errors",
+    "Remove all grammatical errors from this text",
+    "Improve the grammar of this text",
+    "Improve the grammaticality",
+    "Improve the grammaticality of this text",
+    "Improve the grammaticality of this sentence",
+    "Grammar improvements",
+    "Remove grammar mistakes",
+    "Remove grammatical mistakes",
+    "Fix the grammar mistakes",
+    "Fix grammatical mistakes Clarity Clarify the sentence",
+    ]
+Clarify = [
+    "Clarify this sentence",
+    "Clarify this text",
+    "Write a clearer version for the sentence",
+    "Write a clarified version of the sentence",
+    "Write a readable version of the sentence",
+    "Write a better readable version of the sentence",
+    "Rewrite the sentence more clearly",
+    "Rewrite this sentence clearly",
+    "Rewrite this sentence for clarity",
+    "Rewrite this sentence for readability",
+    "Improve this sentence for readability",
+    "Make this sentence better readable",
+    "Make this sentence more readable",
+    "Make this sentence readable",
+    "Make the sentence clear",
+    "Make the sentence clearer",
+    "Clarify",
+    "Make the text more understandable",
+    "Make this easier to read",
+    "Clarification",
+    "Change to clearer wording",
+    "Clarify this paragraph",
+    "Use clearer wording Simplification Simplify the sentence",
+    "Simplify this sentence",
+    "Simplify this text",
+    "Write a simpler version for the sentence",
+    "Rewrite the sentence to be simpler",
+    "Rewrite this sentence in a simpler manner",
+    "Rewrite this sentence for simplicity",
+    "Rewrite this with simpler wording",
+    "Make the sentence simple",
+    "Make the sentence simpler",
+    "Make this text less complex",
+    "Make this simpler",
+    "Simplify",
+    "Simplification",
+    "Change to simpler wording",
+    "Simplify this paragraph",
+    "Simplify this text",
+    "Use simpler wording",
+    "Make this easier to understand"
+    ]
+Coherence = [
+    "Fix coherence",
+    "Fix coherence in this sentence",
+    "Fix coherence in the sentence",
+    "Fix coherence in this text",
+    "Fix coherence in the text",
+    "Fix coherence errors",
+    "Fix sentence flow",
+    "Fix sentence transition",
+    "Fix coherence errors in this sentence",
+    "Fix coherence mistakes in this sentence",
+    "Fix coherence in this sentence",
+    "Fix coherence of the sentence",
+    "Fix lack of coherence in the sentence",
+    "Make the text more coherent",
+    "Make the text coherent",
+    "Make the text more cohesive",
+    "logically linked and consistent as a whole",
+    "Make the text more cohesive",
+    "Improve the cohesiveness of the text",
+    "Make the text more logical",
+    "Make the text more consistent",
+    "Improve the consistency of the text",
+    "Make the text clearer",
+    "Improve the coherence of the text"
+    ]
+Formality_Style_Transfer = [
+    "Formalize",
+    "Improve formality",
+    "Formalize the sentence",
+    "Formalize this sentence",
+    "Formalize the text",
+    "Formalize this text",
+    "Make this formal",
+    "Make this more formal",
+    "Make this sound more formal",
+    "Make the sentence formal",
+    "Make the sentence more formal",
+    "Make the sentence sound more formal",
+    "Write more formally",
+    "Write less informally",
+    "Rewrite more formally",
+    "Write this more formally",
+    "Rewrite this more formally",
+    "Write in a formal manner",
+    "Write in a more formal manner",
+    "Rewrite in a more formal manner"
+    ]
+Neutralization = [
+    "Remove POV",
+    "Remove POVs",
+    "Remove POV in this text",
+    "Remove POVs in this text",
+    "Neutralize this text",
+    "Neutralize the text",
+    "Neutralize this sentence",
+    "Neutralize the sentence",
+    "Make this more neutral",
+    "Make this text more neutral",
+    "Make this sentence more neutral",
+    "Make this paragraph more neutral",
+    "Remove unsourced opinions",
+    "Remove unsourced opinions from this text",
+    "Remove non-neutral POVs",
+    "Remove non-neutral POV",
+    "Remove non-neutral points of view",
+    "Remove points of view",
+    "Make this text less biased Paraphrasing Paraphrase the sentence",
+    "Paraphrase this sentence",
+    "Paraphrase this text",
+    ]
+Paraphrase = [
+    "Write a paraphrase for the sentence",
+    "Write a paraphrased version of the sentence",
+    "Rewrite the sentence with different wording",
+    "Use different wording",
+    "Rewrite this sentence",
+    "Reword this sentence",
+    "Rephrase this sentence",
+    "Rewrite this text",
+    "Reword this text",
+    "Rephrase this text"
+    ]
+
+
+import random
+import os
+
+instruction_prompts = {
+    "Grammar Error Correction": GEC,
+    "Clarify": Clarify,
+    "Coherence": Coherence,
+    "Formality Style Transfer": Formality_Style_Transfer,
+    "Neutralization": Neutralization,
+    "Paraphrase": Paraphrase,
+}
+
+def get_prompt_list(instruction_type: str) -> list:
+    """
+    Returns a list of prompts for the given instruction type.
+
+    Args:
+        instruction_type: The type of instruction, e.g., "Grammar Error Correction".
+
+    Returns:
+        A list of prompts corresponding to the instruction type.
+    """
+    return instruction_prompts[instruction_type]
+
+def get_random_prompt(instruction_type: str) -> str:
+    """
+    Returns a random prompt from the list of prompts for the given instruction type.
+
+    Args:
+        instruction_type: The type of instruction, e.g., "Grammar Error Correction".
+
+    Returns:
+        A random prompt from the list of prompts for the instruction type.
+    """
+    return random.choice(instruction_prompts[instruction_type])
+