Upload folder using huggingface_hub

.gitignore

@@ -162,4 +162,6 @@ cython_debug/
 #.idea/
 
 character_config.yaml
-sample_output.txt
+sample_output.txt
+data_collection/
+data

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

chatUI.py

@@ -3,8 +3,8 @@ import yaml
 import os
 import datetime
 
-from llm import AVAILABLE_LLMS, create_client, get_response_from_llm
-from character import load_character_config, get_character_response
+from llm import AVAILABLE_LLMS, create_client, get_response_from_llm, get_batch_responses_from_llm
+from character import load_character_config, get_character_response, build_prompt, build_system_prompt
 
 # Directory containing character YAML files
 CHARACTER_DIR = "characters"
@@ -198,28 +198,33 @@ class ChatApp:
     def chat(self, user_input, chat_history, selected_llm):
         """Handle the chat interaction."""
         if not user_input:
-            return gr.update(), chat_history
+            return "", []
 
         if self.character_config is None:
-            return gr.update(value="No character selected."), chat_history
+            return "", [{"role": "assistant", "content": "No character selected."}]
 
         # Set the API key based on the selected LLM
         api_key = self.api_key_dict.get(selected_llm, None)
         if api_key:
             self.set_environment_api_key(selected_llm, api_key)
         else:
-            return gr.update(value="Please set the API key for the selected LLM."), chat_history
+            return "", [{"role": "assistant", "content": "Please set the API key for the selected LLM."}]
 
         # Get the character's response using the provided function
         try:
             response_content = get_character_response(user_input, self.character_config, llm_model=selected_llm)
+            
+            # Create new messages list with proper format
+            messages = chat_history + [
+                {"role": "user", "content": user_input},
+                {"role": "assistant", "content": response_content}
+            ]
+            
+            return "", messages
+            
         except Exception as e:
-            return gr.update(value=f"Error during LLM processing: {e}"), chat_history
-
-        # Update chat history
-        chat_history.append((user_input, response_content))
-
-        return "", chat_history
+            error_message = [{"role": "assistant", "content": f"Error during LLM processing: {e}"}]
+            return "", error_message
 
     def set_environment_api_key(self, llm, api_key):
         """Set the environment variable for the API key based on the LLM."""
@@ -231,21 +236,146 @@ class ChatApp:
             os.environ["OPENROUTER_API_KEY"] = api_key
 
     def save_conversation(self, chat_history):
-        """Save the conversation to a file in the /conversations directory."""
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"conversation_{timestamp}.txt"
-        filepath = os.path.join(CONVERSATION_DIR, filename)
+        """Save the conversation to a file in the /home/user/conversations directory."""
+        # Use the persistent storage path for Hugging Face Spaces
+        folder = os.path.join("/home/user/conversations")
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
         character_name = self.character_config['character']['name'] if self.character_config else "AI"
-        with open(filepath, 'w') as f:
-            for idx, (user_msg, ai_msg) in enumerate(chat_history):
-                f.write(f"User: {user_msg}\n")
-                f.write(f"{character_name}: {ai_msg}\n\n")
-        return f"Conversation saved as {filename} in /{CONVERSATION_DIR} directory."
+        safe_char_name = "".join(c for c in character_name if c.isalnum() or c in ('-', '_')).lower()
+        filename = f"chat_{timestamp}_{safe_char_name}.txt"
+        filepath = os.path.join(folder, filename)
+        
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(f"Conversation with {character_name}\n")
+                f.write(f"Timestamp: {timestamp}\n")
+                f.write("-" * 50 + "\n\n")
+                for message in chat_history:
+                    role = message["role"]
+                    content = message["content"]
+                    if role == "user":
+                        f.write(f"User: {content}\n")
+                    else:
+                        f.write(f"{character_name}: {content}\n")
+                    f.write("\n")
+            return f"Conversation saved as {filename}"
+        except Exception as e:
+            return f"Error saving conversation: {e}"
 
     def new_conversation(self):
-        """Start a new conversation by resetting chat history."""
+        """Clear the chat history."""
         return [], []
 
+    def collect_data(self, user_question, k, selected_llm):
+        """Have LLM respond K times to a user question for data collection."""
+        if not user_question:
+            return "Please enter a question.", None
+        if self.character_config is None:
+            return "No character selected.", None
+        api_key = self.api_key_dict.get(selected_llm, None)
+        if api_key:
+            self.set_environment_api_key(selected_llm, api_key)
+        else:
+            return "Please set the API key for the selected LLM.", None
+            
+        prompt = build_prompt(user_question, self.character_config)
+        system_prompt = build_system_prompt(self.character_config['character']['name'])
+        client, model = create_client(selected_llm)
+        try:
+            responses, _ = get_batch_responses_from_llm(
+                msg=prompt,
+                client=client,
+                model=model,
+                system_message=system_prompt,
+                temperature=0.9,
+                n_responses=int(k)
+            )
+            # Format responses for the Dataframe with separate up/down columns
+            responses_data = [[str(i+1), resp, "⬆️", "⬇️"] for i, resp in enumerate(responses)]
+            return "", responses_data
+        except Exception as e:
+            return f"Error during LLM processing: {e}", None
+
+    def save_data_collection(self, user_question, ranked_responses):
+        """Save the question, responses, and their rankings in a format optimized for DPO training."""
+        # Use the persistent storage path for Hugging Face Spaces
+        folder = os.path.join("/home/user/dpo_training")
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+            
+        try:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+            character_config = self.character_config or {}
+            character_name = character_config.get('character', {}).get('name', "Unknown")
+            safe_char_name = "".join(c for c in character_name if c.isalnum() or c in ('-', '_')).lower()
+            
+            jsonl_filename = f"dpo_{timestamp}_{safe_char_name}.jsonl"
+            jsonl_file = os.path.join(folder, jsonl_filename)
+            
+            system_prompt = build_system_prompt(character_name) if self.character_config else ""
+            
+            import json
+            with open(jsonl_file, 'w', encoding='utf-8') as f:
+                for i, (rank1, chosen_response, _, _) in enumerate(ranked_responses[:-1]):
+                    for j, (rank2, rejected_response, _, _) in enumerate(ranked_responses[i+1:], i+1):
+                        messages = [
+                            {
+                                "role": "system",
+                                "content": system_prompt
+                            },
+                            {
+                                "role": "user",
+                                "content": user_question
+                            }
+                        ]
+                        
+                        dpo_example = {
+                            "messages": messages,
+                            "chosen": chosen_response,
+                            "rejected": rejected_response,
+                            "prompt": user_question,
+                            "system_prompt": system_prompt,
+                            "character_name": character_name,
+                            "ranking_info": {
+                                "chosen_rank": int(rank1),
+                                "rejected_rank": int(rank2)
+                            },
+                            "metadata": {
+                                "timestamp": timestamp,
+                                "session_id": timestamp
+                            }
+                        }
+                        
+                        f.write(json.dumps(dpo_example, ensure_ascii=False) + '\n')
+                    
+            return f"Rankings saved to {jsonl_filename}"
+        except Exception as e:
+            return f"Error saving rankings: {e}"
+
+    def move_row(self, data, evt: gr.SelectData):
+        """Move a row up or down based on which column was clicked."""
+        if not data or not evt:
+            return data
+        
+        row_idx = evt.index[0]
+        col_idx = evt.index[1]  # Get column index instead of name
+        
+        if col_idx == 2 and row_idx > 0:  # Up column (index 2)
+            # Swap with row above
+            data[row_idx], data[row_idx-1] = data[row_idx-1], data[row_idx]
+        elif col_idx == 3 and row_idx < len(data) - 1:  # Down column (index 3)
+            # Swap with row below
+            data[row_idx], data[row_idx+1] = data[row_idx+1], data[row_idx]
+        
+        # Update ranks
+        for i, row in enumerate(data):
+            row[0] = str(i + 1)
+        
+        return data
+
 # Instantiate the ChatApp
 app = ChatApp()
 
@@ -269,7 +399,6 @@ with gr.Blocks() as demo:
         character_dropdown = gr.Dropdown(
             label="Select Character", choices=["New Character"] + character_names, value=character_names[0] if character_names else "New Character"
         )
-
         # Character Details
         with gr.Accordion("Character Details", open=True):
             name_input = gr.Textbox(label="Name")
