Minimal working example SPIA2024

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.venv
+wandb

SPIA2024/config.json

@@ -0,0 +1,14 @@
+{
+  "wandb_args" : {
+    "project": "spiaclass2024",
+    "tags": [
+      "dev",
+      "demo",
+      "class 01"
+    ]
+  },
+  "model_args" : {
+    "model": "gpt-4-1106-preview",
+    "temperature": 0.0
+  }
+}

SPIA2024/initial_message.txt

@@ -0,0 +1,5 @@
+Hello! My name is SurveyGPT, a conversational AI designed to help improve interview and survey research.
+
+Today I will be asking you some questions about your background and expectations.
+
+To begin, could you tell me what you hope to get out of this course?

SPIA2024/system_message.txt

@@ -0,0 +1,12 @@
+You are an AI designed to help professors better understand the needs of their classes by fielding chat-based interviews with students at the beginning of the semester.
+Your job is to conduct an interview with students where you ask them about their expectations of the course and previous relevant experience in order to produce interview transcripts that the professor can analyze and create an educational experience that is tailored to students needs, abilities and expectations.
+
+The class you are assisting with this semester is an Introduction to Machine Learning for Public Policy, taught by Professor Brandon Stewart at the School of Public and International Affairs (SPIA) at Princeton University. This is a one-semester applied introduction to machine learning for policy makers and analysts, with an emphasis on building strong foundations and core intutions for applying machine learning in social science and policy settings.
+
+Your instructions for conducting the interview are as follows:
+- Begin by asking the student what they hope to get out of the course.
+- If there are ambiguities in their answer, ask probing questions to elicit further information.
+- Once the conversation makes clear what the student hopes to get out of the course, ask about their background in quantitative and technical work or projects.
+- Finally, ask any other questions that you think are helpful.
+- Maintain a polite and professional demeanor.
+- If asked questions that you do not have the information about, such as about accommodations or assignments, advise the student to direct their question to the Professor instead.

app.py

@@ -1,14 +1,16 @@
 """
-Cognitive Debriefing App - Respondent Interface
+General-Purpose LM Interview Interface
 
 Author: Dr Musashi Hinck
 
 
-Respondent-facing app. Reads arguments from request (in form of shareable link)
+Version Log:
 
-Change Log:
-
-- 2024.01.16: Continuous logging to wandb, change name of run to `userid`
+- 2024.01.29: prototype without separate launching interface for demoing in SPIA class.
+    - Remove URL decoding
+    - Read sysprompt and initial_message from file
+    - Begins with user entering name/alias
+    - Azure OpenAI?
 
 """
 from __future__ import annotations
@@ -20,6 +22,7 @@ import wandb
 import gradio as gr
 import openai
 
+from pathlib import Path
 from base64 import urlsafe_b64decode
 
 logger = logging.getLogger(__name__)
@@ -28,90 +31,68 @@ from utils import PromptTemplate, convert_gradio_to_openai, seed_openai_key
 
 
 # %% Initialization
+CONFIG_DIR: Path = Path("./SPIA2024")
 if os.environ.get(f"OPENAI_API_KEY", "DEFAULT") == "DEFAULT":
     seed_openai_key()
 client = openai.OpenAI()
 
 
 # %% (functions)
-def decode_config(config_dta: str) -> dict[str, str | float]:
-    "Read base64_url encoded json and loads into configuration"
-    config_str: str = urlsafe_b64decode(config_dta)
-    config: dict = json.loads(config_str)
-    return config
-
-
-def load_config(request: gr.Request):
-    "Read parameters from request header"
-    config = decode_config(request.query_params["dta"])
-    survey_question = config["question"]
-    survey_template = config["template"]
-    initial_message = config["initial_message"]
-    model_args = {"model": config["model"], "temperature": config["temperature"]}
-    userid = config["userid"]
-    return survey_question, survey_template, initial_message, model_args, userid
-
-
-# Post-loading
-def update_template(question: str, template: PromptTemplate | str) -> str:
-    """
-    Updates templates. Currently only accepts a "question" variable, but can add future templating in the future.
-    """
-    if isinstance(template, str):
-        template = PromptTemplate(template)
-    if "question" in template.variables:
-        return template.format(question=question)
-    else:
-        return str(template)
-
-
-def reset_interview() -> tuple[list[list[str | None]], gr.Button, gr.Button]:
-    wandb.finish()
-    gr.Info("Interview reset.")
-    return (
-        [],
-        gr.Button("Start Interview", visible=True),
-        gr.Button("Reply", visible=False),
-        gr.Button("Save Survey", visible=False, variant="secondary"),
-        gr.Button("Save and Exit", visible=False, variant="stop"),
+def load_config(
+    path: Path,
+) -> tuple[str, str, dict[str, str | float], dict[str, str | list[str]]]:
+    "Read configs, return inital_message, system_message, model_args, wandb_args"
+    initial_message: str = (path / "initial_message.txt").read_text().strip()
+    system_message: str = (path / "system_message.txt").read_text().strip()
+    cfg: dict[str, str] = json.loads((path / "config.json").read_bytes())
+    model_args: dict[str, str | float] = cfg.get(
+        "model_args", {"model": "gpt4", "temperature": 0.0}
     )
+    wandb_args: dict = cfg.get("wandb_args")
+    return initial_message, system_message, model_args, wandb_args
 
 
 def initialize_interview(
-    system_message: str, first_question: str, model_args: dict[str, str | float]
-) -> tuple[list[list[str | None]], gr.Textbox, gr.Button, gr.Button]:
+    system_message: str, initial_message: str, model_args: dict[str, str | float]
+) -> tuple[gr.Chatbot, gr.Textbox, gr.Button, gr.Button]:
     "Read system prompt and start interview"
-    if len(first_question) == 0:
-        first_question = call_openai(
+    if len(initial_message) == 0:  # If empty inital message, ask the LM to write it.
+        initial_message = call_openai(
             [], system_message, client, model_args, stream=False
         )
-    # Use fixed prompt
-    chat_history = [[None, first_question]]
+    chat_history = [
+        [None, initial_message]
+    ]  # First item is for user, in this case bot starts interaction.
     return (
-        chat_history,
+        gr.Chatbot(visible=True, value=chat_history),
         gr.Textbox(
-            placeholder="Type response here.", interactive=True, show_label=False
-        ),
-        gr.Button(variant="primary", interactive=True),
-        gr.Button("Start Interview", visible=False),
-        gr.Button("Save and Exit", visible=True, variant="stop"),
+            placeholder="Type response here. Hit 'enter' to submit.",
+            visible=True,
+            interactive=True,
+        ),  # chatInput
+        gr.Button(visible=True, interactive=True),  # chatSubmit
+        gr.Button(visible=False),  # startInterview
+        gr.Textbox(visible=False),  # userBox
+        gr.Button(visible=True),  # resetButton
     )
 
 
 def initialize_tracker(
     model_args: dict[str, str | float],
-    question: str,
-    template: PromptTemplate,
-    userid=str,
+    system_message: PromptTemplate,
+    userid: str,
+    wandb_args: dict[str, str | list[str]],
 ) -> None:
     "Initializes wandb run for interview"
     run_config = model_args | {
-        "question": question,
-        "template": str(template),
+        "system_message": str(system_message),
         "userid": userid,
     }
     wandb.init(
-        project="cognitive-debrief", name=userid, config=run_config, tags=["dev"]
+        project=wandb_args["project"],
+        name=userid,
+        config=run_config,
+        tags=wandb_args["tags"],
     )
 
 
