Update leaderboard.py

leaderboard.py

@@ -70,7 +70,11 @@ def initialize_elo_ratings():
     
     # Replay all battles to update ELO ratings
     for model, data in leaderboard.items():
+        if model not in elo_ratings:
+            elo_ratings[model] = 1000 + (get_model_size(model) * 100)
         for opponent, results in data['opponents'].items():
+            if opponent not in elo_ratings:
+                elo_ratings[opponent] = 1000 + (get_model_size(opponent) * 100)
             for _ in range(results['wins']):
                 update_elo_ratings(model, opponent)
             for _ in range(results['losses']):
@@ -212,28 +216,57 @@ def calculate_elo_impact(model):
     leaderboard = load_leaderboard()
     initial_rating = 1000 + (get_model_size(model) * 100)
     
-    for opponent, results in leaderboard[model]['opponents'].items():
-        model_size = get_model_size(model)
-        opponent_size = get_model_size(opponent)
-        max_size = max(get_model_size(m) for m, _ in arena_config.APPROVED_MODELS)
-        
-        size_difference = (opponent_size - model_size) / max_size
-        
-        win_impact = 1 + max(0, size_difference)
-        loss_impact = 1 + max(0, -size_difference)
-        
-        positive_impact += results['wins'] * win_impact
-        negative_impact += results['losses'] * loss_impact
+    if model in leaderboard:
+        for opponent, results in leaderboard[model]['opponents'].items():
+            model_size = get_model_size(model)
+            opponent_size = get_model_size(opponent)
+            max_size = max(get_model_size(m) for m, _ in arena_config.APPROVED_MODELS)
+            
+            size_difference = (opponent_size - model_size) / max_size
+            
+            win_impact = 1 + max(0, size_difference)
+            loss_impact = 1 + max(0, -size_difference)
+            
+            positive_impact += results['wins'] * win_impact
+            negative_impact += results['losses'] * loss_impact
     
     return round(positive_impact), round(negative_impact), round(initial_rating)
 
 def get_elo_leaderboard():
     ensure_elo_ratings_initialized()
     leaderboard = load_leaderboard()
-    sorted_ratings = sorted(elo_ratings.items(), key=lambda x: x[1], reverse=True)
     
-    min_initial_rating = min(1000 + (get_model_size(model) * 100) for model, _ in arena_config.APPROVED_MODELS)
-    max_initial_rating = max(1000 + (get_model_size(model) * 100) for model, _ in arena_config.APPROVED_MODELS)
+    # Create a list of all models, including those from APPROVED_MODELS that might not be in the leaderboard yet
+    all_models = set(dict(arena_config.APPROVED_MODELS).keys()) | set(leaderboard.keys())
+    
+    elo_data = []
+    for model in all_models:
+        initial_rating = 1000 + (get_model_size(model) * 100)
+        current_rating = elo_ratings.get(model, initial_rating)
+        
+        # Calculate battle data only if the model exists in the leaderboard
+        if model in leaderboard:
+            wins = leaderboard[model].get('wins', 0)
+            losses = leaderboard[model].get('losses', 0)
+            total_battles = wins + losses
+            positive_impact, negative_impact, _ = calculate_elo_impact(model)
+        else:
+            wins = losses = total_battles = positive_impact = negative_impact = 0
+        
+        elo_data.append({
+            'model': model,
+            'current_rating': current_rating,
+            'initial_rating': initial_rating,
+            'total_battles': total_battles,
+            'positive_impact': positive_impact,
+            'negative_impact': negative_impact
+        })
+    
+    # Sort the data by current rating
+    sorted_elo_data = sorted(elo_data, key=lambda x: x['current_rating'], reverse=True)
+    
+    min_initial_rating = min(data['initial_rating'] for data in elo_data)
+    max_initial_rating = max(data['initial_rating'] for data in elo_data)
     
     explanation_elo = f"""
     <p style="font-size: 16px; margin-bottom: 20px;">
@@ -276,24 +309,21 @@ def get_elo_leaderboard():
         <th>Negative Impact</th>
         <th>Total Battles</th>
         <th>Initial Rating</th>
-
     </tr>
     """
     
-    for index, (model, rating) in enumerate(sorted_ratings, start=1):
-        total_battles = leaderboard[model]['wins'] + leaderboard[model]['losses']
+    for index, data in enumerate(sorted_elo_data, start=1):
         rank_display = {1: "🥇", 2: "🥈", 3: "🥉"}.get(index, f"{index}")
-        positive_impact, negative_impact, initial_rating = calculate_elo_impact(model)
         
         leaderboard_html += f"""
         <tr>
             <td class='rank-column'>{rank_display}</td>
-            <td>{get_human_readable_name(model)}</td>
-            <td><strong>{round(rating)}</strong></td>
-            <td>{positive_impact}</td>
-            <td>{negative_impact}</td>
-            <td>{total_battles}</td>
-            <td>{initial_rating}</td>
+            <td>{get_human_readable_name(data['model'])}</td>
+            <td><strong>{round(data['current_rating'])}</strong></td>
+            <td>{data['positive_impact']}</td>
+            <td>{data['negative_impact']}</td>
+            <td>{data['total_battles']}</td>
+            <td>{round(data['initial_rating'])}</td>
         </tr>
         """