Upload 14 files

app.py

@@ -9,6 +9,22 @@ import spaces
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 
+# For Prompt Engineering 
+import requests
+from huggingface_hub import AsyncInferenceClient
+
+from system_prompt_config import construct_input_prompt
+
+# Save chat history as JSON
+import json
+import atexit
+
+# From 70B code 
+system_message = "\nYou are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.\n\nIf a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information."
+
+# Add this global variable to store the chat history
+global_chat_history = []
+
 MAX_MAX_NEW_TOKENS = 2048
 DEFAULT_MAX_NEW_TOKENS = 1024
 MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
@@ -48,21 +64,42 @@ if torch.cuda.is_available():
     model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16, device_map="auto")
     tokenizer = AutoTokenizer.from_pretrained(model_id)
     tokenizer.use_default_system_prompt = False
-    
+
+# Add this function to store the chat history
+def save_chat_history():
+    """Save the chat history to a JSON file."""
+    with open("chat_history.json", "w") as json_file:
+        json.dump(global_chat_history, json_file)
+
 @spaces.GPU
+# From 70B code 
+# async def generate(
 def generate(
     message: str,
     chat_history: list[tuple[str, str]],
-    system_prompt: str,
+    # system_prompt: str,
     max_new_tokens: int = 1024,
     temperature: float = 0.6,
     top_p: float = 0.9,
     top_k: int = 50,
     repetition_penalty: float = 1.2,
 ) -> Iterator[str]:
+    
+    # Use the global variable to store the chat history
+    global global_chat_history  
+
     conversation = []
-    if system_prompt:
-        conversation.append({"role": "system", "content": system_prompt})
+
+    #if system_prompt:
+    #   conversation.append({"role": "system", "content": system_prompt})
+    
+    # Construct the input prompt using the functions from the system_prompt_config module
+    input_prompt = construct_input_prompt(chat_history, message)
+
+    # Convert input prompt to tensor
+    input_ids = tokenizer(input_prompt, return_tensors="pt").to(model.device)
+
+
     for user, assistant in chat_history:
         conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
     conversation.append({"role": "user", "content": message})
