Update app.py

app.py

@@ -15,57 +15,8 @@ model = AutoModelForCausalLM.from_pretrained(
 )
 print("Model loaded successfully!")
 
-def analyze_patterns(player_history, opponent_history):
-    """Perform basic pattern analysis on the game history"""
-    analysis = {}
-    
-    # Count frequencies of each move
-    move_counts = collections.Counter(opponent_history)
-    total_moves = len(opponent_history)
-    
-    analysis["move_frequencies"] = {
-        "Rock": f"{move_counts.get('Rock', 0)}/{total_moves} ({move_counts.get('Rock', 0)*100/total_moves:.1f}%)",
-        "Paper": f"{move_counts.get('Paper', 0)}/{total_moves} ({move_counts.get('Paper', 0)*100/total_moves:.1f}%)",
-        "Scissors": f"{move_counts.get('Scissors', 0)}/{total_moves} ({move_counts.get('Scissors', 0)*100/total_moves:.1f}%)"
-    }
-    
-    # Check response patterns (what opponent plays after player's moves)
-    response_patterns = {
-        "After_Rock": collections.Counter(),
-        "After_Paper": collections.Counter(),
-        "After_Scissors": collections.Counter()
-    }
-    
-    for i in range(len(player_history) - 1):
-        player_move = player_history[i]
-        opponent_next = opponent_history[i + 1]
-        response_patterns[f"After_{player_move}"][opponent_next] += 1
-    
-    analysis["response_patterns"] = {}
-    for pattern, counter in response_patterns.items():
-        if sum(counter.values()) > 0:
-            most_common = counter.most_common(1)[0]
-            analysis["response_patterns"][pattern] = f"{most_common[0]} ({most_common[1]}/{sum(counter.values())})"
-    
-    # Check for repeating sequences
-    last_moves = opponent_history[-3:]
-    repeated_sequences = []
-    
-    # Look for this sequence in history
-    for i in range(len(opponent_history) - 3):
-        if opponent_history[i:i+3] == last_moves:
-            if i+3 < len(opponent_history):
-                repeated_sequences.append(opponent_history[i+3])
-    
-    if repeated_sequences:
-        counter = collections.Counter(repeated_sequences)
-        most_common = counter.most_common(1)[0]
-        analysis["sequence_prediction"] = f"After sequence {' → '.join(last_moves)}, opponent most often plays {most_common[0]} ({most_common[1]}/{len(repeated_sequences)} times)"
-    
-    return analysis
-
 def format_rps_game_prompt(game_data):
-    """Format Rock-Paper-Scissors game data into a prompt for the LLM with pattern analysis"""
+    """Format Rock-Paper-Scissors game data into a simple prompt for the LLM"""
     try:
         # Parse the JSON game data
         if isinstance(game_data, str):
@@ -79,40 +30,26 @@ def format_rps_game_prompt(game_data):
         opponent_score = game_data.get("opponent_score", 0)
         draws = game_data.get("draws", 0)
         
-        # Perform pattern analysis
-        pattern_analysis = analyze_patterns(player_history, opponent_history)
-        
-        # Format analysis for prompt
-        move_frequencies = pattern_analysis.get("move_frequencies", {})
-        response_patterns = pattern_analysis.get("response_patterns", {})
-        sequence_prediction = pattern_analysis.get("sequence_prediction", "No clear sequence pattern detected")
-        
-        # Create a more specific prompt with the analysis
-        prompt = f"""You are an expert Rock-Paper-Scissors strategy advisor helping a player win.
+        # Create a simple prompt with just the game state
+        prompt = f"""You are a Rock-Paper-Scissors strategy advisor. 
 
 Game State:
 - Rounds played: {rounds_played}
 - Player score: {player_score}
 - Opponent score: {opponent_score}
 - Draws: {draws}
-- Player's last 5 moves: {', '.join(player_history[-5:])}
-- Opponent's last 5 moves: {', '.join(opponent_history[-5:])}
+- Player's moves (oldest to newest): {', '.join(player_history)}
+- Opponent's moves (oldest to newest): {', '.join(opponent_history)}
 
-Pattern Analysis:
-- Opponent's move frequencies:
-  * Rock: {move_frequencies.get('Rock', 'N/A')}
-  * Paper: {move_frequencies.get('Paper', 'N/A')}
-  * Scissors: {move_frequencies.get('Scissors', 'N/A')}
+Analyze the game history and provide advice on what move (Rock, Paper, or Scissors) the player should make next.
 
-- Opponent's response patterns:
-  * After player's Rock: {response_patterns.get('After_Rock', 'No clear pattern')}
-  * After player's Paper: {response_patterns.get('After_Paper', 'No clear pattern')}
-  * After player's Scissors: {response_patterns.get('After_Scissors', 'No clear pattern')}
+First, explain your thought process and reasoning in detail:
+1. Look for patterns in the opponent's moves
+2. Consider if the opponent seems to be using any strategy
+3. Evaluate if the player should try to counter the opponent's most likely next move
+4. Consider any psychological factors that might be relevant
 
-- Sequence analysis: {sequence_prediction}
-
-Based on this pattern analysis, what should the player choose next (Rock, Paper, or Scissors)?
-Explain your reasoning step-by-step, then end with: "Recommendation: [Rock/Paper/Scissors]"
+After your explanation, end with a clear recommendation: "Recommendation: [Rock/Paper/Scissors]"
 """
         return prompt
     except Exception as e:
@@ -130,7 +67,7 @@ def generate_advice(game_data):
         # Set max_length to avoid excessive generation
         outputs = model.generate(
             inputs["input_ids"],
-            max_new_tokens=150,  # Allow more tokens for a more detailed response
+            max_new_tokens=200,  # Allow more tokens for detailed reasoning
             do_sample=True, 
             temperature=0.7, 
             top_p=0.9
@@ -145,25 +82,19 @@ def generate_advice(game_data):
             
         # If model response is too short, add fallback advice
         if len(response) < 30:
-            pattern_analysis = analyze_patterns(
-                json.loads(game_data)["player_history"] if isinstance(game_data, str) else game_data["player_history"],
-                json.loads(game_data)["opponent_history"] if isinstance(game_data, str) else game_data["opponent_history"]
-            )
-            
-            # Simple fallback strategy based on pattern analysis
-            move_freqs = pattern_analysis.get("move_frequencies", {})
-            max_move = max(["Rock", "Paper", "Scissors"], 
-                          key=lambda m: float(move_freqs.get(m, "0/0 (0%)").split("(")[1].split("%")[0]))
-            
-            # Choose counter to opponent's most frequent move
-            if max_move == "Rock":
-                suggestion = "Paper"
-            elif max_move == "Paper":
-                suggestion = "Scissors"
+            # Simple fallback based on opponent's last move
+            if len(opponent_history) > 0:
+                last_move = opponent_history[-1]
+                if last_move == "Rock":
+                    suggestion = "Paper"
+                elif last_move == "Paper":
+                    suggestion = "Scissors"
+                else:
+                    suggestion = "Rock"
+                    
+                response += f"\n\nBased on the opponent's last move ({last_move}), a reasonable counter would be:\nRecommendation: {suggestion}"
             else:
-                suggestion = "Rock"
-                
-            response += f"\n\nBased on opponent's move frequencies, they play {max_move} most often. \nRecommendation: {suggestion}"
+                response += "\n\nWith no game history to analyze, each move has equal probability of success.\nRecommendation: Paper"
         
         return response
     except Exception as e: