Add AuthorityBench dataset

Uploads the AuthorityBench dataset for evaluating LLM's authority perception ability in RAG systems.

Three sub-datasets:

- DomainAuth: 10K web domains annotated with PageRank-based authority scores.
- EntityAuth: 22K entities (across basketball, movies, and songs) annotated with popularity-based authority (Wikipedia sitelinks).
- RAGAuth: 120 yes/no queries paired with retrieved documents of varying authority, designed to evaluate the practical impact of authority perception on downstream RAG tasks.

.gitattributes

@@ -58,3 +58,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/corpus/corpus_10_scale_with_text.jsonl filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/corpus/corpus_5_scale_with_text.jsonl filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/listwise/listwise_10_scale_with_text.jsonl filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/listwise/listwise_5_scale_with_text.jsonl filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/pairwise/easy_pairs.jsonl filter=lfs diff=lfs merge=lfs -text
+AuthorityBench/dataset/DomainAuth/pairwise/hard_pairs.jsonl filter=lfs diff=lfs merge=lfs -text

AuthorityBench/dataset/DomainAuth/corpus/corpus_10_scale_with_text.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ea21b3565c5bfa9d457398ca926608e1deb26953b1b05251787bd06ac7b0154
+size 56849513

AuthorityBench/dataset/DomainAuth/corpus/corpus_5_scale_with_text.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe6f019aff74d55b25402bf9ac40a6384a4b68bc506389a093fbcf7aa0c37fba
+size 56969513

AuthorityBench/dataset/DomainAuth/listwise/listwise_10_scale_with_text.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afa05543d0a6cbb09e13250b9b70719eb5d9ed09235df36efd376a29c60354b4
+size 143396221

AuthorityBench/dataset/DomainAuth/listwise/listwise_5_scale_with_text.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f8cc5b401c1e73e35a8230efa1f22bcfaa914668914fa52a200add2e23760fe
+size 71286311

AuthorityBench/dataset/DomainAuth/pairwise/easy_pairs.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f711d2ec9796fa67e8c8fcc51c4f2beab2d75961502ff26eeecfac6ddef62951
+size 31904944

AuthorityBench/dataset/DomainAuth/pairwise/hard_pairs.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1074f483806cebd5a878ae327feab05e5a5d638f1791e4e6e0863d68f1cd5940
+size 31671815

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/ListJudge_ListRank.py

@@ -0,0 +1,66 @@
+import json
+import random
+import re
+from typing import List, Dict, Any
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_PAIR_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "YOUR_MODEL_DIR"
+BATCH_SIZE = 16
+
+
+def build_prompt(domains: List[str]) -> str:
+    return (
+        f"You are a web analysis expert. Please score the source authority of each domain "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n"
+        f"Consider all domains together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**DOMAINS**:\n"
+        + "\n".join([f"[{i}] {domain}" for i, domain in enumerate(domains)])
+        + f"\n\nYour output MUST be a single, valid JSON object. The JSON object must map each domain's numerical identifier (as a string) to its integer score (0-9).\n"
+        f"Example format: {{\"0\": 7, \"1\": 4, ..., \"9\": 8}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response: str, num_domains: int) -> List[int]:
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := re.search(r'\{[^{}]*\}', text, re.DOTALL):
+        try:
+            scores = {int(re.sub(r'\D', '', str(k))): float(v) for k, v in json.loads(match.group()).items()}
+            if len(scores) == num_domains and set(scores.keys()) == set(range(num_domains)):
+                return sorted(scores.keys(), key=lambda x: scores[x], reverse=True)
+        except Exception:
+            pass
+    ranking = list(range(num_domains))
+    random.shuffle(ranking)
+    return ranking
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    with open(EVAL_PAIR_FILE, 'r', encoding='utf-8') as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["domains"])}], tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for item, output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                pred = extract_scores(text, len(item["domains"]))
+                out_f.write(json.dumps({"domains": item["domains"], "pageranks": item["pageranks"], "ground_truth": item["ground_truth"], "pred": pred, "llm_output": text}, ensure_ascii=False) + '\n')
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/ListJudge_ListRank_with_text.py

@@ -0,0 +1,138 @@
+import json
+import os
+import re
+import random
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_PAIR_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_DIR"
+BATCH_SIZE = 8
+
+
+def build_ranking_prompt(domains, doc_texts):
+    truncated_texts = [
+        text[:500] + "..." if len(text) > 500 else text
+        for text in doc_texts
+    ]
+
+    prompt = (
+        f"You are a web analysis expert that can rank domains based on their authority.\n\n"
+        f"I will provide you with 10 domains and their web contents, each indicated by a numerical identifier [].\n"
+        f"Rank the domains based on their source authority (credibility, professionalism, official certification, or public recognition).\n"
+    )
+
+    for i in range(10):
+        prompt += f"[{i}] {domains[i]}: {truncated_texts[i]}\n"
+
+    prompt += (
+        f"\nRank the 10 domains above based on their authority (highest to lowest).\n"
+        f"All the domains should be included and listed using identifiers, in descending order of authority.\n"
+        f"The output format should be [] > [], e.g., [4] > [0].\n"
+        f"Only respond with the ranking results, do not say any word or explain.\n"
+        f"Your answer: "
+    )
+
+    return prompt
+
+
+def extract_ranking_answer(response_raw: str, num_domains: int = 10):
+    response = response_raw.strip()
+
+    bracket_matches = re.findall(r'\[(\d+)\]', response)
+    if bracket_matches:
+        try:
+            ranking = [int(x) for x in bracket_matches]
+            if (len(ranking) == num_domains and
+                all(0 <= idx < num_domains for idx in ranking) and
+                set(ranking) == set(range(num_domains))):
+                return ranking
+        except ValueError:
+            pass
+
+    all_numbers = re.findall(r'\b\d+\b', response)
+    if len(all_numbers) >= num_domains:
+        try:
+            ranking = [int(x) for x in all_numbers[:num_domains]]
+            if (len(ranking) == num_domains and
+                all(0 <= idx < num_domains for idx in ranking) and
+                set(ranking) == set(range(num_domains))):
+                return ranking
+        except ValueError:
+            pass
+
+    lines = response.split('\n')
+    for line in reversed(lines):
+        line = line.strip()
+        if line:
+            line_numbers = re.findall(r'\b\d+\b', line)
+            if len(line_numbers) >= num_domains:
+                try:
+                    ranking = [int(x) for x in line_numbers[:num_domains]]
+                    if (len(ranking) == num_domains and
+                        all(0 <= idx < num_domains for idx in ranking) and
+                        set(ranking) == set(range(num_domains))):
+                        return ranking
+                except ValueError:
+                    pass
+
+    random_ranking = list(range(num_domains))
+    random.shuffle(random_ranking)
+    return random_ranking
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        max_tokens=256,
+    )
+
+    with open(EVAL_PAIR_FILE, 'r', encoding='utf-8') as f:
+        listwise_items = [json.loads(line) for line in f]
+
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    results = []
+    for i in range(0, len(listwise_items), BATCH_SIZE):
+        batch = listwise_items[i:i + BATCH_SIZE]
+
+        prompts = []
+        for item in batch:
+            prompt = build_ranking_prompt(item["domains"], item["doc_texts"])
+            messages = [{"role": "user", "content": prompt}]
+            chat_prompt = tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True,
+                enable_thinking=False
+            )
+            prompts.append(chat_prompt)
+
+        outputs = llm.generate(prompts, sampling_params)
+
+        for item, output in zip(batch, outputs):
+            response_raw = output.outputs[0].text if output.outputs else ""
+            pred = extract_ranking_answer(response_raw, len(item["domains"]))
+
+            results.append({
+                "domains": item["domains"],
+                "pageranks": item["pageranks"],
+                "ground_truth": item["ground_truth"],
+                "pred": pred,
+                "llm_output": response_raw
+            })
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
+        for result in results:
+            f.write(json.dumps(result, ensure_ascii=False) + '\n')
+
+    print(f"Results saved to {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/ListJudge_PointScore.py

@@ -0,0 +1,66 @@
+import json
+import random
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_PAIR_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 8
+
+
+def build_prompt(domains):
+    return (
+        f"You are a web analysis expert. Please score the source authority of each domain "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n"
+        f"Consider all domains together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**DOMAINS**:\n"
+        + "\n".join([f"[{i}] {domain}" for i, domain in enumerate(domains)])
+        + f"\n\nYour output MUST be a single, valid JSON object. The JSON object must map each domain's numerical identifier (as a string) to its integer score (0-9).\n"
+        f"Example format: {{\"0\": 7, \"1\": 4, ..., \"9\": 8}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response, num_domains):
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := re.search(r'\{[^{}]*\}', text, re.DOTALL):
+        try:
+            scores = {int(re.sub(r'\D', '', str(k))): float(v) for k, v in json.loads(match.group()).items()}
+            if len(scores) == num_domains and set(scores.keys()) == set(range(num_domains)):
+                return sorted(scores.keys(), key=lambda x: scores[x], reverse=True)
+        except Exception:
+            pass
+    ranking = list(range(num_domains))
+    random.shuffle(ranking)
+    return ranking
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    with open(EVAL_PAIR_FILE, 'r', encoding='utf-8') as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["domains"])}], tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for item, output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                pred = extract_scores(text, len(item["domains"]))
+                out_f.write(json.dumps({"domains": item["domains"], "pageranks": item["pageranks"], "ground_truth": item["ground_truth"], "pred": pred, "llm_output": text}, ensure_ascii=False) + '\n')
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/ListJudge_PointScore_with_text.py

@@ -0,0 +1,123 @@
+import json
+import os
+import re
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_PAIR_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_DIR"
+BATCH_SIZE = 8
+
+# Extract scoring answer from model response
+def extract_scoring_answer(response_raw: str, num_domains: int = 10):
+    """
+    Extract JSON scoring from model output and return ranked indices.
+    Returns (ranking_list, failed_flag).
+    """
+    response = response_raw.strip()
+
+    marker = "Your answer:"
+    marker_pos = response.rfind(marker)
+    if marker_pos != -1:
+        response = response[marker_pos + len(marker):].strip()
+
+    json_match = re.search(r'\{[^{}]*\}', response, re.DOTALL)
+    if json_match:
+        try:
+            score_dict = json.loads(json_match.group())
+            scores = {
+                int(re.sub(r'\D', '', str(k))): float(v)
+                for k, v in score_dict.items()
+            }
+            if len(scores) == num_domains and set(scores.keys()) == set(range(num_domains)):
+                # Sort by score descending and return original indices
+                return sorted(scores.keys(), key=lambda x: scores[x], reverse=True), False
+        except (json.JSONDecodeError, ValueError, KeyError):
+            pass
+
+    random_ranking = list(range(num_domains))
+    random.shuffle(random_ranking)
+    return random_ranking, True
+
+
+def build_scoring_prompt(domains, doc_texts):
+    """Build prompt for listwise domain authority scoring."""
+    truncated_texts = [
+        text[:500] + "..." if len(text) > 500 else text
+        for text in doc_texts
+    ]
+
+    prompt = (
+        f"You are a web analysis expert. Please score the source authority of each domain "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself and its content.\n"
+        f"Consider all domains and their contents together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**DOMAINS & CONTENTS**:\n"
+    )
+    for i, domain in enumerate(domains):
+        prompt += f"[{i}] {domain}: {truncated_texts[i]}\n"
+
+    prompt += (
+        f"\n"
+        f"Your output MUST be a single, valid JSON object. The JSON object must map each domain's numerical identifier (as a string) to its integer score (0-9).\n"
+        f"Example format: {{\"0\": 7, \"1\": 4, ..., \"9\": 8}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+    return prompt
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        max_tokens=256,
+    )
+
+    with open(EVAL_PAIR_FILE, 'r', encoding='utf-8') as f:
+        listwise_items = [json.loads(line) for line in f]
+
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as out_f:
+        for i in range(0, len(listwise_items), BATCH_SIZE):
+            batch = listwise_items[i:i + BATCH_SIZE]
+
+            prompts = []
+            for item in batch:
+                prompt = build_scoring_prompt(item["domains"], item["doc_texts"])
+                messages = [{"role": "user", "content": prompt}]
+                chat_prompt = tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True,
+                    enable_thinking=False
+                )
+                prompts.append(chat_prompt)
+
+            outputs = llm.generate(prompts, sampling_params)
+
+            for item, output in zip(batch, outputs):
+                response_raw = output.outputs[0].text if output.outputs else ""
+                pred, failed = extract_scoring_answer(response_raw, len(item["domains"]))
+
+                result = {
+                    "domains": item["domains"],
+                    "pageranks": item["pageranks"],
+                    "ground_truth": item["ground_truth"],
+                    "pred": pred,
+                    "extraction_failed": failed,
+                    "llm_output": response_raw
+                }
+
+                out_f.write(json.dumps(result, ensure_ascii=False) + '\n')
+                out_f.flush()
+
+    print(f"Results saved to {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PairJudge_PairRank.py

@@ -0,0 +1,163 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_prompt(domain1, domain2):
+    return (
+        f"You are a web analysis expert. Please determine which of the two given domains "
+        f"is more authoritative as an information source based on the following criteria.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n"
+        f"Consider both domains together when making the comparison.\n\n"
+        f"**DOMAINS**:\n"
+        f"Domain A: {domain1}\n"
+        f"Domain B: {domain2}\n\n"
+        f"Which domain is more authoritative? Only return 'A' or 'B'. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_winner(response):
+    if not response:
+        return None
+    text = response.strip().upper()
+    first = text[0] if text else ""
+    if first in ("A", "B"):
+        return first
+    if match := re.search(r'\b([AB])\b', text):
+        return match.group(1)
+    return None
+
+
+def compare(i, j, anchor_set, anchor_wins, non_anchor_wins, direct):
+    i_is_anchor = i in anchor_set
+    j_is_anchor = j in anchor_set
+
+    if not i_is_anchor and not j_is_anchor:
+        return non_anchor_wins.get(i, 0) > non_anchor_wins.get(j, 0)
+    elif i_is_anchor and j_is_anchor:
+        return anchor_wins.get(i, 0) > anchor_wins.get(j, 0)
+    else:
+        if (i, j) in direct:
+            return direct[(i, j)]
+        elif (j, i) in direct:
+            return not direct[(j, i)]
+        else:
+            score_i = anchor_wins.get(i, non_anchor_wins.get(i, 0))
+            score_j = anchor_wins.get(j, non_anchor_wins.get(j, 0))
+            return score_i > score_j
+
+
+def bubble_sort(indices, anchor_set, anchor_wins, non_anchor_wins, direct):
+    arr = list(indices)
+    n = len(arr)
+    for i in range(n):
+        for j in range(n - i - 1):
+            if not compare(arr[j], arr[j + 1], anchor_set, anchor_wins, non_anchor_wins, direct):
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, tensor_parallel_size=4, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=16)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        if "list_id" in (obj := json.loads(line)):
+                            completed.add(obj["list_id"])
+                    except Exception:
+                        pass
+
+    with open(EVAL_FILE, 'r', encoding='utf-8') as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, 'a', encoding='utf-8') as out_f:
+        for idx, item in enumerate(tqdm(items)):
+            list_id = item.get("list_id", idx)
+            if list_id in completed:
+                continue
+
+            domains, n = item["domains"], len(domains)
+            anchors = random.sample(range(n), NUM_ANCHORS)
+            anchor_set = set(anchors)
+            non_anchors = [i for i in range(n) if i not in anchor_set]
+
+            tasks = [{"idx_a": ni, "idx_b": ai, "domain_a": domains[ni], "domain_b": domains[ai], "type": "na_vs_a"}
+                     for ni in non_anchors for ai in anchors]
+            tasks += [{"idx_a": ai, "idx_b": aj, "domain_a": domains[ai], "domain_b": domains[aj], "type": "a_vs_a"}
+                      for ai, aj in itertools.combinations(anchors, 2)]
+
+            results = []
+            for i in range(0, len(tasks), BATCH_SIZE):
+                batch = tasks[i:i + BATCH_SIZE]
+                prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(t["domain_a"], t["domain_b"])}],
+                                                         tokenize=False, add_generation_prompt=True, enable_thinking=False) for t in batch]
+                outputs = llm.generate(prompts, sampling_params)
+                for t, out in zip(batch, outputs):
+                    raw = out.outputs[0].text if out.outputs else ""
+                    winner = extract_winner(raw)
+                    results.append((t, winner, raw))
+
+            direct = {}
+            anchor_wins = defaultdict(int)
+            non_anchor_wins = defaultdict(int)
+            records = []
+
+            for task, winner, raw in results:
+                idx_a, idx_b = task["idx_a"], task["idx_b"]
+                if winner:
+                    i_wins = (winner == "A")
+                    direct[(idx_a, idx_b)] = i_wins
+                    direct[(idx_b, idx_a)] = not i_wins
+
+                    if task["type"] == "na_vs_a":
+                        non_anchor_wins[idx_a] += 1 if i_wins else 0
+                    elif task["type"] == "a_vs_a":
+                        anchor_wins[idx_a] += 1 if i_wins else 0
+                        anchor_wins[idx_b] += 1 if not i_wins else 0
+
+                records.append({"domain_a": task["domain_a"], "idx_a": idx_a, "domain_b": task["domain_b"],
+                               "idx_b": idx_b, "winner": winner, "llm_output": raw, "type": task["type"]})
+
+            for ni in non_anchors:
+                if ni not in non_anchor_wins:
+                    non_anchor_wins[ni] = 0
+            for ai in anchors:
+                if ai not in anchor_wins:
+                    anchor_wins[ai] = 0
+
+            pred = bubble_sort(range(n), anchor_set, anchor_wins, non_anchor_wins, direct)
+
+            out_f.write(json.dumps({
+                "list_id": list_id, "domains": domains, "pageranks": item["pageranks"],
+                "ground_truth": item["ground_truth"], "anchor_indices": anchors,
+                "anchor_wins_vs_anchors": {str(k): v for k, v in anchor_wins.items()},
+                "non_anchor_wins_vs_anchors": {str(k): v for k, v in non_anchor_wins.items()},
+                "pred": pred, "comparisons": records
+            }, ensure_ascii=False) + '\n')
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PairJudge_PairRank_with_text.py

@@ -0,0 +1,165 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+MAX_TEXT_LENGTH = 500
+
+
+def build_pairwise_prompt(domain1, text1, domain2, text2):
+    t1 = (text1[:MAX_TEXT_LENGTH] + "...") if text1 and len(text1) > MAX_TEXT_LENGTH else (text1 or "[No content available]")
+    t2 = (text2[:MAX_TEXT_LENGTH] + "...") if text2 and len(text2) > MAX_TEXT_LENGTH else (text2 or "[No content available]")
+    return (
+        f"You are a web analysis expert. Please determine which of the two given domains "
+        f"is more authoritative as an information source based on the following criteria.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself and its content.\n"
+        f"Consider both domains and their contents together when making the comparison.\n\n"
+        f"**DOMAINS & CONTENTS**:\n"
+        f"Domain A: {domain1}\n"
+        f"Content A: {t1}\n\n"
+        f"Domain B: {domain2}\n"
+        f"Content B: {t2}\n\n"
+        f"Which domain is more authoritative? Only return 'A' or 'B'. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ab_answer(response):
+    if not response:
+        return None
+    text = response.strip()
+    first = text[0].upper() if text else ""
+    if first in ("A", "B"):
+        return first
+    if m := re.search(r"\b([AB])\b", text.upper()):
+        return m.group(1)
+    return None
+
+
+def run_batch_inference(task_list, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(task_list), BATCH_SIZE):
+        batch = task_list[i:i + BATCH_SIZE]
+        prompts = [tokenizer.apply_chat_template(
+            [{"role": "user", "content": build_pairwise_prompt(task["domain_a"], task["text_a"], task["domain_b"], task["text_b"])}],
+            tokenize=False, add_generation_prompt=True, enable_thinking=False
+        ) for task in batch]
+        for task, out in zip(batch, llm.generate(prompts, sampling_params)):
+            raw = out.outputs[0].text if out.outputs else ""
+            winner = extract_ab_answer(raw)
+            results.append((winner, raw, winner is None))
+    return results
+
+
+def anchor_compare(i, j, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    if i not in anchor_set and j not in anchor_set:
+        return non_anchor_wins.get(i, 0) > non_anchor_wins.get(j, 0)
+    if i in anchor_set and j in anchor_set:
+        return anchor_wins.get(i, 0) > anchor_wins.get(j, 0)
+    if (i, j) in direct_results:
+        return direct_results[(i, j)]
+    if (j, i) in direct_results:
+        return not direct_results[(j, i)]
+    return anchor_wins.get(i, non_anchor_wins.get(i, 0)) > anchor_wins.get(j, non_anchor_wins.get(j, 0))
+
+
+def bubble_sort_by_anchor(indices, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    arr = list(indices)
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if not anchor_compare(arr[j], arr[j + 1], anchor_set, anchor_wins, non_anchor_wins, direct_results):
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0)
+
+    os = __import__("os")
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed_ids = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        if "list_id" in (obj := json.loads(line)):
+                            completed_ids.add(obj["list_id"])
+                    except json.JSONDecodeError:
+                        pass
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        for item_idx, item in enumerate(tqdm(items)):
+            list_id = item.get("list_id", item_idx)
+            if list_id in completed_ids:
+                continue
+
+            domains = item["domains"]
+            doc_texts = item.get("doc_texts", [""] * len(domains))
+            n = len(domains)
+            anchor_indices = random.sample(range(n), NUM_ANCHORS)
+            anchor_set = set(anchor_indices)
+            non_anchor_indices = [i for i in range(n) if i not in anchor_set]
+
+            na_vs_a_tasks = [{"idx_a": ni, "domain_a": domains[ni], "text_a": doc_texts[ni],
+                               "idx_b": ai, "domain_b": domains[ai], "text_b": doc_texts[ai], "type": "non_anchor_vs_anchor"}
+                              for ni in non_anchor_indices for ai in anchor_indices]
+            a_vs_a_tasks = [{"idx_a": ai, "domain_a": domains[ai], "text_a": doc_texts[ai],
+                             "idx_b": aj, "domain_b": domains[aj], "text_b": doc_texts[aj], "type": "anchor_vs_anchor"}
+                             for ai, aj in itertools.combinations(anchor_indices, 2)]
+
+            infer_results = run_batch_inference(na_vs_a_tasks + a_vs_a_tasks, llm, tokenizer, sampling_params)
+
+            direct_results, non_anchor_wins, anchor_wins, comparison_records = {}, defaultdict(int), defaultdict(int), []
+            for task, (winner, raw, failed) in zip(na_vs_a_tasks + a_vs_a_tasks, infer_results):
+                idx_a, idx_b = task["idx_a"], task["idx_b"]
+                if not failed:
+                    i_wins = winner == "A"
+                    direct_results[(idx_a, idx_b)] = i_wins
+                    direct_results[(idx_b, idx_a)] = not i_wins
+                    if task["type"] == "non_anchor_vs_anchor" and i_wins:
+                        non_anchor_wins[idx_a] += 1
+                    elif task["type"] == "anchor_vs_anchor":
+                        if i_wins:
+                            anchor_wins[idx_a] += 1
+                        else:
+                            anchor_wins[idx_b] += 1
+
+                comparison_records.append({
+                    "domain_a": task["domain_a"], "idx_a": idx_a,
+                    "domain_b": task["domain_b"], "idx_b": idx_b,
+                    "winner": winner, "extraction_failed": failed, "llm_output": raw, "type": task["type"]
+                })
+
+            pred = bubble_sort_by_anchor(range(n), anchor_set, anchor_wins, non_anchor_wins, direct_results)
+
+            out_f.write(json.dumps({
+                "list_id": list_id, "domains": domains, "pageranks": item["pageranks"],
+                "ground_truth": item["ground_truth"], "anchor_indices": anchor_indices,
+                "anchor_wins_vs_anchors": {str(k): v for k, v in anchor_wins.items()},
+                "non_anchor_wins_vs_anchors": {str(k): v for k, v in non_anchor_wins.items()},
+                "pred": pred, "comparisons": comparison_records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PairJudge_PointScore.py

@@ -0,0 +1,92 @@
+import json
+import random
+import itertools
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "PAIRWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_prompt(domain1, domain2):
+    return (
+        f"You are a web analysis expert. Please score the source authority of each of the two given domains "
+        f"based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n"
+        f"Consider both domains together when assigning scores to ensure consistency.\n\n"
+        f"**DOMAINS**:\n"
+        f"Domain A: {domain1}\n"
+        f"Domain B: {domain2}\n\n"
+        f"Your output MUST be a single, valid JSON object in the format: {{\"A\": X, \"B\": X}}, where each X is an integer score from 0 to 9. "
+        f"Example format: {{\"A\": 7, \"B\": 4}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response):
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := __import__("re").search(r'\{[^{}]*\}', text, __import__("re").DOTALL):
+        try:
+            d = json.loads(match.group())
+            sa, sb = float(d.get("A", d.get("a"))), float(d.get("B", d.get("b")))
+            return (sa, sb) if sa is not None and sb is not None else (None, None)
+        except Exception:
+            pass
+    return None, None
+
+
+def run_inference(tasks, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(tasks), BATCH_SIZE):
+        batch = tasks[i:i + BATCH_SIZE]
+        prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(t["domain_a"], t["domain_b"])}], tokenize=False, add_generation_prompt=True, enable_thinking=False) for t in batch]
+        outputs = llm.generate(prompts, sampling_params)
+        for t, out in zip(batch, outputs):
+            raw = out.outputs[0].text if out.outputs else ""
+            sa, sb = extract_scores(raw)
+            results.append((t["idx_a"], t["idx_b"], sa, sb, raw))
+    return results
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, tensor_parallel_size=4, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=64)
+
+    with open(EVAL_FILE, 'r', encoding='utf-8') as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as out_f:
+        for item in tqdm(items):
+            domains, n = item["domains"], len(domains)
+            anchors = random.sample(range(n), NUM_ANCHORS)
+            non_anchors = [i for i in range(n) if i not in anchors]
+
+            tasks = [{"idx_a": ni, "idx_b": ai, "domain_a": domains[ni], "domain_b": domains[ai]} for ni in non_anchors for ai in anchors]
+            tasks += [{"idx_a": ai, "idx_b": aj, "domain_a": domains[ai], "domain_b": domains[aj]} for ai, aj in itertools.combinations(anchors, 2)]
+
+            scores = defaultdict(list)
+            records = []
+            for idx_a, idx_b, sa, sb, raw in run_inference(tasks, llm, tokenizer, sampling_params):
+                if sa is not None and sb is not None:
+                    scores[idx_a].append(sa)
+                    scores[idx_b].append(sb)
+                records.append({"domain_a": domains[idx_a], "idx_a": idx_a, "domain_b": domains[idx_b], "idx_b": idx_b, "score_a": sa, "score_b": sb, "llm_output": raw})
+
+            avg = {i: float(__import__("numpy").mean(scores[i])) if scores[i] else 0.0 for i in range(n)}
+            pred = sorted(range(n), key=lambda x: avg[x], reverse=True)
+
+            out_f.write(json.dumps({"domains": domains, "pageranks": item["pageranks"], "ground_truth": item["ground_truth"], "anchor_indices": anchors, "avg_scores": avg, "pred": pred, "comparisons": records}, ensure_ascii=False) + '\n')
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PairJudge_PointScore_with_text.py

@@ -0,0 +1,155 @@
+import json
+import os
+import itertools
+from collections import defaultdict
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+import re
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "PAIRWISE_FILE
+OUTPUT_FILE = "OUTPUT_DIR"
+BATCH_SIZE = 8
+MAX_TEXT_LENGTH = 500
+
+
+def build_pairwise_prompt(domain1: str, text1: str, domain2: str, text2: str) -> str:
+    t1 = (text1[:MAX_TEXT_LENGTH] + "...") if text1 and len(text1) > MAX_TEXT_LENGTH else (text1 or "[No content available]")
+    t2 = (text2[:MAX_TEXT_LENGTH] + "...") if text2 and len(text2) > MAX_TEXT_LENGTH else (text2 or "[No content available]")
+
+    prompt = (
+        f"You are a web analysis expert. Please score the source authority of each of the two given domains "
+        f"based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself and its content.\n"
+        f"Consider both domains and their contents together when assigning scores to ensure consistency.\n\n"
+        f"**DOMAINS**:\n"
+        f"Domain A: {domain1}\n"
+        f"Content A: {t1}\n\n"
+        f"Domain B: {domain2}\n"
+        f"Content B: {t2}\n\n"
+        f"Your output MUST be a single, valid JSON object in the format: {{\"A\": X, \"B\": X}}, where each X is an integer score from 0 to 9. "
+        f"Example format: {{\"A\": 7, \"B\": 4}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+    return prompt
+
+
+def extract_pairwise_scores(response_raw: str):
+    response = response_raw.strip()
+
+    marker = "Your answer: "
+    pos = response.rfind(marker)
+    if pos != -1:
+        response = response[pos + len(marker):].strip()
+
+    json_match = re.search(r'\{[^{}]*\}', response, re.DOTALL)
+    if json_match:
+        try:
+            d = json.loads(json_match.group())
+            sa = float(d.get("A", d.get("a", None)))
+            sb = float(d.get("B", d.get("b", None)))
+            if sa is not None and sb is not None:
+                return sa, sb
+        except (json.JSONDecodeError, ValueError, TypeError):
+            pass
+
+    return None, None
+
+
+def run_batch_inference(task_list, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(task_list), BATCH_SIZE):
+        batch = task_list[i:i + BATCH_SIZE]
+        prompts = []
+
+        for task in batch:
+            p = build_pairwise_prompt(task["domain_a"], task["text_a"], task["domain_b"], task["text_b"])
+            msg = [{"role": "user", "content": p}]
+            chat_p = tokenizer.apply_chat_template(
+                msg, tokenize=False, add_generation_prompt=True, enable_thinking=False
+            )
+            prompts.append(chat_p)
+
+        outputs = llm.generate(prompts, sampling_params)
+
+        for task, out in zip(batch, outputs):
+            raw = out.outputs[0].text if out.outputs else ""
+            sa, sb = extract_pairwise_scores(raw)
+            failed = (sa is None or sb is None)
+            results.append((sa, sb, raw, failed))
+
+    return results
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        max_tokens=256,
+    )
+
+    with open(EVAL_FILE, 'r', encoding='utf-8') as f:
+        listwise_items = [json.loads(line) for line in f]
+
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as out_f:
+        for item in listwise_items:
+            domains = item["domains"]
+            doc_texts = item.get("doc_texts", [""] * len(domains))
+            pageranks = item["pageranks"]
+            ground_truth = item["ground_truth"]
+            n = len(domains)
+
+            all_tasks = []
+            for i, j in itertools.combinations(range(n), 2):
+                all_tasks.append({
+                    "idx_a": i, "domain_a": domains[i], "text_a": doc_texts[i],
+                    "idx_b": j, "domain_b": domains[j], "text_b": doc_texts[j]
+                })
+
+            infer_results = run_batch_inference(all_tasks, llm, tokenizer, sampling_params)
+
+            score_lists = defaultdict(list)
+            comparison_records = []
+
+            for task, (sa, sb, raw, failed) in zip(all_tasks, infer_results):
+                if not failed:
+                    score_lists[task["idx_a"]].append(sa)
+                    score_lists[task["idx_b"]].append(sb)
+
+                comparison_records.append({
+                    "domain_a": task["domain_a"], "idx_a": task["idx_a"],
+                    "domain_b": task["domain_b"], "idx_b": task["idx_b"],
+                    "score_a": sa, "score_b": sb,
+                    "extraction_failed": failed,
+                    "llm_output": raw
+                })
+
+            avg_scores = {
+                idx: float(sum(scores) / len(scores)) if scores else 0.0
+                for idx, scores in score_lists.items()
+            }
+
+            pred = sorted(range(n), key=lambda x: avg_scores[x], reverse=True)
+
+            result = {
+                "domains": domains,
+                "pageranks": pageranks,
+                "ground_truth": ground_truth,
+                "avg_scores": avg_scores,
+                "pred": pred,
+                "comparisons": comparison_records,
+            }
+
+            out_f.write(json.dumps(result, ensure_ascii=False) + '\n')
+            out_f.flush()
+
+    print(f"Results saved to {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PointJudge.py

@@ -0,0 +1,70 @@
+import json
+import re
+from typing import List, Dict, Any
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+INPUT_FILE = "CORPUS_FILE"
+OUTPUT_FILE = "OUTPUT_DIR"
+BATCH_SIZE = 8
+
+
+def load_data(file_path: str) -> List[Dict[str, Any]]:
+    with open(file_path, "r", encoding="utf-8") as f:
+        return [json.loads(line.strip()) for line in f if line.strip()]
+
+
+def build_prompt(domain: str) -> str:
+    return (
+        f"You are a web analysis expert. Please score the source authority of the given domain based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n\n"
+        f"**DOMAIN**: {domain}\n"
+        f"Based on the above criteria, rate the source authority of this DOMAIN (0-9 points).\n"
+        f"Output only: {{\"score\": X}} where X is your evaluated score (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9). Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_score(text: str) -> int:
+    text = text.strip()
+    try:
+        if match := re.search(r'\{[^}]*"score"\s*:\s*(\d+)[^}]*\}', text):
+            score = int(match.group(1))
+            if 0 <= score <= 9:
+                return score
+    except Exception:
+        pass
+    if numbers := re.findall(r'\b([0-9])\b', text):
+        return int(numbers[0])
+    return -1
+
+
+def main():
+    items = load_data(INPUT_FILE)
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=128)
+
+    results = []
+    for i in tqdm(range(0, len(items), BATCH_SIZE)):
+        batch = items[i : i + BATCH_SIZE]
+        messages = [[{"role": "user", "content": build_prompt(item["domain"])}] for item in batch]
+        prompts = [tokenizer.apply_chat_template(m, tokenize=False, add_generation_prompt=True, enable_thinking=False) for m in messages]
+        outputs = llm.generate(prompts, sampling_params)
+
+        for item, output in zip(batch, outputs):
+            text = output.outputs[0].text if output.outputs else ""
+            pred = extract_score(text)
+            results.append({"domain": item["domain"], "true_score": item["pagerank"], "pred_score": pred, "llm_output": text if pred != -1 else ""})
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for r in results:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_DomainAuth/PointJudge_with_text.py

@@ -0,0 +1,104 @@
+import json
+import os
+import re
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+INPUT_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_DIR"
+BATCH_SIZE = 8
+
+
+def build_prompt(domain: str, doc_text: str) -> str:
+    truncated_text = doc_text[:500] if len(doc_text) > 500 else doc_text
+
+    prompt = (
+        f"You are a web analysis expert. Please score the source authority of the given domain based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Source authority refers to the credibility, professionalism, official certification, or public recognition of the domain itself.\n"
+        f"**DOMAIN**: {domain}\n"
+        f"**Webpage Content**: {truncated_text}\n"
+        f"Based on the domain name, their web content and the above criteria, rate the source authority of this DOMAIN (0-9 points).\n"
+        f"Output only: {{\"score\": X}} where X is your evaluated score (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9). Do not add any explanation.\n"
+        f"Your answer: "
+    )
+    return prompt
+
+
+def extract_score(text: str) -> int:
+    text = text.strip()
+
+    # Try to extract JSON format: {"score": X}
+    json_match = re.search(r'\{[^}]*"score"\s*:\s*(\d+)[^}]*\}', text)
+    if json_match:
+        score = int(json_match.group(1))
+        if 0 <= score <= 9:
+            return score
+
+    numbers = re.findall(r'\b([0-9])\b', text)
+    if numbers:
+        return int(numbers[0])
+
+    return -1
+
+
+def main():
+    pointwise_items = []
+    with open(INPUT_FILE, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                pointwise_items.append(json.loads(line))
+
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        max_tokens=256
+    )
+
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for i in range(0, len(pointwise_items), BATCH_SIZE):
+            batch = pointwise_items[i:i + BATCH_SIZE]
+
+            raw_prompts = [
+                build_prompt(item.get("domain", ""), item.get("doc_text", ""))
+                for item in batch
+            ]
+
+            messages_batch = [[{"role": "user", "content": prompt}] for prompt in raw_prompts]
+            prompts = [
+                tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True,
+                    enable_thinking=False
+                )
+                for messages in messages_batch
+            ]
+
+            outputs = llm.generate(prompts, sampling_params)
+
+            for item, output in zip(batch, outputs):
+                response_raw = output.outputs[0].text if output.outputs else ""
+                pred = extract_score(response_raw)
+
+                result = {
+                    "domain": item.get("domain", ""),
+                    "url": item.get("url", ""),
+                    "docid": item.get("docid", ""),
+                    "true_score": item["pagerank"],
+                    "pred_score": pred,
+                    "llm_output": response_raw
+                }
+
+                f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_ListRank_ba.py

@@ -0,0 +1,69 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_ranking_prompt(question_entity):
+    return (
+        f"You are a Wikipedia notability expert and a pop-culture sports expert that can rank entities based on their authority.\n\n"
+        f"I will provide you with 10 basketball entities, each indicated by a numerical identifier [].\n"
+        f"Rank the basketball entities based on their authority (the public recognition, fame, historical significance, or widespread knowledge of the entity).\n"
+        f"Context: These entities are the subjects of questions like 'Where is the birthplace of the basketball player...'\n\n"
+        + "\n".join([f"[{i}] \"{question_entity[i]}\"" for i in range(10)])
+        + f"\n\nRank the 10 basketball entities above based on their authority (highest to lowest).\n"
+        f"All the basketball entities should be included and listed using identifiers, in descending order of authority.\n"
+        f"The output format should be [] > [], e.g., [4] > [0].\n"
+        f"Only respond with the ranking results, do not say any word or explain.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ranking_answer(response, num_entities=10):
+    text = response.strip()
+    if match := re.search(r"Your answer:\s*(.*)", text, re.IGNORECASE | re.DOTALL):
+        text = match.group(1).strip()
+    for extractor in [re.compile(r"\[(\d+)\]"), re.compile(r"\b\d+\b")]:
+        if nums := [int(x) for x in extractor.findall(text)]:
+            if len(nums) >= num_entities:
+                ranking = nums[:num_entities]
+                if len(ranking) == num_entities and set(ranking) == set(range(num_entities)):
+                    return ranking
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_ranking_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            for item, output in zip(batch, llm.generate(prompts, sampling_params)):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred = extract_ranking_answer(text, n)
+                out_f.write(json.dumps({
+                    "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_ListRank_mo.py

@@ -0,0 +1,69 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_ranking_prompt(question_entity):
+    return (
+        f"You are a Wikipedia notability expert and a film expert that can rank entities based on their authority.\n\n"
+        f"I will provide you with 10 movie entities, each indicated by a numerical identifier [].\n"
+        f"Rank the movie entities based on their authority (the public recognition, fame, historical significance, or widespread knowledge of the entity).\n"
+        f"Context: These entities are the subjects of questions like 'Who is the director of the movie...'\n\n"
+        + "\n".join([f"[{i}] \"{question_entity[i]}\"" for i in range(10)])
+        + f"\n\nRank the 10 movie entities above based on their authority (highest to lowest).\n"
+        f"All the movie entities should be included and listed using identifiers, in descending order of authority.\n"
+        f"The output format should be [] > [], e.g., [4] > [0].\n"
+        f"Only respond with the ranking results, do not say any word or explain.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ranking_answer(response, num_entities=10):
+    text = response.strip()
+    if match := re.search(r"Your answer:\s*(.*)", text, re.IGNORECASE | re.DOTALL):
+        text = match.group(1).strip()
+    for extractor in [re.compile(r"\[(\d+)\]"), re.compile(r"\b\d+\b")]:
+        if nums := [int(x) for x in extractor.findall(text)]:
+            if len(nums) >= num_entities:
+                ranking = nums[:num_entities]
+                if len(ranking) == num_entities and set(ranking) == set(range(num_entities)):
+                    return ranking
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_ranking_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            for item, output in zip(batch, llm.generate(prompts, sampling_params)):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred = extract_ranking_answer(text, n)
+                out_f.write(json.dumps({
+                    "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_ListRank_so.py

@@ -0,0 +1,69 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_ranking_prompt(question_entity):
+    return (
+        f"You are a Wikipedia notability expert and a music industry expert that can rank entities based on their authority.\n\n"
+        f"I will provide you with 10 song entities, each indicated by a numerical identifier [].\n"
+        f"Rank the song entities based on their authority (the public recognition, fame, historical significance, or widespread knowledge of the entity).\n"
+        f"Context: These entities are the subjects of questions like 'Who is the performer of the song ...'\n\n"
+        + "\n".join([f"[{i}] \"{question_entity[i]}\"" for i in range(10)])
+        + f"\n\nRank the 10 song entities above based on their authority (highest to lowest).\n"
+        f"All the song entities should be included and listed using identifiers, in descending order of authority.\n"
+        f"The output format should be [] > [], e.g., [4] > [0].\n"
+        f"Only respond with the ranking results, do not say any word or explain.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ranking_answer(response, num_entities=10):
+    text = response.strip()
+    if match := re.search(r"Your answer:\s*(.*)", text, re.IGNORECASE | re.DOTALL):
+        text = match.group(1).strip()
+    for extractor in [re.compile(r"\[(\d+)\]"), re.compile(r"\b\d+\b")]:
+        if nums := [int(x) for x in extractor.findall(text)]:
+            if len(nums) >= num_entities:
+                ranking = nums[:num_entities]
+                if len(ranking) == num_entities and set(ranking) == set(range(num_entities)):
+                    return ranking
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_ranking_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            for item, output in zip(batch, llm.generate(prompts, sampling_params)):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred = extract_ranking_answer(text, n)
+                out_f.write(json.dumps({
+                    "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_PointScore_ba.py

@@ -0,0 +1,78 @@
+import json
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_prompt(entities):
+    return (
+        f"You are a Wikipedia notability expert and a pop-culture sports expert. Please score the entity authority of each basketball entity "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider all entities together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Where is the birthplace of the basketball player...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        + "\n".join([f'[{i}] "{entity}"' for i, entity in enumerate(entities)])
+        + f"\n\nYour output MUST be a single, valid JSON object. The JSON object must map each entity's numerical identifier (as a string) to its integer score (0-9).\n"
+        f'Example format: {{"0": 7, "1": 4, ..., "9": 8}}. Do not add any explanation.\n'
+        f"Your answer: "
+    )
+
+
+def extract_scores(response, num_entities):
+    text = response.strip()
+    try:
+        start, end = text.find("{"), text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            scores = {int(k.strip("[]")): float(v) for k, v in json.loads(text[start:end + 1]).items()}
+            if len(scores) == num_entities:
+                return sorted(range(num_entities), key=lambda x: scores.get(x, 0), reverse=True), scores
+    except Exception:
+        pass
+    return list(range(num_entities)), None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=4, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for i in tqdm(range(0, len(pending), BATCH_SIZE)):
+            batch = pending[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for _, item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for (idx, item), output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred, scores = extract_scores(text, n)
+                out_f.write(json.dumps({
+                    "item_id": idx, "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "scores": scores, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_PointScore_mo.py

@@ -0,0 +1,78 @@
+import json
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_prompt(entities):
+    return (
+        f"You are a Wikipedia notability expert and a film expert. Please score the entity authority of each movie entity "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider all entities together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Who is the director of the movie ...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        + "\n".join([f'[{i}] "{entity}"' for i, entity in enumerate(entities)])
+        + f"\n\nYour output MUST be a single, valid JSON object. The JSON object must map each entity's numerical identifier (as a string) to its integer score (0-9).\n"
+        f'Example format: {{"0": 7, "1": 4, ..., "9": 8}}. Do not add any explanation.\n'
+        f"Your answer: "
+    )
+
+
+def extract_scores(response, num_entities):
+    text = response.strip()
+    try:
+        start, end = text.find("{"), text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            scores = {int(k.strip("[]")): float(v) for k, v in json.loads(text[start:end + 1]).items()}
+            if len(scores) == num_entities:
+                return sorted(range(num_entities), key=lambda x: scores.get(x, 0), reverse=True), scores
+    except Exception:
+        pass
+    return list(range(num_entities)), None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=4, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for i in tqdm(range(0, len(pending), BATCH_SIZE)):
+            batch = pending[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for _, item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for (idx, item), output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred, scores = extract_scores(text, n)
+                out_f.write(json.dumps({
+                    "item_id": idx, "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "scores": scores, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/ListJudge_PointScore_so.py

@@ -0,0 +1,78 @@
+import json
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+
+
+def build_prompt(entities):
+    return (
+        f"You are a Wikipedia notability expert and a music industry expert. Please score the entity authority of each song entity "
+        f"in the provided list based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider all entities together when assigning scores to ensure consistency and relative calibration.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Who is the performer of the song...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        + "\n".join([f'[{i}] "{entity}"' for i, entity in enumerate(entities)])
+        + f"\n\nYour output MUST be a single, valid JSON object. The JSON object must map each entity's numerical identifier (as a string) to its integer score (0-9).\n"
+        f'Example format: {{"0": 7, "1": 4, ..., "9": 8}}. Do not add any explanation.\n'
+        f"Your answer: "
+    )
+
+
+def extract_scores(response, num_entities):
+    text = response.strip()
+    try:
+        start, end = text.find("{"), text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            scores = {int(k.strip("[]")): float(v) for k, v in json.loads(text[start:end + 1]).items()}
+            if len(scores) == num_entities:
+                return sorted(range(num_entities), key=lambda x: scores.get(x, 0), reverse=True), scores
+    except Exception:
+        pass
+    return list(range(num_entities)), None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=4, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for i in tqdm(range(0, len(pending), BATCH_SIZE)):
+            batch = pending[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for _, item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for (idx, item), output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                n = len(item["question_entity"])
+                pred, scores = extract_scores(text, n)
+                out_f.write(json.dumps({
+                    "item_id": idx, "question_entity": item["question_entity"], "score": item["score"],
+                    "ground_truth": item["ground_truth"], "pred": pred, "scores": scores, "llm_output": text
+                }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PairRank_ba.py

@@ -0,0 +1,157 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_pairwise_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a pop-culture sports expert. Please determine which of the two given entities is more authoritative based on the following criteria.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Where is the birthplace of the basketball player ...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: \"{entity1}\"\n"
+        f"Entity B: \"{entity2}\"\n\n"
+        f"Which entity is more authoritative? Only return 'A' or 'B'. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ab_answer(response):
+    if not response:
+        return None
+    text = response.strip()
+    first = text[0].upper() if text else ""
+    if first in ("A", "B"):
+        return first
+    if m := re.search(r"\b([AB])\b", text.upper()):
+        return m.group(1)
+    return None
+
+
+def run_batch_inference(task_list, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(task_list), BATCH_SIZE):
+        batch = task_list[i:i + BATCH_SIZE]
+        prompts = [tokenizer.apply_chat_template(
+            [{"role": "user", "content": build_pairwise_prompt(task["entity_a"], task["entity_b"])}],
+            tokenize=False, add_generation_prompt=True, enable_thinking=False
+        ) for task in batch]
+        for task, out in zip(batch, llm.generate(prompts, sampling_params)):
+            raw = out.outputs[0].text if out.outputs else ""
+            winner = extract_ab_answer(raw)
+            results.append((winner, raw, winner is None))
+    return results
+
+
+def anchor_compare(i, j, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    if i not in anchor_set and j not in anchor_set:
+        return non_anchor_wins.get(i, 0) > non_anchor_wins.get(j, 0)
+    if i in anchor_set and j in anchor_set:
+        return anchor_wins.get(i, 0) > anchor_wins.get(j, 0)
+    if (i, j) in direct_results:
+        return direct_results[(i, j)]
+    if (j, i) in direct_results:
+        return not direct_results[(j, i)]
+    return anchor_wins.get(i, non_anchor_wins.get(i, 0)) > anchor_wins.get(j, non_anchor_wins.get(j, 0))
+
+
+def bubble_sort_by_anchor(indices, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    arr = list(indices)
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if not anchor_compare(arr[j], arr[j + 1], anchor_set, anchor_wins, non_anchor_wins, direct_results):
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0)
+
+    os = __import__("os")
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed_ids = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        if "list_id" in (obj := json.loads(line)):
+                            completed_ids.add(obj["list_id"])
+                    except json.JSONDecodeError:
+                        pass
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        for item_idx, item in enumerate(tqdm(items)):
+            list_id = item.get("list_id", item_idx)
+            if list_id in completed_ids:
+                continue
+
+            entities = item["question_entity"]
+            n = len(entities)
+            anchor_indices = random.sample(range(n), NUM_ANCHORS)
+            anchor_set = set(anchor_indices)
+            non_anchor_indices = [i for i in range(n) if i not in anchor_set]
+
+            na_vs_a_tasks = [{"idx_a": ni, "entity_a": entities[ni], "idx_b": ai, "entity_b": entities[ai], "type": "non_anchor_vs_anchor"}
+                              for ni in non_anchor_indices for ai in anchor_indices]
+            a_vs_a_tasks = [{"idx_a": ai, "entity_a": entities[ai], "idx_b": aj, "entity_b": entities[aj], "type": "anchor_vs_anchor"}
+                             for ai, aj in itertools.combinations(anchor_indices, 2)]
+
+            infer_results = run_batch_inference(na_vs_a_tasks + a_vs_a_tasks, llm, tokenizer, sampling_params)
+
+            direct_results, non_anchor_wins, anchor_wins, comparison_records = {}, defaultdict(int), defaultdict(int), []
+            for task, (winner, raw, failed) in zip(na_vs_a_tasks + a_vs_a_tasks, infer_results):
+                idx_a, idx_b = task["idx_a"], task["idx_b"]
+                if not failed:
+                    i_wins = winner == "A"
+                    direct_results[(idx_a, idx_b)] = i_wins
+                    direct_results[(idx_b, idx_a)] = not i_wins
+                    if task["type"] == "non_anchor_vs_anchor" and i_wins:
+                        non_anchor_wins[idx_a] += 1
+                    elif task["type"] == "anchor_vs_anchor":
+                        if i_wins:
+                            anchor_wins[idx_a] += 1
+                        else:
+                            anchor_wins[idx_b] += 1
+
+                comparison_records.append({
+                    "entity_a": task["entity_a"], "idx_a": idx_a,
+                    "entity_b": task["entity_b"], "idx_b": idx_b,
+                    "winner": winner, "extraction_failed": failed, "llm_output": raw, "type": task["type"]
+                })
+
+            pred = bubble_sort_by_anchor(range(n), anchor_set, anchor_wins, non_anchor_wins, direct_results)
+
+            out_f.write(json.dumps({
+                "list_id": list_id, "question_entity": entities, "score": item["score"],
+                "ground_truth": item["ground_truth"], "anchor_indices": anchor_indices,
+                "anchor_wins_vs_anchors": {str(k): v for k, v in anchor_wins.items()},
+                "non_anchor_wins_vs_anchors": {str(k): v for k, v in non_anchor_wins.items()},
+                "pred": pred, "comparisons": comparison_records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PairRank_mo.py

@@ -0,0 +1,157 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_pairwise_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a film expert. Please determine which of the two given entities is more authoritative based on the following criteria.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Who is the director of the movie ...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: \"{entity1}\"\n"
+        f"Entity B: \"{entity2}\"\n\n"
+        f"Which entity is more authoritative? Only return 'A' or 'B'. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ab_answer(response):
+    if not response:
+        return None
+    text = response.strip()
+    first = text[0].upper() if text else ""
+    if first in ("A", "B"):
+        return first
+    if m := re.search(r"\b([AB])\b", text.upper()):
+        return m.group(1)
+    return None
+
+
+def run_batch_inference(task_list, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(task_list), BATCH_SIZE):
+        batch = task_list[i:i + BATCH_SIZE]
+        prompts = [tokenizer.apply_chat_template(
+            [{"role": "user", "content": build_pairwise_prompt(task["entity_a"], task["entity_b"])}],
+            tokenize=False, add_generation_prompt=True, enable_thinking=False
+        ) for task in batch]
+        for task, out in zip(batch, llm.generate(prompts, sampling_params)):
+            raw = out.outputs[0].text if out.outputs else ""
+            winner = extract_ab_answer(raw)
+            results.append((winner, raw, winner is None))
+    return results
+
+
+def anchor_compare(i, j, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    if i not in anchor_set and j not in anchor_set:
+        return non_anchor_wins.get(i, 0) > non_anchor_wins.get(j, 0)
+    if i in anchor_set and j in anchor_set:
+        return anchor_wins.get(i, 0) > anchor_wins.get(j, 0)
+    if (i, j) in direct_results:
+        return direct_results[(i, j)]
+    if (j, i) in direct_results:
+        return not direct_results[(j, i)]
+    return anchor_wins.get(i, non_anchor_wins.get(i, 0)) > anchor_wins.get(j, non_anchor_wins.get(j, 0))
+
+
+def bubble_sort_by_anchor(indices, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    arr = list(indices)
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if not anchor_compare(arr[j], arr[j + 1], anchor_set, anchor_wins, non_anchor_wins, direct_results):
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0)
+
+    os = __import__("os")
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed_ids = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        if "list_id" in (obj := json.loads(line)):
+                            completed_ids.add(obj["list_id"])
+                    except json.JSONDecodeError:
+                        pass
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        for item_idx, item in enumerate(tqdm(items)):
+            list_id = item.get("list_id", item_idx)
+            if list_id in completed_ids:
+                continue
+
+            entities = item["question_entity"]
+            n = len(entities)
+            anchor_indices = random.sample(range(n), NUM_ANCHORS)
+            anchor_set = set(anchor_indices)
+            non_anchor_indices = [i for i in range(n) if i not in anchor_set]
+
+            na_vs_a_tasks = [{"idx_a": ni, "entity_a": entities[ni], "idx_b": ai, "entity_b": entities[ai], "type": "non_anchor_vs_anchor"}
+                              for ni in non_anchor_indices for ai in anchor_indices]
+            a_vs_a_tasks = [{"idx_a": ai, "entity_a": entities[ai], "idx_b": aj, "entity_b": entities[aj], "type": "anchor_vs_anchor"}
+                             for ai, aj in itertools.combinations(anchor_indices, 2)]
+
+            infer_results = run_batch_inference(na_vs_a_tasks + a_vs_a_tasks, llm, tokenizer, sampling_params)
+
+            direct_results, non_anchor_wins, anchor_wins, comparison_records = {}, defaultdict(int), defaultdict(int), []
+            for task, (winner, raw, failed) in zip(na_vs_a_tasks + a_vs_a_tasks, infer_results):
+                idx_a, idx_b = task["idx_a"], task["idx_b"]
+                if not failed:
+                    i_wins = winner == "A"
+                    direct_results[(idx_a, idx_b)] = i_wins
+                    direct_results[(idx_b, idx_a)] = not i_wins
+                    if task["type"] == "non_anchor_vs_anchor" and i_wins:
+                        non_anchor_wins[idx_a] += 1
+                    elif task["type"] == "anchor_vs_anchor":
+                        if i_wins:
+                            anchor_wins[idx_a] += 1
+                        else:
+                            anchor_wins[idx_b] += 1
+
+                comparison_records.append({
+                    "entity_a": task["entity_a"], "idx_a": idx_a,
+                    "entity_b": task["entity_b"], "idx_b": idx_b,
+                    "winner": winner, "extraction_failed": failed, "llm_output": raw, "type": task["type"]
+                })
+
+            pred = bubble_sort_by_anchor(range(n), anchor_set, anchor_wins, non_anchor_wins, direct_results)
+
+            out_f.write(json.dumps({
+                "list_id": list_id, "question_entity": entities, "score": item["score"],
+                "ground_truth": item["ground_truth"], "anchor_indices": anchor_indices,
+                "anchor_wins_vs_anchors": {str(k): v for k, v in anchor_wins.items()},
+                "non_anchor_wins_vs_anchors": {str(k): v for k, v in non_anchor_wins.items()},
+                "pred": pred, "comparisons": comparison_records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PairRank_so.py

@@ -0,0 +1,157 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "EVAL_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_pairwise_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a music industry expert. Please determine which of the two given entities is more authoritative based on the following criteria.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"**QUESTION CONTEXT**: These entities are the subjects of questions like 'Who is the performer of the song ...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: \"{entity1}\"\n"
+        f"Entity B: \"{entity2}\"\n\n"
+        f"Which entity is more authoritative? Only return 'A' or 'B'. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_ab_answer(response):
+    if not response:
+        return None
+    text = response.strip()
+    first = text[0].upper() if text else ""
+    if first in ("A", "B"):
+        return first
+    if m := re.search(r"\b([AB])\b", text.upper()):
+        return m.group(1)
+    return None
+
+
+def run_batch_inference(task_list, llm, tokenizer, sampling_params):
+    results = []
+    for i in range(0, len(task_list), BATCH_SIZE):
+        batch = task_list[i:i + BATCH_SIZE]
+        prompts = [tokenizer.apply_chat_template(
+            [{"role": "user", "content": build_pairwise_prompt(task["entity_a"], task["entity_b"])}],
+            tokenize=False, add_generation_prompt=True, enable_thinking=False
+        ) for task in batch]
+        for task, out in zip(batch, llm.generate(prompts, sampling_params)):
+            raw = out.outputs[0].text if out.outputs else ""
+            winner = extract_ab_answer(raw)
+            results.append((winner, raw, winner is None))
+    return results
+
+
+def anchor_compare(i, j, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    if i not in anchor_set and j not in anchor_set:
+        return non_anchor_wins.get(i, 0) > non_anchor_wins.get(j, 0)
+    if i in anchor_set and j in anchor_set:
+        return anchor_wins.get(i, 0) > anchor_wins.get(j, 0)
+    if (i, j) in direct_results:
+        return direct_results[(i, j)]
+    if (j, i) in direct_results:
+        return not direct_results[(j, i)]
+    return anchor_wins.get(i, non_anchor_wins.get(i, 0)) > anchor_wins.get(j, non_anchor_wins.get(j, 0))
+
+
+def bubble_sort_by_anchor(indices, anchor_set, anchor_wins, non_anchor_wins, direct_results):
+    arr = list(indices)
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if not anchor_compare(arr[j], arr[j + 1], anchor_set, anchor_wins, non_anchor_wins, direct_results):
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0)
+
+    os = __import__("os")
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed_ids = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        if "list_id" in (obj := json.loads(line)):
+                            completed_ids.add(obj["list_id"])
+                    except json.JSONDecodeError:
+                        pass
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        for item_idx, item in enumerate(tqdm(items)):
+            list_id = item.get("list_id", item_idx)
+            if list_id in completed_ids:
+                continue
+
+            entities = item["question_entity"]
+            n = len(entities)
+            anchor_indices = random.sample(range(n), NUM_ANCHORS)
+            anchor_set = set(anchor_indices)
+            non_anchor_indices = [i for i in range(n) if i not in anchor_set]
+
+            na_vs_a_tasks = [{"idx_a": ni, "entity_a": entities[ni], "idx_b": ai, "entity_b": entities[ai], "type": "non_anchor_vs_anchor"}
+                              for ni in non_anchor_indices for ai in anchor_indices]
+            a_vs_a_tasks = [{"idx_a": ai, "entity_a": entities[ai], "idx_b": aj, "entity_b": entities[aj], "type": "anchor_vs_anchor"}
+                             for ai, aj in itertools.combinations(anchor_indices, 2)]
+
+            infer_results = run_batch_inference(na_vs_a_tasks + a_vs_a_tasks, llm, tokenizer, sampling_params)
+
+            direct_results, non_anchor_wins, anchor_wins, comparison_records = {}, defaultdict(int), defaultdict(int), []
+            for task, (winner, raw, failed) in zip(na_vs_a_tasks + a_vs_a_tasks, infer_results):
+                idx_a, idx_b = task["idx_a"], task["idx_b"]
+                if not failed:
+                    i_wins = winner == "A"
+                    direct_results[(idx_a, idx_b)] = i_wins
+                    direct_results[(idx_b, idx_a)] = not i_wins
+                    if task["type"] == "non_anchor_vs_anchor" and i_wins:
+                        non_anchor_wins[idx_a] += 1
+                    elif task["type"] == "anchor_vs_anchor":
+                        if i_wins:
+                            anchor_wins[idx_a] += 1
+                        else:
+                            anchor_wins[idx_b] += 1
+
+                comparison_records.append({
+                    "entity_a": task["entity_a"], "idx_a": idx_a,
+                    "entity_b": task["entity_b"], "idx_b": idx_b,
+                    "winner": winner, "extraction_failed": failed, "llm_output": raw, "type": task["type"]
+                })
+
+            pred = bubble_sort_by_anchor(range(n), anchor_set, anchor_wins, non_anchor_wins, direct_results)
+
+            out_f.write(json.dumps({
+                "list_id": list_id, "question_entity": entities, "score": item["score"],
+                "ground_truth": item["ground_truth"], "anchor_indices": anchor_indices,
+                "anchor_wins_vs_anchors": {str(k): v for k, v in anchor_wins.items()},
+                "non_anchor_wins_vs_anchors": {str(k): v for k, v in non_anchor_wins.items()},
+                "pred": pred, "comparisons": comparison_records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PointScore_ba.py

@@ -0,0 +1,114 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a pop-culture sports expert. Please score the entity authority of each of the two given basketball entities "
+        f"based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"QUESTION CONTEXT: These entities are the subjects of questions like 'Where is the birthplace of the basketball player...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: {entity1}\n"
+        f"Entity B: {entity2}\n\n"
+        f"Your output MUST be a single, valid JSON object in the format: {{\"A\": X, \"B\": Y}}, where X and Y are integer scores from 0 to 9. "
+        f"Example format: {{\"A\": 7, \"B\": 4}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response):
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := re.search(r'\{[^{}]*\}', text, re.DOTALL):
+        try:
+            d = json.loads(match.group())
+            sa, sb = float(d.get("A", d.get("a"))), float(d.get("B", d.get("b")))
+            if sa is not None and sb is not None and 0 <= sa <= 9 and 0 <= sb <= 9:
+                return sa, sb
+        except Exception:
+            pass
+    return None, None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=4, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=64)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for idx, item in tqdm(pending):
+            entities = item["question_entity"]
+            n = len(entities)
+            anchors = random.sample(range(n), NUM_ANCHORS)
+            non_anchors = [i for i in range(n) if i not in anchors]
+
+            tasks = [{"idx_a": ni, "idx_b": ai, "entity_a": entities[ni], "entity_b": entities[ai]}
+                     for ni in non_anchors for ai in anchors]
+            tasks += [{"idx_a": ai, "idx_b": aj, "entity_a": entities[ai], "entity_b": entities[aj]}
+                      for ai, aj in itertools.combinations(anchors, 2)]
+
+            # Batch inference
+            results = []
+            for i in range(0, len(tasks), BATCH_SIZE):
+                batch = tasks[i:i + BATCH_SIZE]
+                prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(t["entity_a"], t["entity_b"])}],
+                                                         tokenize=False, add_generation_prompt=True, enable_thinking=False) for t in batch]
+                outputs = llm.generate(prompts, sampling_params)
+                for t, out in zip(batch, outputs):
+                    raw = out.outputs[0].text if out.outputs else ""
+                    sa, sb = extract_scores(raw)
+                    results.append((t, sa, sb, raw))
+
+            # Aggregate scores
+            scores = defaultdict(list)
+            records = []
+            for task, sa, sb, raw in results:
+                if sa is not None and sb is not None:
+                    scores[task["idx_a"]].append(sa)
+                    scores[task["idx_b"]].append(sb)
+                records.append({"entity_a": task["entity_a"], "idx_a": task["idx_a"], "entity_b": task["entity_b"],
+                               "idx_b": task["idx_b"], "score_a": sa, "score_b": sb, "llm_output": raw})
+
+            avg = {i: float(__import__("numpy").mean(scores[i])) if scores[i] else 0.0 for i in range(n)}
+            pred = sorted(range(n), key=lambda x: avg[x], reverse=True)
+
+            out_f.write(json.dumps({
+                "item_id": idx, "question_entity": entities, "score": item.get("score"),
+                "ground_truth": item["ground_truth"], "anchor_indices": anchors,
+                "avg_scores": avg, "pred": pred, "comparisons": records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PointScore_mo.py

@@ -0,0 +1,114 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a film expert. Please score the entity authority of each of the two given movie entities "
+        f"based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"QUESTION CONTEXT: These entities are the subjects of questions like 'Who is the director of the movie ...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: {entity1}\n"
+        f"Entity B: {entity2}\n\n"
+        f"Your output MUST be a single, valid JSON object in the format: {{\"A\": X, \"B\": Y}}, where X and Y are integer scores from 0 to 9. "
+        f"Example format: {{\"A\": 7, \"B\": 4}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response):
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := re.search(r'\{[^{}]*\}', text, re.DOTALL):
+        try:
+            d = json.loads(match.group())
+            sa, sb = float(d.get("A", d.get("a"))), float(d.get("B", d.get("b")))
+            if sa is not None and sb is not None and 0 <= sa <= 9 and 0 <= sb <= 9:
+                return sa, sb
+        except Exception:
+            pass
+    return None, None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=4, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=64)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for idx, item in tqdm(pending):
+            entities = item["question_entity"]
+            n = len(entities)
+            anchors = random.sample(range(n), NUM_ANCHORS)
+            non_anchors = [i for i in range(n) if i not in anchors]
+
+            tasks = [{"idx_a": ni, "idx_b": ai, "entity_a": entities[ni], "entity_b": entities[ai]}
+                     for ni in non_anchors for ai in anchors]
+            tasks += [{"idx_a": ai, "idx_b": aj, "entity_a": entities[ai], "entity_b": entities[aj]}
+                      for ai, aj in itertools.combinations(anchors, 2)]
+
+            # Batch inference
+            results = []
+            for i in range(0, len(tasks), BATCH_SIZE):
+                batch = tasks[i:i + BATCH_SIZE]
+                prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(t["entity_a"], t["entity_b"])}],
+                                                         tokenize=False, add_generation_prompt=True, enable_thinking=False) for t in batch]
+                outputs = llm.generate(prompts, sampling_params)
+                for t, out in zip(batch, outputs):
+                    raw = out.outputs[0].text if out.outputs else ""
+                    sa, sb = extract_scores(raw)
+                    results.append((t, sa, sb, raw))
+
+            # Aggregate scores
+            scores = defaultdict(list)
+            records = []
+            for task, sa, sb, raw in results:
+                if sa is not None and sb is not None:
+                    scores[task["idx_a"]].append(sa)
+                    scores[task["idx_b"]].append(sb)
+                records.append({"entity_a": task["entity_a"], "idx_a": task["idx_a"], "entity_b": task["entity_b"],
+                               "idx_b": task["idx_b"], "score_a": sa, "score_b": sb, "llm_output": raw})
+
+            avg = {i: float(__import__("numpy").mean(scores[i])) if scores[i] else 0.0 for i in range(n)}
+            pred = sorted(range(n), key=lambda x: avg[x], reverse=True)
+
+            out_f.write(json.dumps({
+                "item_id": idx, "question_entity": entities, "score": item.get("score"),
+                "ground_truth": item["ground_truth"], "anchor_indices": anchors,
+                "avg_scores": avg, "pred": pred, "comparisons": records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PairJudge_PointScore_so.py

@@ -0,0 +1,114 @@
+import json
+import random
+import itertools
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+EVAL_FILE = "LISTWISE_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 16
+NUM_ANCHORS = 5
+
+
+def build_prompt(entity1, entity2):
+    return (
+        f"You are a Wikipedia notability expert and a music industry expert. Please score the entity authority of each of the two given song entities "
+        f"based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"Consider both entities together when assigning scores to ensure consistency.\n\n"
+        f"QUESTION CONTEXT: These entities are the subjects of questions like 'Who is the performer of the song...'\n\n"
+        f"**TARGET ENTITIES**:\n"
+        f"Entity A: {entity1}\n"
+        f"Entity B: {entity2}\n\n"
+        f"Your output MUST be a single, valid JSON object in the format: {{\"A\": X, \"B\": Y}}, where X and Y are integer scores from 0 to 9. "
+        f"Example format: {{\"A\": 7, \"B\": 4}}. Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_scores(response):
+    text = response.strip()
+    if pos := text.rfind("Your answer:"):
+        text = text[pos + 12:].strip()
+    if match := re.search(r'\{[^{}]*\}', text, re.DOTALL):
+        try:
+            d = json.loads(match.group())
+            sa, sb = float(d.get("A", d.get("a"))), float(d.get("B", d.get("b")))
+            if sa is not None and sb is not None and 0 <= sa <= 9 and 0 <= sb <= 9:
+                return sa, sb
+        except Exception:
+            pass
+    return None, None
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR, max_num_seqs=256, trust_remote_code=True, tensor_parallel_size=2, dtype="bfloat16")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=64)
+
+    __import__("os").makedirs(__import__("os").path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    completed = set()
+    if __import__("os").path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    completed.add(json.loads(line).get("item_id", -1))
+
+    with open(EVAL_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line) for line in f]
+
+    with open(OUTPUT_FILE, "a", encoding="utf-8") as out_f:
+        pending = [(idx, item) for idx, item in enumerate(items) if idx not in completed]
+        for idx, item in tqdm(pending):
+            entities = item["question_entity"]
+            n = len(entities)
+            anchors = random.sample(range(n), NUM_ANCHORS)
+            non_anchors = [i for i in range(n) if i not in anchors]
+
+            tasks = [{"idx_a": ni, "idx_b": ai, "entity_a": entities[ni], "entity_b": entities[ai]}
+                     for ni in non_anchors for ai in anchors]
+            tasks += [{"idx_a": ai, "idx_b": aj, "entity_a": entities[ai], "entity_b": entities[aj]}
+                      for ai, aj in itertools.combinations(anchors, 2)]
+
+            # Batch inference
+            results = []
+            for i in range(0, len(tasks), BATCH_SIZE):
+                batch = tasks[i:i + BATCH_SIZE]
+                prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(t["entity_a"], t["entity_b"])}],
+                                                         tokenize=False, add_generation_prompt=True, enable_thinking=False) for t in batch]
+                outputs = llm.generate(prompts, sampling_params)
+                for t, out in zip(batch, outputs):
+                    raw = out.outputs[0].text if out.outputs else ""
+                    sa, sb = extract_scores(raw)
+                    results.append((t, sa, sb, raw))
+
+            # Aggregate scores
+            scores = defaultdict(list)
+            records = []
+            for task, sa, sb, raw in results:
+                if sa is not None and sb is not None:
+                    scores[task["idx_a"]].append(sa)
+                    scores[task["idx_b"]].append(sb)
+                records.append({"entity_a": task["entity_a"], "idx_a": task["idx_a"], "entity_b": task["entity_b"],
+                               "idx_b": task["idx_b"], "score_a": sa, "score_b": sb, "llm_output": raw})
+
+            avg = {i: float(__import__("numpy").mean(scores[i])) if scores[i] else 0.0 for i in range(n)}
+            pred = sorted(range(n), key=lambda x: avg[x], reverse=True)
+
+            out_f.write(json.dumps({
+                "item_id": idx, "question_entity": entities, "score": item.get("score"),
+                "ground_truth": item["ground_truth"], "anchor_indices": anchors,
+                "avg_scores": avg, "pred": pred, "comparisons": records
+            }, ensure_ascii=False) + "\n")
+            out_f.flush()
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PointJudge_ba.py

@@ -0,0 +1,69 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+INPUT_FILE = "INPUT_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 8
+
+
+def build_prompt(question, entity):
+    return (
+        f"You are a Wikipedia notability expert and a pop-culture sports expert. Please score the authority of the given basketball entity based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"**QUESTION CONTEXT**: {question}\n"
+        f"**TARGET ENTITY**: {entity}\n"
+        f"Based on the question context and the above criteria, rate the authority of this ENTITY (0-9 points).\n"
+        f"Output only: {{\"score\": X}} where X is your evaluated score (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9). Do not add any explanation.\n"
+        f"Your answer:"
+    )
+
+
+def extract_score(text):
+    text = text.strip()
+    if "Your answer:" in text:
+        text = text.split("Your answer:")[-1].strip()
+    text = re.sub(r'^(user|assistant|Your answer:|Answer:)\s*', '', text, flags=re.IGNORECASE).strip()
+    try:
+        if match := re.search(r'\{[^}]*"score"\s*:\s*(\d+)[^}]*\}', text, re.IGNORECASE):
+            score = int(match.group(1))
+            if 0 <= score <= 9:
+                return score
+    except Exception:
+        pass
+    if numbers := re.findall(r'\b([0-9])\b', text):
+        return int(numbers[0])
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    with open(INPUT_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line.strip()) for line in f if line.strip()]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question"], item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for item, output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                pred = extract_score(text)
+                out_f.write(json.dumps({
+                    "question": item["question"], "question_entity": item["question_entity"],
+                    "popularity": item["popularity"], "true_score": item["score"],
+                    "pred_score": pred, "llm_output": text if pred != -1 else ""
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PointJudge_mo.py

@@ -0,0 +1,69 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+INPUT_FILE = "INPUT_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 8
+
+
+def build_prompt(question, entity):
+    return (
+        f"You are a Wikipedia notability expert and a film expert. Please score the authority of the given movie entity based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"**QUESTION CONTEXT**: {question}\n"
+        f"**TARGET ENTITY**: {entity}\n"
+        f"Based on the question context and the above criteria, rate the authority of this ENTITY (0-9 points).\n"
+        f"Output only: {{\"score\": X}} where X is your evaluated score (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9). Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_score(text):
+    text = text.strip()
+    if "Your answer:" in text:
+        text = text.split("Your answer:")[-1].strip()
+    text = re.sub(r'^(user|assistant|Your answer:|Answer:)\s*', '', text, flags=re.IGNORECASE).strip()
+    try:
+        if match := re.search(r'\{[^}]*"score"\s*:\s*(\d+)[^}]*\}', text, re.IGNORECASE):
+            score = int(match.group(1))
+            if 0 <= score <= 9:
+                return score
+    except Exception:
+        pass
+    if numbers := re.findall(r'\b([0-9])\b', text):
+        return int(numbers[0])
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    with open(INPUT_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line.strip()) for line in f if line.strip()]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question"], item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for item, output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                pred = extract_score(text)
+                out_f.write(json.dumps({
+                    "question": item["question"], "question_entity": item["question_entity"],
+                    "popularity": item["popularity"], "true_score": item["score"],
+                    "pred_score": pred, "llm_output": text if pred != -1 else ""
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/Judges/Judges_on_EntityAuth/PointJudge_so.py

@@ -0,0 +1,65 @@
+import json
+import re
+
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+MODEL_DIR = "YOUR_MODEL_DIR"
+INPUT_FILE = "INPUT_FILE"
+OUTPUT_FILE = "OUTPUT_FILE"
+BATCH_SIZE = 8
+
+
+def build_prompt(question, entity):
+    return (
+        f"You are a Wikipedia notability expert and a music industry expert. Please score the authority of the given song entity based on the following criteria, with a rating range of 0 to 9.\n\n"
+        f"Entity authority refers to the public recognition, fame, historical significance, or widespread knowledge of the entity (person, place, organization, etc.).\n"
+        f"**QUESTION CONTEXT**: {question}\n"
+        f"**TARGET ENTITY**: {entity}\n"
+        f"Based on the question context and the above criteria, rate the authority of this ENTITY (0-9 points).\n"
+        f"Output only: {{\"score\": X}} where X is your evaluated score (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9). Do not add any explanation.\n"
+        f"Your answer: "
+    )
+
+
+def extract_score(text):
+    text = text.strip()
+    try:
+        if match := re.search(r'\{[^}]*"score"\s*:\s*(\d+)[^}]*\}', text):
+            score = int(match.group(1))
+            if 0 <= score <= 9:
+                return score
+    except Exception:
+        pass
+    if numbers := re.findall(r'\b([0-9])\b', text):
+        return int(numbers[0])
+    return -1
+
+
+def main():
+    llm = LLM(model=MODEL_DIR, tokenizer=MODEL_DIR)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256)
+
+    with open(INPUT_FILE, "r", encoding="utf-8") as f:
+        items = [json.loads(line.strip()) for line in f if line.strip()]
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out_f:
+        for i in tqdm(range(0, len(items), BATCH_SIZE)):
+            batch = items[i:i + BATCH_SIZE]
+            prompts = [tokenizer.apply_chat_template([{"role": "user", "content": build_prompt(item["question"], item["question_entity"])}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False) for item in batch]
+            outputs = llm.generate(prompts, sampling_params)
+            for item, output in zip(batch, outputs):
+                text = output.outputs[0].text if output.outputs else ""
+                pred = extract_score(text)
+                out_f.write(json.dumps({
+                    "question": item["question"], "question_entity": item["question_entity"],
+                    "popularity": item["popularity"], "true_score": item["score"],
+                    "pred_score": pred, "llm_output": text if pred != -1 else ""
+                }, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

AuthorityBench/judge_and_eval/eval/eval_list.py

@@ -0,0 +1,129 @@
+import json
+import numpy as np
+import argparse
+from scipy.stats import spearmanr, kendalltau
+
+
+def ranking_to_ranks(ranking):
+    n = len(ranking)
+    ranks = np.empty(n, dtype=int)
+    for rank, doc_idx in enumerate(ranking):
+        ranks[doc_idx] = rank
+    return ranks
+
+
+def calculate_metrics(file_path):
+    spearman_scores = []
+    kendall_scores = []
+    valid_count = 0
+
+    skip_json_error = 0
+    skip_wrong_type = 0
+    skip_wrong_length = 0
+    skip_not_permutation = 0
+    skip_other = 0
+
+    with open(file_path, 'r', encoding='utf-8') as f:
+        total_lines = 0
+        for line in f:
+            total_lines += 1
+            if not line.strip():
+                continue
+
+            try:
+                data = json.loads(line)
+                pred_ranking = data.get('pred')
+                ground_truth_ranking = data.get('ground_truth')
+
+                if not isinstance(pred_ranking, list) or not isinstance(ground_truth_ranking, list):
+                    skip_wrong_type += 1
+                    continue
+
+                n = len(ground_truth_ranking)
+
+                if len(pred_ranking) != n or n < 2:
+                    skip_wrong_length += 1
+                    continue
+
+                pred_set = set(pred_ranking)
+                gt_set = set(ground_truth_ranking)
+                expected_set = set(range(n))
+
+                if pred_set != expected_set:
+                    skip_not_permutation += 1
+                    continue
+
+                if gt_set != expected_set:
+                    skip_not_permutation += 1
+                    continue
+
+                gt_ranks = ranking_to_ranks(ground_truth_ranking)
+                pred_ranks = ranking_to_ranks(pred_ranking)
+
+                s_corr, _ = spearmanr(gt_ranks, pred_ranks)
+                k_corr, _ = kendalltau(gt_ranks, pred_ranks)
+
+                spearman_scores.append(s_corr if not np.isnan(s_corr) else 0.0)
+                kendall_scores.append(k_corr if not np.isnan(k_corr) else 0.0)
+
+                valid_count += 1
+
+            except json.JSONDecodeError:
+                skip_json_error += 1
+                continue
+            except (KeyError, TypeError, ValueError):
+                skip_other += 1
+                continue
+
+    print(f"Evaluation File: {file_path}")
+
+    if valid_count == 0:
+        print(f"Error: No valid evaluation data found in {file_path}")
+
+    total_skipped = (skip_json_error + skip_wrong_type +
+                     skip_wrong_length + skip_not_permutation + skip_other)
+    total_processed = total_lines - skip_json_error
+
+    print(f"\n[Sample Statistics]")
+    print(f"  Total lines:    {total_lines}")
+    print(f"  Valid samples:  {valid_count}")
+    print(f"  Skipped samples: {total_skipped}")
+    print(f"\n[Skip Details]")
+    print(f"  JSON parse error:       {skip_json_error}")
+    print(f"  Wrong field type:       {skip_wrong_type}")
+    print(f"  List length mismatch:   {skip_wrong_length}")
+    print(f"  Not a permutation:      {skip_not_permutation}")
+    print(f"  Other errors:           {skip_other}")
+
+    if valid_count > 0:
+        avg_spearman = np.mean(spearman_scores)
+        avg_kendall = np.mean(kendall_scores)
+
+        print(f"  Spearman's Rho: {avg_spearman:.4f}")
+        print(f"  Kendall's Tau:  {avg_kendall:.4f}")
+
+
+    return {
+        'total_lines': total_lines,
+        'valid_count': valid_count,
+        'skipped': {
+            'json_error': skip_json_error,
+            'wrong_type': skip_wrong_type,
+            'wrong_length': skip_wrong_length,
+            'not_permutation': skip_not_permutation,
+            'other': skip_other,
+            'total': total_skipped
+        },
+        'spearman': avg_spearman if valid_count > 0 else None,
+        'kendall': avg_kendall if valid_count > 0 else None,
+    }
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Evaluate ranking metrics (Spearman / Kendall)"
+    )
+    parser.add_argument("file_path", type=str, help="Path to JSONL file with evaluation results")
+    args = parser.parse_args()
+
+    calculate_metrics(args.file_path)

AuthorityBench/judge_and_eval/eval/eval_pair.py

@@ -0,0 +1,51 @@
+import json
+import argparse
+
+
+def calculate_accuracy(file_path):
+    total = 0
+    correct = 0
+
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if not line.strip():
+                continue
+
+            try:
+                data = json.loads(line.strip())
+                label = data.get('label')
+                pred = data.get('pred')
+
+                if label is not None and pred is not None:
+                    total += 1
+                    if label == pred:
+                        correct += 1
+
+            except json.JSONDecodeError:
+                continue
+
+    accuracy = correct / total if total > 0 else 0.0
+
+    return {
+        'total': total,
+        'correct': correct,
+        'accuracy': accuracy
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Calculate prediction accuracy from JSONL file"
+    )
+    parser.add_argument("file_path", type=str, help="Path to JSONL file")
+    args = parser.parse_args()
+
+    result = calculate_accuracy(args.file_path)
+
+    print(f"  Accuracy:       {result['accuracy']:.4f} ({result['accuracy']*100:.2f}%)")
+
+    return result
+
+
+if __name__ == '__main__':
+    main()