@@ -73,7 +110,14 @@ def generate(
         gr.Warning(f"Trimmed input from conversation as it was longer than {MAX_INPUT_TOKEN_LENGTH} tokens.")
     input_ids = input_ids.to(model.device)
 
+
+
+
+
+    # Set up the TextIteratorStreamer
     streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
+    
+    # Set up the generation arguments
     generate_kwargs = dict(
         {"input_ids": input_ids},
         streamer=streamer,
@@ -85,14 +129,31 @@ def generate(
         num_beams=1,
         repetition_penalty=repetition_penalty,
     )
+
+    # Start the model generation thread
     t = Thread(target=model.generate, kwargs=generate_kwargs)
     t.start()
 
+    # Yield generated text chunks
     outputs = []
     for text in streamer:
         outputs.append(text)
         yield "".join(outputs)
 
+    # Update the global_chat_history with the current conversation
+    global_chat_history.append({
+        "message": message,
+        "chat_history": chat_history,
+        "system_prompt": system_prompt,
+        "output": outputs[-1],  # Assuming you want to save the latest model output
+    })
+ 
+# The modification above starting with "global_chat.history.append" introduces a global_chat_history variable to store the chat history globally. 
+# The save_chat_history function is registered to be called when the program exits 
+# using atexit.register(save_chat_history). 
+# It saves the chat history to a JSON file named "chat_history.json". 
+# The generate function is updated to append the current conversation to global_chat_history 
+# after generating each response.
 
 chat_interface = gr.ChatInterface(
     fn=generate,
@@ -100,6 +161,7 @@ chat_interface = gr.ChatInterface(
     retry_btn=None,
     clear_btn=None,
     undo_btn=None,
+    chatbot=gr.Chatbot(avatar_images=('user.png', 'bot.png'), bubble_full_width = False), 
     examples=[
         ["How much should I invest in order to win?"],
         ["What happened in the last round?"],
@@ -109,7 +171,7 @@ chat_interface = gr.ChatInterface(
     ],
 )
 
-with gr.Blocks(css="style.css") as demo:
+with gr.Blocks(css="style.css") as demo:  
     gr.Markdown(DESCRIPTION)
     #gr.DuplicateButton(value="Duplicate Space for private use", elem_id="duplicate-button")
     chat_interface.render()
@@ -119,3 +181,7 @@ if __name__ == "__main__":
     #demo.queue(max_size=20).launch()
     demo.queue(max_size=20)
     demo.launch(share=True, debug=True)
+
+# Register the function to be called when the program exits
+atexit.register(save_chat_history)
+

calculator.py

@@ -0,0 +1,38 @@
+import tiktoken 
+
+DEFAULT_SYSTEM_PROMPT = """\ Your task is to answer in a consistent style. You answer per question is maximum 2 sentences long. 
+You are an intelligent and fair game guide in a 2-player trust game. 
+Your role is to assist players in making decisions during the game. 
+The game consists of 3 rounds, and each player starts with an initial asset of 10€.
+In each round, both players can trust each other with an amount between 0€ and 10€. 
+The trusted amounts are added, multiplied by 3, divided by 2, and then evenly distributed among the participants. 
+This sum, along with what's left of their initial assets, becomes their new asset for the next round.
+For example, if player A trusts player B with 5€, and player B trusts player A with 3€, the combined trust is (5 + 3) = 8€. 
+After the multiplier and division, both players receive (8 * 3 / 2) = 12€. 
+Adding this to what's left from their initial 10€ forms their asset for the next round.
+After 3 rounds, the final earnings are calculated using the same process. 
+You will receive a JSON with information on who trusted whom with how much money after each round as context.
+Your goal is to guide players through the game, providing clear instructions and explanations. 
+If any question or action seems unclear, explain it rather than providing inaccurate information. 
+If you're unsure about an answer, it's better not to guess.
+
+Example JSON context after a round:
+{
+    "round": 1,
+    "trust_data": {
+        "player_A": {"trusts": "player_B", "amount": 5},
+        "player_B": {"trusts": "player_A", "amount": 3}
+    }
+}
+
+# Example JSON context after a round: {json_result}
+
+# Few-shot training examples
+{B_SYS} Give an overview of the trust game. {E_SYS}
+{B_SYS} Explain how trust amounts are calculated. {E_SYS}
+{B_SYS} What happens if a player doesn't trust in a round? {E_SYS}
+"""
+
+encoder_name = 'p50k_base'
+tokenizer = tiktoken.get_encoding(encoder_name)
+print(len(tokenizer.encode(DEFAULT_SYSTEM_PROMPT))) 

cpu_app.py

@@ -0,0 +1,109 @@
+import os
+from threading import Thread
+from typing import Iterator
+
+import gradio as gr
+import spaces
+import torch 
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+
+MAX_MAX_NEW_TOKENS = 2048
+DEFAULT_MAX_NEW_TOKENS = 1024
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
+
+model_id = "meta-llama/Llama-2-7b-chat-hf"
+model = AutoModelForCausalLM.from_pretrained(model_id)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.use_default_system_prompt = False
+
+def generate(
+    message: str,
+    chat_history: list[tuple[str, str]],
+    system_prompt: str,
+    max_new_tokens: int = 1024,
+    temperature: float = 0.6,
+    top_p: float = 0.9,
+    top_k: int = 50,
+    repetition_penalty: float = 1.2,
+) -> str:
+    conversation = []
+    if system_prompt:
+        conversation.append({"role": "system", "content": system_prompt})
+    for user, assistant in chat_history:
+        conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
+    conversation.append({"role": "user", "content": message})
+
+    input_ids = tokenizer.apply_chat_template(conversation, return_tensors="pt")
+    if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
+        input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
+        gr.Warning(f"Trimmed input from conversation as it was longer than {MAX_INPUT_TOKEN_LENGTH} tokens.")
+    # Use CPU for inference
+    input_ids = input_ids.to('cpu')
+
+    output = model.generate(
+        input_ids=input_ids,
+        max_length=len(tokenizer.encode(system_prompt)) + max_new_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        top_k=top_k,
+        repetition_penalty=repetition_penalty,
+        pad_token_id=tokenizer.eos_token_id,
+    )
+
+    return tokenizer.decode(output[0], skip_special_tokens=True)
+
+chat_interface = gr.ChatInterface(
+    fn=generate,
+    additional_inputs=[
+        gr.Textbox(label="System prompt", lines=6),
+        gr.Slider(
+            label="Max new tokens",
+            minimum=1,
+            maximum=MAX_MAX_NEW_TOKENS,
+            step=1,
+            value=DEFAULT_MAX_NEW_TOKENS,
+        ),
+        gr.Slider(
+            label="Temperature",
+            minimum=0.1,
+            maximum=4.0,
+            step=0.1,
+            value=0.6,
+        ),
+        gr.Slider(
+            label="Top-p (nucleus sampling)",
+            minimum=0.05,
+            maximum=1.0,
+            step=0.05,
+            value=0.9,
+        ),
+        gr.Slider(
+            label="Top-k",
+            minimum=1,
+            maximum=1000,
+            step=1,
+            value=50,
+        ),
+        gr.Slider(
+            label="Repetition penalty",
+            minimum=1.0,
+            maximum=2.0,
+            step=0.05,
+            value=1.2,
+        ),
+    ],
+    stop_btn=None,
+    examples=[
+        ["Hello there! How are you doing?"],
+        ["Can you explain briefly to me what is the Python programming language?"],
+        ["Explain the plot of Cinderella in a sentence."],
+        ["How many hours does it take a man to eat a Helicopter?"],
+        ["Write a 100-word article on 'Benefits of Open-Source in AI research'"],
+    ],
+)
+
+with gr.Blocks(css="style.css") as demo:
+    chat_interface.render()
+
+if __name__ == "__main__":
+    demo.queue(max_size=20).launch(share=True, debug=True)

data_fetcher.py

@@ -0,0 +1,191 @@
+# To test open trust-game-llama2-7b in terminal,
+# open conda environment via conda activate  
+# and run this file via python3 data_fetcher.py
+
+# Example from here: https://www.techgropse.com/blog/how-to-return-sql-data-in-json-format-python/
+# Use the built-in json module and the pymysql package if using MySQL as database: 
+
+import mysql.connector
+import json
+
+# Connect to the database
+conn = mysql.connector.connect(
+# try 127.0.0.1 or localhost as the Hostname of the database 
+# host="ip-172-31-18-225", mysql.connector.errors.DatabaseError: 2005 (HY000): Unknown MySQL server host 'ip-172-31-18-225' (8)
+# user="root@127.0.0.1",
+# host="ec2-18-153-94-89.eu-central-1.compute.amazonaws.com", 
+# current error: mysql.connector.errors.DatabaseError: 2003 (HY000): 
+# Can't connect to MySQL server on 'ec2-18-153-94-89.eu-central-1.compute.amazonaws.com:3306' (60)
+# Connect to the database
+    host="18.153.94.89",
+    user="root",
+    password="N12RXMKtKxRj",
+    database="lionessdb"
+)
+
+
+# Create a cursor object
+cursor = conn.cursor()
+
+# Execute the SQL query
+# query = 'SELECT * FROM e5390g36814_decisions'
+query = "SELECT playerNr, subjectNr,initialCredit,transfer1,tripledAmount1,keptForSelf1,returned1,newCreditRound2,transfer2,tripledAmount2,keptForSelf2,returned2,results2rounds,newCreditRound3,transfer3,tripledAmount3,keptForSelf3,returned3,results3rounds FROM e5390g36814_decisions" 
+# query = "SELECT playerNr,initialCredit,transfer1,tripledAmount1,keptForSelf1,returned1,newCreditRound2,transfer2,tripledAmount2,keptForSelf2,returned2,results2rounds,newCreditRound3,transfer3,tripledAmount3,keptForSelf3,returned3,results3rounds FROM e5390g36814_decisions WHERE playerNr IN (1, 2, 3)"
+# query = "SELECT playerNr, initialCredit, transfer1, tripledAmount1, keptForSelf1, newCreditRound2, transfer2, tripledAmount2, keptForSelf2, results2rounds, newCreditRound3, transfer3, tripledAmount3, keptForSelf3, results3rounds FROM e5390g36814_decisions WHERE playerNr IN (1)"
+# query = "SELECT playerNr,initialCredit,tripledAmount1,keptForSelf1,returned1,newCreditRound2,tripledAmount2,keptForSelf2,returned2,results2rounds,newCreditRound3,tripledAmount3,keptForSelf3,returned3,results3rounds FROM e5390g36814_decisions WHERE playerNr IN (2)"
+cursor.execute(query)
+
+# Fetch all rows and convert to a list of dictionaries
+rows = cursor.fetchall()
+result = []
+for row in rows:
+    d = {}
+    for i, col in enumerate(cursor.description):
+        d[col[0]] = row[i]
+    result.append(d)
+
+# Convert the list of dictionaries to JSON and print it
+json_result = json.dumps(result)
+print(json_result)
+
+# In the above code, we first connect to the database using pymysql, then create a cursor object to execute the SQL query. 
+# We then fetch all rows from the query result and convert them to a list of dictionaries, 
+# where each dictionary represents a row in the table with column names as keys and their values as values. 
+# Finally, we convert the list of dictionaries to JSON format using the json.dumps() method and print it.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+# Example from here: https://www.a2hosting.com/kb/developer-corner/mysql/connecting-to-mysql-using-python/ 
+print("Using pymysql:")
+import pymysql
+myConnection = pymysql.connect( host='ec2-18-153-94-89.eu-central-1.compute.amazonaws.com', user='root', password='N12RXMKtKxRj', db='lionessdb' )
+doQuery(myConnection)
+myConnection.close()
+print("Connection closed")
+
+print( "Using mysqlclient (MySQLdb):" )
+import MySQLdb
+myConnection = MySQLdb.connect( host='ec2-18-153-94-89.eu-central-1.compute.amazonaws.com', user='root', password='N12RXMKtKxRj', db='lionessdb' )
+doQuery( myConnection )
+myConnection.close()
+
+
+print( "Using mysql.connector:" )
+import mysql.connector
+myConnection = mysql.connector.connect( host='ec2-18-153-94-89.eu-central-1.compute.amazonaws.com', user='root', password='N12RXMKtKxRj', db='lionessdb' )
+doQuery( myConnection )
+myConnection.close()
+'''
+
+
+
+
+"""
+# Own idea - did not work - no error message whatsoever 
+
+import pandas as pd
+import sqlite3
+
+def fetch_data_as_json():
+    conn = sqlite3.connect('lionessdb')
+    query = 'SELECT * FROM e5390g36407_decisions'
+    df = pd.read_sql(query, conn)
+    json_data = df.to_json(orient='records', lines=True)
+    print(json_data)
+    conn.close()
+    return json_data
+
+
+    
+    
+# Example from here: https://www.bacancytechnology.com/qanda/python/return-sql-data-in-json-format-python
+# Establish a Connection
+connection_string = 'Driver={SQL Server};Server=ec2-18-153-94-89.eu-central-1.compute.amazonaws.com;Database=lionessdb;UID=root;PWD=N12RXMKtKxRj;'
+conn = pyodbc.connect(connection_string)
+
+# Execute SQL Query
+cursor = conn.cursor()
+sql_query = "SELECT * FROM e5390g36407_decisions;"
+cursor.execute(sql_query)
+
+# Fetch Data
+columns = [column[0] for column in cursor.description]
+data = [dict(zip(columns, row)) for row in cursor.fetchall()]
+
+#Convert to JSON
+json_data = json.dumps(data, indent=4)
+
+# Save or Use JSON Data - save JSON data to a file:
+with open('data.json', 'w') as json_file:
+    json_file.write(json_data)
+
+# Alternatively, you can use the JSON data directly in your program:
+print(json_data)
+
+
+
+
+
+# Example from here: https://stackoverflow.com/questions/43796423/python-converting-mysql-query-result-to-json
+# Simpler way: Return a dictionary and convert it to JSON.
+# Just pass dictionary=True to the cursor constructor as mentioned 
+# in MySQL's documents: https://dev.mysql.com/doc/connector-python/en/connector-python-api-mysqlconnection-cursor.html 
+
+import json
+import mysql.connector
+
+db = mysql.connector.connect(host='18.153.94.89',
+                             user='root',
+                             passwd='N12RXMKtKxRj',
+                             db='lionessdb',
+                             port=3306)
+
+# This is the line that you need
+cursor = db.cursor(dictionary=True)
+
+name = "Bob"
+cursor.execute("SELECT fname, lname FROM table WHERE fname=%s;", (name))
+
+result = cursor.fetchall()
+
+print(f"json: {json.dumps(result)}")
+# Which will print for example: json: [{'fname': "Bob", 'lname': "Dole"}, {'fname': "Bob", 'lname': "Marley"}]
+# Note that types are preserved this way, a good thing
+# BUT will need to be transformed, parsed, or serialized into a string; 
+# for instance, if there is a date, the SQL query may return a datetime object, which will need to be parsed or serialized depending on your next step. 
+# A great way to serialize is in this answer: https://stackoverflow.com/a/36142844/4513509  
+
+
+
+
+
+# Example from here: https://dev.mysql.com/doc/connector-python/en/connector-python-example-connecting.html
+
+import mysql.connector
+
+cnx = mysql.connector.connect(user='root', password='N12RXMKtKxRj',
+                              host='18.153.94.89',
+                              database='lionessdb')
+cnx.close()
+
+"""
+

requirements.txt

@@ -1,3 +1,5 @@
+# If new requirements added, open Llama2_local in terminal again and run: pip3 install -r requirements.txt  
+
 accelerate==0.25.0
 bitsandbytes==0.41.1
 gradio==4.14.0
@@ -7,3 +9,41 @@ sentencepiece==0.1.99
 spaces==0.20.0
 torch==2.0.0
 transformers==4.36.2
+
+auto-gptq==0.3.0
+tiktoken #newly added for Prompt Engineering from here: 23:53 https://www.youtube.com/watch?v=BP9fi_0XTlw 
+CTransformers #newly added for Prompt Engineering from here: https://www.youtube.com/watch?v=AJOhV6Ryy5o
+mysqlclient #newly added for data_fetcher.py 
+#mysql-client installation did not work via terminal or requirements.txt, so I did run brew install mysql aswell as brew install mysql-client in terminal
+#Note: MySQL is configured to only allow connections from localhost by default. To connect run: mysql -u root in terminal. Did not work for me. 
+mysql-connector-python #newly added for data_fetcher.py
+mysql-connector #newly added for data_fetcher.py
+pymysql #newly added for data_fetcher.py
+
+#from: https://singhaldhruv.medium.com/the-heros-sqlguide-conquering-the-subprocess-exited-with-error-error-92732cbe300#:~:text=The%20%E2%80%9Csubprocess%2Dexited%2Dwith%2Derror%E2%80%9D%20error%20is,confound%20even%20the%20bravest%20heroes.
+#ran brew install python3-dev libmysqlclient-dev build-essential, then pip3 install --upgrade pip, then again pip3 install mysqlclient
+#mysqlclient still did not work
+
+#from: https://pypi.org/project/mysqlclient/
+#ran brew install mysql pkg-config and then pip3 install mysqlclient
+#mysqlclient could be installed successfully!! 
+
+#Homebrew if zhs brew not found, run: export PATH="/opt/homebrew/bin:$PATH"
+
+#mysql module not found :( 
+#Troubleshooting from: https://stackabuse.com/bytes/fixing-modulenotfounderror-no-module-named-mysql-in-python/ 
+#Checking if MySQL Package is Installed
+#Before we proceed to install the MySQL module, it's good practice to first check if it's already installed. 
+#You can do this by using the pip show command in your terminal:
+#pip3 show mysql-connector-python
+#If the MySQL module is installed, the above command will return information about the module.
+#However, if it's not installed, the command will return nothing.
+#If not installed, then run in terminal: pip3 install mysql-connector-python
+
+#Still did not work, error: import mysql.connector ModuleNotFoundError: No module named 'mysql'
+#Try to run in terminal: pip3 install mysql -> Getting requirements to build wheel ... error error: subprocess-exited-with-error
+#Need to run: pip3 install mysql-connector BECAUSE THE MYSQL_CONNECTOR IS NEEDED IN ORDER TO RUN MYSQL WITH PYTHON, found at https://www.youtube.com/watch?v=Yugm4lzEPTU
+mysql-connector
+
+#ALSO, pip3 install tokenizer needed! 
+tokenizer 

system_prompt_config.py

@@ -0,0 +1,97 @@
+# From Llama2 Local code 
+from data_fetcher import json_result
+'''
+# These variables represent the beginning-of-sequence (BOS) and end-of-sequence (EOS) tokens. 
+BOS, EOS = "<s>", "</s>" 
+
+# These variables represent the beginning and end markers for an instruction. 
+BINST, EINST = "[INST]", "[/INST]"
+
+# These variables define markers to denote the beginning and end of a system message. 
+# In the context of a chatbot, a system message is information or instructions provided by the system rather than the user. 
+# The markers here use <<SYS>> to indicate the start and <</SYS>> to indicate the end, with newline characters \n for formatting.
+BSYS, ESYS = "<<SYS>>\n", "\n<</SYS>>\n\n"
+
+# This line initializes a multiline string (""") for the default system prompt. 
+# It's the set of instructions for the chatbot to follow during a conversation in the trust game scenario that will be contained in the system message. 
+DEFAULT_SYSTEM_PROMPT = """\ Your task is to answer in a consistent style. You answer per question is maximum 2 sentences long. 
+You are an intelligent and fair game guide in a 2-player trust game. 
+Your role is to assist players in making decisions during the game. 
+The game consists of 3 rounds, and each player starts with an initial asset of 10€.
+In each round, both players can trust each other with an amount between 0€ and 10€. 
+The trusted amounts are added, multiplied by 3, divided by 2, and then evenly distributed among the participants. 
+This sum, along with what's left of their initial assets, becomes their new asset for the next round.
+For example, if player A trusts player B with 5€, and player B trusts player A with 3€, the combined trust is (5 + 3) = 8€. 
+After the multiplier and division, both players receive (8 * 3 / 2) = 12€. 
+Adding this to what's left from their initial 10€ forms their asset for the next round.
+After 3 rounds, the final earnings are calculated using the same process. 
+You will receive a JSON with information on who trusted whom with how much money after each round as context.
+Your goal is to guide players through the game, providing clear instructions and explanations. 
+If any question or action seems unclear, explain it rather than providing inaccurate information. 
+If you're unsure about an answer, it's better not to guess.
+
+Example JSON context after a round:
+{
+    "round": 1,
+    "trust_data": {
+        "player_A": {"trusts": "player_B", "amount": 5},
+        "player_B": {"trusts": "player_A", "amount": 3}
+    }
+}
+
+# Example JSON context after a round: {json_result}
+
+# Few-shot training examples
+{BSYS} Give an overview of the trust game. {ESYS}
+{BSYS} Explain how trust amounts are calculated. {ESYS}
+{BSYS} What happens if a player doesn't trust in a round? {ESYS}
+"""
+
+# Original: DEFAULT_SYSTEM_PROMPT = """\ You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information."""
+
+def construct_input_prompt(chat_history, message) -> str:
+    # chat_history has the following structure:
+    # - dialogs
+    # --- instruction
+    # --- response (None for the most recent dialog)
+    input_prompt = ""
+    for i, dialog in enumerate(chat_history[:-1]):
+      instruction, response = dialog[0], dialog[1]
+      # prepend system instruction before first instruction
+      if i == 0:
+        instruction = f"{BSYS}{DEFAULT_SYSTEM_PROMPT}{ESYS}" + instruction
+      else:
+        # the tokenizer automatically adds a bos_token during encoding,
+        # for this reason the bos_token is not added for the first instruction
+        input_prompt += BOS
+      input_prompt += f"{BINST} {instruction.strip()} {EINST} {response.strip()} " + EOS
+
+    # new instruction from the user
+    new_instruction = chat_history[-1][0].strip()
+
+    # the tokenizer automatically adds a bos_token during encoding,
+    # for this reason the bos_token is not added for the first instruction
+    if len(chat_history) > 1:
+      input_prompt += BOS
+    else:
+      # prepend system instruction before first instruction
+      new_instruction = f"{BSYS}{DEFAULT_SYSTEM_PROMPT}{ESYS}" + new_instruction
+
+    input_prompt += f"{BINST} {new_instruction} {EINST}"
+    return input_prompt
+
+'''
+
+# From own code
+def get_default_system_prompt():
+    return "Default System Prompt"
+
+def construct_input_prompt(chat_history, message):
+    input_prompt = f"<s>[INST] <<SYS>>\n{get_default_system_prompt()}\n<</SYS>>\n\n "
+
+    for user, assistant in chat_history:
+        input_prompt += f"{user} [/INST] {assistant} <s>[INST] "
+
+    input_prompt += f"{message} [/INST] "
+
+    return input_prompt