Update app.py

app.py

@@ -1,9 +1,10 @@
 import gradio as gr
 import json
+import collections
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # Define model name - use a very small model
-MODEL_NAME = "EleutherAI/pythia-70m"  # Extremely small model, no quantization needed
+MODEL_NAME = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"  # Chat-tuned 1.1B parameter model
 
 print(f"Loading model {MODEL_NAME}...")
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
@@ -14,8 +15,57 @@ 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"""
+    """Format Rock-Paper-Scissors game data into a prompt for the LLM with pattern analysis"""
     try:
         # Parse the JSON game data
         if isinstance(game_data, str):
@@ -27,19 +77,42 @@ def format_rps_game_prompt(game_data):
         rounds_played = len(player_history)
         player_score = game_data.get("player_score", 0)
         opponent_score = game_data.get("opponent_score", 0)
+        draws = game_data.get("draws", 0)
         
-        # Create the prompt
-        prompt = f"""You are an assistant helping a player win at Rock-Paper-Scissors.
+        # 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.
 
 Game State:
 - Rounds played: {rounds_played}
 - Player score: {player_score}
 - Opponent score: {opponent_score}
-- Player move history: {', '.join(player_history)}
-- Opponent move history: {', '.join(opponent_history)}
+- Draws: {draws}
+- Player's last 5 moves: {', '.join(player_history[-5:])}
+- Opponent's last 5 moves: {', '.join(opponent_history[-5:])}
+
+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')}
+
+- 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')}
+
+- Sequence analysis: {sequence_prediction}
 
-Based on the opponent's pattern of moves, what should the player choose next (Rock, Paper, or Scissors)?
-Explain your reasoning, then provide a clear recommendation.
+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]"
 """
         return prompt
     except Exception as e:
@@ -57,17 +130,41 @@ def generate_advice(game_data):
         # Set max_length to avoid excessive generation
         outputs = model.generate(
             inputs["input_ids"],
-            max_new_tokens=100,  # Limit token generation
+            max_new_tokens=150,  # Allow more tokens for a more detailed response
             do_sample=True, 
             temperature=0.7, 
             top_p=0.9
         )
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Remove the prompt from the response
-        if response.startswith(prompt):
-            response = response[len(prompt):].strip()
+        # Extract just the model's response (remove the prompt)
+        if full_response.startswith(prompt):
+            response = full_response[len(prompt):].strip()
+        else:
+            response = full_response
             
+        # 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"
+            else:
+                suggestion = "Rock"
+                
+            response += f"\n\nBased on opponent's move frequencies, they play {max_move} most often. \nRecommendation: {suggestion}"
+        
         return response
     except Exception as e:
         return f"Error generating advice: {str(e)}"
@@ -77,7 +174,8 @@ sample_game_data = {
     "player_history": ["Rock", "Paper", "Scissors", "Rock", "Paper"],
     "opponent_history": ["Scissors", "Rock", "Paper", "Scissors", "Rock"],
     "player_score": 3,
-    "opponent_score": 2
+    "opponent_score": 2,
+    "draws": 0
 }
 
 # Create Gradio interface