diff --git a/ai_diplomacy/prompt_constructor.py b/ai_diplomacy/prompt_constructor.py index 24780ac..5bff2ff 100644 --- a/ai_diplomacy/prompt_constructor.py +++ b/ai_diplomacy/prompt_constructor.py @@ -127,6 +127,13 @@ def build_context_prompt( if display_phase is None: display_phase = year_phase + # Check if max_year is in the template and handle it + if "{max_year}" in context_template: + # For now, we'll use a default value or extract from game if available + # This could be passed as a parameter or extracted from game settings + max_year = getattr(game, 'max_year', 1935) # Default to 1935 if not available + context_template = context_template.replace("{max_year}", str(max_year)) + context = context_template.format( power_name=power_name, current_phase=display_phase, diff --git a/ai_diplomacy/prompts/prompts_benchmark/austria_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/austria_system_prompt.txt new file mode 100644 index 0000000..468d4d8 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/austria_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as AUSTRIA in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/context_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/context_prompt.txt new file mode 100644 index 0000000..236ca58 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/context_prompt.txt @@ -0,0 +1,35 @@ +Your Power: {power_name} +Current Phase: {current_phase} +Game Ends After: {max_year} + +# Your Power's Home Centers +{home_centers} +Note: You can only build units in your home centers if they are empty. If you lose control of a home center, you cannot build units there, so holding them is critical. + +# Player Status +Current Goals: +{agent_goals} + +# Relationships: +{agent_relationships} + +# Order History +{order_history} + +# Game Map +Unit Locations: +{all_unit_locations} + +Supply Centers Held: +{all_supply_centers} + +Possible Orders For {current_phase} +{possible_orders} +End Possible Orders + +# Recent Private Diary Entries (Your inner thoughts and plans): +{agent_private_diary} + +Messages This Round +{messages_this_round} +End Messages \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/conversation_instructions.txt b/ai_diplomacy/prompts/prompts_benchmark/conversation_instructions.txt new file mode 100644 index 0000000..55bb2d4 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/conversation_instructions.txt @@ -0,0 +1,28 @@ +NEGOTIATION MESSAGES + +TASK +Generate one or more (preferably several) strategic messages to advance your interests. +Always prioritize responding to the messages in the "RECENT MESSAGES REQUIRING YOUR ATTENTION" section. +Maintain consistent conversation threads (unless you are choosing to ignore). + +RESPONSE FORMAT +Return ONLY a single JSON array containing one or more message objects, remembering to properly escape strings: + +Required JSON structure: +[ + { + "message_type": "global" or "private", + "content": "Your message text" + }, + ... +] + +For private messages, also include the recipient: +[ + { + "message_type": "private", + "recipient": "POWER_NAME", + "content": "Your message text" + }, + ... +] \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/diary_consolidation_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/diary_consolidation_prompt.txt new file mode 100644 index 0000000..6538041 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/diary_consolidation_prompt.txt @@ -0,0 +1,18 @@ +DIARY CONSOLIDATION REQUEST +Your Power: {power_name} + +GAME CONTEXT +You are playing Diplomacy, a strategic board game set in pre-WWI Europe. Seven powers compete for control by conquering supply centers. Victory requires 18 supply centers. + +FULL DIARY HISTORY +{full_diary_text} + +TASK +Create a concise consolidated summary of the most important parts of this diary history. It will serve as your long-term memory. Do not include anything that is not strategically or diplomatically useful going forward. Aim for 300 words. + +Prioritize the following: +1. **Key Historical Diplomatic Events:** Prioritise both *strategically impactful* and *recent* events. +2. **Information that has ongoing importance & usefulness** + +RESPONSE FORMAT +Return ONLY the consolidated summary text. Do not include JSON, formatting markers, or meta-commentary. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/england_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/england_system_prompt.txt new file mode 100644 index 0000000..b880942 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/england_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as ENGLAND in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/few_shot_example.txt b/ai_diplomacy/prompts/prompts_benchmark/few_shot_example.txt new file mode 100644 index 0000000..cf0f3ba --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/few_shot_example.txt @@ -0,0 +1,30 @@ +EXAMPLE GAME STATE +Power: FRANCE +Phase: S1901M +Your Units: ['A PAR','F BRE'] +Possible Orders: + PAR: ['A PAR H','A PAR - BUR','A PAR - GAS'] + BRE: ['F BRE H','F BRE - MAO'] + +PAST PHASE SUMMARIES +- Your move A BUD -> SER bounced last time because Turkey also moved A SMY -> SER with support. +- Your support F TRI S A BUD -> SER was wasted because F TRI was needed to block Ionian invasion. + +THINKING PROCESS +1. Consider enemy units, centers, and likely moves +2. Review your units, centers, and strategic position +3. Analyze recent conversations and phase summaries +4. Evaluate public/private goals and reality of positions +5. Choose best strategic moves from possible orders + +Example thought process: +- Germany might move to BUR with support - consider bounce or defend +- Moving A PAR -> BUR is aggressive but strategic +- F BRE -> MAO secures Atlantic expansion +- Avoid contradictory or random supports + +RESPONSE FORMAT +PARSABLE OUTPUT: +{{ + "orders": ["A PAR - BUR","F BRE - MAO"] +}} \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/france_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/france_system_prompt.txt new file mode 100644 index 0000000..9284fba --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/france_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as France in a game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/germany_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/germany_system_prompt.txt new file mode 100644 index 0000000..4d2afc8 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/germany_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as GERMANY in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/initial_state_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/initial_state_prompt.txt new file mode 100644 index 0000000..e69de29 diff --git a/ai_diplomacy/prompts/prompts_benchmark/italy_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/italy_system_prompt.txt new file mode 100644 index 0000000..f7f457a --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/italy_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as ITALY in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/negotiation_diary_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/negotiation_diary_prompt.txt new file mode 100644 index 0000000..ac89dec --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/negotiation_diary_prompt.txt @@ -0,0 +1,46 @@ +NEGOTIATION SUMMARY REQUEST +Power: {power_name} +Phase: {current_phase} + +Game State: +{board_state_str} + +Private Diary: +{private_diary_summary} + +Messages This Round: +{messages_this_round} + +Goals: +{agent_goals} + +Relationships: +{agent_relationships} + + + +TASK +Analyze the negotiations, goals, relationships, and game state to: +1. Summarize key outcomes and agreements concisely +2. Concisely state your specific intents for {current_phase}, including moves you have agreed to in negotiations and whether you intend to fulfil them. +3. Update relationships as needed (Enemy, Unfriendly, Neutral, Friendly, Ally) +4. Include your latest overarching goals (including any updates) +5. Important: You will not see the full negotiation log in the order decision phase, so you must transmit key information about the negotiations to your future self via this summary. + +RESPONSE FORMAT +Return ONLY a JSON object with this structure: + +{{ + "negotiation_summary": "Key outcomes from negotiations", + "intent": "Specific intent for upcoming orders this phase", + "updated_relationships": {{ + "POWER_NAME": "Enemy|Unfriendly|Neutral|Friendly|Ally" + }}, + "goals": [ + "goal 1", + "goal 2", + ... + ] +}} + +Reminder: If you need to quote something, only use single quotes in the actual messages so as not to interfere with the JSON structure. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/order_diary_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/order_diary_prompt.txt new file mode 100644 index 0000000..1ca3c87 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/order_diary_prompt.txt @@ -0,0 +1,24 @@ +ORDER DIARY ENTRY +Power: {power_name} +Phase: {current_phase} + +ORDERS ISSUED +{orders_list_str} + +CURRENT STATUS +Game State: +{board_state_str} + +Relationships: +{agent_relationships} + +TASK +Write a concise diary note summarizing your orders. + +RESPONSE FORMAT +Return ONLY a JSON object with this structure: +{ +"order_summary": "Brief summary of orders and strategic intent" +} + +Do not include any text outside the JSON. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/order_instructions_adjustment_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_adjustment_phase.txt new file mode 100644 index 0000000..907c7c4 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_adjustment_phase.txt @@ -0,0 +1,32 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows your units' allowed adjustment orders +2. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F STP/NC B' + - Only fleet builds need coast specification. + +# Adjustment Phase Orders: +You have two main order types in the adjustment phase: +Build: '[UnitType] [Location] B' +e.g. 'A PAR B', 'F LON B' +Disband: '[UnitType] [Location] D' +e.g. 'A PAR D', 'F LON D' + +Your Task: +1. Reason + - comprehensive reasoning about your adjustment decisions +2. Output Moves in JSON + - return all build/disband orders needed + +Respond with this exact format: + +Reasoning: +(Your reasoning goes here) + +PARSABLE OUTPUT: +{{ + "orders": ["order1", "order2", ...] +}} \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/order_instructions_movement_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_movement_phase.txt new file mode 100644 index 0000000..251d940 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_movement_phase.txt @@ -0,0 +1,28 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows your units' allowed moves & supports of your own units. +2. The possible orders section does *not* list possible supports for other powers' units; you can work these out yourself by looking at the units that are adjacent to your own. +3. If your goal is to *take* a province, give exactly one move order on that province and any additional support from other units must be properly formatted support orders. +4. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F SPA/SC - MAO' + - Only fleets need coast specification. +5. Aim to issue an order for all of your units. Holds tend to be wasted orders. + +Your Task: +1. Reason + - comprehensive reasoning about your move decisions +2. Output Moves in JSON + - aim to return an order for each of your units. + +Respond with this exact format: + +Reasoning: +(Your reasoning goes here) + +PARSABLE OUTPUT: +{{ + "orders": ["order1", "order2", ...] +}} \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/order_instructions_retreat_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_retreat_phase.txt new file mode 100644 index 0000000..33a0130 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/order_instructions_retreat_phase.txt @@ -0,0 +1,30 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows where your dislodged units can retreat. +2. Units cannot retreat to: + - The province they were dislodged from + - A province occupied after this turn's moves + - A province where a standoff occurred +3. If no valid retreat exists, the unit must disband. +4. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F SPA/SC - MAO' + - Only fleet retreat orders need coast specification. + +Your Task: +1. Reason + - comprehensive reasoning about your retreat decisions +2. Output Moves in JSON + - provide a retreat or disband order for each dislodged unit + +Respond with this exact format: + +Reasoning: +(Your reasoning goes here) + +PARSABLE OUTPUT: +{{ + "orders": ["order1", "order2", ...] +}} \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/phase_result_diary_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/phase_result_diary_prompt.txt new file mode 100644 index 0000000..b992ed8 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/phase_result_diary_prompt.txt @@ -0,0 +1,45 @@ +PHASE RESULT ANALYSIS +Your Power: {power_name} +Phase: {current_phase} + +RECENT DIARY ENTRIES +{formatted_diary} + +BOARD STATE +{board_state} + +PHASE SUMMARY +{phase_summary} + +ALL POWERS' ORDERS THIS PHASE +{all_orders_formatted} + +YOUR NEGOTIATIONS THIS PHASE +{your_negotiations} + +YOUR RELATIONSHIPS BEFORE THIS PHASE +{pre_phase_relationships} + +YOUR GOALS +{agent_goals} + +TASK +Analyze what actually happened this phase compared to negotiations and expectations. + +Consider: +1. BETRAYALS: Who broke their promises? Did you break any promises? +2. COLLABORATIONS: Which agreements were successfully executed? +3. SURPRISES: What unexpected moves occurred? +4. IMPACT: How did these events affect your strategic position? + +Write a concise diary entry (100-150 words) of the most important things you would like to remember, e.g.: +- Key betrayals or successful collaborations +- Assess impact on your position +- Update your understanding of other powers' trustworthiness +- Strategic lessons learned +- Moves that failed, and ideas on how to avoid the error in the future + +Focus on concrete events and their implications for your future strategy. + +RESPONSE FORMAT +Return ONLY a diary entry text. Do not include JSON or formatting markers. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/planning_instructions.txt b/ai_diplomacy/prompts/prompts_benchmark/planning_instructions.txt new file mode 100644 index 0000000..2b6cb9a --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/planning_instructions.txt @@ -0,0 +1,44 @@ +STRATEGIC PLANNING + +PRIMARY OBJECTIVE +Capture 18 supply centers to win. Be aggressive and expansionist. +- Prioritize capturing supply centers +- Seize opportunities aggressively +- Take calculated risks for significant gains +- Find alternative paths if blocked +- Avoid purely defensive postures + +KEY CONSIDERATIONS +1. Target Supply Centers + - Which centers can you capture this phase? + - Which centers should you target in future phases? + +2. Success Requirements + - What must happen for your moves to succeed? + - How to prevent bounces? + +3. Diplomatic Strategy + - Which negotiations could help your moves succeed? + - What deals or threats might be effective? + - Consider alliances, deception, and concessions + +4. Defense Assessment + - Which of your centers might others target? + - How can you protect vulnerable positions? + +5. Diplomatic Protection + - What negotiations could deter attacks? + - How to mislead potential attackers? + +TASK +Write a detailed one-paragraph directive covering: +- Supply centers to capture +- How to capture them (orders, allies, deals) +- Defensive considerations +- Diplomatic approach (including potential deception) + + +This directive will guide your future negotiations and orders. +Be specific, strategic, and wary of deception from others. + +RESPOND WITH YOUR DIRECTIVE BELOW diff --git a/ai_diplomacy/prompts/prompts_benchmark/russia_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/russia_system_prompt.txt new file mode 100644 index 0000000..40b7e15 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/russia_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as RUSSIA in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/state_update_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/state_update_prompt.txt new file mode 100644 index 0000000..acf3e64 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/state_update_prompt.txt @@ -0,0 +1,30 @@ +You are analyzing the results of a phase in Diplomacy. Your power is {power_name}. + +GAME STATE +Year: {current_year} +Phase: {current_phase} +Board State: +{board_state_str} + +TASK +Analyze the phase summary and game state to update your relationships and goals. + +IMPORTANT RULES +1. Update relationships for ALL powers in {other_powers} +2. Use ONLY these relationship values: Enemy, Unfriendly, Neutral, Friendly, Ally +3. Make goals specific and actionable +4. Return ONLY valid JSON - no text before or after + +Response Structure: +{{ + "reasoning": "Brief reasoning about the update", + "relationships": {{ + "POWER NAME": "Relationship Status", + ... + }}, + "goals": [ + "Specific goal 1", + "Specific goal 2", + ... + ] +}} \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/system_prompt.txt new file mode 100644 index 0000000..e69de29 diff --git a/ai_diplomacy/prompts/prompts_benchmark/turkey_system_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/turkey_system_prompt.txt new file mode 100644 index 0000000..d0817ef --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/turkey_system_prompt.txt @@ -0,0 +1,8 @@ +You are playing as TURKEY in the game of Diplomacy. + +Your Goal: Achieve world domination by controlling 18 supply centers. + +Important Gameplay Tips: +- Expand aggressively +- Ensure all your units have orders assigned +- Avoid passive hold moves \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/conversation_instructions.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/conversation_instructions.txt new file mode 100644 index 0000000..99eb5ff --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/conversation_instructions.txt @@ -0,0 +1,15 @@ +NEGOTIATION MESSAGES + +TASK +Generate one or more (preferably several) strategic messages to advance your interests. +Always prioritize responding to the messages in the "RECENT MESSAGES REQUIRING YOUR ATTENTION" section. +Maintain consistent conversation threads (unless you are choosing to ignore). + +Please respond in two parts: + +1. REASONING: First, explain your diplomatic strategy for this round. Who are you trying to influence and why? Which messages require responses? What deals are you proposing or accepting? Who might you be deliberately ignoring and why? + +2. MESSAGES: Then, list each message you want to send. For each message, clearly indicate: + - Whether it's a global message (visible to all) or private (to a specific power) + - If private, who the recipient is + - The content of your message \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/initial_state_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/initial_state_prompt.txt new file mode 100644 index 0000000..166cbb6 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/initial_state_prompt.txt @@ -0,0 +1,7 @@ +You are the agent for {power_name} in a game of Diplomacy at the very start (Spring 1901). Analyze the initial board position and suggest 2-3 strategic high-level goals for the early game. Consider your power's strengths, weaknesses, and neighbors. Also, provide an initial assessment of relationships with other powers. IMPORTANT: For each relationship, you MUST use exactly one of the following labels: {allowed_labels_str}. + +Please respond in two parts: + +1. REASONING: First, explain your strategic analysis of the starting position. + +2. STRATEGY: Then, provide your 2-3 strategic high-level goals and your initial assessment of relationships with other powers. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/negotiation_diary_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/negotiation_diary_prompt.txt new file mode 100644 index 0000000..a29ea54 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/negotiation_diary_prompt.txt @@ -0,0 +1,39 @@ +NEGOTIATION SUMMARY REQUEST +Power: {power_name} +Phase: {current_phase} + +MESSAGES THIS ROUND +{messages_this_round} +{ignored_messages_context} + +CURRENT STATUS +Goals: +{agent_goals} + +Relationships: +{agent_relationships} + +Game State: +{board_state_str} + +TASK +Analyze the negotiations, goals, relationships, and game state to: +1. Summarize key outcomes and agreements +2. State your specific intents for {current_phase}, including moves you have agreed to in negotiations and whether you intend to fulfil them. +3. Update relationships as needed (Enemy, Unfriendly, Neutral, Friendly, Ally) +4. Important: You will not see the full negotiation log in the order decision phase, so you must transmit key information about the negotiations to your future self via this summary. + +When powers ignore your messages, consider: +- They may be intentionally avoiding commitment +- They could be prioritizing other relationships +- Your approach may need adjustment (more direct questions, different incentives) +- Their silence might indicate hostility or indifference + +Please respond in two parts: + +1. REASONING: First, explain your analysis of the negotiations. What did each power communicate or fail to communicate? What do their messages (or silence) reveal about their intentions? How does this affect your strategic position? + +2. NEGOTIATION SUMMARY: Then provide: + - A summary of key outcomes from the negotiations + - Your strategic intent for upcoming orders (be specific about agreed moves and whether you'll honor them) + - Your current assessment of relationships with all powers (reflecting any changes from negotiations) \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_diary_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_diary_prompt.txt new file mode 100644 index 0000000..6c0cce8 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_diary_prompt.txt @@ -0,0 +1,25 @@ +ORDER DIARY ENTRY +Power: {power_name} +Phase: {current_phase} + +ORDERS ISSUED +{orders_list_str} + +CURRENT STATUS +Game State: +{board_state_str} + +Goals: +{agent_goals} + +Relationships: +{agent_relationships} + +TASK +Write a diary entry analyzing your orders for this turn. + +Please respond in two parts: + +1. REASONING: First, explain your strategic analysis of the current situation. What threats and opportunities do you see? How do your relationships with other powers influence your decisions? What are you trying to achieve this turn? + +2. ORDER SUMMARY: Then, provide a clear summary of the orders you submitted and explain why you chose these specific moves. How do they advance your strategic goals? What risks are you taking? \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_adjustment_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_adjustment_phase.txt new file mode 100644 index 0000000..48a9d5f --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_adjustment_phase.txt @@ -0,0 +1,25 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows your units' allowed adjustment orders +2. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F STP/NC B' + - Only fleet builds need coast specification. + +# Adjustment Phase Orders: +You have two main order types in the adjustment phase: +Build: '[UnitType] [Location] B' +e.g. 'A PAR B', 'F LON B' +Disband: '[UnitType] [Location] D' +e.g. 'A PAR D', 'F LON D' + +Your Task: +Analyze the adjustment situation and decide which units to build or disband. + +Please respond in two parts: + +1. REASONING: First, explain your adjustment decisions. What is your unit count vs supply center count? Where should you build for maximum strategic impact? Which units should be disbanded if necessary? + +2. ADJUSTMENT ORDERS: Then, provide all build/disband orders needed. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_movement_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_movement_phase.txt new file mode 100644 index 0000000..93a9cff --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_movement_phase.txt @@ -0,0 +1,18 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows your units' allowed moves & supports of your own units. +2. The possible orders section does *not* list possible supports for other powers' units; you can work these out yourself by looking at the units that are adjacent to your own. +3. If your goal is to *take* a province, give exactly one move order on that province and any additional support from other units must be properly formatted support orders. +4. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F SPA/SC - MAO' + - Only fleets need coast specification. + +Your Task: +Please respond in two parts: + +1. REASONING: First, provide comprehensive reasoning about your move decisions. What are your immediate objectives? Which supply centers are you targeting? How will you deal with threats? What coordinated moves are you planning? Consider all your units and their best uses. + +2. ORDERS: Then, list each order you want to submit, one per line. Be precise with unit types (A/F) and location codes. Aim to return an order for each of your units. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_retreat_phase.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_retreat_phase.txt new file mode 100644 index 0000000..9da6000 --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/order_instructions_retreat_phase.txt @@ -0,0 +1,23 @@ +# Primary Objective +Control 18 supply centers. Nothing else will do. + +# Critical Rules +1. The possible orders section shows where your dislodged units can retreat. +2. Units cannot retreat to: + - The province they were dislodged from + - A province occupied after this turn's moves + - A province where a standoff occurred +3. If no valid retreat exists, the unit must disband. +4. Dual-coast provinces (STP, SPA, BUL) require coast specification: + - Format: 'F [PROVINCE]/[COAST]' where [COAST] = NC (North), SC (South), EC (East), or WC (West) + - Example: 'F SPA/SC - MAO' + - Only fleet retreat orders need coast specification. + +Your Task: +Analyze the retreat situation and decide on the best retreat or disband orders for your dislodged units. + +Please respond in two parts: + +1. REASONING: First, explain your retreat decisions. Which units are dislodged? Where can they retreat? Is it better to retreat or disband? Consider the strategic implications of each choice. + +2. RETREAT ORDERS: Then, provide a retreat or disband order for each dislodged unit. \ No newline at end of file diff --git a/ai_diplomacy/prompts/prompts_benchmark/unformatted/state_update_prompt.txt b/ai_diplomacy/prompts/prompts_benchmark/unformatted/state_update_prompt.txt new file mode 100644 index 0000000..71dab1f --- /dev/null +++ b/ai_diplomacy/prompts/prompts_benchmark/unformatted/state_update_prompt.txt @@ -0,0 +1,32 @@ +You are analyzing the results of a phase in Diplomacy for {power_name}. + +GAME STATE +Year: {current_year} +Phase: {current_phase} +Board State: +{board_state_str} + +PHASE SUMMARY ({current_phase}): +{phase_summary} + +CURRENT STATUS + +Relationships with other powers ({other_powers}): +{current_relationships} + +TASK +Analyze the phase summary and game state to update your relationships and goals. + +IMPORTANT RULES +1. Update relationships for ALL powers in {other_powers} +2. Use ONLY these relationship values: Enemy, Unfriendly, Neutral, Friendly, Ally +3. Make goals specific and actionable +4. Base analysis on actual events, not assumptions + +Please respond in two parts: + +1. REASONING: First, explain your analysis of what happened this phase. Which powers acted as expected? Who surprised you? What new threats or opportunities have emerged? How do the results affect your strategic position? + +2. UPDATES: Then provide: + - Your updated assessment of relationships with ALL other powers + - Your updated goals (2-4 specific, actionable goals based on the current situation) \ No newline at end of file diff --git a/ai_diplomacy/utils.py b/ai_diplomacy/utils.py index 4360ce6..d0d9180 100644 --- a/ai_diplomacy/utils.py +++ b/ai_diplomacy/utils.py @@ -15,6 +15,7 @@ import requests from pathlib import Path from config import config from models import POWERS_ORDER +from datetime import datetime # Avoid circular import for type hinting if TYPE_CHECKING: @@ -369,8 +370,8 @@ def log_llm_response( file_exists = os.path.isfile(log_file_path) and os.path.getsize(log_file_path) > 0 with open(log_file_path, "a", newline="", encoding="utf-8") as csvfile: - # Added "raw_input" to fieldnames - fieldnames = ["model", "power", "phase", "response_type", "raw_input", "raw_response", "success"] + # Added "raw_input" and "timestamp" to fieldnames + fieldnames = ["timestamp", "model", "power", "phase", "response_type", "raw_input", "raw_response", "success"] writer = csv.DictWriter( csvfile, fieldnames=fieldnames, @@ -383,6 +384,7 @@ def log_llm_response( writer.writerow( { + "timestamp": datetime.now().isoformat(), # Add current timestamp in ISO format "model": model_name, "power": power_name if power_name else "game", # Use 'game' if no specific power "phase": phase, diff --git a/benchmark_results.ipynb b/benchmark_results.ipynb new file mode 100644 index 0000000..5e60313 --- /dev/null +++ b/benchmark_results.ipynb @@ -0,0 +1,2049 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "b39ccd32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "warning: directory not found, skipping: /mnt/i/diplo/sam-exp114-bench/analysis/statistical_game_analysis/individual\n", + "warning: directory not found, skipping: /mnt/i/diplo/sam-exp115-bench/analysis/statistical_game_analysis/individual\n", + "--- France Game Score Summary ---\n", + " Label Mean N CI_95_low CI_95_high\n", + "0 Qwen3-235B-A22B-Instruct 42.35 20 39.805275 44.894725\n", + "10 o3 41.25 20 38.194083 44.305917\n", + "6 kimi-k2 40.60 20 36.940351 44.259649\n", + "4 gemini-2.5-flash-preview-05-20 39.45 20 36.735354 42.164646\n", + "11 o4-mini 39.15 20 36.504000 41.796000\n", + "8 llama-4-maverick 39.00 20 36.217221 41.782779\n", + "2 command-a-03-2025 32.75 20 31.487158 34.012842\n", + "3 devstral-small-1.1-24b 32.30 20 31.216155 33.383845\n", + "5 gpt-4.1-nano 32.30 20 31.225523 33.374477\n", + "9 mistral-small-3.2-24b-instruct 31.10 20 30.027406 32.172594\n", + "7 llama-3.3-70b-instruct 24.85 20 23.310137 26.389863\n", + "1 Qwen3-235B-A22B-Instruct-2507 23.65 20 22.284092 25.015908\n", + "---------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1703/4209919605.py:98: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " ax = sns.barplot(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# EDIT THE LIST BELOW: absolute or relative paths to your experiment folders\n", + "# Each folder should contain analysis/statistical_game_analysis/individual/*\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"./Users/alxdfy/Documents/mldev/AI_Diplomacy/results/nectarine\": \"nectarine\",\n", + "}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Collect all individual France game_score values into a long-form DataFrame\n", + "# This format is ideal for Seaborn.\n", + "# ---------------------------------------------------------------------------\n", + "records = []\n", + "for exp_dir, label in exp_dirs.items():\n", + " exp_path = Path(exp_dir).expanduser().resolve()\n", + " csv_dir = exp_path / \"analysis\" / \"statistical_game_analysis\" / \"individual\"\n", + " \n", + " if not csv_dir.exists():\n", + " print(f\"warning: directory not found, skipping: {csv_dir}\")\n", + " continue\n", + " \n", + " csv_files = sorted(csv_dir.glob(\"run_*_game_analysis.csv\"))\n", + " \n", + " num_scores_found = 0\n", + " for csv_file in csv_files:\n", + " try:\n", + " df = pd.read_csv(csv_file)\n", + " france_rows = df[df[\"power_name\"] == \"FRANCE\"]\n", + " if not france_rows.empty and \"game_score\" in france_rows.columns:\n", + " score = float(france_rows.iloc[0][\"game_score\"])\n", + " records.append({\"Label\": label, \"Score\": score})\n", + " num_scores_found += 1\n", + " except Exception as exc:\n", + " print(f\"warning: could not process {csv_file} – {exc}\")\n", + " \n", + " if num_scores_found == 0:\n", + " print(f\"no France scores found for {label} in {exp_path}\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Build the main DataFrame from the collected records\n", + "# ---------------------------------------------------------------------------\n", + "if not records:\n", + " raise RuntimeError(\"No data collected – check the paths and directory structure.\")\n", + "\n", + "all_scores_df = pd.DataFrame(records)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Optional: Create a summary table for display, similar to the original\n", + "# We can do this easily from the long-form DataFrame.\n", + "# ---------------------------------------------------------------------------\n", + "# The `sem` function for standard error of the mean\n", + "def sem(x):\n", + " return np.std(x, ddof=1) / np.sqrt(np.size(x))\n", + "\n", + "summary_df = all_scores_df.groupby('Label')['Score'].agg(['mean', sem, 'count']).reset_index()\n", + "summary_df = summary_df.rename(columns={'mean': 'Mean', 'sem': 'SEM', 'count': 'N'})\n", + "# Calculate 95% CI from the aggregated data\n", + "summary_df['CI_95_low'] = summary_df['Mean'] - 1.96 * summary_df['SEM']\n", + "summary_df['CI_95_high'] = summary_df['Mean'] + 1.96 * summary_df['SEM']\n", + "\n", + "print(\"--- France Game Score Summary ---\")\n", + "print(summary_df[['Label', 'Mean', 'N', 'CI_95_low', 'CI_95_high']].sort_values('Mean', ascending=False))\n", + "print(\"-\" * 33)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Plot horizontal bar chart with Seaborn for a nicer look\n", + "# ---------------------------------------------------------------------------\n", + "# Set the aesthetic style of the plots\n", + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "# Determine the order of bars by sorting the labels based on their mean score\n", + "order = all_scores_df.groupby('Label')['Score'].mean().sort_values(ascending=False).index\n", + "\n", + "# Create the figure and axes\n", + "plt.figure(figsize=(10, max(3, 0.7 * len(exp_dirs))))\n", + "\n", + "# Create the bar plot\n", + "# Seaborn automatically calculates the mean (for bar length) and 95% CI (for error bars)\n", + "ax = sns.barplot(\n", + " data=all_scores_df,\n", + " x=\"Score\",\n", + " y=\"Label\",\n", + " order=order, # Use the sorted order\n", + " palette=\"viridis\", # A nice color palette\n", + " errorbar=(\"ci\", 95), # Explicitly request 95% CI\n", + " capsize=0.1, # Add caps to the error bars\n", + ")\n", + "\n", + "# Improve the plot's labels and title\n", + "ax.set_title(\"Model Performance as France\", fontsize=16, pad=20)\n", + "ax.set_xlabel(\"Average Game Score (with 95% CI)\", fontsize=12)\n", + "ax.set_ylabel(\"\") # The labels on the y-axis are self-explanatory\n", + "\n", + "# Add the mean value as a label on each bar for clarity\n", + "for i, bar in enumerate(ax.patches):\n", + " # Get the mean value from our summary dataframe\n", + " label = ax.get_yticklabels()[i].get_text()\n", + " mean_val = summary_df.loc[summary_df['Label'] == label, 'Mean'].iloc[0]\n", + " \n", + " # Position the text\n", + " ax.text(\n", + " bar.get_width() + 0.01, # Position text slightly to the right of the bar\n", + " bar.get_y() + bar.get_height() / 2, # Center vertically on the bar\n", + " f'{mean_val:.3f}', # Format the number\n", + " va='center', \n", + " ha='left'\n", + " )\n", + "\n", + "# Adjust x-axis limits to make space for the text labels\n", + "plt.xlim(right=plt.xlim()[1] * 1.15)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a4b3623", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- France Game Score Summary (sorted by Mean) ---\n", + " mean median count\n", + "Label \n", + "o3 41.25 41.5 20\n", + "kimi-k2 40.60 36.0 20\n", + "gemini-2.5-flash-preview-05-20 39.45 40.5 20\n", + "o4-mini 39.15 39.0 20\n", + "o3-nopress 34.90 35.0 20\n", + "command-a-03-2025 32.75 32.5 20\n", + "devstral-small-1.1-24b 32.30 31.5 20\n", + "kimi-k2-nopress 31.80 32.5 20\n", + "mistral-small-3.2-24b-instruct 31.10 31.0 20\n", + "Qwen3-235B-A22B-Instruct 26.20 26.0 20\n", + "llama-4-maverick 24.90 24.0 20\n", + "llama-3.3-70b-instruct 24.85 24.0 20\n", + "Qwen3-235B-A22B-Instruct-2507 23.65 22.0 20\n", + "gpt-4.1-nano 21.55 21.0 20\n", + "--------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1703/1132184167.py:90: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " ax.boxplot(scores_by_label, labels=sorted_labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# EDIT THE LIST BELOW: absolute or relative paths to your experiment folders\n", + "# Each folder should contain analysis/statistical_game_analysis/individual/*\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"kimi-k2\",\n", + " \"../data/sam-exp081-bench\": \"mistral-small-3.2-24b-instruct\",\n", + " \"../data/sam-exp082-bench\": \"devstral-small-1.1-24b\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash-preview-05-20\",\n", + " \"../data/sam-exp089-bench\":\"command-a-03-2025\",\n", + " \"../data/sam-exp090-bench\": \"Qwen3-235B-A22B-Instruct\",\n", + " \"../data/sam-exp091-bench\": \"llama-4-maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"llama-3.3-70b-instruct\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B-Instruct-2507\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + " \"../data/sam-exp114-bench\": \"o3-nopress\",\n", + " \"../data/sam-exp115-bench\": \"kimi-k2-nopress\",\n", + "}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Collect all individual France game_score values into a long-form DataFrame\n", + "# ---------------------------------------------------------------------------\n", + "records = []\n", + "for exp_dir, label in exp_dirs.items():\n", + " exp_path = Path(exp_dir).expanduser().resolve()\n", + " csv_dir = exp_path / \"analysis\" / \"statistical_game_analysis\" / \"individual\"\n", + "\n", + " if not csv_dir.exists():\n", + " print(f\"warning: directory not found, skipping: {csv_dir}\")\n", + " continue\n", + "\n", + " csv_files = sorted(csv_dir.glob(\"run_*_game_analysis.csv\"))\n", + "\n", + " num_scores_found = 0\n", + " for csv_file in csv_files:\n", + " try:\n", + " df = pd.read_csv(csv_file)\n", + " france_rows = df[df[\"power_name\"] == \"FRANCE\"]\n", + " if not france_rows.empty and \"game_score\" in france_rows.columns:\n", + " score = float(france_rows.iloc[0][\"game_score\"])\n", + " records.append({\"Label\": label, \"Score\": score})\n", + " num_scores_found += 1\n", + " except Exception as exc:\n", + " print(f\"warning: could not process {csv_file} – {exc}\")\n", + "\n", + " if num_scores_found == 0:\n", + " print(f\"no France scores found for {label} in {exp_path}\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Build the main DataFrame and print a summary\n", + "# ---------------------------------------------------------------------------\n", + "if not records:\n", + " raise RuntimeError(\"No data collected – check the paths and directory structure.\")\n", + "\n", + "all_scores_df = pd.DataFrame(records)\n", + "\n", + "print(\"--- France Game Score Summary (sorted by Mean) ---\")\n", + "summary = all_scores_df.groupby('Label')['Score'].agg(['mean', 'median', 'count'])\n", + "print(summary.sort_values('mean', ascending=False))\n", + "print(\"-\" * 50)\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Prepare data for Matplotlib boxplot\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Determine the order of models based on mean score (descending)\n", + "# This makes the chart much easier to read.\n", + "sorted_labels = all_scores_df.groupby('Label')['Score'].mean().sort_values(ascending=False).index\n", + "\n", + "# 2. Create a list of score Series, in the desired order.\n", + "# This is the format that plt.boxplot() expects.\n", + "scores_by_label = [all_scores_df[all_scores_df['Label'] == label]['Score'] for label in sorted_labels]\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Plot: Vertical Box Plot using the Template Style\n", + "# ---------------------------------------------------------------------------\n", + "# Set a dynamic figure size to accommodate the number of models\n", + "plt.figure(figsize=(max(8, 0.7 * len(exp_dirs)), 7))\n", + "ax = plt.gca()\n", + "\n", + "# Create the box plot\n", + "ax.boxplot(scores_by_label, labels=sorted_labels)\n", + "\n", + "# Apply styling from the template\n", + "ax.set_title(\"Model Performance as France\", fontsize=14)\n", + "ax.set_ylabel(\"Game Score\", fontsize=12)\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "# Rotate x-axis labels for better readability\n", + "plt.xticks(rotation=45, ha=\"right\") # 'ha' aligns the label with the tick\n", + "\n", + "# ---- Add reference line + annotations from the template -------------------\n", + "threshold = 33\n", + "ax.axhline(threshold, linestyle=\"--\", linewidth=1, color=\"red\")\n", + "\n", + "y_span = ax.get_ylim()[1] - ax.get_ylim()[0]\n", + "\n", + "# Define offsets relative to the y-axis span for consistent appearance\n", + "arrow_head_offset = 0.15 * y_span\n", + "arrow_tail_offset = 0.05 * y_span\n", + "text_offset = 0.01 * y_span\n", + "\n", + "# The x-position for the annotations should be in the middle of the plot\n", + "x_midpoint = (1 + len(sorted_labels)) / 2\n", + "\n", + "# ↑ Win\n", + "arrow_tail_top = threshold + arrow_tail_offset\n", + "arrow_head_top = threshold + arrow_head_offset\n", + "ax.annotate(\n", + " '', xy=(x_midpoint, arrow_head_top),\n", + " xytext=(x_midpoint, arrow_tail_top),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1)\n", + ")\n", + "ax.text(\n", + " x_midpoint, threshold + text_offset,\n", + " 'Win',\n", + " ha='center', va='bottom'\n", + ")\n", + "\n", + "# Survived to 1950 ↓\n", + "arrow_tail_bottom = threshold - arrow_tail_offset\n", + "arrow_head_bottom = threshold - arrow_head_offset\n", + "ax.annotate(\n", + " '', xy=(x_midpoint, arrow_head_bottom),\n", + " xytext=(x_midpoint, arrow_tail_bottom),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1)\n", + ")\n", + "ax.text(\n", + " x_midpoint, threshold - text_offset,\n", + " 'Survived to 1925',\n", + " ha='center', va='top'\n", + ")\n", + "# ---------------------------------------------------------------------------\n", + "\n", + "# Adjust layout to prevent labels from being cut off\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd6bd925", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- France Game Score Summary (sorted by Mean) ---\n", + " mean median count\n", + "Label \n", + "Qwen3-235B-A22B-Instruct 42.35 42.5 20\n", + "o3 41.25 41.5 20\n", + "Kimi-K2 40.60 36.0 20\n", + "gemini-2.5-flash-preview-05-20 39.45 40.5 20\n", + "o4-mini 39.15 39.0 20\n", + "Llama-4-Maverick-17B-128E-Instruct 39.00 37.5 20\n", + "Llama-3.3-70B-Instruct 38.10 37.0 20\n", + "o3 No Press 34.90 35.0 20\n", + "c4ai-command-a-03-2025 32.75 32.5 20\n", + "Devstral-Small-2507 32.30 31.5 20\n", + "gpt-4.1-nano 32.30 33.0 20\n", + "Kimi-K2 No Press 31.80 32.5 20\n", + "Mistral-Small-3.2-24B-Instruct-2506 31.10 31.0 20\n", + "Qwen3-235B-A22B-Instruct-2507 23.65 22.0 20\n", + "--------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1703/2655535977.py:93: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " ax.boxplot(scores_by_label, labels=sorted_labels, showfliers=False)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# EDIT THE LIST BELOW: absolute or relative paths to your experiment folders\n", + "# Each folder should contain analysis/statistical_game_analysis/individual/*\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2-24B-Instruct-2506\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash-preview-05-20\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a-03-2025\",\n", + " \"../data/sam-exp090-bench\": \"Qwen3-235B-A22B-Instruct\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick-17B-128E-Instruct\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B-Instruct\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B-Instruct-2507\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + " \"../data/sam-exp114-bench\": \"o3 No Press\",\n", + " \"../data/sam-exp115-bench\": \"Kimi-K2 No Press\",\n", + "}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Collect all individual France game_score values into a long-form DataFrame\n", + "# ---------------------------------------------------------------------------\n", + "records = []\n", + "for exp_dir, label in exp_dirs.items():\n", + " exp_path = Path(exp_dir).expanduser().resolve()\n", + " csv_dir = exp_path / \"analysis\" / \"statistical_game_analysis\" / \"individual\"\n", + "\n", + " if not csv_dir.exists():\n", + " print(f\"warning: directory not found, skipping: {csv_dir}\")\n", + " continue\n", + "\n", + " csv_files = sorted(csv_dir.glob(\"run_*_game_analysis.csv\"))\n", + "\n", + " num_scores_found = 0\n", + " for csv_file in csv_files:\n", + " try:\n", + " df = pd.read_csv(csv_file)\n", + " france_rows = df[df[\"power_name\"] == \"FRANCE\"]\n", + " if not france_rows.empty and \"game_score\" in france_rows.columns:\n", + " score = float(france_rows.iloc[0][\"game_score\"])\n", + " records.append({\"Label\": label, \"Score\": score})\n", + " num_scores_found += 1\n", + " except Exception as exc:\n", + " print(f\"warning: could not process {csv_file} – {exc}\")\n", + "\n", + " if num_scores_found == 0:\n", + " print(f\"no France scores found for {label} in {exp_path}\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Build the main DataFrame and print a summary\n", + "# ---------------------------------------------------------------------------\n", + "if not records:\n", + " raise RuntimeError(\"No data collected – check the paths and directory structure.\")\n", + "\n", + "all_scores_df = pd.DataFrame(records)\n", + "\n", + "print(\"--- France Game Score Summary (sorted by Mean) ---\")\n", + "summary = all_scores_df.groupby('Label')['Score'].agg(['mean', 'median', 'count'])\n", + "print(summary.sort_values('mean', ascending=False))\n", + "print(\"-\" * 50)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Prepare data for Matplotlib boxplot\n", + "# ---------------------------------------------------------------------------\n", + "sorted_labels = (\n", + " all_scores_df.groupby('Label')['Score']\n", + " .mean()\n", + " .sort_values(ascending=False)\n", + " .index\n", + ")\n", + "scores_by_label = [\n", + " all_scores_df[all_scores_df['Label'] == label]['Score'] for label in sorted_labels\n", + "]\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Plot: Vertical Box Plot using the Template Style\n", + "# ---------------------------------------------------------------------------\n", + "plt.figure(\n", + " figsize=(\n", + " max(8, 0.7 * len(exp_dirs)) * 0.5, # ½ previous width\n", + " 7 * 2 / 3 # ⅔ previous height\n", + " )\n", + ")\n", + "ax = plt.gca()\n", + "\n", + "ax.boxplot(scores_by_label, labels=sorted_labels, showfliers=False)\n", + "\n", + "ax.set_title(\"Model Performance as France\", fontsize=14)\n", + "ax.set_ylabel(\"Game Score\", fontsize=12)\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "plt.xticks(rotation=45, ha=\"right\")\n", + "\n", + "# ---- Add reference line + annotations positioned at the right edge --------\n", + "threshold = 33\n", + "ax.axhline(threshold, linestyle=\"--\", linewidth=1, color=\"red\")\n", + "\n", + "y_span = ax.get_ylim()[1] - ax.get_ylim()[0]\n", + "arrow_head_offset = 0.15 * y_span\n", + "arrow_tail_offset = 0.05 * y_span\n", + "text_offset = 0.01 * y_span\n", + "x_right_position = len(sorted_labels) # Position at the rightmost box plot\n", + "\n", + "# ↑ Win\n", + "ax.annotate(\n", + " '',\n", + " xy=(x_right_position - 0.1, threshold + arrow_head_offset * 1.5),\n", + " xytext=(x_right_position - 0.1, threshold + arrow_tail_offset * 2),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1),\n", + ")\n", + "ax.text(x_right_position + 0.1, threshold + text_offset, 'Win', ha='right', va='bottom')\n", + "\n", + "# Survived to 1915 ↓\n", + "ax.annotate(\n", + " '',\n", + " xy=(x_right_position - 0.1, threshold - arrow_head_offset * 1.5),\n", + " xytext=(x_right_position - 0.1, threshold - arrow_tail_offset * 2),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1),\n", + ")\n", + "ax.text(x_right_position + 0.1, threshold - text_offset, 'Survived to 1925', ha='right', va='top')\n", + "# ---------------------------------------------------------------------------\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0763210b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "Bar chart with 95 % CIs.\n", + "\n", + "Changes relative to the previous version ONLY:\n", + " • ylim fixed at 0 → 40.05\n", + " • removed numeric labels above bars\n", + " • bars now have a light‑grey fill (edge still black)\n", + " • everything else (size, DPI, arrows, grid, etc.) unchanged\n", + "\"\"\"\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Load France game scores → all_scores_df (identical to earlier)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a\",\n", + " #\"../data/sam-exp090-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + " \"../data/sam-exp114-bench\": \"o3 No Press\",\n", + " \"../data/sam-exp115-bench\": \"Kimi-K2 No Press\", \n", + " \"../data/sam-exp118-bench\": \"gemma-3-12b\",\n", + " \"../data/sam-exp119-bench\": \"qwen3-30b-a3b\",\n", + " \n", + " \n", + "}\n", + "\n", + "records = []\n", + "for exp_dir, label in exp_dirs.items():\n", + " csv_dir = (Path(exp_dir).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\")\n", + " if not csv_dir.exists():\n", + " continue\n", + "\n", + " for csv_file in csv_dir.glob(\"run_*_game_analysis.csv\"):\n", + " try:\n", + " df = pd.read_csv(csv_file)\n", + " fr = df[df[\"power_name\"] == \"FRANCE\"]\n", + " if not fr.empty and \"game_score\" in fr.columns:\n", + " records.append({\"Label\": label,\n", + " \"Score\": float(fr.iloc[0][\"game_score\"])})\n", + " except Exception:\n", + " pass\n", + "\n", + "if not records:\n", + " raise RuntimeError(\"No data collected – check paths & structure.\")\n", + "\n", + "all_scores_df = pd.DataFrame(records)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Summary statistics\n", + "# ---------------------------------------------------------------------------\n", + "stats = (\n", + " all_scores_df\n", + " .groupby(\"Label\")[\"Score\"]\n", + " .agg([\"mean\", \"std\", \"count\"])\n", + " .rename(columns={\"mean\": \"Mean\", \"std\": \"Std\", \"count\": \"N\"})\n", + " .reset_index()\n", + ")\n", + "stats[\"SEM\"] = stats[\"Std\"] / np.sqrt(stats[\"N\"])\n", + "stats[\"CI95\"] = 1.96 * stats[\"SEM\"]\n", + "stats = stats.sort_values(\"Mean\", ascending=False)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Figure (same formula; DPI remains 200)\n", + "# ---------------------------------------------------------------------------\n", + "fig_w = max(7, 0.4 * len(exp_dirs)) * 0.5\n", + "fig_h = 7 * 1/2\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=200)\n", + "ax = plt.gca()\n", + "\n", + "x = np.arange(len(stats))\n", + "bars = ax.bar(\n", + " x, stats[\"Mean\"],\n", + " width=0.6,\n", + " yerr=stats[\"CI95\"],\n", + " capsize=4,\n", + " color=\"0.85\", # light grey fill\n", + " edgecolor=\"black\",\n", + " linewidth=1.0\n", + ")\n", + "\n", + "ax.set_title(\"Benchmarked Model Performance\", fontsize=14, pad=10)\n", + "ax.set_ylabel(\"Game Score\", fontsize=12)\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(stats[\"Label\"], rotation=45, ha=\"right\")\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Fixed y‑limits + threshold & annotations\n", + "# ---------------------------------------------------------------------------\n", + "ax.set_ylim(20, 50.05) # ← requested ylim\n", + "\n", + "threshold = 42\n", + "ax.axhline(threshold, linestyle=\"--\", linewidth=1, color=\"red\")\n", + "\n", + "y_span = ax.get_ylim()[1] - ax.get_ylim()[0]\n", + "head_off = 0.15 * y_span\n", + "tail_off = 0.05 * y_span\n", + "txt_off = 0.01 * y_span\n", + "x_anno = len(stats) - 0.3\n", + "\n", + "# ↑ Win\n", + "ax.annotate('', xy=(x_anno, threshold + head_off),\n", + " xytext=(x_anno, threshold + tail_off),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1))\n", + "ax.text(x_anno, threshold + txt_off, 'Win',\n", + " ha='right', va='bottom')\n", + "\n", + "# Survived to 1915 ↓\n", + "ax.annotate('', xy=(x_anno, threshold - head_off),\n", + " xytext=(x_anno, threshold - tail_off),\n", + " arrowprops=dict(arrowstyle='->', linewidth=1))\n", + "ax.text(x_anno, threshold - txt_off, 'Survived to 1925',\n", + " ha='right', va='top')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ccae5ca8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "o3 – Kimi-K2 Δ= +0.65 t= +0.267 p=7.908e-01\n", + "o3 No Press – Kimi-K2 No Press Δ= +3.10 t= +2.425 p=2.080e-02\n" + ] + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "Welch’s two-sample t-tests for each score disparity.\n", + "\n", + "Outputs the t-statistic and two-tailed p-value:\n", + " • o3 vs Kimi-K2\n", + " • o3 No Press vs Kimi-K2 No Press\n", + "\"\"\"\n", + "from scipy.stats import ttest_ind\n", + "\n", + "pairs = [\n", + " (\"o3\", \"Kimi-K2\"),\n", + " (\"o3 No Press\", \"Kimi-K2 No Press\"),\n", + "]\n", + "\n", + "for left, right in pairs:\n", + " left_scores = all_scores_df.loc[all_scores_df[\"Label\"] == left, \"Score\"]\n", + " right_scores = all_scores_df.loc[all_scores_df[\"Label\"] == right, \"Score\"]\n", + "\n", + " if left_scores.empty or right_scores.empty:\n", + " raise ValueError(f\"Missing scores for '{left}' or '{right}'\")\n", + "\n", + " t_stat, p_val = ttest_ind(left_scores, right_scores, equal_var=False)\n", + " delta = left_scores.mean() - right_scores.mean()\n", + "\n", + " print(f\"{left:<13} – {right:<17} Δ={delta:+6.2f} t={t_stat:+7.3f} p={p_val:.3e}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09844cc9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pearson r (Diplomacy Mean ⇆ Arena overall) : +0.651 n=12\n", + "Pearson r (Diplomacy Mean ⇆ Arena hard) : +0.644 n=12\n", + "Pearson r (Diplomacy Mean ⇆ Arena long) : +0.539 n=12\n" + ] + }, + { + "ename": "KeyError", + "evalue": "'Mean'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 86\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[38;5;66;03m# ────────────────────────────────────────────────────────────────────────────────\u001b[39;00m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;66;03m# 1. Build formatted column\u001b[39;00m\n\u001b[1;32m 80\u001b[0m \u001b[38;5;66;03m# ────────────────────────────────────────────────────────────────────────────────\u001b[39;00m\n\u001b[1;32m 81\u001b[0m merged[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDiplomacy Game Score\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m merged\u001b[38;5;241m.\u001b[39mapply(\n\u001b[1;32m 82\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m r: \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mr[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMean\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mr[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCI95\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 83\u001b[0m )\n\u001b[1;32m 85\u001b[0m table_df \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m---> 86\u001b[0m \u001b[43mmerged\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLabel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43marena_overall\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mDiplomacy Game Score\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 87\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrename\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLabel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mModel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43marena_overall\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mArena Overall\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 88\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort_values\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mMean\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mascending\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Mean still in index; used only for sort\u001b[39;00m\n\u001b[1;32m 89\u001b[0m \u001b[38;5;241m.\u001b[39mreset_index(drop\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 90\u001b[0m )\n\u001b[1;32m 92\u001b[0m latex_table \u001b[38;5;241m=\u001b[39m table_df\u001b[38;5;241m.\u001b[39mto_latex(\n\u001b[1;32m 93\u001b[0m index\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 94\u001b[0m column_format\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlrl\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 95\u001b[0m escape\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;66;03m# keep ± symbol\u001b[39;00m\n\u001b[1;32m 96\u001b[0m )\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28mprint\u001b[39m(latex_table)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/frame.py:7189\u001b[0m, in \u001b[0;36mDataFrame.sort_values\u001b[0;34m(self, by, axis, ascending, inplace, kind, na_position, ignore_index, key)\u001b[0m\n\u001b[1;32m 7183\u001b[0m indexer \u001b[38;5;241m=\u001b[39m lexsort_indexer(\n\u001b[1;32m 7184\u001b[0m keys, orders\u001b[38;5;241m=\u001b[39mascending, na_position\u001b[38;5;241m=\u001b[39mna_position, key\u001b[38;5;241m=\u001b[39mkey\n\u001b[1;32m 7185\u001b[0m )\n\u001b[1;32m 7186\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(by):\n\u001b[1;32m 7187\u001b[0m \u001b[38;5;66;03m# len(by) == 1\u001b[39;00m\n\u001b[0;32m-> 7189\u001b[0m k \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_label_or_level_values\u001b[49m\u001b[43m(\u001b[49m\u001b[43mby\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7191\u001b[0m \u001b[38;5;66;03m# need to rewrap column in Series to apply key function\u001b[39;00m\n\u001b[1;32m 7192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 7193\u001b[0m \u001b[38;5;66;03m# error: Incompatible types in assignment (expression has type\u001b[39;00m\n\u001b[1;32m 7194\u001b[0m \u001b[38;5;66;03m# \"Series\", variable has type \"ndarray\")\u001b[39;00m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/generic.py:1911\u001b[0m, in \u001b[0;36mNDFrame._get_label_or_level_values\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1909\u001b[0m values \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxes[axis]\u001b[38;5;241m.\u001b[39mget_level_values(key)\u001b[38;5;241m.\u001b[39m_values\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1911\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key)\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;66;03m# Check for duplicates\u001b[39;00m\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n", + "\u001b[0;31mKeyError\u001b[0m: 'Mean'" + ] + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "Correlate Diplomacy benchmark means (France game scores) with Chatbot-Arena Elo.\n", + "\n", + "• Builds an in-memory DataFrame of the published Arena scores\n", + "• Maps our internal labels → Arena model names\n", + "• Joins on the overlap and prints Pearson r for:\n", + " – overall Elo\n", + " – hard-query Elo\n", + " – long-query Elo\n", + "\"\"\"\n", + "\n", + "from io import StringIO\n", + "import textwrap\n", + "\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "# 1. Chatbot-Arena data (2025-07 snapshot)\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "arena_csv = textwrap.dedent(\"\"\"\n", + "model,arena_overall,arena_hard,arena_long\n", + "o3,1451,1454,1417\n", + "kimi-k2,1420,1431,1405\n", + "qwen3-235b-a22b (no thinking),1397,1408,1398\n", + "gemini-2.5-flash,1409,1413,1419\n", + "o4-mini,1396,1405,1371\n", + "llama-4-maverick,1330,1334,1335\n", + "llama-3.3-070b,1316,1313,1310\n", + "command-a-03-2025,1345,1351,1355\n", + "gpt-4.1-nano,1319,1325,1322\n", + "qwen3-30b-a3b,1329,1344,1341\n", + "mistral-small-2506,1349,1356,1351\n", + "gemma-3-12b-it,1340,1329,1345\n", + "\"\"\")\n", + "arena_df = pd.read_csv(StringIO(arena_csv))\n", + "\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "# 2. Label mapping (bench label → Arena label)\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "label_to_arena = {\n", + " \"o3\": \"o3\",\n", + " \"Kimi-K2\": \"kimi-k2\",\n", + " \"Qwen3-235B-A22B\": \"qwen3-235b-a22b (no thinking)\",\n", + " \"gemini-2.5-flash\": \"gemini-2.5-flash\",\n", + " \"o4-mini\": \"o4-mini\",\n", + " \"Llama-4-Maverick\": \"llama-4-maverick\",\n", + " \"Llama-3.3-70B\": \"llama-3.3-070b\",\n", + " \"c4ai-command-a\": \"command-a-03-2025\",\n", + " \"gpt-4.1-nano\": \"gpt-4.1-nano\",\n", + " \"qwen3-30b-a3b\": \"qwen3-30b-a3b\",\n", + " \"Mistral-Small-3.2\": \"mistral-small-2506\",\n", + " \"gemma-3-12b\": \"gemma-3-12b-it\",\n", + "}\n", + "\n", + "# attach mapping → join on common models\n", + "stats[\"arena_model\"] = stats[\"Label\"].map(label_to_arena)\n", + "merged = stats.merge(arena_df, left_on=\"arena_model\", right_on=\"model\", how=\"inner\")\n", + "\n", + "if merged.empty:\n", + " raise RuntimeError(\"No overlapping models between Diplomacy benchmark and Arena data – check mapping.\")\n", + "\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "# 3. Pearson correlations\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "for col in [\"arena_overall\", \"arena_hard\", \"arena_long\"]:\n", + " r = merged[\"Mean\"].corr(merged[col])\n", + " metric = col.split(\"_\", 1)[1]\n", + " print(f\"Pearson r (Diplomacy Mean ⇆ Arena {metric}) : {r:+.3f} n={len(merged)}\")\n", + "\n", + "\n", + "# %%\n", + "\"\"\"\n", + "Build a LaTeX table of (our) model ID → Chatbot-Arena overall Elo → mean Diplomacy score.\n", + "\"\"\"\n", + "\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "table_df = (\n", + " merged[[\"Label\", \"arena_overall\", \"Mean\"]]\n", + " .rename(columns={\"Label\": \"Model\", \"arena_overall\": \"ArenaOverall\", \"Mean\": \"BenchMean\"})\n", + " .sort_values(\"BenchMean\", ascending=False)\n", + " .reset_index(drop=True)\n", + ")\n", + "table_df[\"BenchMean\"] = table_df[\"BenchMean\"].round(2)\n", + "\n", + "latex_table = table_df.to_latex(index=False, column_format=\"lrr\", float_format=\"%.0f\")\n", + "print(latex_table)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7c8bd2c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{lrl}\n", + "\\toprule\n", + "Model & Arena Overall & Diplomacy Game Score \\\\\n", + "\\midrule\n", + "o3 & 1451 & 41.2 ± 3.1 \\\\\n", + "Kimi-K2 & 1420 & 40.6 ± 3.7 \\\\\n", + "gemini-2.5-flash & 1409 & 39.5 ± 2.7 \\\\\n", + "o4-mini & 1396 & 39.1 ± 2.6 \\\\\n", + "Llama-4-Maverick & 1330 & 39.0 ± 2.8 \\\\\n", + "Llama-3.3-70B & 1316 & 38.1 ± 2.5 \\\\\n", + "Qwen3-235B-A22B & 1397 & 35.4 ± 2.1 \\\\\n", + "c4ai-command-a & 1345 & 32.8 ± 1.3 \\\\\n", + "gpt-4.1-nano & 1319 & 32.3 ± 1.1 \\\\\n", + "qwen3-30b-a3b & 1329 & 31.6 ± 1.3 \\\\\n", + "Mistral-Small-3.2 & 1349 & 31.1 ± 1.1 \\\\\n", + "gemma-3-12b & 1340 & 29.4 ± 1.0 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "LaTeX table: canonical model ID → Chatbot-Arena overall Elo → Diplomacy game score\n", + "(mean ± 95 % CI, one decimal). Rows sorted by mean game score.\n", + "\n", + "Fix: sort before dropping auxiliary columns so “Mean” is still present during sort.\n", + "\"\"\"\n", + "\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "# 1. Sort by benchmark mean, then format ± CI95\n", + "# ────────────────────────────────────────────────────────────────────────────────\n", + "sorted_df = merged.sort_values(\"Mean\", ascending=False).copy()\n", + "\n", + "sorted_df[\"Diplomacy Game Score\"] = sorted_df.apply(\n", + " lambda r: f\"{r['Mean']:.1f} ± {r['CI95']:.1f}\", axis=1\n", + ")\n", + "\n", + "table_df = (\n", + " sorted_df[[\"Label\", \"arena_overall\", \"Diplomacy Game Score\"]]\n", + " .rename(columns={\"Label\": \"Model\", \"arena_overall\": \"Arena Overall\"})\n", + " .reset_index(drop=True)\n", + ")\n", + "\n", + "latex_table = table_df.to_latex(\n", + " index=False,\n", + " column_format=\"lrl\",\n", + " escape=False # keep the “±” symbol\n", + ")\n", + "\n", + "print(latex_table)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9fa15526", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Relationship‑Perception Error (per game) ---\n", + " model Mean N CI95\n", + "10 o3 -1.014643 20 0.150473\n", + "1 Kimi-K2 -0.621992 20 0.107580\n", + "6 Qwen3-235B-A22B-2 -0.522384 20 0.145026\n", + "11 o4-mini -0.520034 20 0.120289\n", + "5 Qwen3-235B-A22B -0.356464 20 0.194125\n", + "8 gemini-2.5-flash -0.246503 20 0.103871\n", + "0 Devstral-Small-2507 -0.141038 20 0.154086\n", + "4 Mistral-Small-3.2 -0.083490 20 0.122267\n", + "3 Llama-4-Maverick -0.020554 20 0.101359\n", + "2 Llama-3.3-70B 0.119772 20 0.154622\n", + "9 gpt-4.1-nano 0.137841 20 0.154038\n", + "7 c4ai-command-a 0.185353 20 0.124374\n", + "-----------------------------------------------\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %%\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Map label → benchmark directory (EDIT AS NEEDED)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"Kimi-K2\": \"../data/sam-exp080-bench\",\n", + " \"Mistral-Small-3.2\": \"../data/sam-exp081-bench\",\n", + " \"Devstral-Small-2507\": \"../data/sam-exp082-bench\",\n", + " \"gemini-2.5-flash\": \"../data/sam-exp083-bench\",\n", + " \"c4ai-command-a\": \"../data/sam-exp089-bench\",\n", + " \"Qwen3-235B-A22B\": \"../data/sam-exp090-bench\",\n", + " \"Llama-4-Maverick\": \"../data/sam-exp091-bench\",\n", + " \"gpt-4.1-nano\": \"../data/sam-exp092-bench\",\n", + " \"Llama-3.3-70B\": \"../data/sam-exp106-bench\",\n", + " \"Qwen3-235B-A22B-2\": \"../data/sam-exp108-bench\", # distinct run folder\n", + " \"o3\": \"../data/sam-exp113-bench\",\n", + " \"o4-mini\": \"../data/sam-exp112-bench\",\n", + "}\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Helpers\n", + "# ---------------------------------------------------------------------------\n", + "rel_pat = re.compile(r'([A-Z]+):(-?\\d+\\.?\\d*)')\n", + "\n", + "def rel_dict(s: str):\n", + " \"\"\"'RUSSIA:0|GERMANY:1' → {'RUSSIA':0.0, 'GERMANY':1.0}\"\"\"\n", + " if not isinstance(s, str): return {}\n", + " return {p: float(v) for p, v in rel_pat.findall(s)}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Iterate over every phase file and collect phase‑level errors\n", + "# ---------------------------------------------------------------------------\n", + "phase_errors = [] # rows: model, game_id, phase_error\n", + "\n", + "for label, dir_ in exp_dirs.items():\n", + " csv_dir = (Path(dir_).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\")\n", + " if not csv_dir.exists():\n", + " print(f\"skip {label}: dir not found\")\n", + " continue\n", + "\n", + " for csv in csv_dir.glob(\"run_*_phase_analysis.csv\"):\n", + " game_id = f\"{label}_{csv.stem}\"\n", + "\n", + " df = pd.read_csv(csv)\n", + "\n", + " # keep only order_generation rows\n", + " df = df[df[\"analyzed_response_type\"] == \"order_generation\"]\n", + "\n", + " # index by power for fast lookups\n", + " df_by_phase = df.groupby(\"game_phase\")\n", + "\n", + " for phase, ph_df in df_by_phase:\n", + " fr_row = ph_df[ph_df[\"power_name\"] == \"FRANCE\"]\n", + " if fr_row.empty: # France eliminated already\n", + " continue\n", + " if fr_row[\"supply_centers_owned_count\"].iloc[0] == 0:\n", + " continue # eliminate phases post‑elimination\n", + "\n", + " fr_rel = rel_dict(fr_row[\"relationships\"].iloc[0])\n", + "\n", + " # build error list across other powers\n", + " errs = []\n", + " for _, row in ph_df.iterrows():\n", + " pow_name = row[\"power_name\"]\n", + " if pow_name == \"FRANCE\": # skip self\n", + " continue\n", + " other_to_fr = rel_dict(row[\"relationships\"]).get(\"FRANCE\")\n", + " fr_to_other = fr_rel.get(pow_name)\n", + " if other_to_fr is None or fr_to_other is None:\n", + " continue\n", + " errs.append(fr_to_other - other_to_fr)\n", + " if errs:\n", + " phase_errors.append({\n", + " \"model\": label,\n", + " \"game_id\": game_id,\n", + " \"phase_error\": np.mean(errs)\n", + " })\n", + "\n", + "if not phase_errors:\n", + " raise RuntimeError(\"No usable data found – check directory mapping.\")\n", + "\n", + "phase_df = pd.DataFrame(phase_errors)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Per‑game aggregation → one error value per match\n", + "# ---------------------------------------------------------------------------\n", + "game_err = (\n", + " phase_df\n", + " .groupby([\"model\", \"game_id\"])[\"phase_error\"]\n", + " .mean()\n", + " .reset_index(name=\"game_error\")\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Summary stats for bar chart (mean ± 95 % CI)\n", + "# ---------------------------------------------------------------------------\n", + "summary = (\n", + " game_err\n", + " .groupby(\"model\")[\"game_error\"]\n", + " .agg([\"mean\", \"std\", \"count\"])\n", + " .rename(columns={\"mean\":\"Mean\", \"std\":\"Std\", \"count\":\"N\"})\n", + " .reset_index()\n", + ")\n", + "\n", + "summary[\"SEM\"] = summary[\"Std\"] / np.sqrt(summary[\"N\"])\n", + "summary[\"CI95\"] = 1.96 * summary[\"SEM\"]\n", + "summary = summary.sort_values(\"Mean\") # lower error ⇒ better\n", + "\n", + "print(\"--- Relationship‑Perception Error (per game) ---\")\n", + "print(summary[[\"model\", \"Mean\", \"N\", \"CI95\"]])\n", + "print(\"-----------------------------------------------\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Bar chart (light grey bars, 95 % CI whiskers, DPI 200)\n", + "# ---------------------------------------------------------------------------\n", + "fig_w = max(8, 0.7*len(summary)) * 0.5\n", + "fig_h = 7 * 2/3\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=200)\n", + "ax = plt.gca()\n", + "\n", + "x = np.arange(len(summary))\n", + "ax.bar(\n", + " x, summary[\"Mean\"],\n", + " width=0.6,\n", + " yerr=summary[\"CI95\"],\n", + " capsize=4,\n", + " color=\"0.85\",\n", + " edgecolor=\"black\",\n", + " linewidth=1.0,\n", + ")\n", + "\n", + "ax.set_title(\"Relationship perception disparity\", fontsize=14, pad=10)\n", + "ax.set_ylabel(\"France:other - other:France\", fontsize=12)\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(summary[\"model\"], rotation=45, ha=\"right\")\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "05fd495d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Relationship‑Perception Error (per game) ---\n", + " model Mean N CI95\n", + "3 Llama-4-Maverick 0.391202 20 0.076001\n", + "0 Devstral-Small-2507 0.549214 20 0.072654\n", + "9 gpt-4.1-nano 0.673045 20 0.123313\n", + "7 c4ai-command-a 0.682438 20 0.086291\n", + "6 Qwen3-235B-A22B-2 0.685271 20 0.143192\n", + "5 Qwen3-235B-A22B 0.736448 20 0.141611\n", + "8 gemini-2.5-flash 0.777771 20 0.085197\n", + "4 Mistral-Small-3.2 0.778789 20 0.087606\n", + "1 Kimi-K2 0.829580 20 0.091462\n", + "11 o4-mini 1.054657 20 0.094752\n", + "2 Llama-3.3-70B 1.086544 20 0.100048\n", + "10 o3 1.202454 20 0.120922\n", + "-----------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1703/939141411.py:146: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " plt.tight_layout()\n", + "/home/sam/.local/lib/python3.10/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %%\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Map label → benchmark directory (EDIT AS NEEDED)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"Kimi-K2\": \"../data/sam-exp080-bench\",\n", + " \"Mistral-Small-3.2\": \"../data/sam-exp081-bench\",\n", + " \"Devstral-Small-2507\": \"../data/sam-exp082-bench\",\n", + " \"gemini-2.5-flash\": \"../data/sam-exp083-bench\",\n", + " \"c4ai-command-a\": \"../data/sam-exp089-bench\",\n", + " \"Qwen3-235B-A22B\": \"../data/sam-exp090-bench\",\n", + " \"Llama-4-Maverick\": \"../data/sam-exp091-bench\",\n", + " \"gpt-4.1-nano\": \"../data/sam-exp092-bench\",\n", + " \"Llama-3.3-70B\": \"../data/sam-exp106-bench\",\n", + " \"Qwen3-235B-A22B-2\": \"../data/sam-exp108-bench\", # distinct run folder\n", + " \"o3\": \"../data/sam-exp113-bench\",\n", + " \"o4-mini\": \"../data/sam-exp112-bench\",\n", + "}\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Helpers\n", + "# ---------------------------------------------------------------------------\n", + "rel_pat = re.compile(r'([A-Z]+):(-?\\d+\\.?\\d*)')\n", + "\n", + "def rel_dict(s: str):\n", + " \"\"\"'RUSSIA:0|GERMANY:1' → {'RUSSIA':0.0, 'GERMANY':1.0}\"\"\"\n", + " if not isinstance(s, str): return {}\n", + " return {p: float(v) for p, v in rel_pat.findall(s)}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Iterate over every phase file and collect phase‑level errors\n", + "# ---------------------------------------------------------------------------\n", + "phase_errors = [] # rows: model, game_id, phase_error\n", + "\n", + "for label, dir_ in exp_dirs.items():\n", + " csv_dir = (Path(dir_).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\")\n", + " if not csv_dir.exists():\n", + " print(f\"skip {label}: dir not found\")\n", + " continue\n", + "\n", + " for csv in csv_dir.glob(\"run_*_phase_analysis.csv\"):\n", + " game_id = f\"{label}_{csv.stem}\"\n", + "\n", + " df = pd.read_csv(csv)\n", + "\n", + " # keep only order_generation rows\n", + " df = df[df[\"analyzed_response_type\"] == \"order_generation\"]\n", + "\n", + " # index by power for fast lookups\n", + " df_by_phase = df.groupby(\"game_phase\")\n", + "\n", + " for phase, ph_df in df_by_phase:\n", + " fr_row = ph_df[ph_df[\"power_name\"] == \"FRANCE\"]\n", + " if fr_row.empty: # France eliminated already\n", + " continue\n", + " if fr_row[\"supply_centers_owned_count\"].iloc[0] == 0:\n", + " continue # eliminate phases post‑elimination\n", + "\n", + " fr_rel = rel_dict(fr_row[\"relationships\"].iloc[0])\n", + "\n", + " # build error list across other powers\n", + " errs = []\n", + " for _, row in ph_df.iterrows():\n", + " pow_name = row[\"power_name\"]\n", + " if pow_name == \"FRANCE\": # skip self\n", + " continue\n", + " other_to_fr = rel_dict(row[\"relationships\"]).get(\"FRANCE\")\n", + " fr_to_other = fr_rel.get(pow_name)\n", + " if other_to_fr is None or fr_to_other is None:\n", + " continue\n", + " errs.append(abs(fr_to_other - other_to_fr))\n", + " if errs:\n", + " phase_errors.append({\n", + " \"model\": label,\n", + " \"game_id\": game_id,\n", + " \"phase_error\": np.mean(errs)\n", + " })\n", + "\n", + "if not phase_errors:\n", + " raise RuntimeError(\"No usable data found – check directory mapping.\")\n", + "\n", + "phase_df = pd.DataFrame(phase_errors)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Per‑game aggregation → one error value per match\n", + "# ---------------------------------------------------------------------------\n", + "game_err = (\n", + " phase_df\n", + " .groupby([\"model\", \"game_id\"])[\"phase_error\"]\n", + " .mean()\n", + " .reset_index(name=\"game_error\")\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Summary stats for bar chart (mean ± 95 % CI)\n", + "# ---------------------------------------------------------------------------\n", + "summary = (\n", + " game_err\n", + " .groupby(\"model\")[\"game_error\"]\n", + " .agg([\"mean\", \"std\", \"count\"])\n", + " .rename(columns={\"mean\":\"Mean\", \"std\":\"Std\", \"count\":\"N\"})\n", + " .reset_index()\n", + ")\n", + "\n", + "summary[\"SEM\"] = summary[\"Std\"] / np.sqrt(summary[\"N\"])\n", + "summary[\"CI95\"] = 1.96 * summary[\"SEM\"]\n", + "summary = summary.sort_values(\"Mean\") # lower error ⇒ better\n", + "\n", + "print(\"--- Relationship‑Perception Error (per game) ---\")\n", + "print(summary[[\"model\", \"Mean\", \"N\", \"CI95\"]])\n", + "print(\"-----------------------------------------------\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Bar chart (light grey bars, 95 % CI whiskers, DPI 200)\n", + "# ---------------------------------------------------------------------------\n", + "fig_w = max(8, 0.7*len(summary)) * 0.5\n", + "fig_h = 7 * 2/3\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=200)\n", + "ax = plt.gca()\n", + "\n", + "x = np.arange(len(summary))\n", + "ax.bar(\n", + " x, summary[\"Mean\"],\n", + " width=0.6,\n", + " yerr=summary[\"CI95\"],\n", + " capsize=4,\n", + " color=\"0.85\",\n", + " edgecolor=\"black\",\n", + " linewidth=1.0,\n", + ")\n", + "\n", + "ax.set_title(\"France: Mean Relationship‑Perception Error\", fontsize=14, pad=10)\n", + "ax.set_ylabel(\"Absolute Relationship Error\", fontsize=12)\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(summary[\"model\"], rotation=45, ha=\"right\")\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5d08e0a0", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "No relationship pairs collected – check directory mapping.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 88\u001b[0m\n\u001b[1;32m 81\u001b[0m pairs\u001b[38;5;241m.\u001b[39mappend({\n\u001b[1;32m 82\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpower\u001b[39m\u001b[38;5;124m\"\u001b[39m: pow_name,\n\u001b[1;32m 83\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfr_to_other\u001b[39m\u001b[38;5;124m\"\u001b[39m: fr_to_other,\n\u001b[1;32m 84\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mother_to_fr\u001b[39m\u001b[38;5;124m\"\u001b[39m: other_to_fr\n\u001b[1;32m 85\u001b[0m })\n\u001b[1;32m 87\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m pairs:\n\u001b[0;32m---> 88\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo relationship pairs collected – check directory mapping.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 90\u001b[0m pairs_df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(pairs)\n\u001b[1;32m 92\u001b[0m \u001b[38;5;66;03m# ---------------------------------------------------------------------------\u001b[39;00m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;66;03m# 2. Aggregate: mean ± 95 % CI per power, direction\u001b[39;00m\n\u001b[1;32m 94\u001b[0m \u001b[38;5;66;03m# ---------------------------------------------------------------------------\u001b[39;00m\n", + "\u001b[0;31mRuntimeError\u001b[0m: No relationship pairs collected – check directory mapping." + ] + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "France vs. Other‑Powers Relationship Values\n", + "(two bars per power: France→Other, Other→France)\n", + "Aggregated across all benchmark runs in `exp_dirs`.\n", + "\"\"\"\n", + "\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Map label → benchmark directory (edit if needed)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a\",\n", + " \"../data/sam-exp090-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + "}\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Helpers\n", + "# ---------------------------------------------------------------------------\n", + "rel_pat = re.compile(r'([A-Z]+):(-?\\d+\\.?\\d*)')\n", + "\n", + "def rel_dict(s: str):\n", + " \"\"\"'RUSSIA:0|GERMANY:-1' → {'RUSSIA':0.0, 'GERMANY':-1.0}\"\"\"\n", + " if not isinstance(s, str): return {}\n", + " return {p: float(v) for p, v in rel_pat.findall(s)}\n", + "\n", + "# The seven other powers (order sets the x‑axis)\n", + "OTHER_POWERS = [\"ENGLAND\", \"GERMANY\", \"ITALY\", \"RUSSIA\", \"AUSTRIA\", \"TURKEY\"]\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Collect relationship pairs for every phase (France still alive)\n", + "# ---------------------------------------------------------------------------\n", + "pairs = [] # rows: power, fr_to_other, other_to_fr\n", + "\n", + "for label, dir_ in exp_dirs.items():\n", + " csv_dir = (Path(dir_).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\")\n", + " if not csv_dir.exists():\n", + " continue\n", + "\n", + " for csv in csv_dir.glob(\"run_*_phase_analysis.csv\"):\n", + " df = pd.read_csv(csv)\n", + " df = df[df[\"analyzed_response_type\"] == \"order_generation\"]\n", + "\n", + " for phase, ph_df in df.groupby(\"game_phase\"):\n", + " fr_row = ph_df[ph_df[\"power_name\"] == \"FRANCE\"]\n", + " if fr_row.empty: continue\n", + " if fr_row[\"supply_centers_owned_count\"].iloc[0] == 0: # France eliminated\n", + " continue\n", + "\n", + " fr_rel = rel_dict(fr_row[\"relationships\"].iloc[0])\n", + "\n", + " for _, row in ph_df.iterrows():\n", + " pow_name = row[\"power_name\"]\n", + " if pow_name == \"FRANCE\" or pow_name not in OTHER_POWERS:\n", + " continue\n", + " other_rel = rel_dict(row[\"relationships\"])\n", + "\n", + " fr_to_other = fr_rel.get(pow_name)\n", + " other_to_fr = other_rel.get(\"FRANCE\")\n", + "\n", + " if fr_to_other is None or other_to_fr is None:\n", + " continue\n", + "\n", + " pairs.append({\n", + " \"power\": pow_name,\n", + " \"fr_to_other\": fr_to_other,\n", + " \"other_to_fr\": other_to_fr\n", + " })\n", + "\n", + "if not pairs:\n", + " raise RuntimeError(\"No relationship pairs collected – check directory mapping.\")\n", + "\n", + "pairs_df = pd.DataFrame(pairs)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Aggregate: mean ± 95 % CI per power, direction\n", + "# ---------------------------------------------------------------------------\n", + "agg = []\n", + "for p in OTHER_POWERS:\n", + " sub = pairs_df[pairs_df[\"power\"] == p]\n", + "\n", + " for dir_col, label in [(\"fr_to_other\", \"France→Other\"),\n", + " (\"other_to_fr\", \"Other→France\")]:\n", + " vals = sub[dir_col].dropna()\n", + " n = len(vals)\n", + " mu = vals.mean()\n", + " sem = vals.std(ddof=1) / np.sqrt(n) if n else np.nan\n", + " agg.append({\n", + " \"power\": p,\n", + " \"direction\": label,\n", + " \"mean\": mu,\n", + " \"ci95\": 1.96 * sem if n else np.nan,\n", + " \"N\": n\n", + " })\n", + "\n", + "agg_df = pd.DataFrame(agg)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Bar chart (paired bars per power)\n", + "# ---------------------------------------------------------------------------\n", + "fig_w = max(8, 0.9 * len(OTHER_POWERS))\n", + "fig_h = 6\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=200)\n", + "ax = plt.gca()\n", + "\n", + "x = np.arange(len(OTHER_POWERS))\n", + "bar_w = 0.35\n", + "\n", + "# split the dataframe for clarity\n", + "fr_bars = agg_df[agg_df[\"direction\"] == \"France→Other\"]\n", + "oth_bars = agg_df[agg_df[\"direction\"] == \"Other→France\"]\n", + "\n", + "# France→Other bars\n", + "ax.bar(x - bar_w/2,\n", + " fr_bars[\"mean\"],\n", + " width=bar_w,\n", + " yerr=fr_bars[\"ci95\"],\n", + " capsize=4,\n", + " color=\"0.85\",\n", + " edgecolor=\"black\",\n", + " label=\"France→Other\")\n", + "\n", + "# Other→France bars\n", + "ax.bar(x + bar_w/2,\n", + " oth_bars[\"mean\"],\n", + " width=bar_w,\n", + " yerr=oth_bars[\"ci95\"],\n", + " capsize=4,\n", + " color=\"white\", # white fill for contrast\n", + " edgecolor=\"black\",\n", + " hatch=\"///\",\n", + " label=\"Other→France\")\n", + "\n", + "ax.set_title(\"Average Relationship Values (All Benchmark Runs)\", fontsize=14, pad=10)\n", + "ax.set_ylabel(\"Relationship Score\", fontsize=12)\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(OTHER_POWERS, rotation=45, ha=\"right\")\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "ax.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6e7bd2fd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sam/.local/lib/python3.10/site-packages/seaborn/utils.py:61: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " fig.canvas.draw()\n", + "/home/sam/.local/lib/python3.10/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "Diplomatic credit vs. unit count\n", + "• Metric: mean( other_power→France relationship score ) ⟂ France unit count\n", + "• One heat‑map cell = average across all phases of all runs in one benchmark dir\n", + "\n", + "Notes\n", + "-----\n", + "* Relationships are parsed from strings like 'GERMANY:1|RUSSIA:-0.5|…'.\n", + "* Phases where France **or the other power** is eliminated are ignored.\n", + "* Sentiment columns are NOT used; everything comes from `relationships`.\n", + "\"\"\"\n", + "\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Map benchmark directory → human‑readable model label (edit as needed)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a\",\n", + " \"../data/sam-exp090-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B‑2\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + "}\n", + "model_order = list(exp_dirs.values()) # preserves the order above\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Helper to parse the `relationships` string\n", + "# ---------------------------------------------------------------------------\n", + "REL_PATTERN = re.compile(r'([A-Z]+):(-?\\d+(?:\\.\\d+)?)')\n", + "\n", + "def relationship_dict(rel_string: str) -> dict[str, float]:\n", + " \"\"\"'GERMANY:1|RUSSIA:-0.5' -> {'GERMANY': 1.0, 'RUSSIA': -0.5}\"\"\"\n", + " if not isinstance(rel_string, str):\n", + " return {}\n", + " return {power: float(score) for power, score in REL_PATTERN.findall(rel_string)}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Collect rows → (model, units, mean_other_to_france_score)\n", + "# ---------------------------------------------------------------------------\n", + "rows: list[dict] = []\n", + "\n", + "for benchmark_dir, model_label in exp_dirs.items():\n", + " csv_directory = (\n", + " Path(benchmark_dir).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\"\n", + " )\n", + " if not csv_directory.exists():\n", + " print(f\"[skip] {model_label}: directory not found\")\n", + " continue\n", + "\n", + " for csv_path in csv_directory.glob(\"run_*_phase_analysis.csv\"):\n", + " phase_df_full = pd.read_csv(csv_path)\n", + "\n", + " # keep only `order_generation` rows (matches earlier scripts)\n", + " phase_df_full = phase_df_full[\n", + " phase_df_full[\"analyzed_response_type\"] == \"order_generation\"\n", + " ]\n", + "\n", + " # group by game_phase for easier phase‑wise filtering\n", + " for _, phase_df in phase_df_full.groupby(\"game_phase\"):\n", + " france_row = phase_df[phase_df[\"power_name\"] == \"FRANCE\"]\n", + " if france_row.empty:\n", + " continue\n", + " if france_row[\"supply_centers_owned_count\"].iloc[0] == 0:\n", + " continue # France eliminated this phase\n", + "\n", + " france_units = int(france_row[\"military_units_count\"].iloc[0])\n", + "\n", + " # Collect other powers’ evaluations of France\n", + " other_to_france_scores = []\n", + " for _, player_row in phase_df.iterrows():\n", + " if player_row[\"power_name\"] == \"FRANCE\":\n", + " continue # skip France itself\n", + " if player_row[\"supply_centers_owned_count\"] == 0:\n", + " continue # other power eliminated\n", + "\n", + " rel_to_france = relationship_dict(\n", + " player_row[\"relationships\"]\n", + " ).get(\"FRANCE\")\n", + "\n", + " if rel_to_france is not None:\n", + " other_to_france_scores.append(rel_to_france)\n", + "\n", + " if other_to_france_scores:\n", + " rows.append({\n", + " \"model\": model_label,\n", + " \"units\": france_units,\n", + " \"score\": np.mean(other_to_france_scores),\n", + " })\n", + "\n", + "if not rows:\n", + " raise RuntimeError(\"No data collected – check directory mapping or filters.\")\n", + "\n", + "raw_df = pd.DataFrame(rows)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Aggregate → mean score per (model, units)\n", + "# ---------------------------------------------------------------------------\n", + "aggregated_df = (\n", + " raw_df\n", + " .groupby([\"model\", \"units\"], as_index=False)[\"score\"]\n", + " .mean()\n", + ")\n", + "\n", + "# pivot to wide form for the heat‑map\n", + "heatmap_data = (\n", + " aggregated_df\n", + " .pivot(index=\"model\", columns=\"units\", values=\"score\")\n", + " .reindex(model_order) # models in user‑defined order\n", + " .sort_index(axis=1) # unit counts ascending left→right\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 5. Plot the heat‑map\n", + "# ---------------------------------------------------------------------------\n", + "sns.set_theme(style=\"white\")\n", + "figure_width = max(8, 0.45 * heatmap_data.shape[1])\n", + "figure_height = max(4, 0.35 * heatmap_data.shape[0])\n", + "\n", + "plt.figure(figsize=(figure_width, figure_height), dpi=200)\n", + "ax = sns.heatmap(\n", + " heatmap_data,\n", + " cmap=\"coolwarm\",\n", + " vmin=-2, vmax=2, # relationship scale −2 … +2\n", + " linewidths=0.3,\n", + " linecolor=\"0.9\",\n", + " cbar_kws={\"label\": \"Mean other→France relationship\"},\n", + ")\n", + "\n", + "ax.set_xlabel(\"France military units\")\n", + "ax.set_ylabel(\"\") # model labels act as y‑axis ticks\n", + "ax.set_title(\"Agg. Relationship Towards France vs. France Military Strength\", pad=12)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "47cb4751", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sam/.local/lib/python3.10/site-packages/seaborn/utils.py:61: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " fig.canvas.draw()\n", + "/home/sam/.local/lib/python3.10/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 8209 (\\N{NON-BREAKING HYPHEN}) missing from font(s) Arial.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %%\n", + "\"\"\"\n", + "Diplomatic credit vs. unit count – *France → others* direction\n", + "• Metric: mean( France→other_power relationship score ) ⟂ France unit count\n", + "• One heat‑map cell = average across all phases of all runs in one benchmark dir\n", + "\n", + "Notes\n", + "-----\n", + "* Relationships are parsed from strings like 'GERMANY:1|RUSSIA:-0.5|…'.\n", + "* A phase is ignored if France is eliminated.\n", + "* When averaging, only powers that are still alive in the phase and for which\n", + " France specifies a relationship value are included.\n", + "\"\"\"\n", + "\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Map benchmark directory → human‑readable model label (edit as needed)\n", + "# ---------------------------------------------------------------------------\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a\",\n", + " \"../data/sam-exp090-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B‑2\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + "}\n", + "model_order = list(exp_dirs.values()) # preserves the order above\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Helper to parse the `relationships` string\n", + "# ---------------------------------------------------------------------------\n", + "REL_PATTERN = re.compile(r'([A-Z]+):(-?\\d+(?:\\.\\d+)?)')\n", + "\n", + "def relationship_dict(rel_string: str) -> dict[str, float]:\n", + " \"\"\"'GERMANY:1|RUSSIA:-0.5' -> {'GERMANY': 1.0, 'RUSSIA': -0.5}\"\"\"\n", + " if not isinstance(rel_string, str):\n", + " return {}\n", + " return {power: float(score) for power, score in REL_PATTERN.findall(rel_string)}\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Collect rows → (model, units, mean_france_to_other_score)\n", + "# ---------------------------------------------------------------------------\n", + "rows: list[dict] = []\n", + "\n", + "for benchmark_dir, model_label in exp_dirs.items():\n", + " csv_directory = (\n", + " Path(benchmark_dir).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\"\n", + " )\n", + " if not csv_directory.exists():\n", + " print(f\"[skip] {model_label}: directory not found\")\n", + " continue\n", + "\n", + " for csv_path in csv_directory.glob(\"run_*_phase_analysis.csv\"):\n", + " phase_df_full = pd.read_csv(csv_path)\n", + "\n", + " # Keep only `order_generation` rows\n", + " phase_df_full = phase_df_full[\n", + " phase_df_full[\"analyzed_response_type\"] == \"order_generation\"\n", + " ]\n", + "\n", + " # Iterate over each phase\n", + " for _, phase_df in phase_df_full.groupby(\"game_phase\"):\n", + " france_row = phase_df[phase_df[\"power_name\"] == \"FRANCE\"]\n", + " if france_row.empty:\n", + " continue\n", + " if france_row[\"supply_centers_owned_count\"].iloc[0] == 0:\n", + " continue # France eliminated this phase\n", + "\n", + " france_units = int(france_row[\"military_units_count\"].iloc[0])\n", + "\n", + " # France's relationship dictionary for this phase\n", + " france_rel = relationship_dict(france_row[\"relationships\"].iloc[0])\n", + "\n", + " france_to_other_scores = []\n", + " for _, player_row in phase_df.iterrows():\n", + " other_power = player_row[\"power_name\"]\n", + " if other_power == \"FRANCE\":\n", + " continue\n", + " if player_row[\"supply_centers_owned_count\"] == 0:\n", + " continue # other power eliminated\n", + "\n", + " rel_value = france_rel.get(other_power)\n", + " if rel_value is not None:\n", + " france_to_other_scores.append(rel_value)\n", + "\n", + " if france_to_other_scores:\n", + " rows.append({\n", + " \"model\": model_label,\n", + " \"units\": france_units,\n", + " \"score\": np.mean(france_to_other_scores),\n", + " })\n", + "\n", + "if not rows:\n", + " raise RuntimeError(\"No data collected – check directory mapping or filters.\")\n", + "\n", + "raw_df = pd.DataFrame(rows)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Aggregate → mean score per (model, units)\n", + "# ---------------------------------------------------------------------------\n", + "aggregated_df = (\n", + " raw_df\n", + " .groupby([\"model\", \"units\"], as_index=False)[\"score\"]\n", + " .mean()\n", + ")\n", + "\n", + "# pivot to wide form for the heat‑map\n", + "heatmap_data = (\n", + " aggregated_df\n", + " .pivot(index=\"model\", columns=\"units\", values=\"score\")\n", + " .reindex(model_order) # models in predefined order\n", + " .sort_index(axis=1) # unit counts ascending left→right\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 5. Plot the heat‑map (colour‑map = coolwarm, −2 … +2 scale)\n", + "# ---------------------------------------------------------------------------\n", + "sns.set_theme(style=\"white\")\n", + "figure_width = max(8, 0.45 * heatmap_data.shape[1])\n", + "figure_height = max(4, 0.35 * heatmap_data.shape[0])\n", + "\n", + "plt.figure(figsize=(figure_width, figure_height), dpi=200)\n", + "ax = sns.heatmap(\n", + " heatmap_data,\n", + " cmap=\"coolwarm\",\n", + " vmin=-2, vmax=2,\n", + " linewidths=0.3,\n", + " linecolor=\"0.9\",\n", + " cbar_kws={\"label\": \"Mean France→other relationship\"},\n", + ")\n", + "\n", + "ax.set_xlabel(\"France military units\")\n", + "ax.set_ylabel(\"\") # model labels serve as y‑axis ticks\n", + "ax.set_title(\"France’s stance toward others vs. military strength\", pad=12)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# %%\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "223ec9b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ╔════════════════════════════════════════════════════════════════════════════╗\n", + "# ║ Relative “Other → France” Relationship (bar chart with 95 % CIs) ║\n", + "# ║ ║\n", + "# ║ • For every run_*/phase_analysis CSV, compute the mean attitude of all ║\n", + "# ║ surviving powers towards France in each phase. ║\n", + "# ║ • Bucket by France’s unit count. ║\n", + "# ║ • For each unit bucket, subtract the *global* mean (across all models). ║\n", + "# ║ • Average those differences across buckets → one relative score / run. ║\n", + "# ║ • Aggregate per experiment dir → mean ± 95 % CI, then plot. ║\n", + "# ╚════════════════════════════════════════════════════════════════════════════╝\n", + "from pathlib import Path\n", + "import re\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ── 1. Benchmark directories ────────────────────────────────────────────────\n", + "exp_dirs = {\n", + " \"../data/sam-exp080-bench\": \"Kimi-K2\",\n", + " \"../data/sam-exp081-bench\": \"Mistral-Small-3.2\",\n", + " \"../data/sam-exp082-bench\": \"Devstral-Small-2507\",\n", + " \"../data/sam-exp083-bench\": \"gemini-2.5-flash\",\n", + " \"../data/sam-exp089-bench\": \"c4ai-command-a\",\n", + " #\"../data/sam-exp090-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp091-bench\": \"Llama-4-Maverick\",\n", + " \"../data/sam-exp092-bench\": \"gpt-4.1-nano\",\n", + " \"../data/sam-exp106-bench\": \"Llama-3.3-70B\",\n", + " \"../data/sam-exp108-bench\": \"Qwen3-235B-A22B\",\n", + " \"../data/sam-exp113-bench\": \"o3\",\n", + " \"../data/sam-exp112-bench\": \"o4-mini\",\n", + " \"../data/sam-exp118-bench\": \"gemma-3-12b\",\n", + " \"../data/sam-exp119-bench\": \"qwen3-30b-a3b\",\n", + "}\n", + "model_order = list(exp_dirs.values())\n", + "\n", + "# ── 2. Relationship-string parser ───────────────────────────────────────────\n", + "REL_PATTERN = re.compile(r'([A-Z]+):(-?\\d+(?:\\.\\d+)?)')\n", + "def parse_relationships(s: str):\n", + " if not isinstance(s, str):\n", + " return {}\n", + " return {p: float(v) for p, v in REL_PATTERN.findall(s)}\n", + "\n", + "# ── 3. Collect (run, model, unit_count, rel_score) rows ─────────────────────\n", + "rows = []\n", + "for bench_path, model_label in exp_dirs.items():\n", + " phase_dir = (Path(bench_path).expanduser().resolve()\n", + " / \"analysis/statistical_game_analysis/individual\")\n", + " if not phase_dir.exists():\n", + " continue\n", + " for csv_file in phase_dir.glob(\"run_*_phase_analysis.csv\"):\n", + " run_id = csv_file.stem.split(\"_\")[1] # crude but unique per file\n", + " df = pd.read_csv(csv_file)\n", + " df = df[df[\"analyzed_response_type\"] == \"order_generation\"]\n", + "\n", + " for _, phase in df.groupby(\"game_phase\"):\n", + " fr = phase[phase[\"power_name\"] == \"FRANCE\"]\n", + " if fr.empty or fr[\"supply_centers_owned_count\"].iat[0] == 0:\n", + " continue # France eliminated\n", + " unit_cnt = int(fr[\"military_units_count\"].iat[0])\n", + "\n", + " scores = []\n", + " for _, row in phase.iterrows():\n", + " if row[\"power_name\"] == \"FRANCE\":\n", + " continue\n", + " if row[\"supply_centers_owned_count\"] == 0:\n", + " continue # other power eliminated\n", + " s = parse_relationships(row[\"relationships\"]).get(\"FRANCE\")\n", + " if s is not None:\n", + " scores.append(s)\n", + "\n", + " if scores:\n", + " rows.append({\n", + " \"model\": model_label,\n", + " \"run\": run_id,\n", + " \"units\": unit_cnt,\n", + " \"score\": np.mean(scores)\n", + " })\n", + "\n", + "if not rows:\n", + " raise RuntimeError(\"No data found – check paths / filters.\")\n", + "\n", + "phase_df = pd.DataFrame(rows)\n", + "\n", + "# ── 4. Compute global baseline per unit bucket ─────────────────────────────\n", + "baseline = (\n", + " phase_df\n", + " .groupby(\"units\", as_index=False)[\"score\"]\n", + " .mean()\n", + " .rename(columns={\"score\": \"baseline\"})\n", + ")\n", + "\n", + "phase_df = phase_df.merge(baseline, on=\"units\")\n", + "phase_df[\"diff\"] = phase_df[\"score\"] - phase_df[\"baseline\"]\n", + "\n", + "# average diff across unit buckets → 1 score per run\n", + "run_scores = (\n", + " phase_df\n", + " .groupby([\"model\", \"run\"], as_index=False)[\"diff\"]\n", + " .mean()\n", + " .rename(columns={\"diff\": \"rel_score\"})\n", + ")\n", + "\n", + "# ── 5. Aggregate per model (mean + 95 % CI) ────────────────────────────────\n", + "def ci95(series):\n", + " n = series.size\n", + " if n < 2:\n", + " return 0.0\n", + " return 1.96 * series.std(ddof=1) / np.sqrt(n)\n", + "\n", + "summary = (\n", + " run_scores\n", + " .groupby(\"model\")\n", + " .agg(mean=(\"rel_score\", \"mean\"), ci95=(\"rel_score\", ci95))\n", + " .reindex(model_order)\n", + " .dropna()\n", + " .sort_values(\"mean\", ascending=False)\n", + ")\n", + "\n", + "# ── 6. Plot (style copied from earlier bar charts) ─────────────────────────\n", + "fig_w = max(7, 0.4 * len(summary)) * 0.5\n", + "fig_h = 7 * 0.5\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=200)\n", + "ax = plt.gca()\n", + "\n", + "x = np.arange(len(summary))\n", + "ax.bar(\n", + " x,\n", + " summary[\"mean\"],\n", + " width=0.6,\n", + " yerr=summary[\"ci95\"],\n", + " capsize=4,\n", + " color=\"0.85\",\n", + " edgecolor=\"black\",\n", + " linewidth=1.0,\n", + ")\n", + "\n", + "ax.set_title(\"Relative Sentiment Towards Player\", fontsize=14, pad=10)\n", + "ax.set_ylabel(\"Mean Δ-Relationship\", fontsize=12)\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(summary.index, rotation=45, ha=\"right\")\n", + "ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lm_game.py b/lm_game.py index 2162057..7c0bcb2 100644 --- a/lm_game.py +++ b/lm_game.py @@ -369,7 +369,9 @@ async def main(): if neg_diary_tasks: await asyncio.gather(*neg_diary_tasks, return_exceptions=True) - # Diary Consolidation + # --- 4c. Parallel Order Generation and Diary Consolidation --- + # Start diary consolidation in parallel with order generation + consolidation_future = None if current_short_phase.startswith("S") and current_short_phase.endswith("M"): consolidation_tasks = [ run_diary_consolidation(agent, game, llm_log_file_path, @@ -378,9 +380,10 @@ async def main(): if not game.powers[agent.power_name].is_eliminated() ] if consolidation_tasks: - await asyncio.gather(*consolidation_tasks, return_exceptions=True) + # Start consolidation tasks but don't await yet + consolidation_future = asyncio.gather(*consolidation_tasks, return_exceptions=True) - # --- 4c. Order Generation --- + # Order Generation (proceeds with current diary state) logger.info("Getting orders from agents...") board_state = game.get_state() order_tasks = [] @@ -403,6 +406,10 @@ async def main(): order_results = await asyncio.gather(*order_tasks, return_exceptions=True) + # Ensure consolidation completes before proceeding to diary entries + if consolidation_future: + await consolidation_future + active_powers = [p for p, a in agents.items() if not game.powers[p].is_eliminated()] order_power_names = [p for p in active_powers if gather_possible_orders(game, p)] submitted_orders_this_phase = defaultdict(list)