Update app.py

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 import torch
-import json
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # --- Configuration ---
@@ -16,90 +15,8 @@ model = AutoModelForCausalLM.from_pretrained(
 )
 print("Model loaded successfully.")
 
-# --- Predefined Data (User's structure) ---
-PREDEFINED_GAMES = {
-    "rps_simple": {
-        "description": "Rock-Paper-Scissors (Simple Format)",
-        "data": {
-            "game_type": "rps",
-            "encoding": {"rock": 0, "paper": 1, "scissors": 2},
-            "result_encoding": {"ai_win": 0, "player_win": 1, "tie": 2},
-            "rounds": [
-                {"round": 1, "player": 0, "ai": 2, "result": 1}, {"round": 2, "player": 1, "ai": 1, "result": 2},
-                {"round": 3, "player": 2, "ai": 0, "result": 0}, {"round": 4, "player": 0, "ai": 0, "result": 2},
-                {"round": 5, "player": 1, "ai": 0, "result": 1}, {"round": 6, "player": 2, "ai": 2, "result": 2},
-                {"round": 7, "player": 0, "ai": 1, "result": 0}, {"round": 8, "player": 1, "ai": 2, "result": 0},
-                {"round": 9, "player": 2, "ai": 1, "result": 1}, {"round": 10, "player": 0, "ai": 2, "result": 1}
-            ],
-            "summary": {"player_wins": 4, "ai_wins": 3, "ties": 3}
-        }
-    },
-    "rps_numeric": {
-        "description": "Rock-Paper-Scissors (Compressed Numeric Format)",
-        "data": {
-            "rules": "RPS: 0=Rock,1=Paper,2=Scissors. Result: 0=AI_win,1=Player_win,2=Tie",
-            "rounds": [[1,0,2,1],[2,1,1,2],[3,2,0,0],[4,0,0,2],[5,1,0,1],[6,2,2,2],[7,0,1,0],[8,1,2,0],[9,2,1,1],[10,0,2,1]],
-            "score": {"P": 4, "AI": 3, "Tie": 3}
-        }
-    }
-}
-
-# --- 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?",
-    "brief_recommendation": "Based on the history, what single move (Rock, Paper, or Scissors) should be played next and give a one-sentence justification?",
-    "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 (Updated format_rps_simple) ---
-def format_rps_simple(game_data):
-    """Format the RPS data clearly, explicitly stating moves and results."""
-    game = game_data["data"]
-    move_names = {0: "Rock", 1: "Paper", 2: "Scissors"}
-    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 += "Move codes: 0=Rock, 1=Paper, 2=Scissors\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_code = round_data["round"], round_data["player"], round_data["ai"], round_data["result"]
-        player_moves[move_names[p_move]] += 1
-        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"
-    return formatted_data
-
-def format_rps_numeric(game_data):
-    """Format the RPS data in a highly compressed numeric format"""
-    game = game_data["data"]
-    formatted_data = "RPS Game Data (compressed format)\n"
-    formatted_data += f"Rules: {game['rules']}\n\n"
-    rounds_str = ",".join([str(r) for r in game['rounds']])
-    formatted_data += f"Rounds: {rounds_str}\n\n"
-    formatted_data += f"Score: Player={game['score']['P']} AI={game['score']['AI']} Ties={game['score']['Tie']}\n"
-    return formatted_data
-
-FORMAT_FUNCTIONS = {
-    "rps_simple": format_rps_simple,
-    "rps_numeric": format_rps_numeric
-}
-
-# --- Generation Function (Using Chat Template) ---
+
+# --- Generation Function (Using Chat Template - No changes needed here) ---
 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:
@@ -129,106 +46,142 @@ 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 (Using Chat Template) ---
+# --- Input Processing Function (Simplified for Frequency Stats) ---
 def process_input(
-    game_format,
-    prompt_template,
-    custom_prompt,
-    use_custom_prompt,
+    player_stats,
+    ai_stats,
     system_prompt,
+    user_query, # Changed from prompt template/custom
     max_length,
     temperature,
     top_p
 ):
-    """Process the input, format using chat template, and generate response."""
-    game_data = PREDEFINED_GAMES[game_format]
-    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}"
+    """Process frequency stats and user query for the model."""
+
+    # Construct the user message content using the provided stats and query
+    user_content = f"Player Move Frequency Stats:\n{player_stats}\n\n"
+    if ai_stats and ai_stats.strip(): # Include AI stats if provided
+         user_content += f"AI Move Frequency Stats:\n{ai_stats}\n\n"
+    user_content += f"User Query:\n{user_query}"
+
+    # Create the messages list for the chat template
     messages = []
-    if system_prompt and system_prompt.strip():
+    if system_prompt and system_prompt.strip(): # Add system prompt if provided
         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 constructed input
     display_prompt = f"System Prompt (if used):\n{system_prompt}\n\n------\n\nUser Content:\n{user_content}"
-    return display_prompt, response
 
-# --- Gradio Interface (Updated system prompt placeholder) ---
+    return display_prompt, response
 
-# 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.
+# --- Gradio Interface (Simplified for Frequency Stats) ---
 
