Update app.py

app.py

@@ -4,22 +4,19 @@ import json
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # --- Configuration ---
-# Updated to the 1.5B Instruct model as requested
 MODEL_ID = "Qwen/Qwen2-1.5B-Instruct"
 
 # --- Load Model and Tokenizer ---
 print(f"Loading model: {MODEL_ID}")
-# Removed trust_remote_code=True as it's generally not needed for standard HF models
-# Using torch_dtype="auto" for flexibility (can use bfloat16 if available)
 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
 model = AutoModelForCausalLM.from_pretrained(
     MODEL_ID,
-    torch_dtype="auto", # Changed from float16 to auto
+    torch_dtype="auto",
     device_map="auto"
 )
 print("Model loaded successfully.")
 
-# --- Predefined Data (Keep user's structure) ---
+# --- Predefined Data (User's structure) ---
 PREDEFINED_GAMES = {
     "rps_simple": {
         "description": "Rock-Paper-Scissors (Simple Format)",
@@ -47,8 +44,7 @@ PREDEFINED_GAMES = {
     }
 }
 
-# --- Predefined Prompts (Keep user's structure) ---
-# Updated default prompts to be more aligned with the goal
+# --- Predefined Prompts (User's structure) ---
 PROMPT_TEMPLATES = {
     "detailed_analysis_recommendation": "Analyze the game history provided. Identify patterns in the player's moves. Based on your analysis, explain the reasoning and recommend the best move for the AI (or player if specified) in the next round.",
     "player_pattern_focus": "Focus specifically on the player's move patterns. Do they favor a specific move? Do they follow sequences? Do they react predictably after winning or losing?",
@@ -56,31 +52,36 @@ PROMPT_TEMPLATES = {
     "structured_output_request": "Provide a structured analysis with these sections: 1) Obvious player patterns, 2) Potential opponent counter-strategies, 3) Final move recommendation with reasoning."
 }
 
-# --- Formatting Functions (Keep user's functions) ---
+# --- Formatting Functions (Updated format_rps_simple) ---
 def format_rps_simple(game_data):
-    """Format the RPS data in a simple way that's easy for small models to understand"""
+    """Format the RPS data clearly, explicitly stating moves and results."""
     game = game_data["data"]
     move_names = {0: "Rock", 1: "Paper", 2: "Scissors"}
-    result_names = {0: "AI wins", 1: "Player wins", 2: "Tie"}
+    result_map = {0: "AI wins", 1: "Player wins", 2: "Tie"} # Changed name
     player_moves = {"Rock": 0, "Paper": 0, "Scissors": 0}
+
     formatted_data = "Game: Rock-Paper-Scissors\n"
-    formatted_data += "Format explanation: [Round#, Player move, AI move, Result]\n"
     formatted_data += "Move codes: 0=Rock, 1=Paper, 2=Scissors\n"
-    formatted_data += "Result codes: 0=AI wins, 1=Player wins, 2=Tie\n\n"
-    formatted_data += "Game Data:\n"
+    formatted_data += "Result codes: 0=AI wins, 1=Player wins, 2=Tie\n\n" # Simplified explanation
+
+    formatted_data += "Game Data (Round, Player Move, AI Move, Result Text):\n" # Clarified header
     for round_data in game["rounds"]:
-        r_num, p_move, ai_move, result = round_data["round"], round_data["player"], round_data["ai"], round_data["result"]
+        r_num, p_move, ai_move, result_code = round_data["round"], round_data["player"], round_data["ai"], round_data["result"]
         player_moves[move_names[p_move]] += 1
-        formatted_data += f"[{r_num}, {p_move}, {ai_move}, {result}] # R{r_num}: Player {move_names[p_move]}, AI {move_names[ai_move]}, {result_names[result]}\n"
+        result_text = result_map[result_code]
+        # Explicitly add text names and result text in the main data line
+        formatted_data += f"R{r_num}: Player={move_names[p_move]}({p_move}), AI={move_names[ai_move]}({ai_move}), Result={result_text}\n"
+
     formatted_data += "\nSummary:\n"
     formatted_data += f"Player wins: {game['summary']['player_wins']}\n"
     formatted_data += f"AI wins: {game['summary']['ai_wins']}\n"
     formatted_data += f"Ties: {game['summary']['ties']}\n\n"
+
     formatted_data += "Player move frequencies:\n"
     total_rounds = len(game["rounds"])
     for move, count in player_moves.items():
          percentage = round((count / total_rounds) * 100) if total_rounds > 0 else 0
-         formatted_data += f"{move}: {count} times ({percentage}%)\n" # Corrected percentage calc
+         formatted_data += f"{move}: {count} times ({percentage}%)\n"
     return formatted_data
 
 def format_rps_numeric(game_data):
@@ -98,21 +99,16 @@ FORMAT_FUNCTIONS = {
     "rps_numeric": format_rps_numeric
 }
 
-# --- Generation Function (Updated for Chat Template) ---
+# --- Generation Function (Using Chat Template) ---
 def generate_response(messages, max_length=512, temperature=0.7, top_p=0.9):
     """Generate a response from the Qwen2 model using chat template."""
     try:
-        # Apply the chat template
         prompt_text = tokenizer.apply_chat_template(
             messages,
             tokenize=False,
-            add_generation_prompt=True # Important for instruct models
+            add_generation_prompt=True
         )
-
-        # Tokenize the formatted prompt
         model_inputs = tokenizer([prompt_text], return_tensors="pt").to(model.device)
-
-        # Generation arguments
         generation_kwargs = {
             "max_new_tokens": max_length,
             "temperature": temperature,
@@ -120,13 +116,9 @@ def generate_response(messages, max_length=512, temperature=0.7, top_p=0.9):
             "do_sample": True,
             "pad_token_id": tokenizer.eos_token_id,
         }
-
-        # Generate response
         print("Generating response...")
         with torch.no_grad():
             generated_ids = model.generate(model_inputs.input_ids, **generation_kwargs)
-
-        # Decode the response, excluding the input tokens
         input_ids_len = model_inputs.input_ids.shape[-1]
         output_ids = generated_ids[0, input_ids_len:]
         response = tokenizer.decode(output_ids, skip_special_tokens=True)
@@ -137,7 +129,7 @@ def generate_response(messages, max_length=512, temperature=0.7, top_p=0.9):
         print(f"Error during generation: {e}")
         return f"An error occurred: {str(e)}"
 
-# --- Input Processing Function (Updated for Chat Template) ---
+# --- Input Processing Function (Using Chat Template) ---
 def process_input(
     game_format,
     prompt_template,
@@ -149,135 +141,94 @@ def process_input(
     top_p
 ):
     """Process the input, format using chat template, and generate response."""
-
-    # Get the selected game data and format it
     game_data = PREDEFINED_GAMES[game_format]
-    formatted_game_data = FORMAT_FUNCTIONS[game_format](game_data) #
-
-    # Determine which prompt question to use
-    user_question = custom_prompt if use_custom_prompt else PROMPT_TEMPLATES[prompt_template] #
-
-    # Construct the user message content
+    formatted_game_data = FORMAT_FUNCTIONS[game_format](game_data)
+    user_question = custom_prompt if use_custom_prompt else PROMPT_TEMPLATES[prompt_template]
     user_content = f"Game History:\n{formatted_game_data}\n\nQuestion:\n{user_question}"
-
-    # Create the messages list for the chat template
     messages = []
-    if system_prompt and system_prompt.strip(): # Add system prompt if provided
+    if system_prompt and system_prompt.strip():
         messages.append({"role": "system", "content": system_prompt})
     messages.append({"role": "user", "content": user_content})
-
-    # Generate response from the model
     response = generate_response(
         messages,
         max_length=max_length,
         temperature=temperature,
         top_p=top_p
     )
-
-    # For display purposes, show the "user" part of the prompt
-    # (The system prompt isn't usually shown in the final input display)
     display_prompt = f"System Prompt (if used):\n{system_prompt}\n\n------\n\nUser Content:\n{user_content}"
-
     return display_prompt, response
 
-# --- Gradio Interface (Minor updates) ---
+# --- Gradio Interface (Updated system prompt placeholder) ---
+
+# Define the improved default system prompt
+DEFAULT_SYSTEM_PROMPT = """You are a highly accurate and methodical Rock-Paper-Scissors (RPS) strategy analyst.
+Your goal is to analyze the provided game history and give the user strategic advice for their next move.
+
+Follow these steps precisely:
+1.  **Verify Rules:** Remember: Rock (0) beats Scissors (2), Scissors (2) beats Paper (1), Paper (1) beats Rock (0).
+2.  **Analyze Player Moves:** Go through the 'Game Data' round by round. List the player's move and the result (Win, Loss, Tie) for each round accurately.
+3.  **Calculate Frequencies:** Use the provided 'Player move frequencies' or calculate them from the rounds. Note any strong preference.
+4.  **Identify Patterns:** Look for sequences (e.g., did the player repeat Rock twice?), reactions (e.g., what did the player do after winning/losing?), or other tendencies based *only* on the provided data. State the patterns clearly.
+5.  **Reasoning:** Explain your reasoning for the recommendation based *only* on the verified round data and identified patterns. Do not invent patterns.
+6.  **Recommendation:** Provide a single, clear recommendation (Rock, Paper, or Scissors) for the *next* round and justify it concisely based on your reasoning.
+
+Structure your response clearly with sections for Analysis, Patterns, Reasoning, and Recommendation. Be factual and base everything strictly on the provided game history."""
+
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown(f"# {MODEL_ID} - RPS Game Analysis Tester") # Updated Title
+    gr.Markdown(f"# {MODEL_ID} - RPS Game Analysis Tester")
     gr.Markdown("Test how the model responds to different RPS game data formats and prompts using its chat template.")
 
     with gr.Row():
         with gr.Column():
-            # Game data selection
             game_format = gr.Dropdown(
-                choices=list(PREDEFINED_GAMES.keys()),
-                value="rps_simple",
-                label="Game Data Format"
+                choices=list(PREDEFINED_GAMES.keys()), value="rps_simple", label="Game Data Format"
             )
-
-            # System prompt (optional)
-            # Added a more relevant placeholder based on the user's goal
+            # Use the detailed DEFAULT_SYSTEM_PROMPT as the placeholder/default value
             system_prompt = gr.Textbox(
                 label="System Prompt (Optional)",
-                placeholder="e.g., You are an expert RPS analyst. Analyze the provided game history, identify patterns, explain your reasoning clearly, and recommend the next move. Structure your output with observations, reasoning, and a final recommendation.",
-                lines=4 # Increased lines slightly
+                placeholder=DEFAULT_SYSTEM_PROMPT, # Set placeholder
+                value=DEFAULT_SYSTEM_PROMPT,       # Set default value
+                lines=15 # Increased lines to show more default text
             )
-
-            # Prompt selection
             with gr.Row():
                 prompt_template = gr.Dropdown(
-                    choices=list(PROMPT_TEMPLATES.keys()),
-                    value="detailed_analysis_recommendation", # Updated default
-                    label="Prompt Template"
+                    choices=list(PROMPT_TEMPLATES.keys()), value="detailed_analysis_recommendation", label="Prompt Template"
                 )
-                use_custom_prompt = gr.Checkbox(
-                    label="Use Custom Prompt",
-                    value=False
-                )
-
+                use_custom_prompt = gr.Checkbox(label="Use Custom Prompt", value=False)
             custom_prompt = gr.Textbox(
                 label="Custom Prompt (if Use Custom Prompt is checked)",
-                placeholder="Enter your custom prompt/question here",
-                lines=3 # Increased lines slightly
+                placeholder="Enter your custom prompt/question here", lines=3
             )
-
-            # Generation parameters
             with gr.Row():
-                max_length = gr.Slider(
-                    minimum=50,
-                    maximum=1024, # Increased max
-                    value=512,    # Increased default
-                    step=16,      # Step size power of 2
-                    label="Max New Tokens" # Renamed label
-                )
-                temperature = gr.Slider(
-                    minimum=0.1, maximum=1.5, value=0.7, step=0.05, label="Temperature" # Step size finer
-                )
-                top_p = gr.Slider(
-                    minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top P" # Step size finer
-                )
-
-            # Generate button
-            submit_btn = gr.Button("Generate Response", variant="primary") # Added variant
+                max_length = gr.Slider(minimum=50, maximum=1024, value=512, step=16, label="Max New Tokens")
+                temperature = gr.Slider(minimum=0.1, maximum=1.5, value=0.7, step=0.05, label="Temperature")
+                top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top P")
+            submit_btn = gr.Button("Generate Response", variant="primary")
 
         with gr.Column():
-            # Display final prompt and model response
-            # Renamed label for clarity
             final_prompt_display = gr.Textbox(
-                label="Formatted Input Sent to Model (via Chat Template)",
-                lines=15 # Increased lines
+                label="Formatted Input Sent to Model (via Chat Template)", lines=15
             )
             response_display = gr.Textbox(
-                label="Model Response",
-                lines=15, # Increased lines
-                show_copy_button=True # Added copy button
+                label="Model Response", lines=15, show_copy_button=True
             )
-
-            # Tips for using the interface
             gr.Markdown("""
             ## Testing Tips
-
-            - **Game Data Format**: Selects how the history is structured. 'rps_simple' is often easier for models to parse.
-            - **System Prompt**: Crucial for setting the AI's role and desired output style (like your example image). Be descriptive!
-            - **Prompt Template / Custom Prompt**: Asks the specific question based on the history and system instructions.
-            - **Generation Params**: Tune `Temperature` and `Top P` to control creativity vs. focus. Adjust `Max New Tokens` for response length.
-            - **Chat Template**: This version now correctly uses the model's chat template for better instruction following.
+            - **Game Data Format**: Selects how history is structured. 'rps_simple' uses the improved format now.
+            - **System Prompt**: Crucial for setting the AI's role and desired output style. The default is now much more detailed.
+            - **Prompt Template / Custom Prompt**: Asks the specific question.
+            - **Generation Params**: Try lowering `Temperature` (e.g., to 0.3-0.5) for more factual, less random output.
+            - **Chat Template**: This version uses the model's chat template correctly.
             """)
 
-    # Handle button click
     submit_btn.click(
         process_input,
         inputs=[
-            game_format,
-            prompt_template,
-            custom_prompt,
-            use_custom_prompt,
-            system_prompt,
-            max_length,
-            temperature,
-            top_p
+            game_format, prompt_template, custom_prompt, use_custom_prompt,
+            system_prompt, max_length, temperature, top_p
         ],
         outputs=[final_prompt_display, response_display],
-        api_name="generate_rps_analysis" # Added api_name
+        api_name="generate_rps_analysis"
     )
 
 # --- Launch the demo ---