Spaces:
Sleeping
Sleeping
import subprocess | |
import sys | |
import os | |
ROOT_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../") | |
sys.path.append(ROOT_FILE) | |
from components.induce_personality import construct_big_five_words | |
# need to import: gradio | |
def install(package, upgrade=False): | |
if upgrade: | |
subprocess.run( | |
[ | |
sys.executable, | |
"-m", | |
"pip", | |
"install", | |
"--upgrade", | |
package, | |
], | |
check=True, | |
) | |
else: | |
subprocess.run( | |
[ | |
sys.executable, | |
"-m", | |
"pip", | |
"install", | |
package, | |
], | |
check=True, | |
) | |
# install("ipdb") | |
# install("gradio") | |
# install("sentence-transformers") | |
# install("git+https://github.com/terrierteam/pyterrier_t5.git") | |
# install("protobuf") | |
# install("transformers", upgrade=True) | |
import random | |
import json | |
import gradio as gr | |
import random | |
import time | |
import ipdb | |
import markdown | |
import gradio as gr | |
import torch | |
from transformers import AutoModelForCausalLM, AutoTokenizer | |
from utils import login_to_huggingface, ACCESS | |
from components.rewrite_passages import rewrite_rag_context | |
from components.query_rewriting import rewrite_query | |
from components.chat_conversation import ( | |
format_message_history, | |
format_user_message, | |
format_context, | |
gradio_to_huggingface_message, | |
huggingface_to_gradio_message, | |
get_system_instruction, | |
prepare_tokenizer, | |
format_rag_context, | |
conversation_window, | |
generate_response, | |
) | |
from components.constant import ( | |
ACCESS, | |
QUERY_REWRITING, | |
RAG, | |
PERSONALITY, | |
PERSONALITY_LIST, | |
REWRITE_PASSAGES, | |
NUM_PASSAGES, | |
DEVICE, | |
RESPONSE_GENERATOR, | |
CONV_WINDOW, | |
API_URL, | |
TEMPLATE_PAYLOAD, | |
) | |
from components.induce_personality import ( | |
build_personality_prompt, | |
) | |
# LOG_FILE = "log_file_bingzhi_information_seeking.txt" | |
LOG_DIR = os.path.join(ROOT_FILE, "log/seperate_preference_elicitation/others/") | |
if os.path.exists(LOG_DIR) is False: | |
os.makedirs(LOG_DIR) | |
STATIC_FILE = os.path.join(ROOT_FILE, "_static") | |
with open(os.path.join(STATIC_FILE, "html/instruction_page.html"), "r") as f: | |
INSTRUCTION_PAGE = f.read() | |
with open(os.path.join(STATIC_FILE, "html/evaluation_instruction.html"), "r") as f: | |
EVALUATION_INSTRUCTION = f.read() | |
with open(os.path.join(STATIC_FILE, "html/general_instruction.html"), "r") as f: | |
GENERAL_INSTRUCTION = f.read() | |
with open(os.path.join(STATIC_FILE, "html/user_narrative.html"), "r") as f: | |
USER_NARRATIVE = f.read() | |
with open(os.path.join(STATIC_FILE, "html/system_instruction_preference_elicitation.html"), "r") as f: | |
PREFERENCE_ELICITATION_TASK = f.read() | |
with open(os.path.join(STATIC_FILE, "html/final_evaluation.html"), "r") as f: | |
FINAL_EVALUATION = f.read() | |
with open(os.path.join(STATIC_FILE, "txt/system_instruction_with_user_persona.txt"), "r") as f: | |
SYSTEM_INSTRUCTION = f.read() | |
with open(os.path.join(STATIC_FILE, "txt/system_instruction_without_personalization.txt"), "r") as f: | |
SYSTEM_INSTRUCTION_WITHOUT_PERSONALIZATION = f.read() | |
with open(os.path.join(STATIC_FILE, "txt/system_instruction_preference_elicitation.txt"), "r") as f: | |
SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION = f.read() | |
with open(os.path.join(STATIC_FILE, "txt/system_summarization_user_preference_elicitation.txt"), "r") as f: | |
SUMMARIZATION_PROMPT = f.read() | |
FIRST_MESSAGE = "Hey" | |
INFORMATION_SEEKING = True | |
USER_PREFERENCE_SUMMARY = True | |
DEBUG = False | |
# if DEBUG: | |
# CONV_WINDOW = 3 | |
def get_context(synthetic_data_path): | |
# Load data from the synthetic data file | |
with open(synthetic_data_path, "r") as f: | |
data = [json.loads(line) for line in f] | |
return data | |
def add_ticker_prefix(ticker_list, context_list): | |
res = [] | |
for ticker, context in zip(ticker_list, context_list): | |
res.append(f"{ticker}: {context}") | |
return res | |
def build_raw_context_list(context_dict): | |
return context_dict["data"] | |
def build_context(context_dict): | |
return [build_context_element(context) for context in context_dict["data"]] | |
def build_context_element(context): | |
# [{topic: ex, data: {}}, {..}, ..] | |
# Extract information from the context | |
ticker = context["ticker"] | |
sector = context["sector"] | |
business_summary = context["business_summary"] | |
name = context["short_name"] | |
stock_price = context["price_data"] | |
earning = context["earning_summary"] | |
beta = context["beta"] | |
# Build the context string | |
stock_candidate = f"Stock Candidate: {name}" | |
stock_info = f"Stock Information: \nIndustry - {sector}, \nBeta (risk indicator) - {beta}, \nEarning Summary - {earning}\n, 2023 Monthly Stock Price - {stock_price}\n, Business Summary - {business_summary}" | |
context_list = [stock_candidate, stock_info] | |
# Combine all parts into a single string | |
return "\n".join(context_list) | |
def get_user_narrative_html(user_narrative): | |
return USER_NARRATIVE.replace("{user_narrative}", user_narrative).replace("\n", "<br>") | |
def get_task_instruction_for_user(context): | |
ticker_name = context["short_name"] | |
user_narrative = context["user_narrative"] | |
user_narrative = user_narrative.replace("\n", "<br>") | |
html_user_narrative = markdown.markdown(user_narrative) | |
general_instruction = GENERAL_INSTRUCTION | |
round_instruction = f""" | |
<div style="background-color: #f9f9f9; padding: 20px; border-radius: 10px; box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); margin-bottom: 20px; max-height: 780px; overflow-y: auto; overflow-x: hidden;"> | |
<!-- Stock Information (Bold label, Normal ticker name) --> | |
<h2 style="color: #2c3e50; text-align: center; margin-bottom: 20px; font-size: 20px; font-weight: 600;"> | |
Round Info | |
</h2> | |
<div style="text-align: left; font-size: 20px; font-weight: bold; margin-bottom: 20px;"> | |
Stock | |
</div> | |
<div style="text-align: left; font-weight: normal; font-size: 16px; margin-bottom: 20px;"> | |
<span style="font-weight: bold;"> | |
This Round's Stock: | |
</span> | |
{ticker_name} | |
</div> | |
<!-- User Narrative (Bold label, Normal narrative) --> | |
<div style="text-align: left; font-size: 20px; font-weight: bold; margin-bottom: 20px;"> | |
User Narrative | |
</div> | |
<div style="text-align: left; font-weight: normal; font-size: 16px; margin-bottom: 20px;"> | |
{html_user_narrative} | |
</div> | |
</div>""" | |
return general_instruction, round_instruction | |
def display_system_instruction_with_html( | |
system_instruction, | |
): | |
html_system_instruction = f""" | |
<p style="text-align: left; margin-bottom: 10px;"> | |
{system_instruction} | |
</p> | |
""" | |
return html_system_instruction | |
def log_action(tab_name, action, details): | |
""" | |
Log actions for each tab (stock). | |
""" | |
log_file = os.path.join(LOG_DIR, f"{tab_name}.txt") | |
with open(log_file, "a") as f: | |
f.write(f"Action: {action} | Details: {details}\n") | |
def create_demo( | |
terminator, | |
system_description_without_context, | |
stock_context_list, | |
raw_context_list, | |
): | |
# Store the history here and use this as an input to each tab. | |
tab_data = {} | |
def tab_creation_exploration_stage(order): | |
comp, context, general_instruction, round_instruction = get_context(order) | |
system_instruction = system_description_without_context + "\n" + context | |
tab_data[comp] = {"history": [], "selection": "", "reason": ""} | |
english_order = ["1", "2", "3", "4", "5"] | |
# with gr.Tab(f"{english_order[order]}: {comp}") as tab: | |
with gr.Tab(f"{english_order[order]}-1:Discuss"): | |
gr.HTML(value=general_instruction, label="General Instruction") | |
with gr.Row(): | |
with gr.Column(): | |
with gr.Row(): | |
gr.HTML( | |
value=round_instruction, | |
label="Round Instruction", | |
) | |
with gr.Column(): | |
with gr.Row(): | |
chatbot = gr.Chatbot(height=600) | |
with gr.Row(): | |
start_conversation = gr.Button(value="Start Conversation") | |
with gr.Row(): | |
msg = gr.Textbox(scale=1, label="User Input") | |
with gr.Row(): | |
msg_button = gr.Button(value="Send This Message to Advisor", interactive=False) | |
continue_button = gr.Button(value="Show More of the Advisor’s Answer", interactive=False) | |
with gr.Row(): | |
clear = gr.ClearButton([msg, chatbot]) | |
if DEBUG: | |
with gr.Row(): | |
display_prompt = gr.HTML( | |
value=display_system_instruction_with_html(system_instruction), | |
label="System Instruction", | |
) | |
with gr.Tab(f"{english_order[order]}-2:Eval"): | |
with gr.Row(): | |
gr.HTML(value=EVALUATION_INSTRUCTION) | |
with gr.Row(): | |
dropdown = gr.Dropdown( | |
label="Would you like to purchase the stock?", | |
choices=["Yes", "No"], | |
show_label=True, | |
) | |
reason = gr.Textbox( | |
scale=1, | |
label="Reason for Your Choice (Explain Your Reasoning & Highlight Useful Parts of Conversation)", | |
lines=5, | |
) | |
with gr.Row(): | |
trust = gr.Slider( | |
label="Trust", | |
minimum=1, | |
maximum=100, | |
value=50, | |
info="How much do you trust the financial advisor? Answer from 1 to 100. A score of 100 means you have complete trust in the financial advisor, while a score of 1 means you have no trust at all.", | |
step=1, | |
) | |
satisfaction = gr.Slider( | |
label="Satisfaction", | |
minimum=1, | |
maximum=100, | |
value=50, | |
info="How satisfied are you with the financial advisor? Answer from 1 to 100. A score of 100 means you are completely satisfied, while a score of 1 means you are not satisfied at all.", | |
step=1, | |
) | |
with gr.Row(): | |
knowledgeable = gr.Slider( | |
label="Knowledgeable", | |
minimum=1, | |
maximum=100, | |
value=50, | |
info="How knowledgeable do you feel after interacting with the financial advisor? Answer from 1 to 100. A score of 100 means you feel very knowledgeable, while a score of 1 means you feel not knowledgeable at all.", | |
step=1, | |
) | |
helpful = gr.Slider( | |
label="Helpful", | |
minimum=1, | |
maximum=100, | |
value=50, | |
info="How helpful do you find the financial advisor? Answer from 1 to 100. A score of 100 means you find the financial advisor very helpful, while a score of 1 means you find the financial advisor not helpful at all.", | |
step=1, | |
) | |
evaluation_send_button = gr.Button(value="Send: Evaluation") | |
return { | |
"comp": comp, | |
"system_instruction": system_instruction, | |
"start_conversation": start_conversation, | |
"msg_button": msg_button, | |
"continue_button": continue_button, | |
"chatbot": chatbot, | |
"msg": msg, | |
"dropdown": dropdown, | |
"reason": reason, | |
"trust": trust, | |
"satisfaction": satisfaction, | |
"knowledgeable": knowledgeable, | |
"helpful": helpful, | |
"evaluation_send_button": evaluation_send_button, | |
} | |
def tab_final_evaluation(first_comp, second_comp, third_comp, fourth_comp, fifth_comp): | |
with gr.Row(): | |
gr.HTML(value=FINAL_EVALUATION) | |
with gr.Row(): | |
ranking_first_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{first_comp}") | |
ranking_second_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{second_comp}") | |
ranking_third_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{third_comp}") | |
ranking_fourth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{fourth_comp}") | |
ranking_fifth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{fifth_comp}") | |
with gr.Row(): | |
textbox = gr.HTML( | |
"""<div style="background-color: #f8d7da; color: #721c24; padding: 15px; border: 1px solid #f5c6cb; border-radius: 5px; margin-bottom: 20px;"> | |
<strong>Please rank the stocks from 1 to 5, where 1 is the most preferred and 5 is the least preferred.</strong> | |
<br> | |
<strong>Make sure to assign different scores to different stocks.</strong> | |
</div>""" | |
) | |
submit_ranking = gr.Button(value="Submit Ranking") | |
return { | |
"first": {"comp": first_comp, "ranking_first_comp": ranking_first_comp}, | |
"second": {"comp": second_comp, "ranking_second_comp": ranking_second_comp}, | |
"third": {"comp": third_comp, "ranking_third_comp": ranking_third_comp}, | |
"fourth": {"comp": fourth_comp, "ranking_fourth_comp": ranking_fourth_comp}, | |
"fifth": {"comp": fifth_comp, "ranking_fifth_comp": ranking_fifth_comp}, | |
"submit_ranking": submit_ranking, | |
"text_box": textbox, | |
} | |
def click_control_exploration_stage(tabs): | |
( | |
comp, | |
system_instruction, | |
start_conversation, | |
msg_button, | |
continue_button, | |
chatbot, | |
msg, | |
dropdown, | |
reason, | |
trust, | |
satisfaction, | |
knowledgeable, | |
helpful, | |
evaluation_send_button, | |
) = ( | |
tabs["comp"], | |
tabs["system_instruction"], | |
tabs["start_conversation"], | |
tabs["msg_button"], | |
tabs["continue_button"], | |
tabs["chatbot"], | |
tabs["msg"], | |
tabs["dropdown"], | |
tabs["reason"], | |
tabs["trust"], | |
tabs["satisfaction"], | |
tabs["knowledgeable"], | |
tabs["helpful"], | |
tabs["evaluation_send_button"], | |
) | |
start_conversation.click( | |
lambda history: respond_start_conversation(history, system_instruction, comp), | |
[chatbot], | |
[chatbot, start_conversation, msg_button, continue_button], | |
) | |
msg_button.click( | |
lambda message, history: respond(message, tab_data[comp]["history"], system_instruction, comp), | |
[msg, chatbot], | |
[msg, chatbot], | |
) | |
continue_button.click( | |
lambda history: respond_continue(tab_data[comp]["history"], system_instruction, comp), | |
[chatbot], | |
[chatbot], | |
) | |
evaluation_send_button.click( | |
lambda dropdown, reason, trust, satisfaction, knowledgeable, helpful: respond_evaluation( | |
{ | |
"selection": dropdown, | |
"reason": reason, | |
"trust": trust, | |
"satisfaction": satisfaction, | |
"knowledgeable": knowledgeable, | |
"helpful": helpful, | |
}, | |
comp, | |
), | |
[dropdown, reason, trust, satisfaction, knowledgeable, helpful], | |
[dropdown, reason, trust, satisfaction, knowledgeable, helpful], | |
) | |
def click_control_final_evaluation(tabs): | |
first_comp, ranking_first_comp = tabs["first"]["comp"], tabs["first"]["ranking_first_comp"] | |
second_comp, ranking_second_comp = tabs["second"]["comp"], tabs["second"]["ranking_second_comp"] | |
third_comp, ranking_third_comp = tabs["third"]["comp"], tabs["third"]["ranking_third_comp"] | |
fourth_comp, ranking_fourth_comp = tabs["fourth"]["comp"], tabs["fourth"]["ranking_fourth_comp"] | |
fifth_comp, ranking_fifth_comp = tabs["fifth"]["comp"], tabs["fifth"]["ranking_fifth_comp"] | |
result_textbox = tabs["text_box"] | |
submit_ranking = tabs["submit_ranking"] | |
submit_ranking.click( | |
lambda ranking_first_comp, ranking_second_comp, ranking_third_comp, ranking_fourth_comp, ranking_fifth_comp: respond_final_ranking( | |
first_comp, | |
ranking_first_comp, | |
second_comp, | |
ranking_second_comp, | |
third_comp, | |
ranking_third_comp, | |
fourth_comp, | |
ranking_fourth_comp, | |
fifth_comp, | |
ranking_fifth_comp, | |
), | |
# Input components (names and rankings) | |
[ | |
ranking_first_comp, | |
ranking_second_comp, | |
ranking_third_comp, | |
ranking_fourth_comp, | |
ranking_fifth_comp, | |
], | |
# Output component(s) where you want the result to appear, e.g., result_textbox | |
[result_textbox], | |
) | |
def respond(message, history, system_instruction, tab_name=None): | |
""" | |
Return: | |
msg | |
chat_history | |
retrieved_passage | |
rewritten_query | |
""" | |
assert ( | |
tab_name is not None | |
), "Tab name is required for the start of the conversation unless it is not preference elicitation." | |
# Formatting Input | |
print(f"User Message: {message} in Tab: {tab_name}") | |
# From string to list [{"role":"user", "content": message}, ...] | |
history = gradio_to_huggingface_message(history) | |
# We can implement context window here as we need all the system interaction. We can cut some of the early interactions if needed. | |
history = conversation_window(history, CONV_WINDOW) | |
print(f"History Length: {len(history)}") | |
print(f"History: {history}") | |
# Add system instruction to the history | |
history = format_context(system_instruction, history) | |
# Add user message to the history | |
history_with_user_utterance = format_user_message(message, history) | |
# Call API instead of locally handle it | |
outputs_text, history = generate_response(history_with_user_utterance, terminator, 128, API_URL) | |
# exclude system interaction and store the others in the history | |
history = huggingface_to_gradio_message(history) | |
if tab_name is not None: | |
print(f"Tab: {tab_name}\nSystem Output: {outputs_text}") | |
# Log the user message and response | |
log_action(tab_name, "User Message", message) | |
log_action(tab_name, "Response", outputs_text) | |
# Store the updated history for this tab | |
tab_data[tab_name]["history"] = history | |
return "", history | |
def respond_start_conversation(history, system_instruction, tab_name=None): | |
assert ( | |
tab_name is not None | |
), "Tab name is required for the start of the conversation unless it is not preference elicitation." | |
print(f"Tab: {tab_name}\nSystem Instruction:{system_instruction}") | |
history = gradio_to_huggingface_message(history) | |
history = format_context(system_instruction, history) | |
first_message = FIRST_MESSAGE | |
history_with_user_utterance = format_user_message(first_message, history) | |
outputs_text, history = generate_response(history_with_user_utterance, terminator, 128, API_URL) | |
# Format | |
history = huggingface_to_gradio_message(history) | |
if tab_name is not None: | |
print(f"Tab: {tab_name}\nHistory: {history}") | |
# Log the user message and response | |
log_action(tab_name, "User Message", first_message) | |
log_action(tab_name, "Response", outputs_text) | |
# Store the updated history for this tab | |
tab_data[tab_name]["history"] = history | |
return ( | |
history, | |
gr.Button(value="Start Conversation", interactive=False), | |
gr.Button(value="Send This Message to Advisor", interactive=True), | |
gr.Button(value="Show More of the Advisor’s Answer", interactive=True), | |
) | |
def respond_continue(history, system_instruction, tab_name=None): | |
assert tab_name is not None, "Tab name is required for the start of the conversation." | |
# print(f"Tab: {tab_name}\nSystem Instruction:{system_instruction}") | |
message = "continue" | |
history = gradio_to_huggingface_message(history) | |
history = conversation_window(history, CONV_WINDOW) | |
history = format_context(system_instruction, history) | |
history_with_user_utterance = format_user_message(message, history) | |
outputs_text, history = generate_response(history_with_user_utterance, terminator, 128, API_URL) | |
history = huggingface_to_gradio_message(history) | |
if tab_name is not None: | |
log_action(tab_name, "Show More of the Advisor’s Answer", "User continued the conversation") | |
log_action(tab_name, "Response", outputs_text) | |
# Update history for this tab | |
tab_data[tab_name]["history"] = history | |
return history | |
def respond_evaluation(evals, tab_name): | |
# dropdown, readon_button, multi-evaluator | |
log_action(tab_name, "Round Evaluation", "Following") | |
for key, value in evals.items(): | |
log_action(tab_name, key, value) | |
# Store the reason for this tab | |
tab_data[tab_name]["multi_evaluator"] = evals | |
return ( | |
evals["selection"], | |
evals["reason"], | |
evals["trust"], | |
evals["satisfaction"], | |
evals["knowledgeable"], | |
evals["helpful"], | |
) | |
def respond_final_ranking( | |
first_comp, | |
ranking_first_comp, | |
second_comp, | |
ranking_second_comp, | |
third_comp, | |
ranking_third_comp, | |
fourth_comp, | |
ranking_fourth_comp, | |
fifth_comp, | |
ranking_fifth_comp, | |
): | |
# make sure that they are not the same | |
ranking_list = [ | |
ranking_first_comp, | |
ranking_second_comp, | |
ranking_third_comp, | |
ranking_fourth_comp, | |
ranking_fifth_comp, | |
] | |
if len(set(ranking_list)) != len(ranking_list): | |
return """<div style="background-color: #fff3cd; color: #856404; padding: 15px; border: 1px solid #ffeeba; border-radius: 5px; margin-bottom: 20px;"> | |
<strong>Please make sure that you are not ranking the same stock multiple times.</strong> | |
</div>""" | |
else: | |
log_action("Final_Ranking", first_comp, ranking_first_comp) | |
log_action("Final_Ranking", second_comp, ranking_second_comp) | |
log_action("Final_Ranking", third_comp, ranking_third_comp) | |
log_action("Final_Ranking", fourth_comp, ranking_fourth_comp) | |
log_action("Final_Ranking", fifth_comp, ranking_fifth_comp) | |
return """<div style="background-color: #d4edda; color: #155724; padding: 15px; border: 1px solid #c3e6cb; border-radius: 5px; margin-bottom: 20px;"> | |
<strong>Thank you for participating in the experiment. This concludes the session. You may now close the tab.</strong> | |
</div>""" | |
def get_context(index): | |
comp = raw_context_list[index]["short_name"] | |
context = stock_context_list[index] | |
general_instruction, round_instruction = get_task_instruction_for_user(raw_context_list[index]) | |
return comp, context, general_instruction, round_instruction | |
with gr.Blocks(title="RAG Chatbot Q&A", theme="Soft") as demo: | |
first_comp, first_context, first_general_instruction, first_round_instruction = get_context(0) | |
second_comp, second_context, second_general_instruction, second_round_instruction = get_context(1) | |
third_comp, third_context, third_general_instruction, third_round_instruction = get_context(2) | |
fourth_comp, fourth_context, forth_general_instruction, forth_round_instruction = get_context(3) | |
fifth_comp, fifth_context, fifth_general_instruction, fifth_round_instruction = get_context(4) | |
user_narrative = markdown.markdown(raw_context_list[0]["user_narrative"].replace("\n", "<br>")) | |
# # initialize tab data | |
for comp in [first_comp, second_comp, third_comp, fourth_comp, fifth_comp]: | |
tab_data[comp] = {"history": [], "selection": "", "reason": ""} | |
# EXperiment Instruction | |
with gr.Tab("Experiment Instruction") as instruction_tab: | |
gr.HTML(value=INSTRUCTION_PAGE, label="Experiment Instruction") | |
# Financial decision making stage | |
with gr.Tab("Financial Decision Stage"): | |
# Experiment Tag | |
first_tab = tab_creation_exploration_stage(0) | |
click_control_exploration_stage(first_tab) | |
second_tab = tab_creation_exploration_stage(1) | |
click_control_exploration_stage(second_tab) | |
third_tab = tab_creation_exploration_stage(2) | |
click_control_exploration_stage(third_tab) | |
fourth_tab = tab_creation_exploration_stage(3) | |
click_control_exploration_stage(fourth_tab) | |
fifth_tab = tab_creation_exploration_stage(4) | |
click_control_exploration_stage(fifth_tab) | |
with gr.Tab("Final Evaluation Stage") as final_evaluation: | |
final_evaluation_tab = tab_final_evaluation(first_comp, second_comp, third_comp, fourth_comp, fifth_comp) | |
click_control_final_evaluation(final_evaluation_tab) | |
return demo | |
if __name__ == "__main__": | |
login_to_huggingface(ACCESS) | |
file_path = os.path.join(ROOT_FILE, "./data/single_stock_data/single_stock_demo.jsonl") | |
context_info = get_context(file_path) # str to List of Dict | |
# For Demo Usage, just use the first dict | |
context_info = context_info[0] | |
stock_context_list = build_context(context_info) # List of str | |
raw_context_list = build_raw_context_list(context_info) # List of str | |
# system instruction consist of Task, Personality, and Context | |
""" | |
Personality | |
["extroverted", "introverted"] | |
["agreeable", "antagonistic"] | |
["conscientious", "unconscientious"] | |
["neurotic", "emotionally stable"] | |
["open to experience", "closed to experience"]] | |
""" | |
personality = [ | |
"extroverted", | |
"agreeable", | |
"conscientious", | |
"emotionally stable", | |
"open to experience", | |
] | |
personality_prompt = build_personality_prompt(personality) | |
system_instruction_without_context = SYSTEM_INSTRUCTION_WITHOUT_PERSONALIZATION + "\n" + personality_prompt + "\n" | |
tokenizer = AutoTokenizer.from_pretrained(RESPONSE_GENERATOR) | |
tokenizer, terminator = prepare_tokenizer(tokenizer) | |
demo = create_demo(terminator, system_instruction_without_context, stock_context_list, raw_context_list) | |
demo.launch(share=True) | |