@@ -320,7 +449,7 @@ with gr.Blocks() as demo:
 
     with gr.Tab("Chat"):
         gr.Markdown("## Chat Interface")
-        chatbot = gr.Chatbot()
+        chatbot = gr.Chatbot(type="messages")
         user_input = gr.Textbox(label="Your Message:", placeholder="Type your message here...")
         send_button = gr.Button("Send")
 
@@ -347,7 +476,119 @@ with gr.Blocks() as demo:
         save_status = gr.Textbox(label="Save Status", interactive=False)
         save_button.click(app.save_conversation, inputs=[chatbot], outputs=save_status)
 
+    with gr.Tab("Data Collection"):
+        gr.Markdown("""
+        ## Data Collection Interface
+        This interface helps collect multiple AI responses for the same question to evaluate response quality.
+        
+        ### How to use:
+        1. Enter your question
+        2. Choose how many responses you want
+        3. Generate responses
+        4. Use ⬆️ and ⬇️ buttons to reorder responses (top = best)
+        5. Save the rankings
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                data_question_input = gr.Textbox(
+                    label="Question for the AI Character",
+                    placeholder="Type your question here...",
+                    lines=3
+                )
+            with gr.Column(scale=1):
+                k_input = gr.Slider(
+                    minimum=2,
+                    maximum=10,
+                    value=5,
+                    step=1,
+                    label="Number of Responses to Generate"
+                )
+                llm_dropdown_data = gr.Dropdown(
+                    label="Select Language Model",
+                    choices=app.available_llms,
+                    value=app.available_llms[0] if app.available_llms else None
+                )
+                
+        generate_button = gr.Button("🔄 Generate Responses", variant="primary")
+        
+        collection_status = gr.Textbox(
+            label="Generation Status",
+            interactive=False,
+            visible=False
+        )
+
+        # New interface for ranking responses
+        responses_df = gr.Dataframe(
+            headers=["Rank", "Response", "Up", "Down"],
+            datatype=["str", "str", "str", "str"],
+            col_count=(4, "fixed"),
+            interactive=True,
+            wrap=True,
+            row_count=10,
+            label="Click ⬆️ or ⬇️ to reorder responses (top = best)",
+            type="array"
+        )
+            
+        def move_row(data, evt: gr.SelectData):
+            """Move a row up or down based on which column was clicked."""
+            if not data or not evt:
+                return data
+            
+            row_idx = evt.index[0]
+            col_idx = evt.index[1]  # Get column index instead of name
+            
+            if col_idx == 2 and row_idx > 0:  # Up column (index 2)
+                # Swap with row above
+                data[row_idx], data[row_idx-1] = data[row_idx-1], data[row_idx]
+            elif col_idx == 3 and row_idx < len(data) - 1:  # Down column (index 3)
+                # Swap with row below
+                data[row_idx], data[row_idx+1] = data[row_idx+1], data[row_idx]
+            
+            # Update ranks
+            for i, row in enumerate(data):
+                row[0] = str(i + 1)
+            
+            return data
+
+        # Add click handler for both Up and Down columns
+        responses_df.select(
+            move_row,
+            inputs=[responses_df],
+            outputs=[responses_df]
+        )
+
+        submit_ranking_button = gr.Button("💾 Save Rankings", variant="secondary")
+        data_save_status = gr.Textbox(
+            label="Save Status",
+            interactive=False,
+            visible=False
+        )
+
+        # Show status messages when they contain content
+        collection_status.change(
+            lambda x: gr.update(visible=bool(x.strip())),
+            inputs=[collection_status],
+            outputs=[collection_status]
+        )
+        
+        data_save_status.change(
+            lambda x: gr.update(visible=bool(x.strip())),
+            inputs=[data_save_status],
+            outputs=[data_save_status]
+        )
+
+        generate_button.click(
+            app.collect_data,
+            inputs=[data_question_input, k_input, llm_dropdown_data],
+            outputs=[collection_status, responses_df]
+        )
         
+        submit_ranking_button.click(
+            app.save_data_collection,
+            inputs=[data_question_input, responses_df],
+            outputs=[data_save_status]
+        )
 
     # Initialize UI components with default character data
     if app.character_config: