Update app.py

app.py

@@ -7,6 +7,8 @@ import re
 import config
 import plotly.graph_objects as go
 from typing import Dict
+import json
+import os
 from leaderboard import (
     get_current_leaderboard,
     update_leaderboard, 
@@ -419,6 +421,90 @@ def continue_conversation(prompt, left_chat, right_chat, left_model, right_model
         tie_count
     )
 
+def normalize_parameter_size(param_size: str) -> str:
+    """Convert parameter size to billions (B) format."""
+    try:
+        # Remove any spaces and convert to uppercase for consistency
+        param_size = param_size.replace(" ", "").upper()
+        
+        # Extract the number and unit
+        if 'M' in param_size:
+            # Convert millions to billions
+            number = float(param_size.replace('M', '').replace(',', ''))
+            return f"{number/1000:.2f}B"
+        elif 'B' in param_size:
+            # Already in billions, just format consistently
+            number = float(param_size.replace('B', '').replace(',', ''))
+            return f"{number:.2f}B"
+        else:
+            # If no unit or unrecognized format, try to convert the raw number
+            number = float(param_size.replace(',', ''))
+            if number >= 1000000000:
+                return f"{number/1000000000:.2f}B"
+            elif number >= 1000000:
+                return f"{number/1000000000:.2f}B"
+            else:
+                return f"{number/1000000000:.2f}B"
+    except:
+        return param_size  # Return original if conversion fails
+
+def load_latest_model_stats():
+    """Load model stats from the model_stats.json file."""
+    try:
+        # Read directly from model_stats.json in root directory
+        with open('model_stats.json', 'r') as f:
+            stats = json.load(f)
+            
+        # Convert stats to table format
+        table_data = []
+        headers = ["Model", "VRAM (GB)", "Size", "Parameters", "Quantization", "Tokens/sec", "Gen Tokens/sec", "Total Tokens", "Response Time (s)"]
+        
+        for model in stats:
+            if not model.get("success", False):  # Skip failed tests
+                continue
+                
+            perf = model.get("performance", {})
+            info = model.get("model_info", {})
+            
+            try:
+                # Format numeric values with 2 decimal places
+                model_size = float(info.get("size", 0))  # Get raw size
+                vram_gb = round(model_size/1024/1024/1024, 2)  # Convert to GB
+                tokens_per_sec = round(float(perf.get("tokens_per_second", 0)), 2)
+                gen_tokens_per_sec = round(float(perf.get("generation_tokens_per_second", 0)), 2)
+                total_tokens = perf.get("total_tokens", 0)
+                response_time = round(float(perf.get("response_time", 0)), 2)
+                
+                # Normalize parameter size to billions format
+                param_size = normalize_parameter_size(info.get("parameter_size", "Unknown"))
+                
+                row = [
+                    model.get("model_name", "Unknown"),      # String
+                    vram_gb,                                 # Number (2 decimals)
+                    model_size,                              # Number (bytes)
+                    param_size,                              # String (normalized to B)
+                    info.get("quantization_level", "Unknown"),  # String
+                    tokens_per_sec,                          # Number (2 decimals)
+                    gen_tokens_per_sec,                      # Number (2 decimals)
+                    total_tokens,                            # Number (integer)
+                    response_time                            # Number (2 decimals)
+                ]
+                table_data.append(row)
+            except Exception as row_error:
+                logger.warning(f"Skipping model {model.get('model_name', 'Unknown')}: {str(row_error)}")
+                continue
+            
+        if not table_data:
+            return None, "No valid model stats found"
+            
+        # Sort by tokens per second (numerically)
+        table_data.sort(key=lambda x: float(x[5]) if isinstance(x[5], (int, float)) else 0, reverse=True)
+        
+        return headers, table_data
+    except Exception as e:
+        logger.error(f"Error in load_latest_model_stats: {str(e)}")
+        return None, f"Error loading model stats: {str(e)}"
+
 # Initialize Gradio Blocks
 with gr.Blocks(css="""
     #dice-button {
@@ -561,6 +647,32 @@ with gr.Blocks(css="""
             outputs=[release_notes]
         )
     
+    # Model Stats Tab
+    with gr.Tab("Model Stats"):
+        gr.Markdown("""
+        ### Model Performance Statistics
+        
+        This tab shows detailed performance metrics for each model, tested using a creative writing prompt.
+        The tests were performed on an **AMD Radeon RX 7600 XT 16GB GPU**.
+        
+        For detailed information about the testing methodology, parameters, and hardware setup, please refer to the 
+        [README_model_stats.md](https://huggingface.co/spaces/k-mktr/gpu-poor-llm-arena/blob/main/README_model_stats.md).
+        
+        """)
+        
+        headers, table_data = load_latest_model_stats()
+        if headers:
+            model_stats_table = gr.Dataframe(
+                headers=headers,
+                value=table_data,
+                row_count=len(table_data),
+                col_count=len(headers),
+                interactive=False,
+                label="Model Performance Statistics"
+            )
+        else:
+            gr.Markdown(f"⚠️ {table_data}")  # Show error message if loading failed
+    
     # Define interactions
     submit_btn.click(
         battle_arena,