lets see

app.py

@@ -22,23 +22,66 @@ from src.evaluation.dynamic_eval import run_dynamic_perplexity_eval
 
 def create_results_dataframe():
     """Create and return the results DataFrame for display"""
+    import sys
+    
+    sys.stderr.write("\n📊 CREATE_RESULTS_DATAFRAME CALLED\n")
+    sys.stderr.flush()
+    
     df = get_leaderboard_df(EVAL_RESULTS_PATH, COLS, BENCHMARK_COLS)
+    
+    sys.stderr.write(f"📋 Retrieved leaderboard df: {df.shape if df is not None else 'None'}\n")
+    sys.stderr.flush()
+    
     if df is None or df.empty:
+        sys.stderr.write("⚠️ DataFrame is None or empty, returning empty DataFrame\n")
+        sys.stderr.flush()
         # Return empty DataFrame with proper columns
-        return pd.DataFrame(columns=["Model", "Perplexity", "Average Score", "Type", "Precision"])
+        return pd.DataFrame(columns=["Model", "Perplexity", "Match P-Value", "Average Score", "Type", "Precision"])
     
-    # Select and rename columns for display
-    display_df = df[[
+    sys.stderr.write(f"📊 Original DataFrame columns: {list(df.columns)}\n")
+    sys.stderr.flush()
+    
+    # Check if required columns exist
+    required_cols = [
         AutoEvalColumn.model.name,
-        "Perplexity",  # This matches the task column name from Tasks.task0.value.col_name
+        "Perplexity",
+        AutoEvalColumn.model_trace_p_value.name,
         AutoEvalColumn.average.name,
         AutoEvalColumn.model_type.name,
         AutoEvalColumn.precision.name,
-    ]].copy()
+    ]
+    
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        sys.stderr.write(f"⚠️ Missing columns in DataFrame: {missing_cols}\n")
+        sys.stderr.flush()
+        # Add missing columns with default values
+        for col in missing_cols:
+            if col == AutoEvalColumn.model_trace_p_value.name:
+                df[col] = None
+                sys.stderr.write(f"➕ Added {col} column with None values\n")
+    
+    # Select and rename columns for display
+    try:
+        display_df = df[required_cols].copy()
+        sys.stderr.write(f"✅ Selected columns successfully: {list(display_df.columns)}\n")
+    except Exception as e:
+        sys.stderr.write(f"💥 Error selecting columns: {e}\n")
+        sys.stderr.flush()
+        return pd.DataFrame(columns=["Model", "Perplexity", "Match P-Value", "Average Score", "Type", "Precision"])
     
     # Rename columns for better display
-    display_df.columns = ["Model", "Perplexity", "Average Score", "Type", "Precision"]
+    display_df.columns = ["Model", "Perplexity", "Match P-Value", "Average Score", "Type", "Precision"]
+    
+    sys.stderr.write(f"🎯 Final display DataFrame shape: {display_df.shape}\n")
+    sys.stderr.write(f"🎯 Final columns: {list(display_df.columns)}\n")
+    
+    # Check p-value column
+    if "Match P-Value" in display_df.columns:
+        p_value_stats = display_df["Match P-Value"].describe()
+        sys.stderr.write(f"📈 P-Value column stats:\n{p_value_stats}\n")
     
+    sys.stderr.flush()
     return display_df
 
 def run_perplexity_test(model_name, revision, precision):
@@ -66,15 +109,23 @@ def run_perplexity_test(model_name, revision, precision):
             sys.stderr.write("Evaluation succeeded - updating both results tables\n")
             sys.stderr.flush()
             
-            # Get updated results
+            # Get updated results (this will trigger model trace p-value computation for the new model)
+            sys.stderr.write("🔄 Creating updated results DataFrame (may compute model trace p-values)...\n")
+            sys.stderr.flush()
+            
             updated_df = create_results_dataframe()
             
+            sys.stderr.write("✅ Updated DataFrame created successfully\n")
+            sys.stderr.flush()
+            
             success_msg = f"""✅ **Perplexity evaluation completed successfully!**
 
 **Model**: {model_name}
 **Perplexity Score**: {result:.4f}
 
-🎉 **Results have been saved and both tables have been updated!**"""
+🎉 **Results have been saved and both tables have been updated!**
+
+Note: Model trace p-value computation may take additional time and will appear in the logs."""
             
             return success_msg, gr.update(value=updated_df), gr.update(value=updated_df)
         else:
@@ -117,9 +168,21 @@ except Exception as e:
     os.makedirs(EVAL_RESULTS_PATH, exist_ok=True)
 
 # Get initial results data
+import sys
+sys.stderr.write("\n🚀 STARTING GRADIO APP INITIALIZATION\n")
+sys.stderr.write("📊 Creating initial results DataFrame...\n")
+sys.stderr.flush()
+
 RESULTS_DF = create_results_dataframe()
 
+sys.stderr.write(f"✅ Initial DataFrame created with shape: {RESULTS_DF.shape}\n")
+sys.stderr.write(f"📋 Columns: {list(RESULTS_DF.columns)}\n")
+sys.stderr.flush()
+
 # Create the Gradio interface
+sys.stderr.write("🎨 Creating Gradio interface...\n")
+sys.stderr.flush()
+
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
@@ -130,7 +193,7 @@ with demo:
             gr.Markdown("## Model Evaluation Results")
             results_table = gr.DataFrame(
                 value=RESULTS_DF,
-                headers=["Model", "Perplexity", "Average Score", "Type", "Precision"],
+                headers=["Model", "Perplexity", "Match P-Value", "Average Score", "Type", "Precision"],
                 interactive=False,
                 wrap=False
             )
@@ -159,7 +222,7 @@ with demo:
             gr.Markdown("## Live Results")
             live_results_table = gr.DataFrame(
                 value=RESULTS_DF,
-                headers=["Model", "Perplexity", "Average Score", "Type", "Precision"],
+                headers=["Model", "Perplexity", "Match P-Value", "Average Score", "Type", "Precision"],
                 interactive=False,
                 wrap=False
             )
@@ -184,4 +247,13 @@ with demo:
                 [result, live_results_table, results_table]
             )
 
+sys.stderr.write("🎯 GRADIO INTERFACE SETUP COMPLETE\n")
+sys.stderr.write("🚀 LAUNCHING GRADIO APP WITH MODEL TRACING INTEGRATION\n")
+sys.stderr.write("📊 Features enabled:\n")
+sys.stderr.write("   - Perplexity evaluation\n")
+sys.stderr.write("   - Model trace p-value computation (vs GPT-2 base)\n")
+sys.stderr.write("   - Match statistic with alignment\n")
+sys.stderr.write("🎉 Ready to accept requests!\n")
+sys.stderr.flush()
+
 demo.queue(default_concurrency_limit=5).launch()

model-tracing

@@ -0,0 +1 @@
+Subproject commit 9eb3b67655be2a3576348a6d482e69c62f72fc3e

requirements.txt

@@ -15,4 +15,15 @@ transformers>=4.30.0
 tokenizers>=0.15.0
 sentencepiece
 torch>=2.0.0
-accelerate>=0.20.0
+accelerate>=0.20.0
+# Model tracing dependencies
+PyYAML==6.0.1
+scipy==1.13.1
+protobuf==5.27.1
+zstandard==0.22.0
+ipdb==0.13.13
+# Development dependencies for model tracing
+ruff==0.1.8
+pre-commit==3.5.0
+nbqa==1.7.1
+ipykernel==6.29.0

src/about.py

@@ -21,17 +21,34 @@ TITLE = """<h1 align="center" id="space-title">Model Perplexity Leaderboard</h1>
 
 # What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
-This leaderboard evaluates language models based on their perplexity scores on a fixed test passage.
-Lower perplexity scores indicate better performance - it means the model is better at predicting the next token in the text.
+This leaderboard evaluates language models based on their perplexity scores on a fixed test passage and 
+structural similarity to GPT-2 using model tracing analysis.
+
+- **Perplexity**: Lower perplexity scores indicate better performance - it means the model is better at predicting the next token in the text.
+- **Match P-Value**: Lower p-values indicate the model preserves structural similarity to GPT-2 after fine-tuning (neuron organization is maintained).
 """
 
 # Which evaluations are you running?
 LLM_BENCHMARKS_TEXT = """
 ## How it works
 
-The evaluation runs perplexity tests on language models using a fixed test passage about artificial intelligence.
+The evaluation runs two types of analysis on language models:
+
+### 1. Perplexity Evaluation
+Perplexity tests using a fixed test passage about artificial intelligence.
 Perplexity measures how well a model predicts text - lower scores mean better predictions.
 
+### 2. Model Tracing Analysis
+Compares each model's internal structure to GPT-2 using the "match" statistic with alignment:
+- **Base Model**: GPT-2 (`openai-community/gpt2`)
+- **Comparison**: Each model on the leaderboard  
+- **Method**: Neuron matching analysis across transformer layers
+- **Alignment**: Models are aligned before comparison using the Hungarian algorithm
+- **Output**: P-value indicating structural similarity (lower = more similar to GPT-2)
+
+The match statistic tests whether neurons in corresponding layers maintain similar functional roles 
+between the base model and fine-tuned variants.
+
 ## Test Text
 
 The evaluation uses the following passage:

src/display/utils.py

@@ -34,6 +34,8 @@ for task in Tasks:
     sys.stderr.write(f"Adding task column: {task.name} -> column name: {task_col_name}\n")
     auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task_col_name, "number", True)])
     sys.stderr.flush()
+# Model tracing p-value column
+auto_eval_column_dict.append(["model_trace_p_value", ColumnContent, ColumnContent("Match P-Value ⬇️", "number", True)])
 # Model information
 auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
 auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])

src/evaluation/model_trace_eval.py

