prompt update

chatbot_simulator.py

@@ -1,5 +1,6 @@
 from openai import OpenAI
 import json_repair
+from transformers import AutoTokenizer
 
 
 class ChatbotSimulation:
@@ -12,7 +13,6 @@ class ChatbotSimulation:
         self.user_state['current_page'] = 'Home'  # Initialize current page
         self.user_state['last_page'] = 'Home'
         self.user_state['task_completed'] = 0
-        self.user_last_action = ''
         self.task = task
         self.app_name = app_name
         self.log_location = log_location
@@ -26,6 +26,7 @@ class ChatbotSimulation:
         self.prompt_count = 0
         self.client = OpenAI(api_key=openai_api_key)
         self.actions = []
+        self.tokenizer = AutoTokenizer.from_pretrained("gpt2")
 
     def _get_page_uid(self, page_name):
         """Retrieve the UID of the given page from the sitemap."""
@@ -45,7 +46,7 @@ class ChatbotSimulation:
         return f"""
 You are a text-based simulator of {self.app_name} app. 
 You are interacting with a user. User's task is: {self.task}.
-User's last page was {last_page} and the user take action: {self.user_last_action}.
+User's last page was {last_page} and the user have taken actions: {self.actions}.
 After action, user is currently on the {current_page} page. 
 Current user state: {self.user_state}.
 
@@ -59,7 +60,7 @@ Provide instructions or request input from the user. If the user provides an inv
 "Invalid action. Please select a valid option."
 
 ### Instruction Format:
-You are at the {current_page} page. You have the following options:
+<if actions is non-empty: You have successfully done {self.actions[-1]}> You are at the {current_page} page. You have the following options:
 1. Feature 1
 2. Feature 2
 3. Feature 3
@@ -70,7 +71,7 @@ Please enter your choice as 'Number. Description'. If you have a query, enter as
 Rules:
 - Be sure to display all options that is available in features. 
 - Be robotic and emotionless. Avoid offering any advice to the user.
-- If user ask to access information that you do not possess. For example, list of restaurants, you can synthesize them.
+- **If the user requests information you do not possess** (such as a list of restaurants, menus, or similar details), you are permitted to create plausible and relevant information to fulfill the request. Present this fabricated information convincingly as if it were real data.
         """
 
     def _get_openai_response(self, prompt):
@@ -80,25 +81,29 @@ Rules:
             model="gpt-4",
             messages=prompt,
             max_tokens=self.buffer_tokens,  # Adjusted max_tokens if needed
-            temperature=0,
+            temperature=0.7,
         )
         return response.choices[0].message.content
 
     def _calculate_token_count(self, conversation):
-        """Estimate the token count in the conversation."""
-        return sum(len(entry['content'].split()) for entry in conversation)
+        """Accurately calculate the token count in the conversation using a tokenizer."""
+        total_tokens = 0
+        for entry in conversation:
+            # Tokenize each entry content and count tokens
+            tokens = self.tokenizer.encode(entry['content'], truncation=False, add_special_tokens=False)
+            total_tokens += len(tokens)
+        return total_tokens
 
     def _trim_conversation(self):
         """Trim the conversation to keep it within the token limit."""
-        while self._calculate_token_count(self.conversation) >= (self.max_tokens - self.buffer_tokens * 4):
+        while self._calculate_token_count(self.conversation) >= (self.max_tokens - self.buffer_tokens * 2):
             self.conversation.pop(0)
 
     def one_conversation_round(self, user_input):
         """Conduct one round of conversation between the user and the assistant."""
         # User provides input
-        self.user_last_action = user_input
+        self.actions.append(user_input + f'on {self.user_state["current_page"]} page')
         self.conversation.append({"role": "user", "content": user_input})
-        self.actions.append(user_input)
 
         # Update user state using GPT's response
         update_prompt = f"""
@@ -131,19 +136,6 @@ Example Output Format:
         # Parse and update the user state
         updated_state = json_repair.loads(updated_state)
 
-#         if isinstance(updated_state, list):
-#             reformat_prompt = f'''
-# Given the {updated_state}, reformat it into a proper JSON.
-# Make sure follow the format:
-# {{
-#     'current_page': 'Home',
-#     'task_completed': 0,
-# }}
-#             '''
-#             self.conversation.append({"role": "assistant", "content": reformat_prompt})
-#             reformat_state = self._get_openai_response(self.conversation)
-#             updated_state = json_repair.loads(reformat_state)
-
         try:
             updated_state['task_completed'] = int(updated_state['task_completed'])
             if updated_state['task_completed']:
@@ -153,7 +145,7 @@ Example Output Format:
 
         self.user_state = updated_state
 
-        self.conversation.clear()
+        #self.conversation.clear()
         system_prompt = self._generate_system_prompt()
 
         # GPT generates the page instructions
@@ -183,7 +175,7 @@ Then generate an "Action" which is the immediate next step you can take.
         agent_response = self.client.chat.completions.create(
             model="gpt-4",
             messages=messages,
-            temperature=1.0,
+            temperature=0.7,
         )
         print(f"LLM-Agent: {agent_response.choices[0].message.content}")
         return agent_response.choices[0].message.content

task_specific_data_population.py

@@ -28,7 +28,7 @@ class DataPopulation:
             model="gpt-4",
             messages=conversation,
             max_tokens=1000,  # Adjusted max_tokens if needed
-            temperature=0,
+            temperature=0.7,
         )
         return response.choices[0].message.content.strip()
 
@@ -38,21 +38,23 @@ class DataPopulation:
             "role": "user",
             "content": (
                 f"Given the task: '{task}' and the sitemap:\n{sitemap}\n\n"
-                "Identify the page(s) relevant to this task. "
+                f"Respond first with a brief 'Plan' which suggests what data we have to pre-populate the sitemap"
+                f"to make task accomplishable. Then identify the page(s) these data going to be stored on. "
                 "Return the page names exactly as they appear in the sitemap, in JSON format. "
                 "For each relevant page, provide a brief explanation of its relevance. "
-                "Example response:\n{{\n  'Ride History': 'Displays previous ride data needed for the task.'\n}}"
+                "Example response:\nPlanning sentences. PAGES: {{\n  'Ride History': 'Displays previous ride data needed for the task.'\n}}"
             )
         })
         response_content = self.gpt4_chat(self.conversation)
         return response_content
 
-    def _update_user_data(self, task, relevant_page_details):
+    def _update_user_data(self, task, relevant_page_details, relevant_pages):
         """Populate the relevant user data for the task."""
         self.conversation.append({
             "role": "user",
             "content": (
                 f"Given the task: '{task}' and the following task-relevant page details:\n{relevant_page_details}\n\n"
+                f"Here is reason behind each relevant page: {relevant_pages}."
                 f"Update each page's 'user_data' value with essential information for task-completion."
                 f"For example, if a task ask us to retrieve previous order, then we will need to populate synthetic order history in user_data."
                 "Ensure output maintain the exact format and structure as input page details."
@@ -96,6 +98,7 @@ class DataPopulation:
 
         # Step 1: Identify relevant pages
         relevant_pages = self.ask_for_relevant_pages(task, sitemap)
+        relevant_pages = relevant_pages.split("PAGES:", 1)[1].strip()
         self.conversation.append({"role": "assistant", "content": relevant_pages})
         relevant_pages = json_repair.loads(relevant_pages)
         target_page_names = relevant_pages.keys()
@@ -109,7 +112,7 @@ class DataPopulation:
         }
 
         # Step 4: Populate user data for the task (only for relevant pages)
-        updated_user_data = self._update_user_data(task, relevant_page_details)
+        updated_user_data = self._update_user_data(task, relevant_page_details, relevant_pages)
         self.conversation.append({"role": "assistant", "content": updated_user_data})
         updated_user_data = json_repair.loads(updated_user_data)
         for uid, page_data in updated_user_data.items():