Create Results PR Comment for Results diff (#444)

* Create Results PR Comment for Results diff

* Added 1 more results file for wide comparison

* Update argument and docstring in script

* Update command in yaml file

* update yaml file

* Revert results

* remove unnecessary model revision

* Updated table format and added it as a tests

* update table format

* Skip comment if nothing is change

* use TaskResult for results fetching

* Remove PR comment generation part and add to only test

* remove changes in yaml file

* Fix CLI command in comment

* fix cli example

* change main score extraction strategy

* Declare and used MTEB_SCORE_EPSILON variable

* modify results for checking tests

* Update tests/test_results_diff.py

Co-authored-by: Kenneth Enevoldsen <kenevoldsen@pm.me>

* Added correct fix

* correct namings

* Delete results/aari1995__German_Semantic_STS_V2/22912542b0ec7a7ef369837e28ffe6352a27afc9/AmazonCounterfactualClassification.json

* Revert "Delete results/aari1995__German_Semantic_STS_V2/22912542b0ec7a7ef369837e28ffe6352a27afc9/AmazonCounterfactualClassification.json"

This reverts commit 9fd40998199e80a1c6ee0fbae53becff76a6da42.

* Moved functions in test file

* correct import

* rollback results file

---------

Co-authored-by: Roman Solomatin <36135455+Samoed@users.noreply.github.com>
Co-authored-by: Kenneth Enevoldsen <kenevoldsen@pm.me>

scripts/create_pr_results_comment.py

@@ -8,21 +8,23 @@ Usage:
 Description:
     - Compares new model results (added in the current PR) against reference models.
     - Outputs a Markdown file with results for each new model and highlights the best scores.
+    - Also generates a table comparing old (base branch) vs new (PR) scores for updated result files.
     - By default, compares against: intfloat/multilingual-e5-large and google/gemini-embedding-001.
     - You can specify reference models with the --models argument.
 
 Arguments:
     --reference-models: List of reference models to compare against (default: intfloat/multilingual-e5-large google/gemini-embedding-001)
-    --output: Output markdown file path (default: model-comparison.md)
+    --output: Output markdown file for reference model comparison (default: model-comparison.md)
 
 Example:
-    python scripts/create_pr_results_comment.py --models intfloat/multilingual-e5-large myorg/my-new-model
+    python scripts/create_pr_results_comment.py --models intfloat/multilingual-e5-large myorg/my-new-model --output model-comparison.md
 """
 
 from __future__ import annotations
 
 import argparse
 import json
+import os
 import logging
 import subprocess
 from collections import defaultdict
@@ -51,7 +53,6 @@ repo_path = Path(__file__).parents[1]
 
 cache = ResultCache(repo_path)
 
-
 def get_diff_from_main() -> list[str]:
     differences = subprocess.run(
         ["git", "diff", "--name-only", "origin/main...HEAD"],
@@ -329,7 +330,7 @@ def create_argparse() -> argparse.ArgumentParser:
         "--output",
         type=Path,
         default=Path("model-comparison.md"),
-        help="Output markdown file path",
+        help="Output markdown file for reference model comparison (default: model-comparison.md)",
     )
     return parser
 
@@ -338,10 +339,9 @@ def main(reference_models: list[str], output_path: Path) -> None:
     logger.info("Starting to create PR results comment...")
     logger.info(f"Using reference models: {', '.join(reference_models)}")
     diff = get_diff_from_main()
-
+    
     model_tasks = extract_new_models_and_tasks(diff)
     markdown = generate_markdown_content(model_tasks, reference_models)
-
     output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(markdown)
 
@@ -349,4 +349,4 @@ def main(reference_models: list[str], output_path: Path) -> None:
 if __name__ == "__main__":
     parser = create_argparse()
     args = parser.parse_args()
-    main(args.reference_models, args.output)
+    main(args.reference_models, args.output)

tests/test_results_diff.py

@@ -0,0 +1,196 @@
+"""
+Tests for result difference validation.
+
+This test module reuses functions from create_pr_results_comment.py to:
+1. Validate that main_score changes don't exceed configured thresholds
+2. Provide a summary of all main_score changes in the PR
+"""
+
+import json
+import os
+import sys
+import subprocess
+from pathlib import Path
+import pandas as pd
+import pytest
+from mteb import TaskResult
+
+MTEB_SCORE_EPSILON=0.001 
+repo_path = Path(__file__).parents[1]
+
+def get_base_ref() -> str:
+    """Get the base reference for comparison (PR_BASE_SHA env var or origin/main)."""
+    return os.getenv("PR_BASE_SHA", "origin/main")
+
+def get_diff_from_main() -> list[str]:
+    differences = subprocess.run(
+        ["git", "diff", "--name-only", "origin/main...HEAD"],
+        cwd=repo_path,
+        text=True,
+        capture_output=True,
+    ).stdout.splitlines()
+
+    return differences
+
+def load_json_from_git_ref(relative_path: str, git_ref: str) -> dict | None:
+    """Load a JSON file from a specific git reference."""
+    result = subprocess.run(
+        ["git", "show", f"{git_ref}:{relative_path}"],
+        cwd=repo_path,
+        text=True,
+        capture_output=True,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return None
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+
+def extract_main_score(task_result_dict: dict) -> dict[tuple[str, str], float]:
+    """
+    Extract main_score for each split/subset combination from task result.
+    No aggregation - returns the main_score value for each (split, subset) pair.
+    
+    Returns:
+        Dict mapping (split, subset) tuples to their main_score value.
+        Example: {("test", "default"): 0.85, ("test", "en"): 0.90}
+    """
+    split_subset_scores: dict[tuple[str, str], float] = {}
+    
+    try:
+        task_result = TaskResult.from_dict(task_result_dict)
+        filtered_result = task_result.only_main_score()
+        
+        for split_name, split_scores in filtered_result.scores.items():
+            for subset_score in split_scores:
+                subset_name = subset_score.get("hf_subset")
+                main_score = subset_score.get("main_score")
+                
+                if (subset_name is not None and main_score is not None 
+                    and not pd.isna(main_score)):
+                    value = float(main_score)
+                    if value > 1:
+                        value /= 100
+                    split_subset_scores[(split_name, subset_name)] = value
+        
+        return split_subset_scores
+    except Exception:
+        return {}
+
+def create_old_new_diff_table(differences: list[str], base_ref: str) -> pd.DataFrame:
+    """Create DataFrame comparing old and new main_score for each split/subset."""
+    columns = ["model_name", "task_name", "split", "subset", "old_revision", "old_value", "new_revision", "new_value", "delta", "pct_change"]
+    rows: list[dict] = []
+
+    for relative_path in differences:
+        path = repo_path / relative_path
+        if not path.exists() or path.suffix != ".json" or path.name == "model_meta.json":
+            continue
+
+        model_meta_path = path.parent / "model_meta.json"
+        task_name = path.stem
+        
+        if not model_meta_path.exists():
+            continue
+            
+        try:
+            with model_meta_path.open("r") as f:
+                model_meta = json.load(f)
+                model_name = model_meta["name"]
+                new_revision = model_meta["revision"]
+        except (json.JSONDecodeError, IOError, KeyError):
+            continue
+
+        old_json = load_json_from_git_ref(relative_path, base_ref)
+        if old_json is None:
+            continue
+
+        old_model_meta = load_json_from_git_ref(str(model_meta_path.relative_to(repo_path)), base_ref)
+        if old_model_meta is None:
+            old_revision = "unknown"
+        else:
+            try:
+                old_revision = old_model_meta.get("revision", "unknown")
+            except (AttributeError, TypeError):
+                old_revision = "unknown"
+
+        try:
+            with path.open("r") as f:
+                new_json = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            continue
+
+        old_scores = extract_main_score(old_json)
+        new_scores = extract_main_score(new_json)
+        
+        if not old_scores or not new_scores:
+            continue
+        
+        for (split, subset), new_value in new_scores.items():
+            if (split, subset) not in old_scores:
+                continue
+            
+            old_value = old_scores[(split, subset)]
+            
+            delta = new_value - old_value
+            if delta == 0:
+                continue
+            
+            pct_change = None if old_value == 0 else delta / old_value
+
+            rows.append({
+                "model_name": model_name,
+                "task_name": task_name,
+                "split": split,
+                "subset": subset,
+                "old_revision": old_revision,
+                "old_value": old_value,
+                "new_revision": new_revision,
+                "new_value": new_value,
+                "delta": delta,
+                "pct_change": pct_change,
+            })
+
+    if not rows:
+        return pd.DataFrame(columns=columns)
+
+    return pd.DataFrame(rows, columns=columns).sort_values(
+        ["model_name", "task_name", "split", "subset"]
+    )
+
+def test_result_diffs_within_threshold():
+    """
+    Fail if any main_score delta exceeds configured thresholds.
+    """
+    
+    base_ref = get_base_ref()
+    differences = get_diff_from_main()
+    print(differences)
+    
+    # Skip test if no changes found
+    if not differences:
+        pytest.skip("No changes found between base and current branch")
+    
+    diff_table = create_old_new_diff_table(differences, base_ref)
+    
+    # Skip test if no comparable results found
+    if diff_table.empty:
+        pytest.skip("No comparable updated result files found")
+    
+    violations = []
+    for _, row in diff_table.iterrows():
+        delta = abs(row["delta"])
+        
+        model_task = f"{row['model_name']}/{row['task_name']}"
+        
+        if delta > MTEB_SCORE_EPSILON:
+            violations.append(
+            f"  {model_task}: The difference between the current score ({row['new_value']}) and the previous ({row['old_value']}) exceeds threshold of {MTEB_SCORE_EPSILON}"
+            )
+    
+    assert not violations, (
+        f"Main score changes exceed configured threshold "
+        f"(MTEB_SCORE_EPSILON={MTEB_SCORE_EPSILON}):\n"
+        + "\n".join(violations)
+    )