Update app

app.py

@@ -0,0 +1,1768 @@
+import gradio as gr
+import pandas as pd
+import os
+from pathlib import Path
+import random
+from utils import display_table,current_time,random_ques_ans2,move_to,score_report_bar,all_contri_ans
+from inference import model_chain
+import warnings
+from huggingface_hub import snapshot_download
+
+snapshot_download(repo_id="CGIAR/weai-ref", 
+                  repo_type="dataset", 
+                  token=os.getenv('HF_TOKEN'), 
+                  local_dir='./rag_data'
+                  )
+warnings.filterwarnings('ignore')
+os.environ["WANDB_DISABLED"] = "true"
+global cnt
+cnt=1
+data=[]
+save_ques_ans=[]
+save_ques_ans_test=[]
+cur_time=current_time()
+
+from huggingface_hub import HfApi
+# Initialize the Hugging Face API client
+api = HfApi()
+
+# Specify the organization where Llama models are hosted
+organization = "meta-llama"
+
+# List all models belonging to the specified organization
+# This will return a list of ModelInfo objects
+llama_models = [model.modelId for model in api.list_models(author=organization)
+                if 'chat' in model.modelId]
+
+def random_ques_ans(model_ans):
+    df_temp=pd.read_excel(os.path.join("model_ans",str(model_ans)))
+    global cnt
+    id=int((df_temp.loc[cnt])['id'])
+    ques_temp=(df_temp.loc[cnt])['question']
+    ans_temp=(df_temp.loc[cnt])['answer']
+    cnt+=1
+    if cnt>=len(df_temp):
+        cnt=0
+        return ques_temp,ans_temp,id,0
+    return ques_temp,ans_temp,id,1
+def save_all(model_ans):
+    temp=pd.DataFrame(data)
+    temp.to_excel(f"score_report\\{model_ans+cur_time}.xlsx",index=False)
+    gr.Info("Sucessfully save all the answer!!!")
+
+def score_save(ques,ans,score,model_ans,token_key):
+    data.append({
+        "question":ques,
+        'answer':ans,
+        'rating':score
+    })
+    # if len(data)%5==0:
+    temp=pd.DataFrame(data)
+    temp.to_excel(f"score_report\\{model_ans+cur_time}.xlsx",index=False)
+    gr.Info("Sucessfully saved in local folder!!!")
+    ques_temp,ans_temp,id,flag=random_ques_ans(model_ans)
+    gr.Info("Your opinion is submitted successfully!!!")
+    return gr.Label(value=id,label="ID"),gr.Label(value=ques_temp, label="Question"), gr.Label(value=ans_temp, label="Answer")
+
+def new_ques(model_ans):
+    ques_temp,ans_temp,id2,flag=random_ques_ans(model_ans)
+    return {
+        id:gr.Label(value=id2,label="ID"),
+        ques:gr.Label(value=ques_temp,label="Question"),
+        ans:gr.Label(value=ans_temp,label="Answer")
+    }
+
+def save_the_ques(ques,ans,file_type = 'xlsx'):
+    """
+    Saves a question and answer pair to a specified file (xlsx or csv).
+
+    Args:
+        ques (str): The question.
+        ans (str): The answer.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success label.
+    """
+
+    new_data = {"question": [ques], "answer": [ans]}
+    df_new = pd.DataFrame(new_data)
+
+    filepath = f"data/finetune_data.{file_type}"
+
+    if Path(filepath).is_file():
+        df_existing = pd.read_excel(filepath) if file_type == "xlsx" else pd.read_csv(filepath)
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+    else:
+        df_combined = df_new
+
+    if file_type == "xlsx":
+        df_combined.to_excel(filepath, index=False)
+    elif file_type == "csv":
+        df_combined.to_csv(filepath, index=False)
+
+    return gr.Label(value="Successfully saved in local folder.", visible=True)
+
+def save_the_ques_test(ques, ans, file_type = 'xlsx'):
+    """
+    Saves a question and answer pair to a specified file (xlsx or csv).
+
+    Args:
+        ques (str): The question.
+        ans (str): The answer.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success label.
+    """
+
+    new_data = {"question": [ques], "answer": [ans]}
+    df_new = pd.DataFrame(new_data)
+
+    filepath = f"data/testing_data.{file_type}"
+
+    if Path(filepath).is_file():
+        df_existing = pd.read_excel(filepath) if file_type == "xlsx" else pd.read_csv(filepath)
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+    else:
+        df_combined = df_new
+
+    if file_type == "xlsx":
+        df_combined.to_excel(filepath, index=False)
+    elif file_type == "csv":
+        df_combined.to_csv(filepath, index=False)
+
+    return gr.Label(value="Successfully saved in local folder.", visible=True)
+
+import pandas as pd
+from pathlib import Path
+
+def save_emb_data(loss_function, first_input, second_input, third_input, file_type="xlsx"):
+    """
+    Saves embedding data based on the specified loss function to either an Excel
+    file (xlsx) or a CSV file (csv).
+
+    Args:
+        loss_function (str): The name of the loss function.
+        first_input: The first input data.
+        second_input: The second input data.
+        third_input: The third input data.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success message indicating whether data was appended or a new file
+             was created.
+    """
+
+    if loss_function == "MultipleNegativesRankingLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+    elif loss_function == "OnlineContrastiveLoss":
+        data = pd.DataFrame({
+            "sentence1": [first_input],
+            "sentence2": [second_input],
+            "label": [third_input]
+        })
+    elif loss_function == "CoSENTLoss":
+        data = pd.DataFrame({
+            "sentence1": [first_input],
+            "sentence2": [second_input],
+            "score": [third_input]
+        })
+    elif loss_function == "GISTEmbedLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+    elif loss_function == "TripletLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+
+    filepath = f"data/emb_data.{file_type}"
+
+    try:
+        if file_type == "xlsx":
+            existing_data = pd.read_excel(filepath)
+        elif file_type == "csv":
+            existing_data = pd.read_csv(filepath)
+
+        if list(data.columns) == list(existing_data.columns):
+            combined_data = pd.concat([existing_data, data], ignore_index=True)
+            if file_type == "xlsx":
+                combined_data.to_excel(filepath, index=False)
+            elif file_type == "csv":
+                combined_data.to_csv(filepath, index=False)
+            return "Data appended to existing file!"
+        else:
+            if file_type == "xlsx":
+                data.to_excel(filepath, index=False)
+            elif file_type == "csv":
+                data.to_csv(filepath, index=False)
+            return "Data saved to a new file (overwritten)!"
+
+    except FileNotFoundError:
+        if file_type == "xlsx":
+            data.to_excel(filepath, index=False)
+        elif file_type == "csv":
+            data.to_csv(filepath, index=False)
+        return "Data saved to a new file!"
+
+def parse_data_func(link_temp,progress=gr.Progress()):
+    progress(0, desc="Starting...")
+    parse_data(link_temp,progress)
+    gr.Info("Finished parsing!! Save as a docx file.")
+
+def next_ques(ques,ans):
+    ques_temp,ans_temp=random_ques_ans2()
+    return gr.Label(value=ques_temp)
+
+with gr.Blocks(title="LLM QA Chatbot Builder",theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+        # LLM QA Chatbot Builder
+            """)
+    with gr.Tab("Data Collection"):
+            gr.Markdown(""" # Instructions:
+            In this page you can prepare data for LLM fine-tuning, testing and embedding model finetuning your model. The data can be provided through Excel file or CSV file or directly via web interface. Additionally, data can be parsed from the target website (Data parsing for RAG) to further enhance the model performance.
+
+            ## 1. If you want to provide data in Excel file or CSV file for model fine-tuning and testing.
+            - Create an Excel or CSV file in the data folder and name it `finetune_data.xlsx` or `finetune_data.csv` for finetuning the model.
+            - Create an Excel or CSV file in the data folder and name it `testing_data.xlsx` or `testing_data.csv` for generating answers using the fine-tuned model.
+            - `finetune_data.xlsx` or `finetune_data.csv` has two columns: `question` and `answer`. `testing_data.xlsx` or `testing_data.csv` has three columns: `question`, `ground_truth` ,`context`.
+        """)
+            gr.Markdown("""
+                    ## `finetune_data.xlsx`  |  `finetune_data.csv`
+                 """)
+            gr.HTML(value=display_table(), label="finetune_data.xlsx or finetune_data.csv")
+            gr.Markdown("""
+                    ## `testing_data.xlsx`  |  `testing_data.csv`
+                 """)
+            gr.HTML(value=display_table("data/demo_test_data.xlsx"), label="testing_data.xlsx or testing_data.csv")
+            gr.Markdown("""
+                    ## 2. You can use the below interface to create the dataset for training and testing models.
+                 """)
+
+            #Training data generation
+            with gr.Tab("Training Data Generation"):
+                with gr.Tab("Existing Questions"):
+                    gr.Markdown("""
+                        Existing questions are provided by the administrator and placed in the data folder named `existing_dataset.xlsx`. This file has only one column: `question`.
+                        After clicking the `Save the Answer` button. Those questions and answers are saved in the `data` folder as a `finetune_data.xlsx` file.
+                    """)
+                    ques_temp,ans_temp=random_ques_ans2()
+                    with gr.Row():
+                        ques=gr.Label(value=ques_temp,label="Question")
+                    with gr.Row():
+                        ans=gr.TextArea(label="Answer")
+                    with gr.Row():
+                        with gr.Row():
+                            type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                            save_training = gr.Button(value="Save")
+                        question = gr.Button("Generate New Question")
+                    with gr.Row():
+                        lab=gr.Label(visible=False)
+                question.click(next_ques,None,ques)
+                save_training.click(save_the_ques,[ques,ans,type_options],lab)
+
+                with gr.Tab("Custom Questions"):
+                    gr.Markdown("""
+                        After clicking the `save the answer` button. Those questions and answers are saved in the `data` folder as a `finetune_data.xlsx` file.
+                    """)
+                    with gr.Row():
+                        ques=gr.Textbox(label="Question")
+                    with gr.Row():
+                        ans=gr.TextArea(label="Answer")
+                    with gr.Row():
+                        with gr.Row():
+                            type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                            save_training = gr.Button(value="Save")
+                    with gr.Row():
+                        lab=gr.Label(visible=False,value="You answer is submitted!!! Thank you for your contribution.",label="Submitted")
+                    save_training.click(save_the_ques,[ques,ans,type_options],lab)
+
+            ### Testing data generation
+            with gr.Tab("Testing Data Generation"):
+                gr.Markdown("""
+                    You can create test data for generating answers using the fine-tune model, which will be used for testing the model's performance.
+                    After clicking the `Save the Answer` button. Those questions and answers are saved in the `data` folder as a `testing_data.xlsx` file.
+                            """)
+                with gr.Row():
+                    ques=gr.Textbox(label="Question")
+                with gr.Row():
+                    ans=gr.TextArea(label="Ground Truth")
+                with gr.Row():
+                    ans=gr.TextArea(label="Contexts")
+                with gr.Row():
+                    with gr.Row():
+                        type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                        save_test = gr.Button(value="Save")
+                with gr.Row():
+                    lab=gr.Label(visible=False,value="You answer is submitted!!! Thank you for your contribution.",label="Submitted")
+                save_test.click(save_the_ques_test,[ques,ans,type_options],None)
+
+            ## Embedding data generation
+            def update_fields(loss_function):
+                if loss_function == "MultipleNegativesRankingLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor.")
+                    markdown = gr.Markdown(
+                    """
+                    **MultipleNegativesRankingLoss:**
+                    Expects data with columns: `anchor`, `positive`, `negative`.
+                    - `anchor`: The sentence to be embedded.
+                    - `positive`: A sentence semantically similar to the anchor.
+                    - `negative`: A sentence semantically dissimilar to the anchor.""",
+                    visible=True
+                )
+                elif loss_function == "OnlineContrastiveLoss":
+                    first_input = gr.Textbox(label="Sentence 1", visible=True, placeholder="The first sentence.")
+                    second_input = gr.Textbox(label="Sentence 2", visible=True, placeholder="The second sentence.")
+                    third_input = gr.Textbox(label="Label", visible=True, placeholder="1 if the sentences are similar, 0 if dissimilar.")
+                    markdown = gr.Markdown(
+                    """
+                    **OnlineContrastiveLoss:**
+                    Expects data with columns: `sentence1`, `sentence2`, `label`.
+                    - `sentence1`, `sentence2`: Pairs of sentences.
+                    - `label`: 1 if the sentences are similar, 0 if dissimilar.""",
+                    visible=True
+                )
+                elif loss_function == "CoSENTLoss":
+                    first_input = gr.Textbox(label="Sentence 1", visible=True, placeholder="The first sentence.")
+                    second_input = gr.Textbox(label="Sentence 2", visible=True, placeholder="The second sentence.")
+                    third_input = gr.Textbox(label="Score", visible=True, placeholder="A float value (e.g., 0-1) representing their similarity.")
+                    markdown = gr.Markdown(
+                    """
+                    **CoSENTLoss:**
+                    Expects data with columns: `sentence1`, `sentence2`, `score`.
+                    - `sentence1`, `sentence2`: Pairs of sentences.
+                    - `score`: A float value (e.g., 0-1) representing their similarity.""",
+                    visible=True
+                )
+                elif loss_function == "GISTEmbedLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor. Can be empty.")
+                    markdown = gr.Markdown(
+                    """
+                    **GISTEmbedLoss:**
+                    Expects data with either:
+                    - Columns: `anchor`, `positive`, `negative` (like TripletLoss).
+                    - Columns: `anchor`, `positive` (for pairs of similar sentences).""",
+                    visible=True
+                )
+                elif loss_function == "TripletLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor.")
+                    markdown = gr.Markdown(
+                    """
+                    **TripletLoss:**
+                    Expects data with columns: `anchor`, `positive`, `negative`.
+                    - `anchor`: The sentence to be embedded.
+                    - `positive`: A sentence semantically similar to the anchor.
+                    - `negative`: A sentence semantically dissimilar to the anchor.""",
+                    visible=True
+                )
+                else:
+                    first_input = gr.Textbox(visible=False)
+                    second_input = gr.Textbox(visible=False)
+                    third_input = gr.Textbox(visible=False)
+                    markdown = gr.Markdown(visible=False)
+
+                return first_input, second_input, third_input, markdown
+
+            with gr.Tab("Embedding Data Generation"):
+                gr.Markdown("**Choose a loss function to format your embedding data.**")
+                with gr.Row():
+                    loss_function = gr.Dropdown(
+                        choices=[
+                            "MultipleNegativesRankingLoss",
+                            "OnlineContrastiveLoss",
+                            "CoSENTLoss",
+                            "GISTEmbedLoss",
+                            "TripletLoss",
+                        ],
+                        label="Select the loss function",
+                    )
+                with gr.Row():
+                    gr.Markdown("""Format `data/emb_data.xlsx` or `data/emb_data.csv` to the expected data format, according to the selected loss function.
+                If the file exists and has matching columns, new data will be appended.
+                Otherwise, the file will be overwritten.""")
+                with gr.Row():
+                    loss_info_markdown = gr.Markdown(visible=False)
+                with gr.Row():
+                    first_input = gr.Textbox(label="Anchor", value="",visible=False)
+                    second_input = gr.Textbox(label="Positive", value="",visible=False)
+                    third_input = gr.Textbox(label="Negative", value="",visible=False)
+                loss_function.change(update_fields, loss_function, [first_input, second_input, third_input,loss_info_markdown])
+                with gr.Row():
+                    with gr.Row():
+                        type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                        save_emb = gr.Button(value="Save")
+                save_emb.click(save_emb_data,[loss_function,first_input,second_input,third_input,type_options])
+
+            with gr.Row():
+                gr.Markdown("""
+                        ## 3. Data parsing for RAG
+                    """)
+            with gr.Row():
+                link_temp=gr.Textbox(label="Enter Link to Parse Data for RAG",info="To provide the link for parsing the data from the website, this link can help create RAG data for the model.")
+                parse_data_btn=gr.Button("Parse Data")
+            from utils import parse_data
+            parse_data_btn.click(parse_data_func,link_temp,link_temp)
+
+#***************************************************
+    with gr.Tab("Fine-tuning"):
+        with gr.Tab("Fine-tune LLM"):
+            with gr.Row():
+                def login_hug(token):
+                    from huggingface_hub import login
+                    login(token=token)
+                login_hug(os.getenv('HF_TOKEN'))
+            gr.Markdown("""
+                # Instructions:
+                - Required VRAM for training: 24GB, for inference: 16GB.(Mistral, Zepyhr and Lllama)\n
+                - Required VRAM for training: 5GB, for inference: 4GB.(Phi,Flan-T5)
+                - For fine-tuning a custom model select `custom model` option in `Select the model for fine-tuning` dropdown section. The custom model can be configured by editing the code section.\n
+                - After fine-tuning the model, it will be saved in the `models` folder.
+            """)
+
+            def edit_model_parameter(model_name_temp,edit_code,code_temp,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout, progress=gr.Progress()):
+                progress(0, desc="Fine-tune started!! please wait ...")
+                # write code to files if code was edited
+                if edit_code and len(code_temp)!=0:
+                    if model_name_temp=="Mistral":
+                        open(r"fine_tune_file/mistral_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Zephyr":
+                        open(r"fine_tune_file/zepyhr_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Llama":
+                        open(r"fine_tune_file/llama_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Phi":
+                        open(r"fine_tune_file/phi_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Custom model":
+                        open(r"fine_tune_file/finetune_file.py","w").write(code_temp)
+                # importing just before finetuning, to ensure the latest code is used
+                # from fine_tune_file.mistral_finetune import mistral_trainer
+                # from fine_tune_file.zepyhr_finetune import zephyr_trainer
+                # from fine_tune_file.llama_finetune import llama_trainer
+                # from fine_tune_file.phi_finetune import phi_trainer
+                from fine_tune_file.finetune_file import custom_model_trainer
+                # from fine_tune_file.flant5_finetune import flant5_trainer
+                from fine_tune_file.modular_finetune import get_trainer
+                # create instance of the finetuning classes and then call the finetune function
+
+                if model_name_temp=="Custom model":
+                    gr.Info("Fine-tune started!!!")
+                    trainer=custom_model_trainer()
+                    trainer.custom_model_finetune()
+                    gr.Info("Fine-tune Ended!!!")
+                else:
+                    trainer=get_trainer(model_name_temp)
+                    gr.Info("Fine-tune started!!!")
+                    if model_name_temp=="Mistral":
+                        trainer.mistral_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Zephyr":
+                        trainer.zepyhr_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Llama":
+                        trainer.llama_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Phi":
+                        trainer.phi_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Flant5":
+                        trainer.flant5_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    gr.Info("Fine-tune Ended!!!")
+
+            def code_show(model_name):
+                if model_name=="Mistral":
+                    f=open(r"fine_tune_file/mistral_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Zephyr":
+                    f=open(r"fine_tune_file/zepyhr_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Llama":
+                    f=open(r"fine_tune_file/llama_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Phi":
+                    f=open(r"fine_tune_file/phi_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Flant5":
+                    f=open(r"fine_tune_file/flant5_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+
+            def custom_model(model_name): # It shows custom model code in the UI.
+                if model_name=="Custom model":
+                    f=open(r"fine_tune_file/finetune_file.py").read()
+                    return [gr.Code(visible=True,value=f,interactive=True,language="python"),gr.Button(visible=False)]
+                else:
+                    return [gr.Code(visible=False),gr.Button("Advance Code Editing",visible=True)]
+            def change_code_fun(code_,model_name):
+                if model_name=="Mistral":
+                    open(r"fine_tune_file/mistral_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Zephyr":
+                    open(r"fine_tune_file/zepyhr_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Llama":
+                    open(r"fine_tune_file/llama_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Phi":
+                    open(r"fine_tune_file/phi_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Flant5":
+                    open(r"fine_tune_file/flant5_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+
+            def finetune_emb(model_name, loss_name, epochs = 1, batch_size = 8):
+                gr.Info("Embedding model fine-tune is started!!!")
+                from embedding_tuner import EmbeddingFinetuner
+                finetuner = EmbeddingFinetuner(
+                    model_name=model_name,
+                    loss_function=loss_name,
+                    epochs=epochs,
+                    batch_size=batch_size,
+                )
+                success = finetuner.train()
+                if success:
+                    gr.Info("Embedding model fine-tune finished!!!")
+
+            with gr.Row():
+                code_temp=gr.Code(visible=False)
+            with gr.Row():
+                model_name=gr.Dropdown(choices=["Mistral","Zephyr","Llama","Phi","Flant5","Custom model"],label="Select the LLM for fine-tuning")
+            with gr.Accordion("Parameter Setup"):
+                with gr.Row():
+                    lr=gr.Number(label="learning_rate",value=5e-6,interactive=True,info="The step size at which the model parameters are updated during training. It controls the magnitude of the updates to the model's weights.")
+                    epoch=gr.Number(label="epochs",value=2,interactive=True,info="One complete pass through the entire training dataset during the training process. It's a measure of how many times the algorithm has seen the entire dataset.")
+                    batch_size=gr.Number(label="batch_size",value=4,interactive=True,info="The number of training examples used in one iteration of training. It affects the speed and stability of the training process.")
+                    gradient_accumulation = gr.Number(info="Gradient accumulation involves updating model weights after accumulating gradients over multiple batches, instead of after each individual batch.",label="gradient_accumulation",value=4,interactive=True)
+                with gr.Row():
+                    quantization = gr.Dropdown(info="Quantization is a technique used to reduce the precision of numerical values, typically from 32-bit floating-point numbers to lower bit representations.",label="quantization",choices=[4,8],value=8,interactive=True)
+                    lora_r = gr.Number(info="LoRA_r is a hyperparameter associated with the rank of the low-rank approximation used in LoRA.",label="lora_r",value=16,interactive=True)
+                    lora_alpha = gr.Number(info="LoRA_alpha is a hyperparameter used in LoRA for controlling the strength of the adaptation.",label="lora_alpha",value=32,interactive=True)
+                    lora_dropout = gr.Number(info="LoRA_dropout is a hyperparameter used in LoRA to control the dropout rate during fine-tuning.",label="lora_dropout",value=.05,interactive=True)
+            with gr.Row():
+                edit_code=gr.Button("Advance Code Editing")
+            with gr.Row():
+                code_temp=gr.Code(visible=False)
+            with gr.Row():
+                parameter_alter=gr.Button("Fine-tune")
+            with gr.Row():
+                fin_com=gr.Label(visible=False)
+            edit_code.click(code_show,model_name,code_temp)
+            # On click finetune button
+            parameter_alter.click(edit_model_parameter,[model_name,edit_code,code_temp,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout],model_name)
+            model_name.change(custom_model,model_name,[code_temp,edit_code])
+        with gr.Tab("Embedding model"):
+            with gr.Row():
+                embedding_model = gr.Dropdown(
+                    choices=[
+                        "BAAI/bge-base-en-v1.5",
+                        "dunzhang/stella_en_1.5B_v5",
+                        "dunzhang/stella_en_400M_v5",
+                        "nvidia/NV-Embed-v2",
+                        "Alibaba-NLP/gte-Qwen2-1.5B-instruct",
+                    ],
+                    label="Select the embedding model for fine-tuning",
+                )
+                loss_function = gr.Dropdown(
+                    choices=[
+                        "MultipleNegativesRankingLoss",
+                        "OnlineContrastiveLoss",
+                        "CoSENTLoss",
+                        "GISTEmbedLoss",
+                        "TripletLoss",
+                    ],
+                    label="Select the loss function",
+                )
+
+                epoch=gr.Number(label="epochs",value=1,interactive=True,info="One complete pass through the entire training dataset during the training process.")
+                batch_size=gr.Number(label="batch_size",value=8,interactive=True,info="The number of training examples used in one iteration of training.")
+            with gr.Row():
+                btn_emb = gr.Button("Fine-tune the embedding model")
+
+
+            # with gr.Row():
+            #     with gr.Accordion(label="Expected data format according to loss function"):
+            #         loss_info = gr.Markdown(
+            #             """
+            #             # Expected data format according to loss function:
+            #             ### Format `data/emb_data.xlsx` | `data/emb_data.xlsx` accordingly.
+
+            #             **MultipleNegativesRankingLoss:**
+            #             Expects data with columns: `anchor`, `positive`, `negative`.
+            #             - `anchor`: The sentence to be embedded.
+            #             - `positive`: A sentence semantically similar to the anchor.
+            #             - `negative`: A sentence semantically dissimilar to the anchor.
+
+            #             **OnlineContrastiveLoss:**
+            #             Expects data with columns: `sentence1`, `sentence2`, `label`.
+            #             - `sentence1`, `sentence2`: Pairs of sentences.
+            #             - `label`: 1 if the sentences are similar, 0 if dissimilar.
+
+            #             **CoSENTLoss:**
+            #             Expects data with columns: `sentence1`, `sentence2`, `score`.
+            #             - `sentence1`, `sentence2`: Pairs of sentences.
+            #             - `score`: A float value (e.g., 0-1) representing their similarity.
+
+            #             **GISTEmbedLoss:**
+            #             Expects data with either:
+            #             - Columns: `anchor`, `positive`, `negative` (like TripletLoss).
+            #             - Columns: `anchor`, `positive` (for pairs of similar sentences).
+
+            #             **TripletLoss:**
+            #             Expects data with columns: `anchor`, `positive`, `negative`.
+            #             - `anchor`: The sentence to be embedded.
+            #             - `positive`: A sentence semantically similar to the anchor.
+            #             - `negative`: A sentence semantically dissimilar to the anchor.
+            #             """
+            #         )
+
+
+
+        btn_emb.click(finetune_emb,[embedding_model, loss_function, epoch, batch_size], None)
+#***************************************************
+    with gr.Tab("Testing Data Generation and RAG Customization"):
+        from utils import save_params_to_file
+        def ans_gen_fun(model_name_local,model_name_online,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider,save_as_fav,progress=gr.Progress()):
+            if not os.path.exists(os.path.join("data","testing_dataset.xlsx")):
+                gr.Warning("You need to create testing dataset first from Data collection.")
+                return
+            if save_as_fav:
+                save_params_to_file(model_name_local,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            # if not os.path.exists(model_name_local):
+            #     gr.Error("Model not found in local folder!!")
+            import time
+            from model_ret import calculate_rag_metrics
+            progress(0, desc="Starting...")
+            idx=1
+            model_ques_ans_gen=[]
+            df_temp=pd.read_excel(r"data/testing_dataset.xlsx")
+            infer_model = model_chain(model_name_local,model_name_online,
+                                            True,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            # rag_chain=infer_model.rag_chain_ret()
+            print("Processing test dataset...")
+            for x in progress.tqdm(df_temp.values):
+                model_ques_ans_gen.append({
+                    "id":idx,
+                    "question":x[0],
+                    'answer':infer_model.ans_ret(x[0]),
+                    # "contexts":x[2],
+                    "ground_truths":x[1]
+                })
+                idx+=1
+            print("Done processing test dataset!")
+            model_name = infer_model.model_name.split('/')[-1]
+            temp=calculate_rag_metrics(model_ques_ans_gen,model_name)
+            # print(temp)
+            # temp['Average Rating'] = temp.mean(axis=1)
+            pd.DataFrame(temp).to_excel(os.path.join("model_ans",f"_{model_name+cur_time}.xlsx"),index=False)
+            rag_metrics = ['answer_correctness', 'answer_similarity', 'answer_relevancy', 'faithfulness', 'context_recall', 'context_precision']
+            new_df = pd.DataFrame({'Rag Metric': rag_metrics, 'Average Rating': 0.2})
+
+            return gr.BarPlot(
+                new_df,
+                x="Rag Metric",
+                y="Average Rating",
+                x_title="Rag Metric",
+                y_title="Average Rating",
+                title="RAG performance",
+                tooltip=["Rag Metric", "Average Rating"],
+                y_lim=[1, 200],
+                width=150,
+                # height=1000,
+                visible=True
+            )
+        gr.Info("Generating answer from model is finished!!! Now, it is ready for human evaluation. Model answer is saved in \"model_ans\" folder. ")
+
+        gr.Markdown(""" # Instructions:\n
+                    In this page you can generate answer from fine-tuned models for human evaluation. The questions must be created using `Testing data generation` section of `Data collection` tab.
+                    """)
+        with gr.Row():
+            embedding_name=gr.Dropdown(choices=["BAAI/bge-base-en-v1.5","dunzhang/stella_en_1.5B_v5","dunzhang/stella_en_400M_v5",
+                                                "nvidia/NV-Embed-v2","Alibaba-NLP/gte-Qwen2-1.5B-instruct"],
+                                    label="Select the Embedding Model")
+            splitter_type_dropdown = gr.Dropdown(choices=["character", "recursive", "token"],
+                                             value="character", label="Splitter Type",interactive=True)
+
+            chunk_size_slider = gr.Slider(minimum=100, maximum=2000, value=500, step=50, label="Chunk Size")
+            chunk_overlap_slider = gr.Slider(minimum=0, maximum=500, value=30, step=10, label="Chunk Overlap",interactive=True)
+            separator_textbox = gr.Textbox(value="\n", label="Separator (e.g., newline '\\n')",interactive=True)
+            max_tokens_slider = gr.Slider(minimum=100, maximum=5000, value=1000, step=100, label="Max Tokens",interactive=True)
+        with gr.Row():
+            save_as_fav=gr.Checkbox(label="Save this settings as favorite")
+        inf_checkbox=gr.Checkbox(label="Do you want to use without fine-tuned model from Hugging face?")
+        model_name_local=gr.Dropdown(visible=False)
+        model_name_online=gr.Dropdown(visible=False)
+        def model_online_local_show(inf_checkbox):
+            if inf_checkbox:
+                return [gr.Dropdown(visible=False),
+                        gr.Dropdown(choices=llama_models,
+                        label="Select the LLM from Huggingface",visible=True)]
+            else:
+                return [gr.Dropdown(choices=os.listdir("models"),label="Select the fine-tuned LLM",visible=True),
+                        gr.Dropdown(visible=False)]
+        inf_checkbox.change(model_online_local_show,[inf_checkbox],[model_name_local,model_name_online])
+
+        with gr.Row():
+            ans_gen=gr.Button("Generate Answer for Testing Dataset")
+        with gr.Row():
+            plot = gr.BarPlot(visible=False)
+        ans_gen.click(ans_gen_fun,[model_name_local,model_name_online,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider,save_as_fav],plot)
+#***************************************************Human evaluation
+    import secrets
+
+    def generate_token():
+        while True:
+            token=secrets.token_hex(6)
+            f=[x[:-5] for x in os.listdir("save_ques_ans")]
+            if token not in f:
+                data = {
+                        'id': [],
+                        'question': [],
+                        'answer': []
+                    }
+                df = pd.DataFrame(data)
+                df.to_excel("save_ques_ans//"+str(token)+".xlsx", index=False)
+                return gr.Label(label="Please keep the token for tracking question answer data",value=token,visible=True)
+
+    def bar_plot_fn():
+        temp=score_report_bar()
+        return gr.BarPlot(
+            temp,
+            x="Model Name",
+            y="Average Rating",
+            x_title="Model name",
+            y_title="Average Rating",
+            title="Model performance",
+            tooltip=["Model Name", "Average Rating"],
+            y_lim=[1, 200],
+            width=150,
+            # height=1000,
+            visible=True
+        )
+    with gr.Tab("Human Evaluation"):
+        def answer_updated(model_ans):
+            df_ques_ans=pd.read_excel(os.path.join("model_ans",str(model_ans)))
+            num=0
+            print(df_ques_ans['id'][num],"**"*10)
+            return [gr.Markdown(value=f"""# Model_name: {model_ans}
+                               # Number of questions: {len(df_ques_ans)}""",visible=True),
+                               gr.Label(value=str(df_ques_ans['id'][num])),
+                               gr.Label(value=str(df_ques_ans['question'][num])),
+                               gr.Label(value=str(df_ques_ans['answer'][num])),
+                               gr.Dropdown(visible=False),
+                               gr.Button(visible=False)
+                               ]
+
+        with gr.Row():
+            new_user=gr.Button("New User")
+        with gr.Row():
+            new_user_token=gr.Label(visible=False)
+        with gr.Row():
+            token_key=gr.Textbox(label="Enter your Token")
+            model_ans=gr.Dropdown(choices=os.listdir("model_ans"),label="Select the Model Answer for Human Evaluation")
+        btn_1=gr.Button("Submit")
+        gr.Markdown(""" # Instructions:
+            In this section, humans evaluate the answers of the model given specific questions. Each answer is rated between 1 and 5 by anonymous students.
+            Those values are saved in the `scrore_report` folder.
+                    """)
+        lab_temp=gr.Markdown(visible=False)
+
+        with gr.Row():
+            id=gr.Label(value="",label="ID")
+        with gr.Row():
+            ques=gr.Label(value="",label="Question")
+        with gr.Row():
+            ans=gr.Label(value="",label="Answer")
+        with gr.Row():
+            score = gr.Radio(choices=[1,2,3,4,5],label="Rating")
+        with gr.Row():
+            human_ans_btn=gr.Button("Show Answer From Other Evaluators")
+        with gr.Row():
+            human_ans_lab=gr.Label(label="Human Answer",visible=False)
+        with gr.Row():
+            btn = gr.Button("Save")
+            question = gr.Button("Skip")
+        # with gr.Row():
+            # save_all_btn=gr.Button("Save all the data in dataframe")
+        # with gr.Row():
+        #     move=gr.Number(label="Move to the question")
+        #     move_btn=gr.Button("move")
+        with gr.Row():
+            btn_plot=gr.Button("Plot Generation")
+        with gr.Row():
+            plot = gr.BarPlot(visible=False)
+        btn_plot.click(bar_plot_fn, None, outputs=plot)
+        btn_1.click(answer_updated,model_ans,[lab_temp,id,ques,ans,model_ans,btn_1])
+        btn.click(score_save, inputs=[ques,ans,score,model_ans,token_key], outputs=[id,ques,ans])
+        question.click(new_ques,model_ans,[id,ques,ans])
+        # save_all_btn.click(save_all,model_ans,None)
+        # move_btn.click(move_to,[move,model_ans],[id,ques,ans])
+        def human_ans_func(id, ques):
+            temp=all_contri_ans(id,ques)
+            return [gr.Button("Show Answer from Other Evaluators"),gr.Label(value="\n".join(temp),visible=True)]
+        human_ans_btn.click(human_ans_func,[id, ques],[human_ans_btn,human_ans_lab])
+        new_user.click(generate_token,None,new_user_token)
+
+#***************************************************
+    infer_ragchain=None
+    with gr.Tab("Inference"):
+        def echo(message, history,model_name_local,model_name_online,
+                                            inf_checkbox,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider):
+            global infer_ragchain
+            if infer_ragchain is None:
+                gr.Info("Please wait!!! model is loading!!")
+                if inf_checkbox:
+                    gr.Info("Model is loading from Huggingface!!")
+                infer_ragchain = model_chain(model_name_local,model_name_online,
+                                            inf_checkbox,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            # rag_chain=infer_ragchain.rag_chain_ret()
+            return infer_ragchain.ans_ret(message)
+        from utils import load_params_from_file
+        saved_params = load_params_from_file()
+    # If saved parameters exist, use them; otherwise, set default values
+        default_model_name = saved_params['model_name'] if saved_params else "Llama"
+        default_embedding_name = saved_params['embedding_name'] if saved_params else "BAAI/bge-base-en-v1.5"
+        default_splitter_type = saved_params['splitter_type_dropdown'] if saved_params else "character"
+        default_chunk_size = saved_params['chunk_size_slider'] if saved_params else 500
+        default_chunk_overlap = saved_params['chunk_overlap_slider'] if saved_params else 30
+        default_separator = saved_params['separator_textbox'] if saved_params else "\n"
+        default_max_tokens = saved_params['max_tokens_slider'] if saved_params else 1000
+        # with gr.Row():
+        with gr.Row():
+            def login_hug(token):
+                from huggingface_hub import login
+                login(token=token)
+            login_hug(os.getenv('HF_TOKEN'))
+            embedding_name=gr.Dropdown(choices=["BAAI/bge-base-en-v1.5","dunzhang/stella_en_1.5B_v5","dunzhang/stella_en_400M_v5",
+                                                "nvidia/NV-Embed-v2","Alibaba-NLP/gte-Qwen2-1.5B-instruct"],value=default_embedding_name,
+                                    label="Select the Embedding Model")
+            splitter_type_dropdown = gr.Dropdown(choices=["character", "recursive", "token"],
+                                             value=default_splitter_type, label="Splitter Type",interactive=True)
+
+            chunk_size_slider = gr.Slider(minimum=100, maximum=2000, value=default_chunk_size, step=50, label="Chunk Size")
+            chunk_overlap_slider = gr.Slider(minimum=0, maximum=500, value=default_chunk_overlap, step=10, label="Chunk Overlap",interactive=True)
+            separator_textbox = gr.Textbox(value=default_separator, label="Separator (e.g., newline '\\n')",interactive=True)
+            max_tokens_slider = gr.Slider(minimum=100, maximum=5000, value=default_max_tokens, step=100, label="Max Tokens",interactive=True)
+
+        inf_checkbox=gr.Checkbox(label="Do you want to use without fine-tuned model from Hugging face?")
+        model_name_local=gr.Dropdown(visible=False)
+        model_name_online=gr.Dropdown(visible=False)
+        def model_online_local_show(inf_checkbox):
+            if inf_checkbox:
+                return [gr.Dropdown(visible=False),
+                        gr.Dropdown(choices=llama_models,
+                        label="Select the LLM from Huggingface",visible=True)]
+            else:
+                return [gr.Dropdown(choices=os.listdir("models"),label="Select the fine-tuned LLM",visible=True),
+                        gr.Dropdown(visible=False)]
+
+        inf_checkbox.change(model_online_local_show,[inf_checkbox],[model_name_local,model_name_online])
+        gr.ChatInterface(fn=echo,
+                         additional_inputs=[model_name_local,model_name_online,inf_checkbox,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider],
+                           title="Chatbot")
+    #----------------------------------------------
+    with gr.Tab("Deployment"):
+        gr.Markdown("""`deploy` folder has all the code for the deployment of the model.
+                    For installing dependencies use the following command: `pip install -r requirements.txt`.
+                    """)
+        def deploy_func(model_name):
+            import shutil
+            import os
+            src_folder = 'src'
+            deploy_folder = 'deploy'
+            files_to_copy = ['model_ret.py', 'create_retriever.py', 'inference.py']
+            for file_name in files_to_copy:
+                src_file_path = os.path.join(src_folder, file_name)
+                dest_file_path = os.path.join(deploy_folder, file_name)
+            param_list=load_params_from_file()
+            param_list["model_name"]=model_name
+            save_params_to_file(param_list)
+            # f.write(f"{model_name}")
+
+
+        model_name=gr.Dropdown(choices=os.listdir("models"),label="Select the Model")
+        btn_model=gr.Button("Deploy")
+        btn_model.click(deploy_func,model_name)
+
+demo.launch(share=True, debug=True)
+save_ques_ans=[]
+save_ques_ans_test=[]
+cur_time=current_time()
+
+def random_ques_ans(model_ans):
+    df_temp=pd.read_excel(os.path.join("model_ans",str(model_ans)))
+    global cnt
+    id=int((df_temp.loc[cnt])['id'])
+    ques_temp=(df_temp.loc[cnt])['question']
+    ans_temp=(df_temp.loc[cnt])['answer']
+    cnt+=1
+    if cnt>=len(df_temp):
+        cnt=0
+        return ques_temp,ans_temp,id,0
+    return ques_temp,ans_temp,id,1
+def save_all(model_ans):
+    temp=pd.DataFrame(data)
+    temp.to_excel(f"score_report\\{model_ans+cur_time}.xlsx",index=False)
+    gr.Info("Sucessfully save all the answer!!!")
+
+def score_save(ques,ans,score,model_ans,token_key):
+    data.append({
+        "question":ques,
+        'answer':ans,
+        'rating':score
+    })
+    # if len(data)%5==0:
+    temp=pd.DataFrame(data)
+    temp.to_excel(f"score_report\\{model_ans+cur_time}.xlsx",index=False)
+    gr.Info("Sucessfully saved in local folder!!!")
+    ques_temp,ans_temp,id,flag=random_ques_ans(model_ans)
+    gr.Info("Your opinion is submitted successfully!!!")
+    return gr.Label(value=id,label="ID"),gr.Label(value=ques_temp, label="Question"), gr.Label(value=ans_temp, label="Answer")
+
+def new_ques(model_ans):
+    ques_temp,ans_temp,id2,flag=random_ques_ans(model_ans)
+    return {
+        id:gr.Label(value=id2,label="ID"),
+        ques:gr.Label(value=ques_temp,label="Question"),
+        ans:gr.Label(value=ans_temp,label="Answer")
+    }
+
+def save_the_ques(ques,ans,file_type = 'xlsx'):
+    """
+    Saves a question and answer pair to a specified file (xlsx or csv).
+
+    Args:
+        ques (str): The question.
+        ans (str): The answer.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success label.
+    """
+
+    new_data = {"question": [ques], "answer": [ans]}
+    df_new = pd.DataFrame(new_data)
+
+    filepath = f"data/finetune_data.{file_type}"
+
+    if Path(filepath).is_file():
+        df_existing = pd.read_excel(filepath) if file_type == "xlsx" else pd.read_csv(filepath)
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+    else:
+        df_combined = df_new
+
+    if file_type == "xlsx":
+        df_combined.to_excel(filepath, index=False)
+    elif file_type == "csv":
+        df_combined.to_csv(filepath, index=False)
+
+    return gr.Label(value="Successfully saved in local folder.", visible=True)
+
+def save_the_ques_test(ques, ans, file_type = 'xlsx'):
+    """
+    Saves a question and answer pair to a specified file (xlsx or csv).
+
+    Args:
+        ques (str): The question.
+        ans (str): The answer.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success label.
+    """
+
+    new_data = {"question": [ques], "answer": [ans]}
+    df_new = pd.DataFrame(new_data)
+
+    filepath = f"data/testing_data.{file_type}"
+
+    if Path(filepath).is_file():
+        df_existing = pd.read_excel(filepath) if file_type == "xlsx" else pd.read_csv(filepath)
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+    else:
+        df_combined = df_new
+
+    if file_type == "xlsx":
+        df_combined.to_excel(filepath, index=False)
+    elif file_type == "csv":
+        df_combined.to_csv(filepath, index=False)
+
+    return gr.Label(value="Successfully saved in local folder.", visible=True)
+
+import pandas as pd
+from pathlib import Path
+
+def save_emb_data(loss_function, first_input, second_input, third_input, file_type="xlsx"):
+    """
+    Saves embedding data based on the specified loss function to either an Excel
+    file (xlsx) or a CSV file (csv).
+
+    Args:
+        loss_function (str): The name of the loss function.
+        first_input: The first input data.
+        second_input: The second input data.
+        third_input: The third input data.
+        file_type (str, optional): The file type to save to ("xlsx" or "csv").
+                                    Defaults to "xlsx".
+
+    Returns:
+        str: A success message indicating whether data was appended or a new file
+             was created.
+    """
+
+    if loss_function == "MultipleNegativesRankingLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+    elif loss_function == "OnlineContrastiveLoss":
+        data = pd.DataFrame({
+            "sentence1": [first_input],
+            "sentence2": [second_input],
+            "label": [third_input]
+        })
+    elif loss_function == "CoSENTLoss":
+        data = pd.DataFrame({
+            "sentence1": [first_input],
+            "sentence2": [second_input],
+            "score": [third_input]
+        })
+    elif loss_function == "GISTEmbedLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+    elif loss_function == "TripletLoss":
+        data = pd.DataFrame({
+            "anchor": [first_input],
+            "positive": [second_input],
+            "negative": [third_input]
+        })
+
+    filepath = f"data/emb_data.{file_type}"
+
+    try:
+        if file_type == "xlsx":
+            existing_data = pd.read_excel(filepath)
+        elif file_type == "csv":
+            existing_data = pd.read_csv(filepath)
+
+        if list(data.columns) == list(existing_data.columns):
+            combined_data = pd.concat([existing_data, data], ignore_index=True)
+            if file_type == "xlsx":
+                combined_data.to_excel(filepath, index=False)
+            elif file_type == "csv":
+                combined_data.to_csv(filepath, index=False)
+            return "Data appended to existing file!"
+        else:
+            if file_type == "xlsx":
+                data.to_excel(filepath, index=False)
+            elif file_type == "csv":
+                data.to_csv(filepath, index=False)
+            return "Data saved to a new file (overwritten)!"
+
+    except FileNotFoundError:
+        if file_type == "xlsx":
+            data.to_excel(filepath, index=False)
+        elif file_type == "csv":
+            data.to_csv(filepath, index=False)
+        return "Data saved to a new file!"
+
+def parse_data_func(link_temp,progress=gr.Progress()):
+    progress(0, desc="Starting...")
+    parse_data(link_temp,progress)
+    gr.Info("Finished parsing!! Save as a docx file.")
+
+def next_ques(ques,ans):
+    ques_temp,ans_temp=random_ques_ans2()
+    return gr.Label(value=ques_temp)
+
+with gr.Blocks(title="LLM QA Chatbot Builder",theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+        # LLM QA Chatbot Builder
+            """)
+    with gr.Tab("Data Collection"):
+            gr.Markdown(""" # Instructions:
+            In this page you can prepare data for LLM fine-tuning, testing and embedding model finetuning your model. The data can be provided through Excel file or CSV file or directly via web interface. Additionally, data can be parsed from the target website (Data parsing for RAG) to further enhance the model performance.
+
+            ## 1. If you want to provide data in Excel file or CSV file for model fine-tuning and testing.
+            - Create an Excel or CSV file in the data folder and name it `finetune_data.xlsx` or `finetune_data.csv` for finetuning the model.
+            - Create an Excel or CSV file in the data folder and name it `testing_data.xlsx` or `testing_data.csv` for generating answers using the fine-tuned model.
+            - `finetune_data.xlsx` or `finetune_data.csv` has two columns: `question` and `answer`. `testing_data.xlsx` or `testing_data.csv` has three columns: `question`, `ground_truth` ,`context`.
+        """)
+            gr.Markdown("""
+                    ## `finetune_data.xlsx`  |  `finetune_data.csv`
+                 """)
+            gr.HTML(value=display_table(), label="finetune_data.xlsx or finetune_data.csv")
+            gr.Markdown("""
+                    ## `testing_data.xlsx`  |  `testing_data.csv`
+                 """)
+            gr.HTML(value=display_table("data/demo_test_data.xlsx"), label="testing_data.xlsx or testing_data.csv")
+            gr.Markdown("""
+                    ## 2. You can use the below interface to create the dataset for training and testing models.
+                 """)
+
+            #Training data generation
+            with gr.Tab("Training Data Generation"):
+                with gr.Tab("Existing Questions"):
+                    gr.Markdown("""
+                        Existing questions are provided by the administrator and placed in the data folder named `existing_dataset.xlsx`. This file has only one column: `question`.
+                        After clicking the `Save the Answer` button. Those questions and answers are saved in the `data` folder as a `finetune_data.xlsx` file.
+                    """)
+                    ques_temp,ans_temp=random_ques_ans2()
+                    with gr.Row():
+                        ques=gr.Label(value=ques_temp,label="Question")
+                    with gr.Row():
+                        ans=gr.TextArea(label="Answer")
+                    with gr.Row():
+                        with gr.Row():
+                            type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                            save_training = gr.Button(value="Save")
+                        question = gr.Button("Generate New Question")
+                    with gr.Row():
+                        lab=gr.Label(visible=False)
+                question.click(next_ques,None,ques)
+                save_training.click(save_the_ques,[ques,ans,type_options],lab)
+
+                with gr.Tab("Custom Questions"):
+                    gr.Markdown("""
+                        After clicking the `save the answer` button. Those questions and answers are saved in the `data` folder as a `finetune_data.xlsx` file.
+                    """)
+                    with gr.Row():
+                        ques=gr.Textbox(label="Question")
+                    with gr.Row():
+                        ans=gr.TextArea(label="Answer")
+                    with gr.Row():
+                        with gr.Row():
+                            type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                            save_training = gr.Button(value="Save")
+                    with gr.Row():
+                        lab=gr.Label(visible=False,value="You answer is submitted!!! Thank you for your contribution.",label="Submitted")
+                    save_training.click(save_the_ques,[ques,ans,type_options],lab)
+
+            ### Testing data generation
+            with gr.Tab("Testing Data Generation"):
+                gr.Markdown("""
+                    You can create test data for generating answers using the fine-tune model, which will be used for testing the model's performance.
+                    After clicking the `Save the Answer` button. Those questions and answers are saved in the `data` folder as a `testing_data.xlsx` file.
+                            """)
+                with gr.Row():
+                    ques=gr.Textbox(label="Question")
+                with gr.Row():
+                    ans=gr.TextArea(label="Ground Truth")
+                with gr.Row():
+                    ans=gr.TextArea(label="Contexts")
+                with gr.Row():
+                    with gr.Row():
+                        type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                        save_test = gr.Button(value="Save")
+                with gr.Row():
+                    lab=gr.Label(visible=False,value="You answer is submitted!!! Thank you for your contribution.",label="Submitted")
+                save_test.click(save_the_ques_test,[ques,ans,type_options],None)
+
+            ## Embedding data generation
+            def update_fields(loss_function):
+                if loss_function == "MultipleNegativesRankingLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor.")
+                    markdown = gr.Markdown(
+                    """
+                    **MultipleNegativesRankingLoss:**
+                    Expects data with columns: `anchor`, `positive`, `negative`.
+                    - `anchor`: The sentence to be embedded.
+                    - `positive`: A sentence semantically similar to the anchor.
+                    - `negative`: A sentence semantically dissimilar to the anchor.""",
+                    visible=True
+                )
+                elif loss_function == "OnlineContrastiveLoss":
+                    first_input = gr.Textbox(label="Sentence 1", visible=True, placeholder="The first sentence.")
+                    second_input = gr.Textbox(label="Sentence 2", visible=True, placeholder="The second sentence.")
+                    third_input = gr.Textbox(label="Label", visible=True, placeholder="1 if the sentences are similar, 0 if dissimilar.")
+                    markdown = gr.Markdown(
+                    """
+                    **OnlineContrastiveLoss:**
+                    Expects data with columns: `sentence1`, `sentence2`, `label`.
+                    - `sentence1`, `sentence2`: Pairs of sentences.
+                    - `label`: 1 if the sentences are similar, 0 if dissimilar.""",
+                    visible=True
+                )
+                elif loss_function == "CoSENTLoss":
+                    first_input = gr.Textbox(label="Sentence 1", visible=True, placeholder="The first sentence.")
+                    second_input = gr.Textbox(label="Sentence 2", visible=True, placeholder="The second sentence.")
+                    third_input = gr.Textbox(label="Score", visible=True, placeholder="A float value (e.g., 0-1) representing their similarity.")
+                    markdown = gr.Markdown(
+                    """
+                    **CoSENTLoss:**
+                    Expects data with columns: `sentence1`, `sentence2`, `score`.
+                    - `sentence1`, `sentence2`: Pairs of sentences.
+                    - `score`: A float value (e.g., 0-1) representing their similarity.""",
+                    visible=True
+                )
+                elif loss_function == "GISTEmbedLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor. Can be empty.")
+                    markdown = gr.Markdown(
+                    """
+                    **GISTEmbedLoss:**
+                    Expects data with either:
+                    - Columns: `anchor`, `positive`, `negative` (like TripletLoss).
+                    - Columns: `anchor`, `positive` (for pairs of similar sentences).""",
+                    visible=True
+                )
+                elif loss_function == "TripletLoss":
+                    first_input = gr.Textbox(label="Anchor", visible=True, placeholder="The sentence to be embedded.")
+                    second_input = gr.Textbox(label="Positive", visible=True, placeholder="A sentence semantically similar to the anchor.")
+                    third_input = gr.Textbox(label="Negative", visible=True, placeholder="A sentence semantically dissimilar to the anchor.")
+                    markdown = gr.Markdown(
+                    """
+                    **TripletLoss:**
+                    Expects data with columns: `anchor`, `positive`, `negative`.
+                    - `anchor`: The sentence to be embedded.
+                    - `positive`: A sentence semantically similar to the anchor.
+                    - `negative`: A sentence semantically dissimilar to the anchor.""",
+                    visible=True
+                )
+                else:
+                    first_input = gr.Textbox(visible=False)
+                    second_input = gr.Textbox(visible=False)
+                    third_input = gr.Textbox(visible=False)
+                    markdown = gr.Markdown(visible=False)
+
+                return first_input, second_input, third_input, markdown
+
+            with gr.Tab("Embedding Data Generation"):
+                gr.Markdown("**Choose a loss function to format your embedding data.**")
+                with gr.Row():
+                    loss_function = gr.Dropdown(
+                        choices=[
+                            "MultipleNegativesRankingLoss",
+                            "OnlineContrastiveLoss",
+                            "CoSENTLoss",
+                            "GISTEmbedLoss",
+                            "TripletLoss",
+                        ],
+                        label="Select the loss function",
+                    )
+                with gr.Row():
+                    gr.Markdown("""Format `data/emb_data.xlsx` or `data/emb_data.csv` to the expected data format, according to the selected loss function.
+                If the file exists and has matching columns, new data will be appended.
+                Otherwise, the file will be overwritten.""")
+                with gr.Row():
+                    loss_info_markdown = gr.Markdown(visible=False)
+                with gr.Row():
+                    first_input = gr.Textbox(label="Anchor", value="",visible=False)
+                    second_input = gr.Textbox(label="Positive", value="",visible=False)
+                    third_input = gr.Textbox(label="Negative", value="",visible=False)
+                loss_function.change(update_fields, loss_function, [first_input, second_input, third_input,loss_info_markdown])
+                with gr.Row():
+                    with gr.Row():
+                        type_options = gr.Dropdown(choices=["Save xlsx", "Save csv"], value="Save xlsx", label="Preferred file type")
+                        save_emb = gr.Button(value="Save")
+                save_emb.click(save_emb_data,[loss_function,first_input,second_input,third_input,type_options])
+
+            with gr.Row():
+                gr.Markdown("""
+                        ## 3. Data parsing for RAG
+                    """)
+            with gr.Row():
+                link_temp=gr.Textbox(label="Enter Link to Parse Data for RAG",info="To provide the link for parsing the data from the website, this link can help create RAG data for the model.")
+                parse_data_btn=gr.Button("Parse Data")
+            from utils import parse_data
+            parse_data_btn.click(parse_data_func,link_temp,link_temp)
+
+#***************************************************
+    with gr.Tab("Fine-tuning"):
+        with gr.Tab("Fine-tune LLM"):
+            with gr.Row():
+                def login_hug(token):
+                    from huggingface_hub import login
+                    login(token=token)
+                login_hug(os.getenv('HF_TOKEN'))
+            gr.Markdown("""
+                # Instructions:
+                - Required VRAM for training: 24GB, for inference: 16GB.(Mistral, Zepyhr and Lllama)\n
+                - Required VRAM for training: 5GB, for inference: 4GB.(Phi,Flan-T5)
+                - For fine-tuning a custom model select `custom model` option in `Select the model for fine-tuning` dropdown section. The custom model can be configured by editing the code section.\n
+                - After fine-tuning the model, it will be saved in the `models` folder.
+            """)
+
+            def edit_model_parameter(model_name_temp,edit_code,code_temp,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout, progress=gr.Progress()):
+                progress(0, desc="Fine-tune started!! please wait ...")
+                # write code to files if code was edited
+                if edit_code and len(code_temp)!=0:
+                    if model_name_temp=="Mistral":
+                        open(r"fine_tune_file/mistral_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Zephyr":
+                        open(r"fine_tune_file/zepyhr_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Llama":
+                        open(r"fine_tune_file/llama_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Phi":
+                        open(r"fine_tune_file/phi_finetune.py","w").write(code_temp)
+                    elif model_name_temp=="Custom model":
+                        open(r"fine_tune_file/finetune_file.py","w").write(code_temp)
+                # importing just before finetuning, to ensure the latest code is used
+                # from fine_tune_file.mistral_finetune import mistral_trainer
+                # from fine_tune_file.zepyhr_finetune import zephyr_trainer
+                # from fine_tune_file.llama_finetune import llama_trainer
+                # from fine_tune_file.phi_finetune import phi_trainer
+                from fine_tune_file.finetune_file import custom_model_trainer
+                # from fine_tune_file.flant5_finetune import flant5_trainer
+                from fine_tune_file.modular_finetune import get_trainer
+                # create instance of the finetuning classes and then call the finetune function
+
+                if model_name_temp=="Custom model":
+                    gr.Info("Fine-tune started!!!")
+                    trainer=custom_model_trainer()
+                    trainer.custom_model_finetune()
+                    gr.Info("Fine-tune Ended!!!")
+                else:
+                    trainer=get_trainer(model_name_temp)
+                    gr.Info("Fine-tune started!!!")
+                    if model_name_temp=="Mistral":
+                        trainer.mistral_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Zephyr":
+                        trainer.zepyhr_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Llama":
+                        trainer.llama_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Phi":
+                        trainer.phi_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    elif model_name_temp=="Flant5":
+                        trainer.flant5_finetune(lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout)
+                    gr.Info("Fine-tune Ended!!!")
+
+            def code_show(model_name):
+                if model_name=="Mistral":
+                    f=open(r"fine_tune_file/mistral_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Zephyr":
+                    f=open(r"fine_tune_file/zepyhr_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Llama":
+                    f=open(r"fine_tune_file/llama_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Phi":
+                    f=open(r"fine_tune_file/phi_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+                elif model_name=="Flant5":
+                    f=open(r"fine_tune_file/flant5_finetune.py").read()
+                    return gr.Code(visible=True,value=f,interactive=True,language="python")
+
+            def custom_model(model_name): # It shows custom model code in the UI.
+                if model_name=="Custom model":
+                    f=open(r"fine_tune_file/finetune_file.py").read()
+                    return [gr.Code(visible=True,value=f,interactive=True,language="python"),gr.Button(visible=False)]
+                else:
+                    return [gr.Code(visible=False),gr.Button("Advance Code Editing",visible=True)]
+            def change_code_fun(code_,model_name):
+                if model_name=="Mistral":
+                    open(r"fine_tune_file/mistral_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Zephyr":
+                    open(r"fine_tune_file/zepyhr_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Llama":
+                    open(r"fine_tune_file/llama_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Phi":
+                    open(r"fine_tune_file/phi_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+                elif model_name=="Flant5":
+                    open(r"fine_tune_file/flant5_finetune.py","w").write(code_)
+                    gr.Info("Successfully saved code!!!")
+
+            def finetune_emb(model_name, loss_name, epochs = 1, batch_size = 8):
+                gr.Info("Embedding model fine-tune is started!!!")
+                from embedding_tuner import EmbeddingFinetuner
+                finetuner = EmbeddingFinetuner(
+                    model_name=model_name,
+                    loss_function=loss_name,
+                    epochs=epochs,
+                    batch_size=batch_size,
+                )
+                success = finetuner.train()
+                if success:
+                    gr.Info("Embedding model fine-tune finished!!!")
+
+            with gr.Row():
+                code_temp=gr.Code(visible=False)
+            with gr.Row():
+                model_name=gr.Dropdown(choices=["Mistral","Zephyr","Llama","Phi","Flant5","Custom model"],label="Select the LLM for fine-tuning")
+            with gr.Accordion("Parameter Setup"):
+                with gr.Row():
+                    lr=gr.Number(label="learning_rate",value=5e-6,interactive=True,info="The step size at which the model parameters are updated during training. It controls the magnitude of the updates to the model's weights.")
+                    epoch=gr.Number(label="epochs",value=2,interactive=True,info="One complete pass through the entire training dataset during the training process. It's a measure of how many times the algorithm has seen the entire dataset.")
+                    batch_size=gr.Number(label="batch_size",value=4,interactive=True,info="The number of training examples used in one iteration of training. It affects the speed and stability of the training process.")
+                    gradient_accumulation = gr.Number(info="Gradient accumulation involves updating model weights after accumulating gradients over multiple batches, instead of after each individual batch.",label="gradient_accumulation",value=4,interactive=True)
+                with gr.Row():
+                    quantization = gr.Dropdown(info="Quantization is a technique used to reduce the precision of numerical values, typically from 32-bit floating-point numbers to lower bit representations.",label="quantization",choices=[4,8],value=8,interactive=True)
+                    lora_r = gr.Number(info="LoRA_r is a hyperparameter associated with the rank of the low-rank approximation used in LoRA.",label="lora_r",value=16,interactive=True)
+                    lora_alpha = gr.Number(info="LoRA_alpha is a hyperparameter used in LoRA for controlling the strength of the adaptation.",label="lora_alpha",value=32,interactive=True)
+                    lora_dropout = gr.Number(info="LoRA_dropout is a hyperparameter used in LoRA to control the dropout rate during fine-tuning.",label="lora_dropout",value=.05,interactive=True)
+            with gr.Row():
+                edit_code=gr.Button("Advance Code Editing")
+            with gr.Row():
+                code_temp=gr.Code(visible=False)
+            with gr.Row():
+                parameter_alter=gr.Button("Fine-tune")
+            with gr.Row():
+                fin_com=gr.Label(visible=False)
+            edit_code.click(code_show,model_name,code_temp)
+            # On click finetune button
+            parameter_alter.click(edit_model_parameter,[model_name,edit_code,code_temp,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout],model_name)
+            model_name.change(custom_model,model_name,[code_temp,edit_code])
+        with gr.Tab("Embedding model"):
+            with gr.Row():
+                embedding_model = gr.Dropdown(
+                    choices=[
+                        "BAAI/bge-base-en-v1.5",
+                        "dunzhang/stella_en_1.5B_v5",
+                        "dunzhang/stella_en_400M_v5",
+                        "nvidia/NV-Embed-v2",
+                        "Alibaba-NLP/gte-Qwen2-1.5B-instruct",
+                    ],
+                    label="Select the embedding model for fine-tuning",
+                )
+                loss_function = gr.Dropdown(
+                    choices=[
+                        "MultipleNegativesRankingLoss",
+                        "OnlineContrastiveLoss",
+                        "CoSENTLoss",
+                        "GISTEmbedLoss",
+                        "TripletLoss",
+                    ],
+                    label="Select the loss function",
+                )
+
+                epoch=gr.Number(label="epochs",value=1,interactive=True,info="One complete pass through the entire training dataset during the training process.")
+                batch_size=gr.Number(label="batch_size",value=8,interactive=True,info="The number of training examples used in one iteration of training.")
+            with gr.Row():
+                btn_emb = gr.Button("Fine-tune the embedding model")
+
+
+            # with gr.Row():
+            #     with gr.Accordion(label="Expected data format according to loss function"):
+            #         loss_info = gr.Markdown(
+            #             """
+            #             # Expected data format according to loss function:
+            #             ### Format `data/emb_data.xlsx` | `data/emb_data.xlsx` accordingly.
+
+            #             **MultipleNegativesRankingLoss:**
+            #             Expects data with columns: `anchor`, `positive`, `negative`.
+            #             - `anchor`: The sentence to be embedded.
+            #             - `positive`: A sentence semantically similar to the anchor.
+            #             - `negative`: A sentence semantically dissimilar to the anchor.
+
+            #             **OnlineContrastiveLoss:**
+            #             Expects data with columns: `sentence1`, `sentence2`, `label`.
+            #             - `sentence1`, `sentence2`: Pairs of sentences.
+            #             - `label`: 1 if the sentences are similar, 0 if dissimilar.
+
+            #             **CoSENTLoss:**
+            #             Expects data with columns: `sentence1`, `sentence2`, `score`.
+            #             - `sentence1`, `sentence2`: Pairs of sentences.
+            #             - `score`: A float value (e.g., 0-1) representing their similarity.
+
+            #             **GISTEmbedLoss:**
+            #             Expects data with either:
+            #             - Columns: `anchor`, `positive`, `negative` (like TripletLoss).
+            #             - Columns: `anchor`, `positive` (for pairs of similar sentences).
+
+            #             **TripletLoss:**
+            #             Expects data with columns: `anchor`, `positive`, `negative`.
+            #             - `anchor`: The sentence to be embedded.
+            #             - `positive`: A sentence semantically similar to the anchor.
+            #             - `negative`: A sentence semantically dissimilar to the anchor.
+            #             """
+            #         )
+
+
+
+        btn_emb.click(finetune_emb,[embedding_model, loss_function, epoch, batch_size], None)
+#***************************************************
+    with gr.Tab("Testing Data Generation and RAG Customization"):
+        from utils import save_params_to_file
+        def ans_gen_fun(model_name,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider,save_as_fav,progress=gr.Progress()):
+            if not os.path.exists(os.path.join("data","testing_dataset.xlsx")):
+                gr.Warning("You need to create testing dataset first from Data collection.")
+                return
+            if save_as_fav:
+                save_params_to_file(model_name,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            if not os.path.exists(model_name):
+                gr.Error("Model not found in local folder!!")
+            import time
+            from model_ret import calculate_rag_metrics
+            progress(0, desc="Starting...")
+            idx=1
+            model_ques_ans_gen=[]
+            df_temp=pd.read_excel(r"data/testing_dataset.xlsx")
+            infer_model = model_chain(model_name,None,
+                                            True,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            rag_chain=infer_model.rag_chain_ret()
+            for x in progress.tqdm(df_temp.values):
+                model_ques_ans_gen.append({
+                    "id":idx,
+                    "question":x[0]
+                    ,'answer':rag_chain.ans_ret(x,rag_chain)
+                    , "contexts":x[2]
+                    , "ground_truths":x[1]
+                })
+                idx+=1
+            temp=calculate_rag_metrics(model_ques_ans_gen,model_name)
+            temp['Average Rating'] = temp.mean(axis=1)
+            pd.DataFrame(temp).to_excel(os.path.join("model_ans",f"_{model_name+cur_time}.xlsx"),index=False)
+            rag_metrics = ['answer_correctness', 'answer_similarity', 'answer_relevancy', 'faithfulness', 'context_recall', 'context_precision']
+            new_df = pd.DataFrame({'Rag Metric': rag_metrics, 'Average Rating': temp.mean()})
+
+            return gr.BarPlot(
+                new_df,
+                x="Rag Metric",
+                y="Average Rating",
+                x_title="Rag Metric",
+                y_title="Average Rating",
+                title="RAG performance",
+                tooltip=["Rag Metric", "Average Rating"],
+                y_lim=[1, 200],
+                width=150,
+                # height=1000,
+                visible=True
+            )
+        gr.Info("Generating answer from model is finished!!! Now, it is ready for human evaluation. Model answer is saved in \"model_ans\" folder. ")
+
+        gr.Markdown(""" # Instructions:\n
+                    In this page you can generate answer from fine-tuned models for human evaluation. The questions must be created using `Testing data generation` section of `Data collection` tab.
+                    """)
+        with gr.Row():
+            embedding_name=gr.Dropdown(choices=["BAAI/bge-base-en-v1.5","dunzhang/stella_en_1.5B_v5","dunzhang/stella_en_400M_v5",
+                                                "nvidia/NV-Embed-v2","Alibaba-NLP/gte-Qwen2-1.5B-instruct"],
+                                    label="Select the Embedding Model")
+            splitter_type_dropdown = gr.Dropdown(choices=["character", "recursive", "token"],
+                                             value="character", label="Splitter Type",interactive=True)
+
+            chunk_size_slider = gr.Slider(minimum=100, maximum=2000, value=500, step=50, label="Chunk Size")
+            chunk_overlap_slider = gr.Slider(minimum=0, maximum=500, value=30, step=10, label="Chunk Overlap",interactive=True)
+            separator_textbox = gr.Textbox(value="\n", label="Separator (e.g., newline '\\n')",interactive=True)
+            max_tokens_slider = gr.Slider(minimum=100, maximum=5000, value=1000, step=100, label="Max Tokens",interactive=True)
+        with gr.Row():
+            save_as_fav=gr.Checkbox(label="Save this settings as favorite")
+        model_name=gr.Dropdown(choices=os.listdir("models"),label="Select the Model")
+        with gr.Row():
+            ans_gen=gr.Button("Generate Answer for Testing Dataset")
+        with gr.Row():
+            plot = gr.BarPlot(visible=False)
+        ans_gen.click(ans_gen_fun,[model_name,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider,save_as_fav],plot)
+#***************************************************Human evaluation
+    import secrets
+
+    def generate_token():
+        while True:
+            token=secrets.token_hex(6)
+            f=[x[:-5] for x in os.listdir("save_ques_ans")]
+            if token not in f:
+                data = {
+                        'id': [],
+                        'question': [],
+                        'answer': []
+                    }
+                df = pd.DataFrame(data)
+                df.to_excel("save_ques_ans//"+str(token)+".xlsx", index=False)
+                return gr.Label(label="Please keep the token for tracking question answer data",value=token,visible=True)
+
+    def bar_plot_fn():
+        temp=score_report_bar()
+        return gr.BarPlot(
+            temp,
+            x="Model Name",
+            y="Average Rating",
+            x_title="Model name",
+            y_title="Average Rating",
+            title="Model performance",
+            tooltip=["Model Name", "Average Rating"],
+            y_lim=[1, 200],
+            width=150,
+            # height=1000,
+            visible=True
+        )
+    with gr.Tab("Human Evaluation"):
+        def answer_updated(model_ans):
+            df_ques_ans=pd.read_excel(os.path.join("model_ans",str(model_ans)))
+            num=0
+            print(df_ques_ans['id'][num],"**"*10)
+            return [gr.Markdown(value=f"""# Model_name: {model_ans}
+                               # Number of questions: {len(df_ques_ans)}""",visible=True),
+                               gr.Label(value=str(df_ques_ans['id'][num])),
+                               gr.Label(value=str(df_ques_ans['question'][num])),
+                               gr.Label(value=str(df_ques_ans['answer'][num])),
+                               gr.Dropdown(visible=False),
+                               gr.Button(visible=False)
+                               ]
+
+        with gr.Row():
+            new_user=gr.Button("New User")
+        with gr.Row():
+            new_user_token=gr.Label(visible=False)
+        with gr.Row():
+            token_key=gr.Textbox(label="Enter your Token")
+            model_ans=gr.Dropdown(choices=os.listdir("model_ans"),label="Select the Model Answer for Human Evaluation")
+        btn_1=gr.Button("Submit")
+        gr.Markdown(""" # Instructions:
+            In this section, humans evaluate the answers of the model given specific questions. Each answer is rated between 1 and 5 by anonymous students.
+            Those values are saved in the `scrore_report` folder.
+                    """)
+        lab_temp=gr.Markdown(visible=False)
+
+        with gr.Row():
+            id=gr.Label(value="",label="ID")
+        with gr.Row():
+            ques=gr.Label(value="",label="Question")
+        with gr.Row():
+            ans=gr.Label(value="",label="Answer")
+        with gr.Row():
+            score = gr.Radio(choices=[1,2,3,4,5],label="Rating")
+        with gr.Row():
+            human_ans_btn=gr.Button("Show Answer From Other Evaluators")
+        with gr.Row():
+            human_ans_lab=gr.Label(label="Human Answer",visible=False)
+        with gr.Row():
+            btn = gr.Button("Save")
+            question = gr.Button("Skip")
+        # with gr.Row():
+            # save_all_btn=gr.Button("Save all the data in dataframe")
+        # with gr.Row():
+        #     move=gr.Number(label="Move to the question")
+        #     move_btn=gr.Button("move")
+        with gr.Row():
+            btn_plot=gr.Button("Plot Generation")
+        with gr.Row():
+            plot = gr.BarPlot(visible=False)
+        btn_plot.click(bar_plot_fn, None, outputs=plot)
+        btn_1.click(answer_updated,model_ans,[lab_temp,id,ques,ans,model_ans,btn_1])
+        btn.click(score_save, inputs=[ques,ans,score,model_ans,token_key], outputs=[id,ques,ans])
+        question.click(new_ques,model_ans,[id,ques,ans])
+        # save_all_btn.click(save_all,model_ans,None)
+        # move_btn.click(move_to,[move,model_ans],[id,ques,ans])
+        def human_ans_func(id, ques):
+            temp=all_contri_ans(id,ques)
+            return [gr.Button("Show Answer from Other Evaluators"),gr.Label(value="\n".join(temp),visible=True)]
+        human_ans_btn.click(human_ans_func,[id, ques],[human_ans_btn,human_ans_lab])
+        new_user.click(generate_token,None,new_user_token)
+
+#***************************************************
+    infer_ragchain=None
+    with gr.Tab("Inference"):
+        def echo(message, history,model_name_local,model_name_online,
+                                            inf_checkbox,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider):
+            global infer_ragchain
+            if infer_ragchain is None:
+                gr.Info("Please wait!!! model is loading!!")
+                if inf_checkbox:
+                    gr.Info("Model is loading from Huggingface!!")
+                infer_ragchain = model_chain(model_name_local,model_name_online,
+                                            inf_checkbox,embedding_name,splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider)
+            rag_chain=infer_ragchain.rag_chain_ret()
+            return infer_ragchain.ans_ret(message,rag_chain)
+        from utils import load_params_from_file
+        saved_params = load_params_from_file()
+    # If saved parameters exist, use them; otherwise, set default values
+        default_model_name = saved_params['model_name'] if saved_params else "Llama"
+        default_embedding_name = saved_params['embedding_name'] if saved_params else "BAAI/bge-base-en-v1.5"
+        default_splitter_type = saved_params['splitter_type_dropdown'] if saved_params else "character"
+        default_chunk_size = saved_params['chunk_size_slider'] if saved_params else 500
+        default_chunk_overlap = saved_params['chunk_overlap_slider'] if saved_params else 30
+        default_separator = saved_params['separator_textbox'] if saved_params else "\n"
+        default_max_tokens = saved_params['max_tokens_slider'] if saved_params else 1000
+        with gr.Row():
+            def login_hug(token):
+                from huggingface_hub import login
+                login(token=token)
+            login_hug(os.getenv('HF_TOKEN'))
+        with gr.Row():
+            embedding_name=gr.Dropdown(choices=["BAAI/bge-base-en-v1.5","dunzhang/stella_en_1.5B_v5","dunzhang/stella_en_400M_v5",
+                                                "nvidia/NV-Embed-v2","Alibaba-NLP/gte-Qwen2-1.5B-instruct"],value=default_embedding_name,
+                                    label="Select the Embedding Model")
+            splitter_type_dropdown = gr.Dropdown(choices=["character", "recursive", "token"],
+                                             value=default_splitter_type, label="Splitter Type",interactive=True)
+
+            chunk_size_slider = gr.Slider(minimum=100, maximum=2000, value=default_chunk_size, step=50, label="Chunk Size")
+            chunk_overlap_slider = gr.Slider(minimum=0, maximum=500, value=default_chunk_overlap, step=10, label="Chunk Overlap",interactive=True)
+            separator_textbox = gr.Textbox(value=default_separator, label="Separator (e.g., newline '\\n')",interactive=True)
+            max_tokens_slider = gr.Slider(minimum=100, maximum=5000, value=default_max_tokens, step=100, label="Max Tokens",interactive=True)
+
+        inf_checkbox=gr.Checkbox(label="Do you want to use without fine-tuned model from Hugging face?")
+        model_name_local=gr.Dropdown(choices=os.listdir("models"),visible=True,label="Select the fine-tuned LLM",value=default_model_name)
+        model_name_online=gr.Dropdown(visible=False)
+        def model_online_local_show(inf_checkbox):
+            if inf_checkbox:
+                return [gr.Dropdown(visible=False),
+                        gr.Dropdown(choices=["Zephyr","Llama","Mistral", "Phi", "Flant5"],
+                        label="Select the LLM from Huggingface",visible=True)]
+            else:
+                return [gr.Dropdown(choices=os.listdir("models"),label="Select the fine-tuned LLM",visible=True),
+                        gr.Dropdown(visible=False)]
+
+        inf_checkbox.change(model_online_local_show,[inf_checkbox],[model_name_local,model_name_online])
+        gr.ChatInterface(fn=echo,
+                         additional_inputs=[model_name_local,model_name_online,inf_checkbox,embedding_name,
+                                            splitter_type_dropdown,chunk_size_slider,
+                                            chunk_overlap_slider,separator_textbox,max_tokens_slider],
+                           title="Chatbot")
+    #----------------------------------------------
+    with gr.Tab("Deployment"):
+        gr.Markdown("""`deploy` folder has all the code for the deployment of the model.
+                    For installing dependencies use the following command: `pip install -r requirements.txt`.
+                    """)
+        def deploy_func(model_name):
+            import shutil
+            import os
+            src_folder = 'src'
+            deploy_folder = 'deploy'
+            files_to_copy = ['model_ret.py', 'create_retriever.py', 'inference.py']
+            for file_name in files_to_copy:
+                src_file_path = os.path.join(src_folder, file_name)
+                dest_file_path = os.path.join(deploy_folder, file_name)
+            param_list=load_params_from_file()
+            param_list["model_name"]=model_name
+            save_params_to_file(param_list)
+            # f.write(f"{model_name}")
+
+
+        model_name=gr.Dropdown(choices=os.listdir("models"),label="Select the Model")
+        btn_model=gr.Button("Deploy")
+        btn_model.click(deploy_func,model_name)
+
+demo.launch(share=False)

create_retriever.py

@@ -0,0 +1,98 @@
+import os
+import glob
+from langchain_community.document_loaders import Docx2txtLoader, TextLoader, PyPDFLoader
+from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter, TokenTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.retrievers import EnsembleRetriever
+# from ragatouille import RAGPretrainedModel
+
+# Function to load and process documents
+def docs_return(flag):
+    directory_path = 'rag_data/'
+    docx_file_pattern = '*.docx'
+    pdf_file_pattern = '*.pdf'
+    txt_file_pattern = '*.txt'
+
+    docx_file_paths = glob.glob(directory_path + docx_file_pattern)
+    pdf_file_paths = glob.glob(directory_path + pdf_file_pattern)
+    txt_file_paths = glob.glob(directory_path + txt_file_pattern)
+
+    all_doc, all_doc2 = [], []
+
+    for x in docx_file_paths:
+        loader = Docx2txtLoader(x)
+        documents = loader.load()
+        all_doc.extend(documents)
+        all_doc2.append(str(documents[0].page_content))
+
+    for x in pdf_file_paths:
+        loader = PyPDFLoader(x, extract_images=True)
+        docs_lazy = loader.lazy_load()
+        documents = []
+        for doc in docs_lazy:
+            documents.append(doc)
+        all_doc.extend(documents)
+        all_doc2.append(str(documents[0].page_content))
+
+    for x in txt_file_paths:
+        loader = TextLoader(x)
+        documents = loader.load()
+        all_doc.extend(documents)
+        all_doc2.append(str(documents[0].page_content))
+
+    docs = '\n\n'.join(all_doc2)
+
+    return all_doc if flag == 0 else docs
+
+# Function to get or download the embedding model
+def get_embedding_model(model_name):
+    local_model_path = f"embedding_model/{model_name.replace('/', '_')}"
+    if os.path.exists(local_model_path):
+        print(f"Loading local model from {local_model_path}")
+        return HuggingFaceEmbeddings(model_name=local_model_path)
+    else:
+        print(f"Downloading model {model_name}")
+        return HuggingFaceEmbeddings(model_name=model_name)
+
+# Function to return different types of text splitters
+def get_text_splitter(splitter_type='character', chunk_size=500, chunk_overlap=30, separator="\n", max_tokens=1000):
+    if splitter_type == 'character':
+        return CharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap, separator=separator)
+    elif splitter_type == 'recursive':
+        return RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    elif splitter_type == 'token':
+        return TokenTextSplitter(chunk_size=max_tokens, chunk_overlap=chunk_overlap)
+    else:
+        raise ValueError("Unsupported splitter type. Choose from 'character', 'recursive', or 'token'.")
+
+# Retriever using Chroma and HuggingFace embeddings
+def retriever_chroma(flag, model_name="BAAI/bge-large-en-v1.5", splitter_type='character', chunk_size=500, chunk_overlap=30, separator="\n", max_tokens=1000):
+    # Load or download the embedding model
+    embeddings = get_embedding_model(model_name)
+
+    if not flag:
+        # Load the documents
+        all_doc = docs_return(0)
+
+        # Use the splitter parameters
+        text_splitter = get_text_splitter(splitter_type=splitter_type, chunk_size=chunk_size, chunk_overlap=chunk_overlap, separator=separator, max_tokens=max_tokens)
+
+        # Split the documents using the text splitter
+        docs = text_splitter.split_documents(documents=all_doc)
+
+        # Create a Chroma vector database
+        vectordb = Chroma.from_documents(docs, embeddings, persist_directory="./chroma_db")
+
+        # Create the retriever
+        chroma_retriever = vectordb.as_retriever(
+            search_type="mmr", search_kwargs={"k": 4, "fetch_k": 10}
+        )
+        return chroma_retriever
+    else:
+        # Load a local Chroma vectorstore
+        vectordb = Chroma.load_local("vectorstore", embeddings)
+        chroma_retriever = vectordb.as_retriever(
+            search_type="mmr", search_kwargs={"k": 4, "fetch_k": 10}
+        )
+        return chroma_retriever

data_ret.py

@@ -0,0 +1,6 @@
+from langchain_community.document_loaders import WebBaseLoader
+def data_ret2(link):
+    start=1
+    loader = WebBaseLoader(f"{link}")
+    data = loader.load()
+    return data

deploy/create_retriever.py

@@ -0,0 +1,114 @@
+import os
+import glob
+from langchain_community.document_loaders import Docx2txtLoader, TextLoader
+from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter, TokenTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.retrievers import EnsembleRetriever
+from ragatouille import RAGPretrainedModel
+
+# Function to load and process documents
+def docs_return(flag):
+    directory_path = 'rag_data/'
+    docx_file_pattern = '*.docx'
+    txt_file_pattern = '*.txt'
+    
+    docx_file_paths = glob.glob(directory_path + docx_file_pattern)
+    txt_file_paths = glob.glob(directory_path + txt_file_pattern)
+    
+    all_doc, all_doc2 = [], []
+    
+    for x in docx_file_paths:
+        loader = Docx2txtLoader(x)
+        documents = loader.load()
+        all_doc.extend(documents)
+        all_doc2.append(str(documents[0].page_content))
+    
+    for x in txt_file_paths:
+        loader = TextLoader(x)
+        documents = loader.load()
+        all_doc.extend(documents)
+        all_doc2.append(str(documents[0].page_content))
+    
+    docs = '\n\n'.join(all_doc2)
+    
+    return all_doc if flag == 0 else docs
+
+# Function to get or download the embedding model
+def get_embedding_model(model_name):
+    local_model_path = f"embedding_model/{model_name.replace('/', '_')}"
+    if os.path.exists(local_model_path):
+        print(f"Loading local model from {local_model_path}")
+        return HuggingFaceEmbeddings(model_name=local_model_path)
+    else:
+        print(f"Downloading model {model_name}")
+        return HuggingFaceEmbeddings(model_name=model_name)
+
+# Function to return different types of text splitters
+def get_text_splitter(splitter_type='character', chunk_size=500, chunk_overlap=30, separator="\n", max_tokens=1000):
+    if splitter_type == 'character':
+        return CharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap, separator=separator)
+    elif splitter_type == 'recursive':
+        return RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    elif splitter_type == 'token':
+        return TokenTextSplitter(chunk_size=max_tokens, chunk_overlap=chunk_overlap)
+    else:
+        raise ValueError("Unsupported splitter type. Choose from 'character', 'recursive', or 'token'.")
+
+# Retriever using Chroma and HuggingFace embeddings
+def retriever_chroma(flag, model_name="BAAI/bge-large-en-v1.5", splitter_type='character', chunk_size=500, chunk_overlap=30, separator="\n", max_tokens=1000):
+    # Load or download the embedding model
+    embeddings = get_embedding_model(model_name)
+    
+    if not flag:
+        # Load the documents
+        all_doc = docs_return(0)
+        
+        # Use the splitter parameters
+        text_splitter = get_text_splitter(splitter_type=splitter_type, chunk_size=chunk_size, chunk_overlap=chunk_overlap, separator=separator, max_tokens=max_tokens)
+        
+        # Split the documents using the text splitter
+        docs = text_splitter.split_documents(documents=all_doc)
+        
+        # Create a Chroma vector database
+        vectordb = Chroma.from_documents(docs, embeddings, persist_directory="./chroma_db")
+        
+        # Create the retriever
+        chroma_retriever = vectordb.as_retriever(
+            search_type="mmr", search_kwargs={"k": 4, "fetch_k": 10}
+        )
+        return chroma_retriever
+    else:
+        # Load a local Chroma vectorstore
+        vectordb = Chroma.load_local("vectorstore", embeddings)
+        chroma_retriever = vectordb.as_retriever(
+            search_type="mmr", search_kwargs={"k": 4, "fetch_k": 10}
+        )
+        return chroma_retriever
+
+# ColBERT retriever
+def colbert_retriever():
+    docs = docs_return(1)
+    RAG = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")
+    RAG.index(
+        collection=[docs],
+        index_name="ensemble_colbert",
+        max_document_length=256,
+        split_documents=True,
+    )
+    retriever = RAG.as_langchain_retriever(k=3)
+    return retriever
+
+# Ensemble retriever
+def ensemble_retriever(model_name="BAAI/bge-large-en-v1.5", splitter_type='character', chunk_size=500, chunk_overlap=30, separator="\n", max_tokens=1000):
+    retriever1 = colbert_retriever()
+    retriever2 = retriever_chroma(False, model_name=model_name, splitter_type=splitter_type, chunk_size=chunk_size, chunk_overlap=chunk_overlap, separator=separator, max_tokens=max_tokens)
+    retriever = EnsembleRetriever(retrievers=[retriever1, retriever2], weights=[0.50, 0.50])
+    return retriever
+
+# Example usage:
+# dat = ensemble_retriever(model_name="sentence-transformers/all-mpnet-base-v2", splitter_type='token', chunk_size=500)
+# data = dat.invoke("What is KUET?")
+# context = ""
+# for x in data[:2]:
+#     context += (x.page_content) + "\n"

deploy/inference.py

@@ -0,0 +1,119 @@
+import os
+import torch
+import pandas as pd
+import transformers
+from pynvml import *
+import torch
+from langchain import hub
+from model_ret import zephyr_model,llama_model,mistral_model,phi_model,flant5_model
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from create_retriever import ensemble_retriever
+# HuggingFace model mapping
+hf_model_map = {
+    "Zephyr": "HuggingFaceH4/zephyr-7b-beta",
+    "Llama": "NousResearch/Meta-Llama-3-8B",
+    "Mistral": "unsloth/mistral-7b-instruct-v0.3",
+    "Phi": "microsoft/Phi-3-mini-4k-instruct",
+    "Flant5": "google/flan-t5-base"
+}
+
+# Model chain class
+class model_chain:
+    model_name = ""
+
+    def __init__(self, 
+                 model_name_local, 
+                 model_name_online="Llama", 
+                 use_local=True, 
+                 embedding_name="BAAI/bge-base-en-v1.5", 
+                 splitter_type_dropdown="character", 
+                 chunk_size_slider=512, 
+                 chunk_overlap_slider=30, 
+                 separator_textbox="\n", 
+                 max_tokens_slider=2048) -> None:
+        if use_local:
+            quantization, self.model_name = model_name_local.split("_")[0], model_name_local.split("_")[1]
+            model_name_temp = model_name_local
+        else:
+            self.model_name = model_name_online
+            model_name_temp = hf_model_map[model_name_online]
+
+        if self.model_name == "Zephyr":
+            self.llm = zephyr_model(model_name_temp, quantization, use_local=use_local)
+        elif self.model_name == "Llama":
+            self.llm = llama_model(model_name_temp, quantization, use_local=use_local)
+        elif self.model_name == "Mistral":
+            self.llm = mistral_model(model_name_temp, quantization, use_local=use_local)
+        elif self.model_name == "Phi":
+            self.llm = phi_model(model_name_temp, quantization, use_local=use_local)
+        elif self.model_name == "Flant5":
+            self.tokenizer, self.model, self.llm = flant5_model(model_name_temp, use_local=use_local)
+
+        # Creating the retriever
+        self.retriever = ensemble_retriever(embedding_name,
+                                            splitter_type=splitter_type_dropdown,
+                                            chunk_size=chunk_size_slider,
+                                            chunk_overlap=chunk_overlap_slider,
+                                            separator=separator_textbox,
+                                            max_tokens=max_tokens_slider)
+
+        # Defining the RAG chain
+        prompt = hub.pull("rlm/rag-prompt")
+        self.rag_chain = (
+            {"context": self.retriever | self.format_docs, "question": RunnablePassthrough()}
+            | prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+    # Helper function to format documents
+    def format_docs(self, docs):
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    # Retrieve RAG chain
+    def rag_chain_ret(self):
+        return self.rag_chain
+
+    # Answer retrieval function
+    def ans_ret(self, inp, rag_chain):
+        if self.model_name == 'Flant5':
+            my_question = "What is KUET?"
+            data = self.retriever.invoke(inp)
+            context = ""
+            for x in data[:2]:
+                context += (x.page_content) + "\n"
+            inputs = f"""Please answer to this question using this context:\n{context}\n{my_question}"""
+            inputs = self.tokenizer(inputs, return_tensors="pt")
+            outputs = self.model.generate(**inputs)
+            answer = self.tokenizer.decode(outputs[0])
+            from textwrap import fill
+            ans = fill(answer, width=100)
+            return ans
+
+        ans = rag_chain.invoke(inp)
+        ans = ans.split("Answer:")[1]
+        return ans
+
+# def model_push(hf):
+#     from transformers import AutoTokenizer, AutoModelForCausalLM
+#     if model_name=="Mistral":
+#         path="models/full_KUET_LLM_mistral"
+#     elif model_name=="Zepyhr":
+#         path="models/full_KUET_LLM_zepyhr"
+#     elif model_name=="Llama2":
+#         path="models/full_KUET_LLM_llama" 
+#     tokenizer = AutoTokenizer.from_pretrained(path)
+#     model = AutoModelForCausalLM.from_pretrained(path,
+#                                                     device_map='auto',
+#                                                     torch_dtype=torch.float16,
+#                                                     use_auth_token=True,
+#                                                     load_in_8bit=True,
+#                                                     #  load_in_4bit=True
+#                                                     )
+#     model.push_to_hub(repo_id=f"My_model",token=hf)
+#     tokenizer.push_to_hub(repo_id=f"My_model",token=hf)
+
+
+
+

deploy/main.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import os
+from utils import load_params_from_file
+from inference import model_chain
+
+infer_ragchain = None
+
+# Define the main interface logic
+def echo(message, history, model_name_local, model_name_online,
+         inf_checkbox, embedding_name, splitter_type_dropdown, chunk_size_slider,
+         chunk_overlap_slider, separator_textbox, max_tokens_slider):
+    global infer_ragchain
+    if infer_ragchain is None:
+        gr.Info("Please wait!!! model is loading!!")
+        if inf_checkbox:
+            gr.info("local model is loading!!")
+        infer_ragchain = model_chain(model_name_local, model_name_online,
+                                     inf_checkbox, embedding_name, splitter_type_dropdown, chunk_size_slider,
+                                     chunk_overlap_slider, separator_textbox, max_tokens_slider)
+    rag_chain = infer_ragchain.rag_chain_ret()
+    return infer_ragchain.ans_ret(message, rag_chain)
+
+# Load saved parameters if available
+saved_params = load_params_from_file()
+
+# Set default values
+default_embedding_name = saved_params['embedding_name'] if saved_params else "BAAI/bge-base-en-v1.5"
+default_splitter_type = saved_params['splitter_type_dropdown'] if saved_params else "character"
+default_chunk_size = saved_params['chunk_size_slider'] if saved_params else 500
+default_chunk_overlap = saved_params['chunk_overlap_slider'] if saved_params else 30
+default_separator = saved_params['separator_textbox'] if saved_params else "\n"
+default_max_tokens = saved_params['max_tokens_slider'] if saved_params else 1000
+
+# Initialize the Gradio Interface
+with gr.Blocks() as demo:
+    with gr.Tab("Inference"):
+        with gr.Row():
+            embedding_name = gr.Dropdown(choices=["BAAI/bge-base-en-v1.5", "dunzhang/stella_en_1.5B_v5", "dunzhang/stella_en_400M_v5",
+                                                  "nvidia/NV-Embed-v2", "Alibaba-NLP/gte-Qwen2-1.5B-instruct"],
+                                         value=default_embedding_name, label="Select the Embedding Model")
+            splitter_type_dropdown = gr.Dropdown(choices=["character", "recursive", "token"],
+                                                 value=default_splitter_type, label="Splitter Type", interactive=True)
+
+            chunk_size_slider = gr.Slider(minimum=100, maximum=2000, value=default_chunk_size, step=50, label="Chunk Size")
+            chunk_overlap_slider = gr.Slider(minimum=0, maximum=500, value=default_chunk_overlap, step=10, label="Chunk Overlap", interactive=True)
+            separator_textbox = gr.Textbox(value=default_separator, label="Separator (e.g., newline '\\n')", interactive=True)
+            max_tokens_slider = gr.Slider(minimum=100, maximum=5000, value=default_max_tokens, step=100, label="Max Tokens", interactive=True)
+
+        inf_checkbox = gr.Checkbox(label="Do you want to use a fine-tuned model?")
+        model_name_local = gr.Dropdown(visible=False)
+        model_name_online = gr.Dropdown(choices=["Zephyr", "Llama", "Mistral", "Phi", "Flant5"],
+                                        label="Select the LLM from Huggingface", visible=True)
+
+        # Function to toggle model selection between local and online based on checkbox
+        def model_online_local_show(inf_checkbox):
+            if inf_checkbox:
+                return [gr.Dropdown(choices=os.listdir("models"), label="Select the local LLM", visible=True),
+                        gr.Dropdown(visible=False)]
+            else:
+                return [gr.Dropdown(visible=False),
+                        gr.Dropdown(choices=["Zephyr", "Llama", "Mistral", "Phi", "Flant5"],
+                                    label="Select the LLM from Huggingface", visible=True)]
+
+        # Event listener to switch between local and online models
+        inf_checkbox.change(model_online_local_show, [inf_checkbox], [model_name_local, model_name_online])
+
+        # Chat interface
+        gr.ChatInterface(fn=echo,
+                         additional_inputs=[model_name_local, model_name_online, inf_checkbox, embedding_name,
+                                            splitter_type_dropdown, chunk_size_slider,
+                                            chunk_overlap_slider, separator_textbox, max_tokens_slider],
+                         title="Chatbot")
+
+# Launch the demo
+demo.launch()

deploy/model_ret.py

@@ -0,0 +1,114 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, T5Tokenizer, T5ForConditionalGeneration, pipeline
+from langchain import HuggingFacePipeline
+import os
+import torch
+
+def load_model_and_pipeline(model_info, quantization=4, is_t5=False, use_local=True):
+    # Check if the model is local or should be downloaded from Hugging Face
+    # if use_local:
+    #     path = f"models/{model_info}"
+    #     if not os.path.exists(path):
+    #         print(f"Local model not found at {path}. Downloading from Hugging Face...")
+    #         use_local = False  # Fallback to Hugging Face download if local not found
+    # if not use_local:
+    #     # Replace model_info with the corresponding Hugging Face repo name
+    #     hf_model_map = {
+    #         "zephyr-7b-beta": "HuggingFaceH4/zephyr-7b-beta",
+    #         "llama-3-8b": "NousResearch/Meta-Llama-3-8B",
+    #         "mistral-7b": "unsloth/mistral-7b-instruct-v0.3",
+    #         "phi-3-mini": "microsoft/Phi-3-mini-4k-instruct",
+    #         "flan-t5-base": "google/flan-t5-base"
+    #     }
+    #     path = hf_model_map.get(model_info.split("_")[1], model_info)
+
+    tokenizer = AutoTokenizer.from_pretrained(model_info, use_auth_token=True)
+
+    if quantization == "8":
+        model = AutoModelForCausalLM.from_pretrained(
+            model_info,
+            device_map='auto',
+            torch_dtype=torch.float16,
+            use_auth_token=True,
+            load_in_8bit=True
+        )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(
+            model_info,
+            device_map='auto',
+            torch_dtype=torch.float16,
+            use_auth_token=True,
+            load_in_4bit=True
+        )
+
+    if is_t5:
+        model = T5ForConditionalGeneration.from_pretrained(model_info)
+        tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-base")
+
+    pipe = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        max_new_tokens=512,
+        do_sample=True,
+        top_k=30,
+        num_return_sequences=1,
+        eos_token_id=tokenizer.eos_token_id
+    )
+
+    llm = HuggingFacePipeline(pipeline=pipe, model_kwargs={'temperature': 0})
+    return tokenizer, model, llm
+
+def zephyr_model(model_info, quantization, use_local=True):
+    return load_model_and_pipeline(model_info, quantization, use_local=use_local)
+
+def llama_model(model_info, quantization, use_local=True):
+    return load_model_and_pipeline(model_info, quantization, use_local=use_local)
+
+def mistral_model(model_info, quantization, use_local=True):
+    return load_model_and_pipeline(model_info, quantization, use_local=use_local)
+
+def phi_model(model_info, quantization, use_local=True):
+    return load_model_and_pipeline(model_info, quantization, use_local=use_local)
+
+def flant5_model(model_info, use_local=True):
+    return load_model_and_pipeline(model_info, is_t5=True, use_local=use_local)
+
+
+import pandas as pd
+from datasets import Dataset
+
+def calculate_rag_metrics(model_ques_ans_gen, llm_model, embedding_model="BAAI/bge-base-en-v1.5"):
+    # Create a dictionary from the model_ques_ans_gen list
+    from ragas import evaluate
+    from ragas.metrics import faithfulness, answer_correctness,answer_similarity,answer_relevancy,context_recall, context_precision
+    data_samples = {
+        'question': [item['question'] for item in model_ques_ans_gen],
+        'answer': [item['answer'] for item in model_ques_ans_gen],
+        'contexts': [item['contexts'] for item in model_ques_ans_gen],
+        'ground_truths': [item['ground_truths'] for item in model_ques_ans_gen]
+    }
+
+    # Convert the dictionary to a pandas DataFrame
+    rag_df = pd.DataFrame(data_samples)
+
+    # Convert the DataFrame to a HuggingFace Dataset
+    rag_eval_dataset = Dataset.from_pandas(rag_df)
+
+    # Define the list of metrics to calculate
+    metrics = [
+        "answer_correctness", "answer_similarity", 
+        "answer_relevancy", "faithfulness", 
+        "context_recall", "context_precision"
+    ]
+
+    # Perform the evaluation using the provided LLM and embedding models
+    result = evaluate(
+        rag_eval_dataset,
+        metrics=metrics,
+        llm=llm_model,
+        embeddings=embedding_model
+    )
+    result.to_pandas()
+    return result

deploy/params.txt

@@ -0,0 +1 @@
+{"model_name": "M1", "embedding_name": "BAAI/bge-base-en-v1.5", "splitter_type_dropdown": "character", "chunk_size_slider": 500, "chunk_overlap_slider": 30, "separator_textbox": "\n", "max_tokens_slider": 1000}

embedding_tuner.py

@@ -0,0 +1,202 @@
+from datasets import load_dataset, Dataset
+from sentence_transformers import (
+    SentenceTransformer,
+    SentenceTransformerTrainer,
+    SentenceTransformerTrainingArguments,
+)
+from sentence_transformers.losses import (
+    MultipleNegativesRankingLoss,
+    OnlineContrastiveLoss,
+    CoSENTLoss,
+    GISTEmbedLoss,
+    TripletLoss,
+)
+import pandas as pd
+
+
+class EmbeddingFinetuner:
+    """
+    A class for finetuning SentenceTransformer models on various loss functions.
+
+    Supports the following loss functions:
+        - MultipleNegativesRankingLoss
+        - OnlineContrastiveLoss
+        - CoSENTLoss
+        - GISTEmbedLoss
+        - TripletLoss
+
+    Loads data from an xlsx file named "emb_data.xlsx".
+    """
+
+    def __init__(
+        self,
+        model_name="microsoft/mpnet-base",
+        loss_function="MultipleNegativesRankingLoss",
+        epochs=1,
+        batch_size=16,
+        test_size=0.1,
+    ):
+        """
+        Initializes the EmbeddingFinetuner.
+
+        Args:
+            model_name (str): Name of the SentenceTransformer model to use.
+            loss_function (str): Name of the loss function to use.
+            epochs (int): Number of training epochs.
+            batch_size (int): Batch size for training.
+            test_size (float): Proportion of the dataset to include in the test split. 
+                              If less than 1, no test set is created.
+        """
+        self.model_name = model_name
+        self.loss_function = loss_function
+        self.epochs = epochs
+        self.batch_size = batch_size
+        self.test_size = test_size
+
+        self.model = SentenceTransformer(self.model_name)
+        self.train_dataset, self.dev_dataset, self.test_dataset = self._load_data()
+        self.loss = self._get_loss_function()
+
+    def _load_data(self):
+        """
+        Loads data from "emb_data.xlsx" and prepares it for the selected loss function.
+        """
+        df = pd.read_excel(f"data/emb_data.xlsx")
+
+        if self.loss_function == "MultipleNegativesRankingLoss":
+            """
+            Expects data in the format:
+            | anchor | positive | negative |
+            |---|---|---|
+            | sentence1 | sentence2 | sentence3 |
+            | ... | ... | ... |
+
+            Where 'anchor' is the sentence to be embedded, 'positive' is a sentence 
+            semantically similar to the anchor, and 'negative' is a sentence 
+            semantically dissimilar to the anchor.
+            """
+            dataset = Dataset.from_pandas(df)
+
+        elif self.loss_function == "OnlineContrastiveLoss":
+            """
+            Expects data in the format:
+            | sentence1 | sentence2 | label |
+            |---|---|---|
+            | sentenceA | sentenceB | 1 | 
+            | sentenceC | sentenceD | 0 |
+            | ... | ... | ... |
+
+            Where 'sentence1' and 'sentence2' are pairs of sentences, and 'label' 
+            indicates whether they are semantically similar (1) or dissimilar (0).
+            """
+            dataset = Dataset.from_pandas(df)
+
+        elif self.loss_function == "CoSENTLoss":
+            """
+            Expects data in the format:
+            | sentence1 | sentence2 | score |
+            |---|---|---|
+            | sentenceA | sentenceB | 0.8 |
+            | sentenceC | sentenceD | 0.2 |
+            | ... | ... | ... |
+
+            Where 'sentence1' and 'sentence2' are pairs of sentences, and 'score' 
+            is a float value representing their similarity (e.g., from 0 to 1).
+            """
+            dataset = Dataset.from_pandas(df)
+
+        elif self.loss_function == "GISTEmbedLoss":
+            """
+            Expects data in either of the following formats:
+
+            Triplets:
+            | anchor | positive | negative |
+            |---|---|---|
+            | sentence1 | sentence2 | sentence3 |
+            | ... | ... | ... |
+
+            Pairs:
+            | anchor | positive |
+            |---|---|
+            | sentence1 | sentence2 |
+            | ... | ... |
+
+            Where 'anchor' is the sentence to be embedded, 'positive' is a sentence 
+            semantically similar to the anchor, and 'negative' (if present) is a 
+            sentence semantically dissimilar to the anchor.
+            """
+            dataset = Dataset.from_pandas(df)
+
+        elif self.loss_function == "TripletLoss":
+            """
+            Expects data in the format:
+            | anchor | positive | negative |
+            |---|---|---|
+            | sentence1 | sentence2 | sentence3 |
+            | ... | ... | ... |
+
+            Where 'anchor' is the sentence to be embedded, 'positive' is a sentence 
+            semantically similar to the anchor, and 'negative' is a sentence 
+            semantically dissimilar to the anchor.
+            """
+            dataset = Dataset.from_pandas(df)
+
+        else:
+            raise ValueError(f"Unsupported loss function: {self.loss_function}")
+
+        # Split into train and dev
+        train_dev_dataset = dataset.train_test_split(test_size=self.test_size)
+        train_dataset = train_dev_dataset["train"]
+        dev_dataset = train_dev_dataset["test"]
+        test_dataset = None
+
+        return train_dataset, dev_dataset, test_dataset
+
+    def _get_loss_function(self):
+        """
+        Returns the selected loss function instance.
+        """
+        if self.loss_function == "MultipleNegativesRankingLoss":
+            return MultipleNegativesRankingLoss(self.model)
+        elif self.loss_function == "OnlineContrastiveLoss":
+            return OnlineContrastiveLoss(self.model)
+        elif self.loss_function == "CoSENTLoss":
+            return CoSENTLoss(self.model)
+        elif self.loss_function == "GISTEmbedLoss":
+            guide_model = SentenceTransformer("all-MiniLM-L6-v2")  # You can change this
+            return GISTEmbedLoss(self.model, guide_model)
+        elif self.loss_function == "TripletLoss":
+            return TripletLoss(self.model)
+        else:
+            raise ValueError(f"Unsupported loss function: {self.loss_function}")
+
+    def train(self):
+        """
+        Trains the SentenceTransformer model using the specified loss function.
+        """
+        args = SentenceTransformerTrainingArguments(
+            output_dir=f"models/{self.model_name}-{self.loss_function}",
+            num_train_epochs=self.epochs,
+            per_device_train_batch_size=self.batch_size,
+            per_device_eval_batch_size=self.batch_size,
+            evaluation_strategy="epoch",
+            # ... other training arguments as needed ...
+        )
+
+        trainer = SentenceTransformerTrainer(
+            model=self.model,
+            args=args,
+            train_dataset=self.train_dataset,
+            eval_dataset=self.dev_dataset,
+            loss=self.loss,
+        )
+        trainer.train()
+
+        # Save the trained model
+        self.model.save_pretrained(
+            f"models/emb-{self.model_name}-{self.loss_function}"
+        )
+        
+        return True
+        
+        

fine_tune_file/finetune_file.py

@@ -0,0 +1,138 @@
+#code changed
+import os
+import torch
+from datasets import load_dataset, Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+import transformers
+# from peft import AutoPeftModelForCausalLM
+from transformers import GenerationConfig
+from pynvml import *
+import glob
+class custom_model_trainer:
+    lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout=5e-6,3,4,4,4,16,32,.05 # setup the parameter accoring to your model.
+    def formatted_text(self, x ,tokenizer):
+            # change this templete according to your model
+            #Example: 
+            temp = [
+            {"role": "user", "content": """You are a helpful chatbot, help users by answering their queries.
+            Question: """ + x["question"]},
+            {"role": "assistant", "content": x["answer"]}
+            ]
+            return tokenizer.apply_chat_template(temp, add_generation_prompt=False, tokenize=False)
+    def custom_model_finetune(self):
+        base_model = 'Qwen/Qwen2.5-0.5B-Instruct' # Write the base model repo name from huggingface
+        lora_output = f'models/q{self.quantization}_mymodel_lora' # Write the folder name for saving lora output
+        full_output = f'models/q{self.quantization}_mymodel_full' # Write the folder name for saving full model output
+        DEVICE = 'cuda'
+        tokenizer = AutoTokenizer.from_pretrained(base_model)
+        tokenizer.padding_side = 'right'
+        ### read csv with Prompt, Answer pair 
+        data_location = r"data/finetune_data.xlsx" ## replace here
+        data_df=pd.read_excel( data_location )
+        ### set formatting
+        data_df["text"] = data_df[["question", "answer"]].apply(lambda x: self.formatted_text(x,tokenizer), axis=1) ## replace Prompt and Answer if collected dataset has different column names
+        print(data_df.iloc[0])
+        dataset = Dataset.from_pandas(data_df)
+
+
+        # set quantization config
+        if self.quantization == '8':
+            bnb_config = BitsAndBytesConfig(  
+                load_in_8bit= True,
+            )
+        else:
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit= True,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",  
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+        model = AutoModelForCausalLM.from_pretrained(
+                base_model,
+                quantization_config=bnb_config,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True,
+        )
+        model.config.use_cache = False # silence the warnings
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+
+        tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.add_eos_token = True
+        # tokenizer.add_bos_token, tokenizer.add_eos_token
+
+        # Set PEFT adapter config (16:32)
+        from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        # target modules are currently selected for zephyr base model
+        config = LoraConfig(
+            r= self.lora_r if self.lora_r else 16,
+            lora_alpha= self.lora_alpha if self.lora_alpha else 32,
+            target_modules=["q_proj", "v_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],   # target all the linear layers for full finetuning
+            lora_dropout= self.lora_dropout if self.lora_dropout else 0.05,
+            bias="none",
+            task_type="CAUSAL_LM")
+
+        # stabilize output layer and layernorms
+        model = prepare_model_for_kbit_training(model, self.quantization)
+        # Set PEFT adapter on model (Last step)
+        model = get_peft_model(model, config)
+
+        # Set Hyperparameters
+        MAXLEN=512
+        BATCH_SIZE = self.batch_size if self.batch_size else 4
+        GRAD_ACC = self.gradient_accumulation if self.gradient_accumulation else 4
+        OPTIMIZER ='paged_adamw_8bit' # save memory
+        LR=self.lr if self.lr else 5e-06                       # slightly smaller than pretraining lr | and close to LoRA standard
+
+
+        training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,
+                                                        gradient_accumulation_steps=GRAD_ACC,
+                                                        optim=OPTIMIZER,
+                                                        learning_rate=LR,
+                                                        fp16=True,            # consider compatibility when using bf16
+                                                        logging_steps=10,
+                                                        num_train_epochs = self.epoch if self.epoch else 2,
+                                                        output_dir=lora_output,
+                                                        remove_unused_columns=True,
+                                                        )
+
+        # Set collator
+        data_collator = transformers.DataCollatorForLanguageModeling(tokenizer,mlm=False)
+
+        # Setup trainer
+        trainer = SFTTrainer(model=model,
+                                    train_dataset=dataset,
+                                    data_collator=data_collator,
+                                    args=training_config,
+                                    dataset_text_field="text",
+                                    #    callbacks=[early_stop], need to learn, lora easily overfits
+                                    )
+
+        trainer.train()
+
+        trainer.save_model(lora_output)
+
+        # Get peft config
+        from peft import PeftConfig
+        config = PeftConfig.from_pretrained(lora_output)
+
+        model = transformers.AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+
+        # Load the Lora model
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        # Get tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+        merged_model = model.merge_and_unload()
+
+        merged_model.save_pretrained(full_output)
+        tokenizer.save_pretrained(full_output)
+        print("*"*10,": Model is saved!!!")

fine_tune_file/flant5_finetune.py

@@ -0,0 +1,97 @@
+import nltk
+import evaluate
+import numpy as np
+import pandas as pd
+from datasets import load_dataset, Dataset
+from transformers import T5Tokenizer, DataCollatorForSeq2Seq
+from transformers import T5ForConditionalGeneration, Seq2SeqTrainingArguments, Seq2SeqTrainer
+import os
+from datetime import datetime
+os.environ["WANDB_DISABLED"] = "true"
+
+class flant5_trainer:
+   def __init__(self) -> None:
+        # Load the tokenizer, model, and data collator
+      MODEL_NAME = "google/flan-t5-base"
+      self.tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)
+      self.model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)
+      self.data_collator = DataCollatorForSeq2Seq(tokenizer=self.tokenizer, model=self.model)
+      nltk.download("punkt", quiet=True)
+      self.metric = evaluate.load("rouge")
+   def preprocess_function(self,examples):
+         """Add prefix to the sentences, tokenize the text, and set the labels"""
+         # The "inputs" are the tokenized answer:
+         inputs = [self.prefix + doc for doc in examples["question"]]
+         model_inputs = self.tokenizer(inputs, max_length=1024, truncation=True)
+      
+         # The "labels" are the tokenized outputs:
+         labels = self.tokenizer(text_target=examples["answer"], 
+                           max_length=1024,         
+                           truncation=True)
+
+         model_inputs["labels"] = labels["input_ids"]
+         return model_inputs
+   def compute_metrics(self,eval_preds):
+         preds, labels = eval_preds
+
+         # decode preds and labels
+         labels = np.where(labels != -100, labels, self.tokenizer.pad_token_id)
+         decoded_preds = self.tokenizer.batch_decode(preds, skip_special_tokens=True)
+         decoded_labels = self.tokenizer.batch_decode(labels, skip_special_tokens=True)
+
+         # rougeLSum expects newline after each sentence
+         decoded_preds = ["\n".join(nltk.sent_tokenize(pred.strip())) for pred in decoded_preds]
+         decoded_labels = ["\n".join(nltk.sent_tokenize(label.strip())) for label in decoded_labels]
+
+         result = self.metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
+      
+         return result
+   def flant5_finetune(self,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout):
+      
+      data_location = r"data/finetune_data.xlsx" 
+      data_df=pd.read_excel(data_location)
+      dataset = Dataset.from_pandas(data_df)
+      # We prefix our tasks with "answer the question"
+      self.prefix = "Please answer this question: "
+
+      # Define the preprocessing function
+      dataset = dataset.train_test_split(test_size=0.1)
+      # Map the preprocessing function across our dataset
+      tokenized_dataset = dataset.map(self.preprocess_function, batched=True)
+
+      # Global Parameters
+    
+      PER_DEVICE_EVAL_BATCH = 4
+      WEIGHT_DECAY = 0.01
+      SAVE_TOTAL_LIM = 3
+      
+      # Set up training arguments
+      training_args = Seq2SeqTrainingArguments(
+         output_dir="./results",
+         evaluation_strategy="epoch",
+         learning_rate=lr,
+         per_device_train_batch_size=batch_size,
+         per_device_eval_batch_size=PER_DEVICE_EVAL_BATCH,
+         weight_decay=WEIGHT_DECAY,
+         save_total_limit=SAVE_TOTAL_LIM,
+         num_train_epochs=epoch,
+         predict_with_generate=True,
+         push_to_hub=False,
+         gradient_accumulation_steps=gradient_accumulation
+      )
+      trainer = Seq2SeqTrainer(
+         model=self.model,
+         args=training_args,
+         train_dataset=tokenized_dataset["train"],
+         eval_dataset=tokenized_dataset["test"],
+         tokenizer=self.tokenizer,
+         data_collator=self.data_collator,
+         compute_metrics=self.compute_metrics
+      )
+      trainer.train()
+      
+      current_time = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+      full_output = f'models/0_flant5_{current_time}'
+      self.model.save_pretrained(full_output)
+      self.model.save_pretrained(full_output)
+      print("*"*10,": Model is saved!!!")

fine_tune_file/llama_finetune.py

@@ -0,0 +1,136 @@
+import os
+import torch
+from datasets import load_dataset, Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+import transformers
+# from peft import AutoPeftModelForCausalLM
+from transformers import GenerationConfig
+from pynvml import *
+import glob
+class llama_trainer: 
+    def llama_model(self,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout):
+        # base_model = "NousResearch/Llama-2-7b-chat-hf"
+        base_model="NousResearch/Meta-Llama-3-8B"
+        # base_model="unsloth/Meta-Llama-3.1-8B-Instruct"
+        from datetime import datetime
+        lora_output = f'models/{quantization}_Llama_lora_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        full_output = f'models/{quantization}_Llama_full_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        DEVICE = 'cuda'
+
+        # set quantization config
+        bnb_config = BitsAndBytesConfig(  
+                load_in_8bit= True,
+            )
+        if quantization == 4:
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit= True,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",  
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+        model = AutoModelForCausalLM.from_pretrained(
+                base_model,
+                quantization_config=bnb_config,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True,
+        )
+        model.config.use_cache = False # silence the warnings
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+
+        tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.add_eos_token = True
+        tokenizer.add_eos_token
+
+        data_location = r"data/finetune_data.xlsx" ## replace here
+        data_df=pd.read_excel( data_location )
+
+        for i in range(len(data_df)):
+
+            data_df.loc[i,'Text']="### Instruction:"+str(data_df.loc[i,'question'])+"### Response:"+str(data_df.loc[i,'answer'])
+
+        dataset = Dataset.from_pandas(data_df)
+
+        # Set PEFT adapter config (16:32)
+        from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        config = LoraConfig(
+            r= lora_r if lora_r else 16,
+            lora_alpha= lora_alpha if lora_alpha else 32,
+            target_modules=["q_proj", "v_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],   # target all the linear layers for full finetuning
+            lora_dropout= lora_dropout if lora_dropout else 0.05,
+            bias="none",
+            task_type="CAUSAL_LM")
+
+        # stabilize output layer and layernorms
+        model = prepare_model_for_kbit_training(model)
+        # Set PEFT adapter on model (Last step)
+        model = get_peft_model(model, config)
+
+        # Set Hyperparameters
+        MAXLEN=512
+        BATCH_SIZE = batch_size if batch_size else 4
+        GRAD_ACC = gradient_accumulation if gradient_accumulation else 4
+        OPTIMIZER ='paged_adamw_8bit' # save memory
+        LR=lr if lr else 5e-06                          # slightly smaller than pretraining lr | and close to LoRA standard
+
+        # Set training config
+        training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,
+                                                        gradient_accumulation_steps=GRAD_ACC,
+                                                        optim=OPTIMIZER,
+                                                        learning_rate=LR,
+                                                        fp16=True,            # consider compatibility when using bf16
+                                                        logging_steps=10,
+                                                        num_train_epochs = epoch if epoch else 2,
+                                                        output_dir=lora_output,
+                                                        remove_unused_columns=True,
+                                                        
+                                                        )
+
+        # Set collator
+        data_collator = transformers.DataCollatorForLanguageModeling(tokenizer,mlm=False)
+
+        # Setup trainer
+        trainer = SFTTrainer(model=model,
+                                    train_dataset=dataset,
+                                    data_collator=data_collator,
+                                    args=training_config,
+                                    dataset_text_field="Text",
+                                    #    callbacks=[early_stop], need to learn, lora easily overfits
+                                    )
+
+        trainer.train()
+
+        trainer.save_model(lora_output)
+
+
+        # Get peft config
+        from peft import PeftConfig
+        config = PeftConfig.from_pretrained(lora_output)
+
+        model = transformers.AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+
+        # Load the Lora model
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        # Get tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+        merged_model = model.merge_and_unload()
+
+        merged_model.save_pretrained(full_output)
+        tokenizer.save_pretrained(full_output)
+        print("*"*10,": Model is saved!!!")
+
+
+lm=llama_trainer()
+lm.llama_model(5e-6,2,4,4,8,16,32,.05)
+
+
+

fine_tune_file/mistral_finetune.py

@@ -0,0 +1,138 @@
+# %% Saved
+import os
+import torch
+from datasets import load_dataset, Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+import transformers
+# from peft import AutoPeftModelForCausalLM
+from transformers import GenerationConfig
+from pynvml import *
+import glob
+class mistral_trainer:
+    def formatted_text(self,x,tokenizer):
+            temp = [
+            # {"role": "system", "content": "Answer as a medical assistant. Respond concisely."},
+            {"role": "user", "content": """You are a helpful chatbot, help users by answering their queries.
+            Question: """ + x["question"]},
+            {"role": "assistant", "content": x["answer"]}
+            ]
+            return tokenizer.apply_chat_template(temp, add_generation_prompt=False, tokenize=False)
+    def mistral_finetune(self,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout):
+        # base_model = "mistralai/Mistral-7B-Instruct-v0.2"
+        base_model="unsloth/mistral-7b-instruct-v0.3"
+        from datetime import datetime
+        lora_output = f'models/{quantization}_Mistral_lora_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        full_output = f'models/{quantization}_Mistral_full_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        DEVICE = 'cuda'
+        tokenizer = AutoTokenizer.from_pretrained(base_model)
+        tokenizer.padding_side = 'right'
+        ### read csv with Prompt, Answer pair 
+        data_location = r"data/finetune_data.xlsx" ## replace here
+        data_df=pd.read_excel(data_location)
+        ### set formatting
+        data_df["text"] = data_df[["question", "answer"]].apply(lambda x: self.formatted_text(x,tokenizer), axis=1) ## replace Prompt and Answer if collected dataset has different column names
+        print(data_df.iloc[0])
+        dataset = Dataset.from_pandas(data_df)
+        # set quantization config
+        bnb_config = BitsAndBytesConfig(  
+                load_in_8bit= True,
+            )
+        if quantization == 4:
+            print("*"*10,": 4 bit quantization")
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit= True,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",  
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+        model = AutoModelForCausalLM.from_pretrained(
+                base_model,
+                quantization_config=bnb_config,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True,
+        )
+        model.config.use_cache = False # silence the warnings
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+
+        tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.add_eos_token = True
+        tokenizer.add_bos_token, tokenizer.add_eos_token
+
+        # Set PEFT adapter config (16:32)
+        from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        # target modules are currently selected for zephyr base model
+        config = LoraConfig(
+            r= lora_r if lora_r else 16,
+            lora_alpha= lora_alpha if lora_alpha else 32,
+            target_modules=["q_proj", "v_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],   # target all the linear layers for full finetuning
+            lora_dropout= lora_dropout if lora_dropout else 0.05,
+            bias="none",
+            task_type="CAUSAL_LM")
+
+        # stabilize output layer and layernorms
+        model = prepare_model_for_kbit_training(model)
+        # Set PEFT adapter on model (Last step)
+        model = get_peft_model(model, config)
+
+        # Set Hyperparameters
+        MAXLEN=512
+        BATCH_SIZE = batch_size if batch_size else 4
+        GRAD_ACC = gradient_accumulation if gradient_accumulation else 4
+        OPTIMIZER ='paged_adamw_8bit' # save memory
+        LR=lr if lr else 5e-06 # slightly smaller than pretraining lr | and close to LoRA standard
+
+        training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,
+                                                        gradient_accumulation_steps=GRAD_ACC,
+                                                        optim=OPTIMIZER,
+                                                        learning_rate=LR,
+                                                        fp16=True,            # consider compatibility when using bf16
+                                                        logging_steps=10,
+                                                        num_train_epochs = epoch if epoch else 2,
+                                                        output_dir=lora_output,
+                                                        remove_unused_columns=True,
+                                                        )
+
+        # Set collator
+        data_collator = transformers.DataCollatorForLanguageModeling(tokenizer,mlm=False)
+
+        # Setup trainer
+        trainer = SFTTrainer(model=model,
+                                    train_dataset=dataset,
+                                    data_collator=data_collator,
+                                    args=training_config,
+                                    dataset_text_field="text",
+                                    #    callbacks=[early_stop], need to learn, lora easily overfits
+                                    )
+
+        trainer.train()
+        print("*"*10,": Finetune ended!!!!")
+        trainer.save_model(lora_output)
+
+        # Get peft config
+        from peft import PeftConfig
+        config = PeftConfig.from_pretrained(lora_output)
+
+        model = transformers.AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+
+        # Load the Lora model
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        # Get tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+        merged_model = model.merge_and_unload()
+
+        merged_model.save_pretrained(full_output)
+        tokenizer.save_pretrained(full_output)
+        print("*"*10,": Model is saved!!!")
+
+mis=mistral_trainer()
+mis.mistral_finetune(5e-6,2,4,4,8,16,32,.05)

fine_tune_file/modular_finetune.py

@@ -0,0 +1,177 @@
+import os
+import torch
+from datetime import datetime
+from datasets import Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, T5Tokenizer, T5ForConditionalGeneration
+from trl import SFTTrainer
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, PeftConfig, PeftModel
+import os
+# cache_folder="/mnt/FA00A16100A1259B/shakib/model_cache"
+# os.environ['HF_HOME'] = cache_folder
+# os.environ['HF_DATASETS_CACHE'] = cache_folder
+# os.environ['TRANSFORMERS_CACHE'] = cache_folder
+# print("*"*20)
+# print(os.environ['HF_HOME'])
+# print(os.environ['HF_DATASETS_CACHE'])
+# print(os.environ['TRANSFORMERS_CACHE'])
+# print(os.path.isdir(cache_folder))
+# assert(False)
+class BaseTrainer:
+    def __init__(self, model_name, base_model):
+        self.model_name = model_name
+        self.base_model = base_model
+        self.tokenizer = self.load_tokenizer()
+        self.model = self.load_model()
+
+    def load_tokenizer(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+        return tokenizer
+
+    def load_model(self):
+        raise NotImplementedError("Subclasses must implement load_model method")
+
+    def preprocess_function(self, examples):
+        raise NotImplementedError("Subclasses must implement preprocess_function method")
+
+    def formatted_text(self, x):
+        self.tokenizer.chat_template = {
+                "role": "user",
+                "content": "You are a helpful chatbot. Question: {question}\nAnswer: {answer}"
+            }
+        temp = [
+            {"role": "user", "content": f"You are a helpful chatbot, help users by answering their queries.\nQuestion: {x['question']}"},
+            {"role": "assistant", "content": x["answer"]}
+        ]
+        return self.tokenizer.apply_chat_template(temp, add_generation_prompt=False, tokenize=False,chat_template='content')
+
+    def train(self, lr, epoch, batch_size, gradient_accumulation, quantization, lora_r, lora_alpha, lora_dropout):
+        csv_file = "data/finetune_data.csv"
+        xlsx_file = "data/finetune_data.xlsx"
+        if os.path.exists(csv_file):
+            data_df = pd.read_csv(csv_file)
+            print("Reading CSV file...")
+        elif os.path.exists(xlsx_file):
+            data_df = pd.read_excel(xlsx_file)
+            print("CSV file not found, reading Excel file...")
+            
+        data_df["text"] = data_df[["question", "answer"]].apply(lambda x: self.formatted_text(x), axis=1)
+        dataset = Dataset.from_pandas(data_df)
+
+        lora_output = f'models/{quantization}_{self.model_name}_lora_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        full_output = f'models/{quantization}_{self.model_name}_full_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+
+        config = LoraConfig(
+            r=lora_r or 16,
+            lora_alpha=lora_alpha or 32,
+            target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            lora_dropout=lora_dropout or 0.05,
+            bias="none",
+            task_type="CAUSAL_LM"
+        )
+
+        self.model = prepare_model_for_kbit_training(self.model)
+        self.model = get_peft_model(self.model, config)
+
+        training_args = transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size or 4,
+            gradient_accumulation_steps=gradient_accumulation or 4,
+            optim='paged_adamw_8bit',
+            learning_rate=lr or 5e-6,
+            fp16=True,
+            logging_steps=10,
+            num_train_epochs=epoch or 2,
+            output_dir=lora_output,
+            remove_unused_columns=True,
+        )
+
+        data_collator = transformers.DataCollatorForLanguageModeling(self.tokenizer, mlm=False)
+
+        trainer = SFTTrainer(
+            model=self.model,
+            train_dataset=dataset,
+            data_collator=data_collator,
+            args=training_args,
+            dataset_text_field="text",
+        )
+
+        trainer.train()
+        trainer.save_model(lora_output)
+
+        config = PeftConfig.from_pretrained(lora_output)
+        model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        merged_model = model.merge_and_unload()
+        merged_model.save_pretrained(full_output)
+        self.tokenizer.save_pretrained(full_output)
+        print("*" * 10, ": Model is saved!!!")
+
+class LlamaTrainer(BaseTrainer):
+    def load_model(self):
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            self.base_model,
+            quantization_config=bnb_config,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+            trust_remote_code=True,
+            # cache_dir=cache_folder
+        )
+        model.config.use_cache = False
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+        return model
+
+class MistralTrainer(BaseTrainer):
+    def load_model(self):
+        return LlamaTrainer.load_model(self)
+
+class PhiTrainer(BaseTrainer):
+    def load_model(self):
+        return LlamaTrainer.load_model(self)
+
+class ZephyrTrainer(BaseTrainer):
+    def load_model(self):
+        return LlamaTrainer.load_model(self)
+
+class FlanT5Trainer(BaseTrainer):
+    def load_tokenizer(self):
+        tokenizer = T5Tokenizer.from_pretrained(self.base_model)
+        tokenizer.padding_side = 'right'
+        return tokenizer
+
+    def load_model(self):
+        model = T5ForConditionalGeneration.from_pretrained(self.base_model)
+        return model
+
+    def preprocess_function(self, examples):
+        prefix = "Please answer this question: "
+        inputs = [prefix + doc for doc in examples["question"]]
+        model_inputs = self.tokenizer(inputs, max_length=1024, truncation=True)
+        labels = self.tokenizer(text_target=examples["answer"], max_length=1024, truncation=True)
+        model_inputs["labels"] = labels["input_ids"]
+        return model_inputs
+
+def get_trainer(model_name):
+    model_map = {
+        "Llama": ("NousResearch/Meta-Llama-3-8B", LlamaTrainer),
+        "Mistral": ("unsloth/mistral-7b-instruct-v0.3", MistralTrainer),
+        "Phi": ("microsoft/Phi-3-mini-4k-instruct", PhiTrainer),
+        "Zephyr": ("HuggingFaceH4/zephyr-7b-beta", ZephyrTrainer),
+        "Flant5": ("google/flan-t5-base", FlanT5Trainer),
+    }
+    
+    base_model, trainer_class = model_map[model_name]
+    if not base_model or not trainer_class:
+        raise ValueError(f"Unsupported model: {model_name}")
+    
+    return trainer_class(model_name, base_model)

fine_tune_file/phi_finetune.py

@@ -0,0 +1,135 @@
+# %% Saved
+import os
+import torch
+from datasets import load_dataset, Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+import transformers
+# from peft import AutoPeftModelForCausalLM
+from transformers import GenerationConfig
+from pynvml import *
+import glob
+class phi_trainer:
+    def formatted_text(self,x,tokenizer):
+            temp = [
+            # {"role": "system", "content": "Answer as a medical assistant. Respond concisely."},
+            {"role": "user", "content": """You are a helpful chatbot, help users by answering their queries.
+            Question: """ + x["question"]},
+            {"role": "assistant", "content": x["answer"]}
+            ]
+            return tokenizer.apply_chat_template(temp, add_generation_prompt=False, tokenize=False)
+    def phi_finetune(self,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout):
+        base_model = "microsoft/Phi-3-mini-4k-instruct"
+        from datetime import datetime
+        lora_output = f'models/{quantization}_Phi_lora_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        full_output = f'models/{quantization}_Phi_full_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        DEVICE = 'cuda'
+        tokenizer = AutoTokenizer.from_pretrained(base_model)
+        tokenizer.padding_side = 'right'
+        ### read csv with Prompt, Answer pair 
+        data_location = r"data/finetune_data.xlsx" ## replace here
+        data_df=pd.read_excel( data_location )
+        ### set formatting
+        data_df["text"] = data_df[["question", "answer"]].apply(lambda x: self.formatted_text(x,tokenizer), axis=1) ## replace Prompt and Answer if collected dataset has different column names
+        print(data_df.iloc[0])
+        dataset = Dataset.from_pandas(data_df)
+        # set quantization config
+        bnb_config = BitsAndBytesConfig(  
+                load_in_8bit= True,
+            )
+        if quantization == 4:
+            print("*"*10,": 4 bit quantization")
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit= True,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",  
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+        model = AutoModelForCausalLM.from_pretrained(
+                base_model,
+                quantization_config=bnb_config,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True,
+        )
+        model.config.use_cache = False # silence the warnings
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+
+        tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+  
+
+        # Set PEFT adapter config (16:32)
+        from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        # target modules are currently selected for zephyr base model
+        config = LoraConfig(
+            r= lora_r if lora_r else 16,
+            lora_alpha= lora_alpha if lora_alpha else 32,
+            target_modules=["q_proj", "v_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],   # target all the linear layers for full finetuning
+            lora_dropout= lora_dropout if lora_dropout else 0.05,
+            bias="none",
+            task_type="CAUSAL_LM")
+
+        # stabilize output layer and layernorms
+        model = prepare_model_for_kbit_training(model)
+        # Set PEFT adapter on model (Last step)
+        model = get_peft_model(model, config)
+
+        # Set Hyperparameters
+        MAXLEN=512
+        BATCH_SIZE = batch_size if batch_size else 4
+        GRAD_ACC = gradient_accumulation if gradient_accumulation else 4
+        OPTIMIZER ='paged_adamw_8bit' # save memory
+        LR=lr if lr else 5e-06                       # slightly smaller than pretraining lr | and close to LoRA standard
+
+        training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,
+                                                        gradient_accumulation_steps=GRAD_ACC,
+                                                        optim=OPTIMIZER,
+                                                        learning_rate=LR,
+                                                        fp16=True,            # consider compatibility when using bf16
+                                                        logging_steps=10,
+                                                        num_train_epochs = epoch if epoch else 2,
+                                                        output_dir=lora_output,
+                                                        remove_unused_columns=True,
+                                                        )
+
+        # Set collator
+        data_collator = transformers.DataCollatorForLanguageModeling(tokenizer,mlm=False)
+
+        # Setup trainer
+        trainer = SFTTrainer(model=model,
+                                    train_dataset=dataset,
+                                    data_collator=data_collator,
+                                    args=training_config,
+                                    dataset_text_field="text",
+                                    #    callbacks=[early_stop], need to learn, lora easily overfits
+                                    )
+
+        trainer.train()
+        print("*"*10,": Finetune ended!!!!")
+        trainer.save_model(lora_output)
+
+        # Get peft config
+        from peft import PeftConfig
+        config = PeftConfig.from_pretrained(lora_output)
+
+        model = transformers.AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path,trust_remote_code=True)
+
+        # tokenizer = transformers.AutoTokenizer.from_pretrained(base_model)
+
+        # Load the Lora model
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        # Get tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+        merged_model = model.merge_and_unload()
+
+        merged_model.save_pretrained(full_output)
+        tokenizer.save_pretrained(full_output)
+        print("*"*10,": Model is saved!!!")

fine_tune_file/zepyhr_finetune.py

@@ -0,0 +1,136 @@
+#code changed
+import os
+import torch
+from datasets import load_dataset, Dataset
+import pandas as pd
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+import transformers
+# from peft import AutoPeftModelForCausalLM
+from transformers import GenerationConfig
+from pynvml import *
+import glob
+class zephyr_trainer:
+    def formatted_text(self,x,tokenizer):
+            temp = [
+            # {"role": "system", "content": "Answer as a medical assistant. Respond concisely."},
+            {"role": "user", "content": """You are a helpful chatbot, help users by answering their queries.
+            Question: """ + x["question"]},
+            {"role": "assistant", "content": x["answer"]}
+            ]
+            return tokenizer.apply_chat_template(temp, add_generation_prompt=False, tokenize=False)
+    def zepyhr_model(self,lr,epoch,batch_size,gradient_accumulation,quantization,lora_r,lora_alpha,lora_dropout):
+        base_model = 'HuggingFaceH4/zephyr-7b-beta'
+        from datetime import datetime
+        lora_output = f'models/{quantization}_Zepyhr_lora_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        full_output = f'models/{quantization}_Zepyhr_full_{datetime.now().strftime("%Y_%m_%d_%H_%M_%S")}'
+        DEVICE = 'cuda'
+        tokenizer = AutoTokenizer.from_pretrained(base_model)
+        tokenizer.padding_side = 'right'
+        ### read csv with Prompt, Answer pair 
+        data_location = r"data/finetune_data.xlsx" ## replace here
+        data_df=pd.read_excel( data_location )
+        ### set formatting
+        data_df["text"] = data_df[["question", "answer"]].apply(lambda x: self.formatted_text(x,tokenizer), axis=1) ## replace Prompt and Answer if collected dataset has different column names
+        print(data_df.iloc[0])
+        dataset = Dataset.from_pandas(data_df)
+
+
+        # set quantization config
+        bnb_config = BitsAndBytesConfig(  
+                load_in_8bit= True,
+            )
+        if quantization == 4:
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit= True,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",  
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+        model = AutoModelForCausalLM.from_pretrained(
+                base_model,
+                quantization_config=bnb_config,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True,
+        )
+        model.config.use_cache = False # silence the warnings
+        model.config.pretraining_tp = 1
+        model.gradient_checkpointing_enable()
+
+        tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+        tokenizer.padding_side = 'right'
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.add_eos_token = True
+        tokenizer.add_bos_token, tokenizer.add_eos_token
+
+        # Set PEFT adapter config (16:32)
+        from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        # target modules are currently selected for zephyr base model
+        config = LoraConfig(
+            r= lora_r if lora_r else 16,
+            lora_alpha= lora_alpha if lora_alpha else 32,
+            target_modules=["q_proj", "v_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],   # target all the linear layers for full finetuning
+            lora_dropout= lora_dropout if lora_dropout else 0.05,
+            bias="none",
+            task_type="CAUSAL_LM")
+
+        # stabilize output layer and layernorms
+        model = prepare_model_for_kbit_training(model)
+        # Set PEFT adapter on model (Last step)
+        model = get_peft_model(model, config)
+
+        # Set Hyperparameters
+        MAXLEN=512
+        BATCH_SIZE = batch_size if batch_size else 4
+        GRAD_ACC = gradient_accumulation if gradient_accumulation else 4
+        OPTIMIZER ='paged_adamw_8bit' # save memory
+        LR=lr if lr else 5e-06                       # slightly smaller than pretraining lr | and close to LoRA standard
+
+
+        training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,
+                                                        gradient_accumulation_steps=GRAD_ACC,
+                                                        optim=OPTIMIZER,
+                                                        learning_rate=LR,
+                                                        fp16=True,            # consider compatibility when using bf16
+                                                        logging_steps=10,
+                                                        num_train_epochs = epoch if epoch else 2,
+                                                        output_dir=lora_output,
+                                                        remove_unused_columns=True,
+                                                        )
+
+        # Set collator
+        data_collator = transformers.DataCollatorForLanguageModeling(tokenizer,mlm=False)
+
+        # Setup trainer
+        trainer = SFTTrainer(model=model,
+                                    train_dataset=dataset,
+                                    data_collator=data_collator,
+                                    args=training_config,
+                                    dataset_text_field="text",
+                                    #    callbacks=[early_stop], need to learn, lora easily overfits
+                                    )
+
+        trainer.train()
+        print("*"*10,": Finetune ended!!!!")
+        trainer.save_model(lora_output)
+
+        # Get peft config
+        from peft import PeftConfig
+        config = PeftConfig.from_pretrained(lora_output)
+
+        model = transformers.AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+
+        # Load the Lora model
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, lora_output)
+
+        # Get tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+        merged_model = model.merge_and_unload()
+
+        merged_model.save_pretrained(full_output)
+        tokenizer.save_pretrained(full_output)
+        print("*"*10,": Model is saved!!!")

