Update app.py

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import torch
+import json
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # Load the Qwen2 0.5B model
@@ -12,6 +13,114 @@ model = AutoModelForCausalLM.from_pretrained(
     trust_remote_code=True
 )
 
+# Predefined game data in compressed formats
+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 prompt templates
+PROMPT_TEMPLATES = {
+    "basic_analysis": "Who is winning right now? What patterns do you notice in the player's choices?",
+    "prediction": "Based on the player's past choices, predict what the player will choose in the next round. Explain your reasoning.",
+    "strategy": "What strategy should the AI use to improve its win rate? Provide specific recommendations.",
+    "pattern_analysis": "Analyze the frequency of each choice (rock, paper, scissors) made by the player. Is there a dominant pattern?",
+    "structured_analysis": "Provide a structured analysis with these sections: 1) Current winner, 2) Player choice patterns, 3) AI performance, 4) Recommended strategy for AI."
+}
+
+# Prompt formatters
+def format_rps_simple(game_data):
+    """Format the RPS data in a simple way that's easy for small models to understand"""
+    game = game_data["data"]
+    
+    # Create a mapping for move names
+    move_names = {0: "Rock", 1: "Paper", 2: "Scissors"}
+    result_names = {0: "AI wins", 1: "Player wins", 2: "Tie"}
+    
+    # Initialize counters for frequency analysis
+    player_moves = {"Rock": 0, "Paper": 0, "Scissors": 0}
+    
+    # Format each round in a simple way
+    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"
+    for round_data in game["rounds"]:
+        r_num = round_data["round"]
+        p_move = round_data["player"]
+        ai_move = round_data["ai"]
+        result = round_data["result"]
+        
+        # Update player move counter
+        player_moves[move_names[p_move]] += 1
+        
+        # Format as [round, player, ai, result]
+        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"
+    
+    # Add summary statistics
+    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"
+    
+    # Add player move frequencies
+    formatted_data += "Player move frequencies:\n"
+    for move, count in player_moves.items():
+        formatted_data += f"{move}: {count} times ({count*10}%)\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"
+    
+    # Format all rounds on a single line
+    rounds_str = ",".join([str(r) for r in game['rounds']])
+    formatted_data += f"Rounds: {rounds_str}\n\n"
+    
+    # Add score summary
+    formatted_data += f"Score: Player={game['score']['P']} AI={game['score']['AI']} Ties={game['score']['Tie']}\n"
+    
+    return formatted_data
+
+# Format selectors
+FORMAT_FUNCTIONS = {
+    "rps_simple": format_rps_simple,
+    "rps_numeric": format_rps_numeric
+}
+
 def generate_response(prompt, max_length=512, temperature=0.7, top_p=0.9):
     """Generate a response from the Qwen2 model based on the input prompt."""
     
@@ -38,23 +147,29 @@ def generate_response(prompt, max_length=512, temperature=0.7, top_p=0.9):
     return response.strip()
 
 def process_input(
-    raw_prompt, 
-    game_stats_template,
-    template_type,
+    game_format,
+    prompt_template,
+    custom_prompt,
+    use_custom_prompt,
+    system_prompt,
     max_length, 
     temperature, 
     top_p
 ):
-    """Process the input and template to create the final prompt for the model."""
+    """Process the input and generate a response from the model."""
     
-    final_prompt = ""
+    # Get the selected game data and format it
+    game_data = PREDEFINED_GAMES[game_format]
+    formatted_game_data = FORMAT_FUNCTIONS[game_format](game_data)
     