-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.
+# Define a default system prompt suitable for frequency analysis
+DEFAULT_SYSTEM_PROMPT = """You are an expert Rock-Paper-Scissors (RPS) strategist.
+Analyze the provided frequency statistics for the player's (and potentially AI's) past moves.
+Based *only* on these statistics, determine the statistically optimal counter-strategy or recommendation for the AI's next move.
+Explain your reasoning clearly based on the probabilities implied by the frequencies and the rules of RPS (Rock beats Scissors, Scissors beats Paper, Paper beats Rock).
+Provide a clear recommendation (Rock, Paper, or Scissors) and justify it using expected outcomes or probabilities."""
 
-Structure your response clearly with sections for Analysis, Patterns, Reasoning, and Recommendation. Be factual and base everything strictly on the provided game history."""
+# Default example stats
+DEFAULT_PLAYER_STATS = "Rock: 40%\nPaper: 30%\nScissors: 30%"
+DEFAULT_AI_STATS = "Rock: 33%\nPaper: 34%\nScissors: 33%" # Example AI stats
+DEFAULT_USER_QUERY = "Based on the player's move frequencies, what move should the AI make next to maximize its statistical chance of winning? Explain your reasoning."
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    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.")
+    gr.Markdown(f"# {MODEL_ID} - RPS Frequency Analysis Tester")
+    gr.Markdown("Test how the model provides strategic advice based *only* on Player and AI move frequency statistics.")
 
     with gr.Row():
-        with gr.Column():
-            game_format = gr.Dropdown(
-                choices=list(PREDEFINED_GAMES.keys()), value="rps_simple", label="Game Data Format"
+        with gr.Column(scale=2): # Make input column wider
+            # Input for Player Stats
+            player_stats_input = gr.Textbox(
+                label="Player Move Frequency Stats",
+                value=DEFAULT_PLAYER_STATS,
+                lines=4,
+                info="Enter the observed frequencies of the player's moves."
             )
-            # Use the detailed DEFAULT_SYSTEM_PROMPT as the placeholder/default value
-            system_prompt = gr.Textbox(
+             # Input for AI Stats (Optional)
+            ai_stats_input = gr.Textbox(
+                label="AI Move Frequency Stats (Optional)",
+                value=DEFAULT_AI_STATS,
+                lines=4,
+                info="Optionally, enter the AI's own move frequencies if relevant."
+            )
+            # Input for User Query
+            user_query_input = gr.Textbox(
+                label="Your Query / Instruction",
+                value=DEFAULT_USER_QUERY,
+                lines=3,
+                info="Ask the specific question based on the frequency stats."
+            )
+            # System prompt (optional)
+            system_prompt_input = gr.Textbox(
                 label="System Prompt (Optional)",
-                placeholder=DEFAULT_SYSTEM_PROMPT, # Set placeholder
-                value=DEFAULT_SYSTEM_PROMPT,       # Set default value
-                lines=15 # Increased lines to show more default text
+                value=DEFAULT_SYSTEM_PROMPT,
+                placeholder="Define the AI's role and task based on frequency stats...",
+                lines=10 # Reduced lines needed
             )
-            with gr.Row():
-                prompt_template = gr.Dropdown(
-                    choices=list(PROMPT_TEMPLATES.keys()), value="detailed_analysis_recommendation", label="Prompt Template"
-                )
-                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
+
+        with gr.Column(scale=1): # Make params/output column narrower
+             # Generation parameters
+            gr.Markdown("## Generation Parameters")
+            max_length_slider = gr.Slider(
+                minimum=50, maximum=1024, value=350, step=16, label="Max New Tokens" # Reduced default length needed
             )
-            with gr.Row():
-                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")
+            temperature_slider = gr.Slider(
+                minimum=0.1, maximum=1.5, value=0.5, step=0.05, label="Temperature" # Defaulting lower for stats analysis
+            )
+            top_p_slider = gr.Slider(
+                minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top P"
+            )
+            # Generate button
             submit_btn = gr.Button("Generate Response", variant="primary")
 
-        with gr.Column():
+            # Tips for using the interface
+            gr.Markdown("""
+            ## Testing Tips
+            - Input player move frequencies directly. AI stats are optional.
+            - Refine the **User Query** to guide the model's task.
+            - Adjust the **System Prompt** for role/task definition.
+            - Use lower **Temperature** for more deterministic, calculation-like responses based on stats.
+            """)
+
+    with gr.Row():
+         with gr.Column():
+            # Display final prompt and model response
             final_prompt_display = gr.Textbox(
                 label="Formatted Input Sent to Model (via Chat Template)", lines=15
             )
+         with gr.Column():
             response_display = gr.Textbox(
                 label="Model Response", lines=15, show_copy_button=True
             )
-            gr.Markdown("""
-            ## Testing Tips
-            - **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 - Updated inputs list
     submit_btn.click(
         process_input,
         inputs=[
-            game_format, prompt_template, custom_prompt, use_custom_prompt,
-            system_prompt, max_length, temperature, top_p
+            player_stats_input,
+            ai_stats_input,
+            system_prompt_input,
+            user_query_input, # New input
+            max_length_slider,
+            temperature_slider,
+            top_p_slider
         ],
         outputs=[final_prompt_display, response_display],
-        api_name="generate_rps_analysis"
+        api_name="generate_rps_frequency_analysis" # Updated api_name
     )
 
 # --- Launch the demo ---