inference.py

@@ -0,0 +1,81 @@
+import os
+import torch
+import pandas as pd
+import transformers
+from pynvml import *
+import torch
+from langchain import hub
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from model_ret import load_model_and_pipeline
+from create_retriever import retriever_chroma
+
+# Model chain class
+class model_chain:
+    model_name = ""
+
+    def __init__(self,
+                 model_name_local,
+                 model_name_online="Llama",
+                 use_online=True,
+                 embedding_name="BAAI/bge-base-en-v1.5",
+                 splitter_type_dropdown="character",
+                 chunk_size_slider=512,
+                 chunk_overlap_slider=30,
+                 separator_textbox="\n",
+                 max_tokens_slider=2048) -> None:
+        if os.path.exists(f"models//{model_name_local}") and len(os.listdir(f"models//{model_name_local}")):
+            import gradio as gr
+            gr.Info("Model *()* from online!!")
+            self.model_name = model_name_local
+        else:
+            self.model_name = model_name_online
+
+        self.tokenizer, self.model, self.llm = load_model_and_pipeline(self.model_name)
+        # Creating the retriever
+        # self.retriever = ensemble_retriever(embedding_name,
+        #                                     splitter_type=splitter_type_dropdown,
+        #                                     chunk_size=chunk_size_slider,
+        #                                     chunk_overlap=chunk_overlap_slider,
+        #                                     separator=separator_textbox,
+        #                                     max_tokens=max_tokens_slider)
+        self.retriever = retriever_chroma(False, embedding_name, splitter_type_dropdown,
+                                          chunk_size_slider, chunk_size_slider,
+                                          separator_textbox, max_tokens_slider)
+
+        # Defining the RAG chain
+        prompt = hub.pull("rlm/rag-prompt")
+        self.rag_chain = (
+            {"context": self.retriever | self.format_docs, "question": RunnablePassthrough()}
+            | prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+    # Helper function to format documents
+    def format_docs(self, docs):
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    # Retrieve RAG chain
+    def rag_chain_ret(self):
+        return self.rag_chain
+
+    # Answer retrieval function
+    def ans_ret(self, inp):
+        if self.model_name == 'Flant5':
+            my_question = "What is KUET?"
+            data = self.retriever.invoke(inp)
+            context = ""
+            for x in data[:2]:
+                context += (x.page_content) + "\n"
+            inputs = f"""Please answer to this question using this context:\n{context}\n{my_question}"""
+            inputs = self.tokenizer(inputs, return_tensors="pt")
+            outputs = self.model.generate(**inputs)
+            answer = self.tokenizer.decode(outputs[0])
+            from textwrap import fill
+            ans = fill(answer, width=100)
+            return ans
+
+        ans = self.rag_chain.invoke(inp)
+        ans = ans.split("Answer:")[1]
+        return ans

model_ret.py

@@ -0,0 +1,92 @@
+import os
+import torch
+from time import time
+from torch import cuda, bfloat16
+from langchain import HuggingFacePipeline
+from transformers import (AutoTokenizer, AutoModelForCausalLM, T5Tokenizer, AutoConfig,
+                          T5ForConditionalGeneration, pipeline, BitsAndBytesConfig)
+
+def load_model_and_pipeline(model_id, temperature=0):
+    device = f'cuda:{cuda.current_device()}' if cuda.is_available() else 'cpu'
+
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type='nf4',
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_compute_dtype=bfloat16
+    )
+
+    time_1 = time()
+    model_config = AutoConfig.from_pretrained(
+        model_id,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=True)
+    model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    trust_remote_code=True,
+    config=model_config,
+    quantization_config=bnb_config,
+    device_map='auto',
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    time_2 = time()
+    print(f"Prepare model, tokenizer: {round(time_2-time_1, 3)} sec.")
+    time_1 = time()
+
+    pipe = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tokenizer,
+            dtype=torch.float16,
+            device_map="auto",
+            max_new_tokens=512,
+            do_sample=True,
+            top_k=30,
+            num_return_sequences=1,
+            eos_token_id=tokenizer.eos_token_id)
+    time_2 = time()
+    print(f"Prepare pipeline: {round(time_2-time_1, 3)} sec.")
+
+    llm = HuggingFacePipeline(pipeline=pipe, model_kwargs={'temperature': temperature})
+    return tokenizer, model, llm
+
+import pandas as pd
+from datasets import Dataset
+
+def calculate_rag_metrics(model_ques_ans_gen, llm_model, embedding_model="BAAI/bge-base-en-v1.5"):
+    # Create a dictionary from the model_ques_ans_gen list
+    from ragas import evaluate
+    from ragas.metrics import faithfulness, answer_correctness,answer_similarity,answer_relevancy,context_recall, context_precision
+    # context = {'contexts':'NA'}
+    # print([item['question'] for item in model_ques_ans_gen])
+    data_samples = {
+        'question': [item['question'] for item in model_ques_ans_gen],
+        'answer': [item['answer'] for item in model_ques_ans_gen],
+        'contexts': [[''] for item in model_ques_ans_gen],
+        'reference': [item['ground_truths'] for item in model_ques_ans_gen]
+    }
+
+    # Convert the dictionary to a pandas DataFrame
+    rag_df = pd.DataFrame(data_samples)
+
+    # Convert the DataFrame to a HuggingFace Dataset
+    rag_eval_dataset = Dataset.from_pandas(rag_df)
+
+    # Define the list of metrics to calculate
+    metrics = [
+        answer_correctness, answer_similarity,
+        answer_relevancy, faithfulness,
+        context_recall, context_precision
+    ]
+
+    # Perform the evaluation using the provided LLM and embedding models
+    result = evaluate(
+        rag_eval_dataset,
+        metrics=metrics,
+        llm=llm_model,
+        embeddings=embedding_model
+    )
+    # result.to_pandas()
+    return result.to_pandas()