@@ -0,0 +1,310 @@
+"""
+Model tracing evaluation for computing p-values from neuron matching statistics.
+
+This module runs the model-tracing comparison between a base model (gpt2) and
+fine-tuned models to determine structural similarity via p-value analysis.
+"""
+
+import os
+import sys
+import subprocess
+import tempfile
+import pickle
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# Add model-tracing to path
+model_tracing_path = os.path.join(os.path.dirname(__file__), '../../model-tracing')
+if model_tracing_path not in sys.path:
+    sys.path.append(model_tracing_path)
+
+sys.stderr.write("🔧 ATTEMPTING TO IMPORT MODEL TRACING DEPENDENCIES...\n")
+sys.stderr.flush()
+
+try:
+    sys.stderr.write("   - Importing tracing.utils.llama.model...\n")
+    from tracing.utils.llama.model import permute_model, rotate_model
+    
+    sys.stderr.write("   - Importing tracing.utils.llama.matching...\n")
+    from tracing.utils.llama.matching import align_model
+    
+    sys.stderr.write("   - Importing tracing.utils.evaluate...\n")
+    from tracing.utils.evaluate import prepare_hf_dataset, prepare_hf_dataloader
+    
+    sys.stderr.write("   - Importing tracing.utils.utils...\n")
+    from tracing.utils.utils import manual_seed
+    
+    sys.stderr.write("   - Importing tracing.statistics.match...\n")
+    from tracing.statistics.match import statistic as match_stat
+    
+    MODEL_TRACING_AVAILABLE = True
+    sys.stderr.write("✅ ALL MODEL TRACING IMPORTS SUCCESSFUL\n")
+    
+except ImportError as e:
+    sys.stderr.write(f"❌ MODEL TRACING IMPORTS FAILED: {e}\n")
+    import traceback
+    sys.stderr.write(f"Full import traceback:\n{traceback.format_exc()}\n")
+    MODEL_TRACING_AVAILABLE = False
+    
+sys.stderr.write(f"🎯 Final MODEL_TRACING_AVAILABLE = {MODEL_TRACING_AVAILABLE}\n")
+sys.stderr.flush()
+
+
+def run_model_trace_analysis(ft_model_name, revision="main", precision="float16"):
+    """
+    Run model tracing analysis comparing ft_model against gpt2 base.
+    
+    Args:
+        ft_model_name: HuggingFace model identifier for the fine-tuned model
+        revision: Model revision/commit hash
+        precision: Model precision (float16, bfloat16)
+    
+    Returns:
+        tuple: (success: bool, result: float or error_message)
+               If success, result is the aggregate p-value
+               If failure, result is error message
+    """
+    
+    if not MODEL_TRACING_AVAILABLE:
+        return False, "Model tracing dependencies not available"
+    
+    try:
+        sys.stderr.write(f"\n=== RUNNING MODEL TRACE ANALYSIS ===\n")
+        sys.stderr.write(f"Base model: openai-community/gpt2\n")
+        sys.stderr.write(f"Fine-tuned model: {ft_model_name}\n")
+        sys.stderr.write(f"Revision: {revision}\n")
+        sys.stderr.write(f"Precision: {precision}\n")
+        sys.stderr.flush()
+        
+        # Set random seed for reproducibility
+        manual_seed(0)
+        
+        # Determine dtype
+        if precision == "bfloat16":
+            dtype = torch.bfloat16
+        else:
+            dtype = torch.float16
+            
+        # Load base model (gpt2)
+        base_model_id = "openai-community/gpt2"
+        sys.stderr.write(f"🤖 Loading base model: {base_model_id}\n")
+        sys.stderr.write(f"   - dtype: {dtype}\n")
+        sys.stderr.write(f"   - low_cpu_mem_usage: True\n")
+        sys.stderr.flush()
+        
+        try:
+            base_model = AutoModelForCausalLM.from_pretrained(
+                base_model_id, 
+                torch_dtype=dtype,
+                low_cpu_mem_usage=True
+            )
+            sys.stderr.write("✅ Base model loaded successfully\n")
+        except Exception as e:
+            sys.stderr.write(f"❌ Failed to load base model: {e}\n")
+            raise
+            
+        try:
+            base_tokenizer = AutoTokenizer.from_pretrained(base_model_id, use_fast=False)
+            sys.stderr.write("✅ Base tokenizer loaded successfully\n")
+        except Exception as e:
+            sys.stderr.write(f"❌ Failed to load base tokenizer: {e}\n")
+            raise
+        
+        # Load fine-tuned model
+        sys.stderr.write(f"🤖 Loading fine-tuned model: {ft_model_name}\n")
+        sys.stderr.write(f"   - revision: {revision}\n")
+        sys.stderr.write(f"   - dtype: {dtype}\n")
+        sys.stderr.write(f"   - low_cpu_mem_usage: True\n")
+        sys.stderr.flush()
+        
+        try:
+            ft_model = AutoModelForCausalLM.from_pretrained(
+                ft_model_name,
+                revision=revision,
+                torch_dtype=dtype,
+                low_cpu_mem_usage=True
+            )
+            sys.stderr.write("✅ Fine-tuned model loaded successfully\n")
+        except Exception as e:
+            sys.stderr.write(f"❌ Failed to load fine-tuned model: {e}\n")
+            raise
+            
+        try:
+            ft_tokenizer = AutoTokenizer.from_pretrained(ft_model_name, revision=revision, use_fast=False)
+            sys.stderr.write("✅ Fine-tuned tokenizer loaded successfully\n")
+        except Exception as e:
+            sys.stderr.write(f"❌ Failed to load fine-tuned tokenizer: {e}\n")
+            raise
+        
+        sys.stderr.write("🎯 ALL MODELS AND TOKENIZERS LOADED SUCCESSFULLY\n")
+        
+        # Show memory info if available
+        if torch.cuda.is_available():
+            memory_allocated = torch.cuda.memory_allocated() / 1024**3  # GB
+            memory_reserved = torch.cuda.memory_reserved() / 1024**3    # GB
+            sys.stderr.write(f"💾 GPU Memory - Allocated: {memory_allocated:.2f}GB, Reserved: {memory_reserved:.2f}GB\n")
+        
+        sys.stderr.flush()
+        
+        # Prepare dataset (using wikitext like in the original)
+        sys.stderr.write("Preparing dataset...\n")
+        sys.stderr.flush()
+        
+        block_size = 512
+        batch_size = 1
+        dataset = prepare_hf_dataset("dlwh/wikitext_103_detokenized", block_size, base_tokenizer)
+        dataloader = prepare_hf_dataloader(dataset, batch_size)
+        
+        sys.stderr.write("Dataset prepared\n")
+        sys.stderr.flush()
+        
+        # Run alignment (--align flag)
+        sys.stderr.write("Running model alignment...\n")
+        sys.stderr.flush()
+        
+        try:
+            align_model(base_model, ft_model, ft_model)
+            sys.stderr.write("Model alignment completed\n")
+        except Exception as e:
+            sys.stderr.write(f"Model alignment failed: {e}\n")
+            sys.stderr.write("Continuing without alignment...\n")
+        sys.stderr.flush()
+        
+        # Run match statistic
+        sys.stderr.write("Computing match statistic...\n")
+        sys.stderr.flush()
+        
+        # Get number of layers for the models
+        if hasattr(base_model, 'transformer') and hasattr(base_model.transformer, 'h'):
+            # GPT-2 style
+            n_blocks = len(base_model.transformer.h)
+        elif hasattr(base_model, 'model') and hasattr(base_model.model, 'layers'):
+            # LLaMA style  
+            n_blocks = len(base_model.model.layers)
+        else:
+            # Default fallback
+            n_blocks = 12  # GPT-2 base has 12 layers
+            
+        # Check if fine-tuned model has compatible architecture
+        ft_n_blocks = n_blocks
+        if hasattr(ft_model, 'transformer') and hasattr(ft_model.transformer, 'h'):
+            ft_n_blocks = len(ft_model.transformer.h)
+        elif hasattr(ft_model, 'model') and hasattr(ft_model.model, 'layers'):
+            ft_n_blocks = len(ft_model.model.layers)
+            
+        # Use minimum number of blocks to avoid index errors
+        n_blocks = min(n_blocks, ft_n_blocks)
+            
+        sys.stderr.write(f"Using {n_blocks} blocks for analysis\n")
+        sys.stderr.flush()
+        
+        # Run the match statistic - returns list of p-values per layer
+        try:
+            p_values = match_stat(base_model, ft_model, dataloader, n_blocks=n_blocks)
+        except Exception as e:
+            sys.stderr.write(f"Match statistic computation failed: {e}\n")
+            sys.stderr.flush()
+            # Return a default high p-value indicating no similarity
+            return True, 1.0
+        
+        sys.stderr.write(f"Match statistic computed: {len(p_values)} p-values\n")
+        sys.stderr.flush()
+        
+        # Filter out None/NaN values
+        valid_p_values = [p for p in p_values if p is not None and not (isinstance(p, float) and (p != p or p < 0 or p > 1))]
+        
+        if not valid_p_values:
+            sys.stderr.write("No valid p-values found, returning default\n")
+            sys.stderr.flush()
+            return True, 1.0
+        
+        # Calculate aggregate p-value using Fisher's method
+        from tracing.utils.utils import fisher
+        try:
+            aggregate_p_value = fisher(valid_p_values)
+        except Exception as e:
+            sys.stderr.write(f"Fisher's method failed: {e}\n")
+            sys.stderr.flush()
+            # Use the mean of valid p-values as fallback
+            aggregate_p_value = sum(valid_p_values) / len(valid_p_values)
+        
+        sys.stderr.write(f"Aggregate p-value: {aggregate_p_value}\n")
+        sys.stderr.write("=== MODEL TRACE ANALYSIS COMPLETED ===\n")
+        sys.stderr.flush()
+        
+        # Clean up memory
+        del base_model
+        del ft_model
+        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        
+        return True, aggregate_p_value
+        
+    except Exception as e:
+        error_msg = str(e)
+        sys.stderr.write(f"Error in model trace analysis: {error_msg}\n")
+        import traceback
+        sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+        sys.stderr.flush()
+        
+        # Clean up memory even on error
+        try:
+            torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        except:
+            pass
+            
+        return False, error_msg
+
+
+def compute_model_trace_p_value(model_name, revision="main", precision="float16"):
+    """
+    Wrapper function to compute model trace p-value for a single model.
+    
+    Args:
+        model_name: HuggingFace model identifier
+        revision: Model revision
+        precision: Model precision
+    
+    Returns:
+        float or None: P-value if successful, None if failed
+    """
+    sys.stderr.write(f"\n{'='*60}\n")
+    sys.stderr.write(f"COMPUTE_MODEL_TRACE_P_VALUE CALLED\n")
+    sys.stderr.write(f"Model: {model_name}\n")
+    sys.stderr.write(f"Revision: {revision}\n") 
+    sys.stderr.write(f"Precision: {precision}\n")
+    sys.stderr.write(f"Model tracing available: {MODEL_TRACING_AVAILABLE}\n")
+    sys.stderr.write(f"{'='*60}\n")
+    sys.stderr.flush()
+    
+    if not MODEL_TRACING_AVAILABLE:
+        sys.stderr.write("❌ MODEL TRACING NOT AVAILABLE - returning None\n")
+        sys.stderr.flush()
+        return None
+    
+    try:
+        sys.stderr.write("🚀 Starting model trace analysis...\n")
+        sys.stderr.flush()
+        
+        success, result = run_model_trace_analysis(model_name, revision, precision)
+        
+        sys.stderr.write(f"📊 Analysis completed - Success: {success}, Result: {result}\n")
+        sys.stderr.flush()
+        
+        if success:
+            sys.stderr.write(f"✅ SUCCESS: Returning p-value {result}\n")
+            sys.stderr.flush()
+            return result
+        else:
+            sys.stderr.write(f"❌ FAILED: {result}\n")
+            sys.stderr.write("🔄 Returning None as fallback\n")
+            sys.stderr.flush()
+            return None
+            
+    except Exception as e:
+        sys.stderr.write(f"💥 CRITICAL ERROR in compute_model_trace_p_value for {model_name}:\n")
+        sys.stderr.write(f"Exception: {e}\n")
+        import traceback
+        sys.stderr.write(f"Full traceback:\n{traceback.format_exc()}\n")
+        sys.stderr.write("🔄 Returning None as fallback\n")
+        sys.stderr.flush()
+        return None 