-    if template_type == "Raw Prompt Only":
-        final_prompt = raw_prompt
-    elif template_type == "Template + Prompt":
-        final_prompt = f"{game_stats_template}\n\n{raw_prompt}"
-    elif template_type == "Custom Format":
-        final_prompt = f"{game_stats_template}\n\nBased on the game statistics above, {raw_prompt}"
+    # Determine which prompt to use
+    prompt_text = custom_prompt if use_custom_prompt else PROMPT_TEMPLATES[prompt_template]
+    
+    # Create the final prompt with optional system prompt
+    if system_prompt:
+        final_prompt = f"{system_prompt}\n\n{formatted_game_data}\n\n{prompt_text}"
+    else:
+        final_prompt = f"{formatted_game_data}\n\n{prompt_text}"
     
     # Generate response from the model
     response = generate_response(
@@ -69,32 +184,47 @@ def process_input(
 # Create the Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("# Qwen2 0.5B Game Analysis Tester")
-    gr.Markdown("Use this interface to test how the Qwen2 0.5B model responds to different prompts about your game statistics.")
+    gr.Markdown("Test how the Qwen2 0.5B model responds to different game data formats and prompts")
     
     with gr.Row():
         with gr.Column():
-            template_type = gr.Radio(
-                ["Raw Prompt Only", "Template + Prompt", "Custom Format"],
-                label="Prompt Template Type",
-                value="Template + Prompt"
+            # Game data selection
+            game_format = gr.Dropdown(
+                choices=list(PREDEFINED_GAMES.keys()),
+                value="rps_simple",
+                label="Game Data Format"
             )
             
-            game_stats_template = gr.Textbox(
-                label="Game Statistics Template",
-                placeholder="Enter your game statistics here (scores, round history, etc.)",
-                lines=10
+            # System prompt (optional)
+            system_prompt = gr.Textbox(
+                label="System Prompt (Optional)",
+                placeholder="e.g., You are an expert game analyzer. Your task is to analyze game patterns and provide insights.",
+                lines=2
             )
             
-            raw_prompt = gr.Textbox(
-                label="Prompt",
-                placeholder="What do you want the model to analyze or respond to?",
-                lines=3
+            # Prompt selection
+            with gr.Row():
+                prompt_template = gr.Dropdown(
+                    choices=list(PROMPT_TEMPLATES.keys()),
+                    value="basic_analysis",
+                    label="Prompt Template"
+                )
+                use_custom_prompt = gr.Checkbox(
+                    label="Use Custom Prompt",
+                    value=False
+                )
+            
+            custom_prompt = gr.Textbox(
+                label="Custom Prompt (if enabled above)",
+                placeholder="Enter your custom prompt here",
+                lines=2
             )
             
+            # Generation parameters
             with gr.Row():
                 max_length = gr.Slider(
                     minimum=50, 
-                    maximum=1024, 
+                    maximum=512, 
                     value=256, 
                     step=1, 
                     label="Max Response Length"
@@ -114,40 +244,46 @@ with gr.Blocks() as demo:
                     label="Top P"
                 )
                 
+            # Generate button
             submit_btn = gr.Button("Generate Response")
         
         with gr.Column():
+            # Display final prompt and model response
             final_prompt_display = gr.Textbox(
                 label="Final Prompt Sent to Model", 
-                lines=10
+                lines=12
             )
             response_display = gr.Textbox(
                 label="Model Response", 
-                lines=15
+                lines=12
             )
+            
+            # Tips for using the interface
+            gr.Markdown("""
+            ## Testing Tips
+            
+            - The **Game Data Format** determines how game information is presented to the model
+            - The **System Prompt** can be used to provide context or role instructions
+            - **Prompt Templates** offer pre-made queries, or you can use a custom prompt
+            - Experiment with **Temperature** (higher = more creative/random, lower = more focused)
+            - Document successful prompts for fine-tuning datasets
+            """)
     
+    # Handle button click
     submit_btn.click(
         process_input,
         inputs=[
-            raw_prompt,
-            game_stats_template,
-            template_type,
+            game_format,
+            prompt_template,
+            custom_prompt,
+            use_custom_prompt,
+            system_prompt,
             max_length,
             temperature,
             top_p
         ],
         outputs=[final_prompt_display, response_display]
     )
-    
-    gr.Markdown("""
-    ## Tips for Testing
-    
-    1. Start with simple prompts to gauge the model's basic understanding
-    2. Gradually increase complexity to find the model's limitations
-    3. Try different prompt formats to see which works best
-    4. Experiment with temperature and top_p to find optimal settings
-    5. Document which prompts work well as candidates for fine-tuning
-    """)
 
 # Launch the demo
 demo.launch()