Upload app.py

app.py

@@ -0,0 +1,298 @@
+# Original code from https://huggingface.co/spaces/huggingface-projects/llama-2-7b-chat and https://huggingface.co/spaces/radames/gradio-chatbot-read-query-param 
+import gradio as gr
+import time
+import random
+import json
+import mysql.connector
+import os
+import csv
+
+from datetime import datetime
+# from huggingface_hub import Repository, hf_hub_download
+
+import spaces
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+from threading import Thread
+from typing import Iterator
+
+# data_fetcher.py
+import mysql.connector
+import urllib.parse
+import urllib.request
+
+# For Prompt Engineering 
+# import requests
+# from huggingface_hub import AsyncInferenceClient
+
+# Save chat history as JSON
+import atexit
+
+# Add this global variable to store the chat history
+# global_chat_history = []
+# 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)
+
+#from huggingface_hub import login
+#HF_TOKEN = os.getenv('HF_TOKEN')
+
+MAX_MAX_NEW_TOKENS = 2048
+DEFAULT_MAX_NEW_TOKENS = 1024
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
+
+DESCRIPTION = """\
+# Llama-2 7B Chat
+This is your personal space to chat. 
+You can ask anything from strategic questions regarding the game or just chat as you like. 
+"""
+'''LICENSE = """
+<p/>
+
+---
+As a derivate work of [Llama-2-13b-chat](https://huggingface.co/meta-llama/Llama-2-13b-chat) by Meta,
+this demo is governed by the original [license](https://huggingface.co/spaces/huggingface-projects/llama-2-13b-chat/blob/main/LICENSE.txt) and [acceptable use policy](https://huggingface.co/spaces/huggingface-projects/llama-2-13b-chat/blob/main/USE_POLICY.md).
+"""
+'''
+
+if not torch.cuda.is_available():
+    DESCRIPTION += "\n<p>Running on CPU 🥶 This demo does not work on CPU.</p>"
+
+
+if torch.cuda.is_available():
+    model_id = "meta-llama/Llama-2-7b-chat-hf"
+    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
+
+
+## gradio-chatbot-read-query-param
+get_window_session_index = """ 
+    function() {
+        const urlParams = new URLSearchParams(window.location.search);
+        const session_index = urlParams.get('session_index'); 
+        return session_index;
+        }
+    """
+
+def fetch_personalized_data(session_index):
+    # Connect to the database
+    conn = mysql.connector.connect(
+        host="18.153.94.89",
+        user="root",
+        password="N12RXMKtKxRj",
+        database="lionessdb"
+    )
+
+    # Create a cursor object
+    cursor = conn.cursor()
+
+    # Replace the placeholders with your actual database and table names
+    core_table = "e5390g37096_core"
+    decisions_table = "e5390g37096_decisions"
+
+    # Query to fetch relevant data from both tables based on session_index
+    query = f"""
+        SELECT e5390g37096_core.playerNr, 
+               e5390g37096_core.groupNr, 
+               e5390g37096_core.subjectNr 
+        FROM e5390g37096_core
+        JOIN e5390g37096_decisions ON 
+            e5390g37096_core.playerNr = e5390g37096_decisions.playerNr
+        WHERE e5390g37096_decisions.session_index = '{session_index}'
+    """
+
+    try:
+        cursor.execute(query)
+
+        # Fetch all rows as lists of tuples
+        rows = cursor.fetchall()
+
+        # Close the database connection
+        conn.close()
+
+        # return [[str(row[0]), str(row[1]), str(row[2])] for row in rows]  # Convert each row to a list
+        # Convert the rows to a list of dictionaries
+        data = [{'playerNr': row[0], 'groupNr': row[1], 'subjectNr': row[2]} for row in rows]
+        return data
+
+    except mysql.connector.Error as err:
+        print(f"Error: {err}")
+        return None
+
+
+## gradio-chatbot-read-query-param   
+def get_window_url_params():
+    return """
+        function() {
+            const params = new URLSearchParams(window.location.search);
+            const url_params = Object.fromEntries(params);
+            return url_params;
+            }
+        """
+
+## trust-game-llama-2-7b-chat
+# app.py
+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
+
+## trust-game-llama-2-7b-chat
+# app.py 
+@spaces.GPU
+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,
+) -> Iterator[str]: # Change return type hint to Iterator[str]
+
+     # Construct the input prompt using the functions from the system_prompt_config module
+    input_prompt = construct_input_prompt(chat_history, message)
+
+    # Use the global variable to store the chat history
+    # global global_chat_history
+
+    conversation = []
+
+    # Move the condition here after the assignment
+    if input_prompt:
+        conversation.append({"role": "system", "content": input_prompt})
+
+    # 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})
+
+    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.")
+    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,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        top_p=top_p,
+        top_k=top_k,
+        temperature=temperature,
+        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": input_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,
+    theme="soft",
+    retry_btn=None,
+    clear_btn=None,
+    undo_btn=None,
+    chatbot=gr.Chatbot(avatar_images=('user.png', 'bot.png'), bubble_full_width = False), 
+    examples=[
+        ["Can you explain the rules very briefly again?"],
+        ["How much should I invest in order to win?"],
+        ["What happened in the last round?"],
+        ["What is my probability to win if I do not share anything?"],
+    ],
+)
+
+with gr.Blocks(css="style.css") as demo:  
+    #gr.Markdown(DESCRIPTION)
+    #gr.DuplicateButton(value="Duplicate Space for private use", elem_id="duplicate-button")
+    ## gradio-chatbot-read-query-param
+    url_params = gr.JSON({}, visible=False, label="URL Params")
+   
+    ## gradio-chatbot-read-query-param
+    def get_session_index(history, url_params):
+        if history and bool(history[-1][0].strip()):
+            session_index = url_params.get('session_index')
+            print(session_index)
+            # Fetch personalized data
+            personalized_data = fetch_personalized_data(session_index)
+            print(personalized_data)
+        return personalized_data
+
+    ## trust-game-llama-2-7b-chat
+    # app.py 
+    def get_default_system_prompt(personalized_data):
+        #BOS, EOS = "<s>", "</s>" 
+        #BINST, EINST = "[INST]", "[/INST]"
+        BSYS, ESYS = "<<SYS>>\n", "\n<</SYS>>\n\n"
+
+        DEFAULT_SYSTEM_PROMPT = f""" You are an intelligent and fair game guide in a 2-player trust game, assisting players in making decisions to win. 
+        Answer in a consistent style. Answer per question should be maximum 2 sentences long. The players are called The Investor and The Dealer and keep their role throughout the whole game. 
+        Both start with 10€ in round 1. The game consists of 3 rounds. In round 1, The Investor invests between 0€ and 10€. 
+        This amount is tripled automatically, and The Dealer can then distribute the tripled amount. After that, round 1 is over. 
+        Both go into the next round with their current asset: The Investor with 10€ minus what he invested plus what he received back from The Dealer.
+        The Dealer with 10€ plus what he kept from the tripled amount. 
+        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: {personalized_data}
+
+        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}
+        """
+        print(DEFAULT_SYSTEM_PROMPT)
+        return DEFAULT_SYSTEM_PROMPT
+    
+    chat_interface.render()
+    #gr.Markdown(LICENSE)
+
+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)
+