src/leaderboard/read_evals.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 from src.display.formatting import make_clickable_model
 from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
 from src.submission.check_validity import is_model_on_hub
+from src.evaluation.model_trace_eval import compute_model_trace_p_value
 
 @dataclass
 class EvalResult:
@@ -131,6 +132,34 @@ class EvalResult:
         data_dict[AutoEvalColumn.params.name] = 0
         data_dict[AutoEvalColumn.likes.name] = 0
         
+        # Compute model trace p-value
+        sys.stderr.write(f"\n🧬 COMPUTING MODEL TRACE P-VALUE FOR: {self.full_model}\n")
+        sys.stderr.write(f"   - Revision: {self.revision if self.revision else 'main'}\n")
+        sys.stderr.write(f"   - Precision: {self.precision.value.name.lower()}\n")
+        sys.stderr.flush()
+        
+        try:
+            model_trace_p_value = compute_model_trace_p_value(
+                self.full_model, 
+                self.revision if self.revision else "main",
+                self.precision.value.name.lower()
+            )
+            
+            if model_trace_p_value is not None:
+                sys.stderr.write(f"✅ Model trace p-value computed successfully: {model_trace_p_value}\n")
+            else:
+                sys.stderr.write(f"⚠️  Model trace p-value is None (computation failed or not available)\n")
+                
+        except Exception as e:
+            sys.stderr.write(f"💥 Exception during model trace p-value computation: {e}\n")
+            import traceback
+            sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+            model_trace_p_value = None
+            
+        data_dict[AutoEvalColumn.model_trace_p_value.name] = model_trace_p_value
+        sys.stderr.write(f"📝 Added to data_dict: {AutoEvalColumn.model_trace_p_value.name} = {model_trace_p_value}\n")
+        sys.stderr.flush()
+        
         sys.stderr.write(f"Created base data_dict with {len(data_dict)} columns\n")
         sys.stderr.flush()
 

test_model_trace.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+Test script for model tracing integration.
+Tests the p-value computation for a simple model comparison.
+"""
+
+import sys
+import os
+
+# Add src to path
+sys.path.append('src')
+
+from evaluation.model_trace_eval import compute_model_trace_p_value
+
+def test_model_trace():
+    """Test the model trace p-value computation with a simple example."""
+    
+    print("Testing model trace p-value computation...")
+    
+    # Test with a simple model (should be fast)
+    test_model = "openai-community/gpt2"
+    
+    print(f"Computing p-value for {test_model} vs GPT-2...")
+    
+    try:
+        p_value = compute_model_trace_p_value(test_model, "main", "float16")
+        
+        if p_value is not None:
+            print(f"✅ Success! P-value: {p_value}")
+            if 0 <= p_value <= 1:
+                print("✅ P-value is in valid range [0, 1]")
+            else:
+                print(f"⚠️ Warning: P-value {p_value} is outside expected range [0, 1]")
+        else:
+            print("❌ Failed: P-value is None")
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_model_trace()