@@ -166,7 +147,7 @@ def call_openai(
 def user_message(
     message: str, chat_history: list[list[str | None]]
 ) -> tuple[str, list[list[str | None]]]:
-    "Displays user message immediately."
+    "Display user message immediately"
     return "", chat_history + [[message, None]]
 
 
@@ -183,6 +164,7 @@ def bot_message(
         + messages
         + [{"role": "user", "content": user_msg}]
     )
+    # API call
     response = client.chat.completions.create(
         messages=messages, stream=True, **model_args
     )
@@ -195,58 +177,65 @@ def bot_message(
             yield chat_history
 
 
+def reset_interview() -> (
+    tuple[
+        list[list[str | None]], gr.Chatbot, gr.Textbox, gr.Button, gr.Button, gr.Button
+    ]
+):
+    wandb.finish()
+    gr.Info("Interview reset.")
+    return (
+        gr.Chatbot(visible=False, value=[]),  # chatDisplay
+        gr.Textbox(visible=False),  # chatInput
+        gr.Button(visible=False),  # chatSubmit
+        gr.Textbox(value=None, visible=True),  # userBox
+        gr.Button(visible=True),  # startInterview
+        gr.Button(visible=False),  # resetButton
+    )
+
+
 # LAYOUT
 with gr.Blocks() as demo:
-    gr.Markdown("# Cognitive Debriefing Prototype")
+    gr.Markdown("# StewartLab LM Interviewer")
 
-    # Hidden values
-    surveyQuestion = gr.Textbox(visible=False)
-    surveyTemplate = gr.Textbox(visible=False)
+    # Config values
+    configDir = gr.State(value=CONFIG_DIR)
     initialMessage = gr.Textbox(visible=False)
     systemMessage = gr.Textbox(visible=False)
     modelArgs = gr.State(value={"model": "", "temperature": ""})
-    userid = gr.Textbox(visible=False, interactive=False)
+    wandbArgs = gr.State(value={"project": "", "tags": []})
 
-    ## RESPONDENT
-    chatDisplay = gr.Chatbot(
-        show_label=False,
+    ## Start interview by entering name or alias
+    userBox = gr.Textbox(
+        placeholder="Enter name or alias and hit 'enter' to begin.", show_label=False
     )
+    startInterview = gr.Button("Start Interview", variant="primary", visible=True)
+
+    ## RESPONDENT
+    chatDisplay = gr.Chatbot(show_label=False, visible=False)
     with gr.Row():
         chatInput = gr.Textbox(
             placeholder="Click 'Start Interview' to begin.",
+            visible=False,
             interactive=False,
             show_label=False,
             scale=10,
         )
         chatSubmit = gr.Button(
             "",
-            variant="secondary",
+            variant="primary",
             interactive=False,
             icon="./arrow_icon.svg",
+            visible=False,
         )
-    startInterview = gr.Button("Start Interview", variant="primary")
     resetButton = gr.Button("Save and Exit", visible=False, variant="stop")
 
     ## INTERACTIONS
     # Start Interview button
-    startInterview.click(
+    userBox.submit(
         load_config,
-        inputs=None,
-        outputs=[
-            surveyQuestion,
-            surveyTemplate,
-            initialMessage,
-            modelArgs,
-            userid,
-        ],
-    ).then(
-        update_template,
-        inputs=[surveyQuestion, surveyTemplate],
-        outputs=[systemMessage],
-    ).then(
-        update_template,
-        inputs=[surveyQuestion, initialMessage],
-        outputs=initialMessage,
+        inputs=configDir,
+        outputs=[initialMessage, systemMessage, modelArgs, wandbArgs],
     ).then(
         initialize_interview,
         inputs=[systemMessage, initialMessage, modelArgs],
@@ -255,13 +244,26 @@ with gr.Blocks() as demo:
             chatInput,
             chatSubmit,
             startInterview,
+            userBox,
             resetButton,
         ],
     ).then(
-        initialize_tracker, inputs=[modelArgs, surveyQuestion, surveyTemplate, userid]
+        initialize_tracker, inputs=[modelArgs, systemMessage, userBox, wandbArgs]
+    )
+    startInterview.click(
+        load_config,
+        inputs=None,
+        outputs=[initialMessage, systemMessage, modelArgs, wandbArgs],
+    ).then(
+        initialize_interview,
+        inputs=[systemMessage, initialMessage, modelArgs],
+        outputs=[chatDisplay, chatInput, chatSubmit, startInterview, resetButton],
+    ).then(
+        initialize_tracker, inputs=[modelArgs, systemMessage, userBox, wandbArgs]
     )
 
-    # "Enter" on textbox
+    # Chat interaction
+    # "Enter"
     chatInput.submit(
         user_message,
         inputs=[chatInput, chatDisplay],
@@ -274,8 +276,7 @@ with gr.Blocks() as demo:
     ).then(
         save_interview, inputs=[chatDisplay]
     )
-
-    # "Submit" button
+    # Button
     chatSubmit.click(
         user_message,
         inputs=[chatInput, chatDisplay],
@@ -289,9 +290,17 @@ with gr.Blocks() as demo:
         save_interview, inputs=[chatDisplay]
     )
 
+    # Reset button
     resetButton.click(save_interview, [chatDisplay]).then(
         reset_interview,
-        outputs=[chatDisplay, startInterview, resetButton],
+        outputs=[
+            chatDisplay,
+            chatInput,
+            chatSubmit,
+            userBox,
+            startInterview,
+            resetButton,
+        ],
         show_progress=False,
     )