model_ret.py.old

@@ -0,0 +1,179 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from langchain import HuggingFacePipeline
+from transformers import pipeline
+import transformers
+import torch
+from transformers import T5Tokenizer
+from transformers import T5ForConditionalGeneration
+def zepyhr_model(model_info,quanization):
+    path=f"models/{model_info}"
+    tokenizer = AutoTokenizer.from_pretrained(path,
+                                            use_auth_token=True,)
+
+    if quanization=="8":
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                load_in_8bit=True,                                        
+                                                )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                 load_in_4bit=True
+                                                )
+
+    pipe = pipeline("text-generation",
+                    model=model,
+                    tokenizer= tokenizer,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto",
+                    max_new_tokens = 512,
+                    do_sample=True,
+                    top_k=30,
+                    num_return_sequences=1,
+                    eos_token_id=tokenizer.eos_token_id
+                    )
+        
+    llm = HuggingFacePipeline(pipeline = pipe, model_kwargs = {'temperature':0})
+    return llm
+def llama_model(model_info,quanization):
+    path=f"models/{model_info}"
+    tokenizer = AutoTokenizer.from_pretrained(path,
+                                            use_auth_token=True,)
+    
+    if quanization=="8":
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                load_in_8bit=True,
+                                                )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                 load_in_4bit=True
+                                                )
+    pipe = pipeline("text-generation",
+                    model=model,
+                    tokenizer= tokenizer,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto",
+                    max_new_tokens = 512,
+                    do_sample=True,
+                    top_k=30,
+                    num_return_sequences=1,
+                    eos_token_id=tokenizer.eos_token_id
+                    )
+    llm = HuggingFacePipeline(pipeline = pipe, model_kwargs = {'temperature':0})
+    return llm
+
+def mistral_model(model_info,quanization):
+    path=f"models/{model_info}"
+    tokenizer = AutoTokenizer.from_pretrained(path,
+                                            use_auth_token=True,)
+
+    if quanization=="8":
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                load_in_8bit=True,
+                                                )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                 load_in_4bit=True
+                                                )
+
+
+
+    pipe = pipeline("text-generation",
+                    model=model,
+                    tokenizer= tokenizer,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto",
+                    max_new_tokens = 512,
+                    do_sample=True,
+                    top_k=30,
+                    num_return_sequences=1,
+                    eos_token_id=tokenizer.eos_token_id
+                    )
+        
+    llm = HuggingFacePipeline(pipeline = pipe, model_kwargs = {'temperature':0})
+    return llm
+
+def phi_model(model_info,quanization):
+    path=f"models/{model_info}"
+    tokenizer = AutoTokenizer.from_pretrained(path,
+                                            use_auth_token=True,)
+
+    if quanization=="8":
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                load_in_8bit=True,
+                                                trust_remote_code=True
+                                                )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(path,
+                                                device_map='auto',
+                                                torch_dtype=torch.float16,
+                                                use_auth_token=True,
+                                                 load_in_4bit=True,
+                                                 trust_remote_code=True
+                                                )
+
+
+
+    pipe = pipeline("text-generation",
+                    model=model,
+                    tokenizer= tokenizer,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto",
+                    max_new_tokens = 512,
+                    do_sample=True,
+                    top_k=30,
+                    num_return_sequences=1,
+                    eos_token_id=tokenizer.eos_token_id
+                    )
+        
+    llm = HuggingFacePipeline(pipeline = pipe, model_kwargs = {'temperature':0})
+    return llm
+
+def flant5_model(model_info):
+    path=f"models/{model_info}"
+    model = T5ForConditionalGeneration.from_pretrained(path)
+    MODEL_NAME = "google/flan-t5-base"
+    tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)  
+    pipe = pipeline("text-generation",
+                    model=model,
+                    tokenizer= tokenizer,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto",
+                    max_new_tokens = 512,
+                    do_sample=True,
+                    top_k=30,
+                    num_return_sequences=1,
+                    eos_token_id=tokenizer.eos_token_id
+                    )
+        
+    llm = HuggingFacePipeline(pipeline = pipe, model_kwargs = {'temperature':0})
+    return tokenizer,model,llm
+
+ # model = AutoModelForCausalLM.from_pretrained(
+    #     path,
+    #     # quantization_config=bnb_config,
+    #     device_map="auto",
+    #     trust_remote_code=True,
+    #     attn_implementation="flash_attention_2",
+    #     torch_dtype=torch.bfloat16,
+
+    # )

models/.gitignore

@@ -0,0 +1,3 @@
+# ignore all files except .gitignore :
+*
+!.gitignore

params.txt

@@ -0,0 +1 @@
+{"model_name": "M1", "embedding_name": "BAAI/bge-base-en-v1.5", "splitter_type_dropdown": "character", "chunk_size_slider": 500, "chunk_overlap_slider": 30, "separator_textbox": "\n", "max_tokens_slider": 1000}

requirements.txt

@@ -0,0 +1,29 @@
+gradio==4.44
+langchain==0.3.27
+langchain-community==0.3.31
+llama-index
+llama-index-core
+fastapi==0.112.4
+transformers==4.57.0
+pynvml==12.0.0
+datasets==4.0.0
+openpyxl==3.1.5
+trl==0.25.1
+peft==0.17.1
+bitsandbytes==0.48.2
+docx2txt==0.9
+torch
+torchvision
+torchaudio
+jupyter==1.1.1
+langchainhub==0.1.21
+sentence-transformers==5.1.1
+faiss-gpu-cu12==1.13.0
+accelerate==1.10.1
+ninja==1.13.0
+wandb==0.22.2
+docx==0.2.4
+chromadb==1.3.5
+pypdf==6.4.0
+ragas==0.3.9
+# flash-attn --no-build-isolation

testing.ipynb

@@ -0,0 +1,712 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def score_report_bar():\n",
+    "    path=r\"C:\\Users\\Inception\\Desktop\\LLM-based-QA-chatbot-builder\\UI\\score_report\"\n",
+    "    import os\n",
+    "    import math\n",
+    "    dat=[]\n",
+    "    for x in os.listdir(path):\n",
+    "        wh=[]\n",
+    "        flag=0\n",
+    "        for x2 in x:\n",
+    "            if x2>='a' and x2<='z':\n",
+    "                flag=1\n",
+    "                wh.append(x2)\n",
+    "            elif flag==1:\n",
+    "                wh.append(\" \")\n",
+    "        wh=''.join(wh)\n",
+    "        wh=wh.replace(\"model ans\",\"\")\n",
+    "        wh=wh.replace(\"finetuned\",\"\")\n",
+    "        wh=wh.replace(\"  \",\" \")\n",
+    "        wh=wh.replace(\"xlsx\",\"\")\n",
+    "        df_temp=pd.read_excel(os.path.join(path,x))\n",
+    "        rating=sum(df_temp[\"rating\"])/len(df_temp)\n",
+    "        dat.append({\n",
+    "            \"Model Name\":wh,\n",
+    "            \"Average Rating\":rating\n",
+    "        })\n",
+    "    temp=pd.DataFrame(dat)\n",
+    "    return temp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n",
+    "import pandas as pd\n",
+    "\n",
+    "def bar_plot_fn():\n",
+    "    temp=score_report_bar()\n",
+    "    return gr.BarPlot(\n",
+    "            temp,\n",
+    "            x=\"Model Name\",\n",
+    "            y=\"Average Rating\",\n",
+    "            x_title=\"Model name\",\n",
+    "            y_title=\"Average Rating\",\n",
+    "            title=\"Simple Bar Plot with made up data\",\n",
+    "            tooltip=[\"Model Name\", \"Average Rating\"],\n",
+    "            y_lim=[1, 5],\n",
+    "            width=200,\n",
+    "            height=1000\n",
+    "        )\n",
+    "with gr.Blocks() as bar_plot:\n",
+    "    with gr.Row():\n",
+    "        btn=gr.Button(\"test\")\n",
+    "    with gr.Row():\n",
+    "        plot = gr.BarPlot()\n",
+    "    btn.click(bar_plot_fn, None, outputs=plot)\n",
+    "\n",
+    "bar_plot.launch()\t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def parse_data(link,num=None):    \n",
+    "    from bs4 import BeautifulSoup\n",
+    "    import requests\n",
+    "    import re\n",
+    "    from docx import Document       \n",
+    "    from langchain_community.document_loaders import WebBaseLoader\n",
+    "    s=set()\n",
+    "    import time\n",
+    "    start_time = time.time()\n",
+    "    duration = 5\n",
+    "    def get_links(url):\n",
+    "        response = requests.get(url)\n",
+    "        data = response.text\n",
+    "        soup = BeautifulSoup(data, 'lxml')\n",
+    "\n",
+    "        links = []\n",
+    "        for link in soup.find_all('a'):\n",
+    "            link_url = link.get('href')\n",
+    "            if link_url is not None and link_url.startswith('http'):\n",
+    "                s.add(link_url)\n",
+    "                links.append(link_url)\n",
+    "        \n",
+    "        return links\n",
+    "    # def write_to_file(links):\n",
+    "    #     with open('data.txt', 'a') as f:\n",
+    "    #         f.writelines(links)\n",
+    "    def get_all_links(url):\n",
+    "            for link in get_links(url):\n",
+    "                if (time.time() - start_time) >= duration:\n",
+    "                    return\n",
+    "                get_all_links(link)\n",
+    "\n",
+    "    def data_ret2(link):\n",
+    "        loader = WebBaseLoader(f\"{link}\")\n",
+    "        data = loader.load()\n",
+    "        return data[0].page_content\n",
+    "    # link = 'https://kuet.ac.bd'\n",
+    "    s.add(link)\n",
+    "    get_all_links(link)\n",
+    "    li=list(s)\n",
+    "    all_data=[]\n",
+    "    if num==None:\n",
+    "        num=len(li)\n",
+    "    for idx,x in enumerate(li):\n",
+    "        if idx==num:\n",
+    "            break\n",
+    "        try:\n",
+    "            print(\"Link: \",x)\n",
+    "            all_data.append(data_ret2(x))\n",
+    "        except:\n",
+    "            print(\"pass\")\n",
+    "            continue\n",
+    "    all_data2 = re.sub(r'\\n+', '\\n\\n', \"\\n\".join(all_data))\n",
+    "    document = Document()\n",
+    "    document.add_paragraph(all_data2)\n",
+    "    document.save('docx_file.docx')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Link:  http://library.kuet.ac.bd/\n",
+      "Link:  http://kuet.portal.gov.bd/site/page/84728d9d-6059-41c4-940c-0f75eacf7d4c/Quarterly--semiannual-monitoring--evaluation-reports\n",
+      "Link:  https://kuet.ac.bd/index.php/welcome/shownews/943\n"
+     ]
+    }
+   ],
+   "source": [
+    "parse_data(\"https://kuet.ac.bd\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_all=[]\n",
+    "for x in os.listdir(\"save_ques_ans\"):\n",
+    "    path=os.path.join(\"save_ques_ans\",x)\n",
+    "    df_all.append(pd.read_excel(path))\n",
+    "df=pd.concat(df_all,axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "doc=[]\n",
+    "for x in s:\n",
+    "    print(x)\n",
+    "    doc.extend(data_ret2(x))\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "doc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "if model_name==\"Mistral\":\n",
+    "    path=\"models/full_KUET_LLM_mistral\"\n",
+    "elif model_name==\"Zepyhr\":\n",
+    "    path=\"models/full_KUET_LLM_zepyhr\"\n",
+    "elif model_name==\"Llama2\":\n",
+    "    path=\"models/full_KUET_LLM_llama\" \n",
+    "tokenizer = AutoTokenizer.from_pretrained(path)\n",
+    "model = AutoModelForCausalLM.from_pretrained(path,\n",
+    "                                                device_map='auto',\n",
+    "                                                torch_dtype=torch.float16,\n",
+    "                                                use_auth_token=True,\n",
+    "                                                load_in_8bit=True,\n",
+    "                                                #  load_in_4bit=True\n",
+    "                                                )\n",
+    "model.push_to_hub(repo_id=f\"My_model_{model_name}\",token=hf)\n",
+    "tokenizer.push_to_hub(repo_id=f\"My_model_{model_name}\",token=hf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Merge all the evaluation loss lists\n",
+    "eval_loss_lists = [\n",
+    "    [\n",
+    "        0.07517127692699432,\n",
+    "        0.07137121260166168,\n",
+    "        0.06598775833845139,\n",
+    "        0.0005441228277049959,\n",
+    "        0.0002996980620082468,\n",
+    "        0.00021371280308812857,\n",
+    "        0.00028233605553396046,\n",
+    "        9.069988300325349e-05,\n",
+    "        7.004399230936542e-05,\n",
+    "        9.137028973782435e-05,\n",
+    "        5.340397547115572e-05,\n",
+    "        5.0301870942348614e-05\n",
+    "    ],\n",
+    "    [\n",
+    "        1.597152731847018e-05,\n",
+    "        1.162805529020261e-05,\n",
+    "        9.043936188390944e-06,\n",
+    "        1.379685454594437e-05,\n",
+    "        5.367660833144328e-06,\n",
+    "        4.6886875679774676e-06,\n",
+    "        4.490133960644016e-06,\n",
+    "        6.136821866675746e-06,\n",
+    "        3.3243470625166083e-06,\n",
+    "        2.348009729757905e-06,\n",
+    "        2.1804094103572425e-06,\n",
+    "        1.958705070137512e-06\n",
+    "    ],\n",
+    "    [\n",
+    "        3.93469099435606e-06,\n",
+    "        1.65619246672577e-06,\n",
+    "        1.1269650030953926e-06,\n",
+    "        8.881219173417776e-07,\n",
+    "        1.3077693665763945e-06,\n",
+    "        7.212336186057655e-07,\n",
+    "        6.988730092416517e-07,\n",
+    "        5.00343162457284e-07,\n",
+    "        4.1343139400851214e-07,\n",
+    "        5.06081335061026e-07,\n",
+    "        7.039822662591178e-07,\n",
+    "        5.087575800644117e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        5.1233128033345565e-06,\n",
+    "        1.3323343637239304e-06,\n",
+    "        1.1789074960688595e-06,\n",
+    "        1.0221098136753426e-06,\n",
+    "        1.4271246300268103e-06,\n",
+    "        1.0917949566646712e-06,\n",
+    "        1.8720394336924073e-06,\n",
+    "        0.00015229727432597429,\n",
+    "        0.00016713247168809175,\n",
+    "        7.280236604856327e-05,\n",
+    "        5.6143608162528835e-06,\n",
+    "        1.2813707144232467e-06\n",
+    "    ],\n",
+    "    [\n",
+    "        1.7742066802384215e-06,\n",
+    "        3.1642618978366954e-06,\n",
+    "        2.774180939013604e-05,\n",
+    "        7.504659606638597e-06,\n",
+    "        1.0794157105920021e-06,\n",
+    "        8.346623303623346e-07,\n",
+    "        1.572396286064759e-06,\n",
+    "        4.874376031693828e-07,\n",
+    "        6.269995651564386e-07,\n",
+    "        5.949763703938515e-07,\n",
+    "        5.836409968651424e-07,\n",
+    "        5.382337917581026e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        1.3506955838238355e-05,\n",
+    "        2.3305697141040582e-06,\n",
+    "        2.193627324231784e-06,\n",
+    "        3.027681714229402e-07,\n",
+    "        4.6904440864636854e-07,\n",
+    "        4.6231170358623785e-07,\n",
+    "        2.520739883493661e-07,\n",
+    "        2.040175957063184e-07,\n",
+    "        1.8624521658239246e-07,\n",
+    "        4.635896289073571e-07,\n",
+    "        2.6239982275910734e-07,\n",
+    "        2.4372931761718064e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        5.271021564112743e-06,\n",
+    "        3.550181190803414e-06,\n",
+    "        2.5201459266099846e-06,\n",
+    "        2.8312820177234244e-06,\n",
+    "        1.4717104477313114e-06,\n",
+    "        2.2729768716089893e-06,\n",
+    "        1.030095177156909e-06,\n",
+    "        1.0983015954479924e-06,\n",
+    "        8.350090752173855e-07,\n",
+    "        4.235817687003873e-05,\n",
+    "        0.00017692078836262226,\n",
+    "        5.840817902935669e-05\n",
+    "    ],\n",
+    "    [\n",
+    "        1.2606010386662092e-06,\n",
+    "        7.131714937713696e-06,\n",
+    "        8.305702976940665e-06,\n",
+    "        6.520267561427318e-07,\n",
+    "        1.0400606953453462e-07,\n",
+    "        1.2373440938517888e-07,\n",
+    "        1.2282114880690642e-07,\n",
+    "        1.4778217405364558e-07,\n",
+    "        1.125305075788674e-07,\n",
+    "        4.522570762333089e-08,\n",
+    "        2.48692485911306e-05,\n",
+    "        5.199101238417825e-08\n",
+    "    ],\n",
+    "    [\n",
+    "        1.329818132944638e-06,\n",
+    "        9.433363743482914e-07,\n",
+    "        8.183121735783061e-07,\n",
+    "        1.0200094493484357e-06,\n",
+    "        7.936826023069443e-07,\n",
+    "        7.760887115182413e-07,\n",
+    "        2.45380675778506e-07,\n",
+    "        0.0001625938602956012,\n",
+    "        1.0732967581361663e-07,\n",
+    "        1.0528655138841714e-06,\n",
+    "        9.632424280425766e-07,\n",
+    "        7.961476740092621e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        4.5500939904741244e-07,\n",
+    "        7.533798793701862e-07,\n",
+    "        4.7130234293035755e-07,\n",
+    "        7.465733347089554e-07,\n",
+    "        9.549980859446805e-07,\n",
+    "        6.432795771615929e-07,\n",
+    "        6.765155831089942e-07,\n",
+    "        6.765155831089942e-07,\n",
+    "        5.451398692457587e-07,\n",
+    "        4.994994355911331e-07,\n",
+    "        5.466189918479358e-07,\n",
+    "        4.268927682460344e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        2.63293713942403e-07,\n",
+    "        3.551216138930613e-07,\n",
+    "        2.3628319922863739e-07,\n",
+    "        9.180489541904535e-07,\n",
+    "        1.1080908279836876e-06,\n",
+    "        6.248191084523569e-07,\n",
+    "        8.346111712853599e-07,\n",
+    "        5.276984325064404e-07,\n",
+    "        3.681239491015731e-07,\n",
+    "        1.8970614235058747e-07,\n",
+    "        3.114948299298703e-07,\n",
+    "        2.9696289516323304e-07\n",
+    "    ],\n",
+    "    # [\n",
+    "    #     2.38517332036281e-05,\n",
+    "    #     3.9089650272217114e-07,\n",
+    "    #     6.718229883517779e-08,\n",
+    "    #     1.4773820566915674e-07,\n",
+    "    #     5.8338137876035034e-08,\n",
+    "    #     3.57102081238736e-08,\n",
+    "    #     2.2298079329630127e-06,\n",
+    "    #     3.583775196602801e-07,\n",
+    "    #     9.418199908850511e-08,\n",
+    "    #     1.338206288892252e-06,\n",
+    "    #     3.194011810592201e-07,\n",
+    "    #     2.245769792352803e-07\n",
+    "    # ],\n",
+    "    [\n",
+    "        2.3522443370893598e-06,\n",
+    "        1.1711344996001571e-06,\n",
+    "        1.1321773172312533e-06,\n",
+    "        5.756968448622501e-07,\n",
+    "        4.4675923049908306e-07,\n",
+    "        4.365276993212319e-07,\n",
+    "        5.525398591998965e-07,\n",
+    "        4.404951710057503e-07,\n",
+    "        4.4630780848819995e-07,\n",
+    "        4.764913796861947e-07,\n",
+    "        4.10373701242861e-07,\n",
+    "        3.762708331578324e-07\n",
+    "    ],\n",
+    "    [\n",
+    "        2.1882451051169483e-07,\n",
+    "        5.146034354197582e-08,\n",
+    "        3.1587944704369875e-08,\n",
+    "        1.122993165125763e-08,\n",
+    "        8.033423704034703e-09,\n",
+    "        7.330823059703562e-09,\n",
+    "        2.0332389993882316e-08,\n",
+    "        1.718821529550496e-08,\n",
+    "        1.5028433608677005e-08,\n",
+    "        3.9828059072988253e-08,\n",
+    "        2.8266715190738978e-08,\n",
+    "        2.1497044144780375e-08\n",
+    "    ],\n",
+    "    [\n",
+    "        1.4871952558337398e-08,\n",
+    "        1.2490186662716951e-08,\n",
+    "        1.213749456496771e-08,\n",
+    "        1.159435214503901e-08,\n",
+    "        1.1296255486570317e-08,\n",
+    "        1.1153668211250078e-08,\n",
+    "        1.3103758966792611e-08,\n",
+    "        1.2461796927709656e-08,\n",
+    "        1.2030940688134706e-08,\n",
+    "        1.306745200935211e-08,\n",
+    "        1.029541429886649e-08,\n",
+    "        9.854548288501519e-09\n",
+    "    ]\n",
+    "]\n",
+    "\n",
+    "# Flatten the nested list\n",
+    "merged_list = [item for sublist in eval_loss_lists for item in sublist]\n",
+    "\n",
+    "# Number of epochs\n",
+    "epochs = 20\n",
+    "\n",
+    "# Plotting the evaluation loss curve\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(range(1, len(merged_list) + 1), merged_list, marker='o')\n",
+    "plt.title('Evaluation Loss Curve')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Evaluation Loss')\n",
+    "plt.xticks(range(1, len(merged_list) + 1, len(merged_list) // epochs))\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Given numbers\n",
+    "numbers = [\n",
+    "    9.069988300325349e-05,\n",
+    "    7.004399230936542e-05,\n",
+    "    9.137028973782435e-05,\n",
+    "    5.340397547115572e-05,\n",
+    "    5.0301870942348614e-05,\n",
+    "    9.043936188390944e-06,\n",
+    "    4.6886875679774676e-06,\n",
+    "    4.490133960644016e-06,\n",
+    "    6.136821866675746e-06,\n",
+    "    3.3243470625166083e-06,\n",
+    "    2.348009729757905e-06,\n",
+    "    2.1804094103572425e-06,\n",
+    "    1.958705070137512e-06,\n",
+    "    6.988730092416517e-07,\n",
+    "    5.00343162457284e-07,\n",
+    "    4.1343139400851214e-07,\n",
+    "    5.06081335061026e-07,\n",
+    "    7.039822662591178e-07,\n",
+    "    5.087575800644117e-07,\n",
+    "    2.0332389993882316e-08,\n",
+    "    1.718821529550496e-08,\n",
+    "    1.5028433608677005e-08,\n",
+    "    3.9828059072988253e-08,\n",
+    "    2.8266715190738978e-08,\n",
+    "    2.1497044144780375e-08,\n",
+    "    9.854548288501519e-09\n",
+    "]\n",
+    "\n",
+    "# Sorting the numbers in descending order\n",
+    "numbers.sort(reverse=True)\n",
+    "\n",
+    "# Selecting every 3rd number for plotting\n",
+    "selected_numbers = numbers[::3]\n",
+    "\n",
+    "# Creating x-axis values (epochs)\n",
+    "epochs = list(range(1, len(selected_numbers) + 1))\n",
+    "\n",
+    "# Plotting the curve\n",
+    "plt.plot(epochs, selected_numbers, marker='o', linestyle='-')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Evaluation Loss')\n",
+    "plt.title('Evaluation Loss vs Epochs')\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7862\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7862/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import time\n",
+    "def my_function(x, progress=gr.Progress()):\n",
+    "    progress(0, desc=\"Starting...\")\n",
+    "    time.sleep(1)\n",
+    "    for i in progress.tqdm(range(100)):\n",
+    "        time.sleep(0.1)\n",
+    "    return x\n",
+    "with gr.Blocks() as demo:\n",
+    "    a=gr.Textbox()\n",
+    "    b=gr.TextArea(\"tt\")\n",
+    "    btn=gr.Button(\"Test\")\n",
+    "    btn.click(my_function,a,b)\n",
+    "demo.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if self.quantization == '8':\n",
+    "            bnb_config = BitsAndBytesConfig(  \n",
+    "                load_in_8bit= True,\n",
+    "            )\n",
+    "elif self.quantization == '4':\n",
+    "            bnb_config = BitsAndBytesConfig(\n",
+    "                load_in_4bit= True,\n",
+    "                bnb_4bit_use_double_quant=True,\n",
+    "                bnb_4bit_quant_type=\"nf4\",  \n",
+    "                bnb_4bit_compute_dtype=torch.bfloat16\n",
+    "            )\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "                base_model,\n",
+    "                quantization_config=bnb_config,\n",
+    "                torch_dtype=torch.bfloat16,\n",
+    "                device_map=\"auto\",\n",
+    "                trust_remote_code=True,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = LoraConfig(\n",
+    "            r= lora_r if lora_r else 16,\n",
+    "            lora_alpha= lora_alpha if lora_alpha else 32,\n",
+    "            target_modules=[\"q_proj\", \"v_proj\",\"k_proj\",\"o_proj\",\"gate_proj\",\"up_proj\",\"down_proj\"], \n",
+    "            lora_dropout= lora_dropout if lora_dropout else 0.05,\n",
+    "            bias=\"none\",\n",
+    "            task_type=\"CAUSAL_LM\")\n",
+    "\n",
+    "training_config = transformers.TrainingArguments(per_device_train_batch_size=BATCH_SIZE,\n",
+    "                                                        gradient_accumulation_steps=GRAD_ACC,\n",
+    "                                                        optim=OPTIMIZER,\n",
+    "                                                        learning_rate=LR,\n",
+    "                                                        fp16=True,         \n",
+    "                                                        logging_steps=10,\n",
+    "                                                        num_train_epochs = epoch if epoch else 2,\n",
+    "                                                        output_dir=lora_output,\n",
+    "                                                        remove_unused_columns=True,\n",
+    "                                                        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lang",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

utils.py

@@ -0,0 +1,165 @@
+import pandas as pd
+import datetime
+import gradio as gr
+import os
+# It shows the demo data format in finetuning tab
+def move_to(move,model_ans):
+    df_temp=pd.read_excel(os.path.join("model_ans",str(model_ans)))
+    id_temp=int((df_temp.loc[move])['id'])
+    ques_temp=(df_temp.loc[move])['question']
+    ans_temp=(df_temp.loc[move])['answer']
+    if int(move)>=len(df_temp)+1:
+        gr.Info(f"Number of questions: {len(df_temp)}")
+        move=0
+    return [
+        gr.Label(value=str(id_temp),label="ID"),
+        gr.Label(value=ques_temp,label="Question"),
+        gr.Label(value=ans_temp,label="Answer")
+    ]
+def display_table(path=r"data/demo_table_data.xlsx"):
+    df = pd.read_excel(path)
+    df_with_custom_index = df.head(2)
+    # df_with_custom_index.index = [f"Row {i+1}" for i in range(len(df_with_custom_index))]
+    html_table = df_with_custom_index.to_html(index=False)
+    return f"<div style='overflow-x:auto;'>{html_table}</div>"
+def current_time():
+    # ff="model_ans_llama_finetuned486_rag_ensemble"
+    # df=pd.read_excel(r"model_ans/model_ans_mistral_finetuned486_rag_ensemble.xlsx")
+    current_datetime = datetime.datetime.now()
+    # file_name = current_datetime.strftime("%Y_%m_%d_%H_%M_%S")+ff
+    return current_datetime.strftime("%Y_%m_%d_%H_%M_%S")
+# This function use in human evaluation
+def random_ques_ans2():
+    import random
+    import pandas as pd
+    df=pd.read_excel(r"data/existing_dataset.xlsx")
+    id=random.randint(0,len(df))
+    ques_temp=(df.loc[id])['question']
+    ans_temp=""
+    return ques_temp,ans_temp
+def score_report_bar():
+    path="score_report"
+    import os
+    import math
+    dat=[]
+    for x in os.listdir(path):
+        wh=[]
+        flag=0
+        for x2 in x:
+            if x2>='a' and x2<='z':
+                flag=1
+                wh.append(x2)
+            elif flag==1:
+                wh.append(" ")
+        wh=''.join(wh)
+        wh=wh.replace("model ans","")
+        wh=wh.replace("finetuned","")
+        wh=wh.replace("  "," ")
+        wh=wh.replace("xlsx","")
+        df_temp=pd.read_excel(os.path.join(path,x))
+        rating=sum(df_temp["rating"])/len(df_temp)
+        dat.append({
+            "Model Name":wh,
+            "Average Rating":rating
+        })
+    temp=pd.DataFrame(dat)
+    return temp
+def parse_data(link,progress):    
+    from bs4 import BeautifulSoup
+    import requests
+    import re
+    from docx import Document       
+    from langchain_community.document_loaders import WebBaseLoader
+    s=set()
+    import time
+    start_time = time.time()
+    duration = 5
+    def get_links(url):
+        response = requests.get(url)
+        data = response.text
+        soup = BeautifulSoup(data, 'lxml')
+
+        links = []
+        for link in soup.find_all('a'):
+            link_url = link.get('href')
+            if link_url is not None and link_url.startswith('http'):
+                s.add(link_url)
+                links.append(link_url)
+        
+        return links
+    # def write_to_file(links):
+    #     with open('data.txt', 'a') as f:
+    #         f.writelines(links)
+    def get_all_links(url):
+            for link in get_links(url):
+                if (time.time() - start_time) >= duration:
+                    return
+                get_all_links(link)
+
+    def data_ret2(link):
+        loader = WebBaseLoader(f"{link}")
+        data = loader.load()
+        return data[0].page_content
+    # link = 'https://kuet.ac.bd'
+    s.add(link)
+    get_all_links(link)
+    li=list(s)
+    all_data=[]
+    for x in progress.tqdm(li):
+        try:
+            print("Link: ",x)
+            all_data.append(data_ret2(x))
+        except:
+            print("pass")
+            continue
+    all_data2 = re.sub(r'\n+', '\n\n', "\n".join(all_data))
+    all_data2=re.sub(u'[^\u0020-\uD7FF\u0009\u000A\u000D\uE000-\uFFFD\U00010000-\U0010FFFF]+', '', all_data2)
+    document = Document()
+    document.add_paragraph(all_data2)
+    document.save(f'rag_data/{link}.docx')
+    print("Finished!!")
+    return
+def all_contri_ans(id, ques):
+    folder_path = 'save_ques_ans'
+    data_frames = []
+    for filename in os.listdir(folder_path):
+        if filename.endswith(".xlsx") or filename.endswith(".xls"):
+            file_path = os.path.join(folder_path, filename)
+            df = pd.read_excel(file_path)
+            data_frames.append(df)       
+            
+    df_hum = pd.concat(data_frames, ignore_index=True)
+    temp=[]
+    for x,y in zip(df_hum['question'],df_hum['answer']):
+        if x==ques:
+            temp.append(y)
+    if len(temp)==0:
+        temp=["This question's answer is not available."]
+    return temp  
+import json
+import os
+
+def save_params_to_file(model_name,embedding_name, splitter_type_dropdown, chunk_size_slider,
+                        chunk_overlap_slider, separator_textbox, max_tokens_slider, filename="params.txt"):
+    params = {
+        "model_name":model_name,
+        "embedding_name": embedding_name,
+        "splitter_type_dropdown": splitter_type_dropdown,
+        "chunk_size_slider": chunk_size_slider,
+        "chunk_overlap_slider": chunk_overlap_slider,
+        "separator_textbox": separator_textbox,
+        "max_tokens_slider": max_tokens_slider
+    }
+    
+    with open(filename, 'w') as f:
+        json.dump(params, f)
+    with open("deploy//params.txt", 'w') as f:
+        json.dump(params, f)
+
+def load_params_from_file(filename="params.txt"):
+    if os.path.exists(filename):
+        with open(filename, 'r') as f:
+            params = json.load(f)
+        return params
+    else:
+        return None