utils_mewslix.py

"""Utilities for handling Mewsli-X data and evaluation.

This module is adapted from the utilities distributed along with Mewsli-X, i.e.
https://github.com/google-research/google-research/blob/master/dense_representations_for_entity_retrieval/mel/mewsli_x/schema.py
"""

from __future__ import annotations

import collections
import copy
import dataclasses
import json
import pathlib
import re
from typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union

# Constants related to text preprocessing.
#
# Symbols for marking up a mention span in a text passage.
_MARKER_L = "{"
_MARKER_R = "}"
# Regular expressions for escaping pre-existing instances of the marker symbols.
_REGEX = re.compile(rf"{re.escape(_MARKER_L)}(.*?){re.escape(_MARKER_R)}")
_REPLACEMENT = r"(\1)"

# Constants related to task definition.
#
# Mewsli-X eval languages.
MENTION_LANGUAGES = ("ar", "de", "en", "es", "fa", "ja", "pl", "ro", "ta", "tr",
                     "uk")
# The retrieval task for Mewsli-X in XTREME-R is capped at evaluating the top-K
# retrieved entities.
TOP_K = 20

JsonValue = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
JsonDict = Dict[str, JsonValue]
JsonList = List[JsonValue]
StrOrPurePath = Union[str, pathlib.PurePath]


def to_jsonl(obj: JsonDict) -> str:
  return json.dumps(obj, ensure_ascii=False)


@dataclasses.dataclass(frozen=True)
class Span:
  """A [start:end]-span in some external string."""
  start: int
  end: int

  def __post_init__(self):
    if self.start < 0:
      raise ValueError(f"start offset is out of bounds {self}")
    if self.end < 0:
      raise ValueError(f"end offset is out of bounds {self}")
    if self.start >= self.end:
      raise ValueError(f"start and end offsets are non-monotonic {self}")

  @staticmethod
  def from_json(json_dict: JsonDict) -> Span:
    """Creates a new Span instance from the given JSON-dictionary."""
    return Span(start=json_dict["start"], end=json_dict["end"])

  def to_json(self) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    return dict(start=self.start, end=self.end)

  def validate_offsets_relative_to_context(self, context: str) -> None:
    """Validates the span's offsets relative to a context string."""
    if self.start >= len(context):
      raise ValueError(
          f"start offset in {self} is out of bounds w.r.t. '{context}'")
    if self.end > len(context):
      raise ValueError(
          f"end offset in {self} is out of bounds w.r.t. '{context}'")

  def locate_in(self, spans: Iterable[Span]) -> Optional[int]:
    """Returns the index of the first span that fully contains `self`.

    Args:
      spans: The spans to search.

    Returns:
      First i such that spans[i].{start,end} covers `self.{start,end}`, or None
      if there is no such span, indicating that `self` either is out of range
      relative to spans or crosses span boundaries.
    """
    for i, span in enumerate(spans):
      # The starts may coincide and the ends may coincide.
      if (span.start <= self.start and self.start < span.end and
          span.start < self.end and self.end <= span.end):
        return i
    return None


@dataclasses.dataclass(frozen=True)
class TextSpan(Span):
  """A text span relative to an external string T, with text=T[start:end]."""
  text: str

  def validate_relative_to_context(self, context: str) -> None:
    """Validates that `self.text` matches the designated span in `context`."""
    self.validate_offsets_relative_to_context(context)
    ref_text = context[self.start:self.end]
    if self.text != ref_text:
      raise ValueError(f"{self} does not match against context '{context}': "
                       f"'{self.text}' != '{ref_text}'")

  @staticmethod
  def from_context(span: Span, context: str) -> TextSpan:
    """Creates a new TextSpan by extracting the given `span` from `context`."""
    span.validate_offsets_relative_to_context(context)
    return TextSpan(span.start, span.end, text=context[span.start:span.end])

  @staticmethod
  def from_elements(start: int, end: int, context: str) -> TextSpan:
    """Creates a new TextSpan by extracting [start:end] from `context`."""
    return TextSpan.from_context(span=Span(start, end), context=context)

  @staticmethod
  def from_json(json_dict: JsonDict) -> TextSpan:
    """Creates a new TextSpan from the given JSON-dictionary."""
    return TextSpan(
        start=json_dict["start"], end=json_dict["end"], text=json_dict["text"])

  def to_json(self) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    return dict(start=self.start, end=self.end, text=self.text)


@dataclasses.dataclass(frozen=True)
class Entity:
  """An entity and its textual representation.

  Attributes:
    entity_id: Unique identifier of the entity, e.g. WikiData QID.
    title: A title phrase that names the entity.
    description: A definitional description of the entity that serves as its
      unique textual representation, e.g. taken from the beginning of the
      entity's Wikipedia page.
    sentence_spans: Sentence break annotations for the description, as
      character-level Span objects that index into `description`
    sentences: Sentences extracted from `description` according to
      `sentence_spans`. These TextSpan objects include the actual sentence text
      for added convenience. E.g., the string of the description's first
      sentence is `sentences[0].text`.
    description_language: Primary language code of the description and title,
      matching the Wikipedia language edition from which they were extracted.
    description_url: URL of the page where the description was extracted from.
  """
  entity_id: str
  title: str
  description: str
  sentence_spans: Tuple[Span, ...]
  description_language: str
  description_url: str

  def __post_init__(self):
    self.validate()

  @property
  def sentences(self) -> Iterator[TextSpan]:
    for span in self.sentence_spans:
      yield TextSpan.from_context(span, self.description)

  def validate(self):
    for sentence_span in self.sentence_spans:
      sentence_span.validate_offsets_relative_to_context(self.description)

  @staticmethod
  def from_json(json_dict: JsonDict) -> Entity:
    """Creates a new Entity from the given JSON-dictionary."""
    return Entity(
        entity_id=json_dict["entity_id"],
        title=json_dict["title"],
        description=json_dict["description"],
        description_language=json_dict["description_language"],
        description_url=json_dict["description_url"],
        sentence_spans=tuple(
            Span.from_json(t) for t in json_dict["sentence_spans"]),
    )

  def to_json(self) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    return dict(
        entity_id=self.entity_id,
        title=self.title,
        description=self.description,
        description_language=self.description_language,
        description_url=self.description_url,
        sentence_spans=[t.to_json() for t in self.sentence_spans],
    )


@dataclasses.dataclass(frozen=True)
class Mention:
  """A single mention of an entity, referring to some external context.

  Attributes:
    example_id: Unique identifier for the mention instance.
    mention_span: A TextSpan denoting one mention, relative to external context.
    entity_id: ID of the mentioned entity.
    metadata: Optional dictionary of additional information about the instance.
  """
  example_id: str
  mention_span: TextSpan
  entity_id: str
  metadata: Optional[Dict[str, str]] = None

  @staticmethod
  def from_json(json_dict: JsonDict) -> Mention:
    """Creates a new Mention from the given JSON-dictionary."""
    return Mention(
        example_id=json_dict["example_id"],
        mention_span=TextSpan.from_json(json_dict["mention_span"]),
        entity_id=json_dict["entity_id"],
        metadata=json_dict.get("metadata"),
    )

  def to_json(self) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    json_dict = dict(
        example_id=self.example_id,
        mention_span=self.mention_span.to_json(),
        entity_id=self.entity_id,
    )
    if self.metadata is not None:
      json_dict["metadata"] = self.metadata
    return json_dict


@dataclasses.dataclass()
class Context:
  """A document text fragment and metadata.

  Attributes:
    document_title: Title of the document.
    document_url: URL of the document.
    document_id: An identifier for the document. For a Wikipedia page, this may
      be the associated WikiData QID.
    language: Primary language code of the document.
    text: Original text from the document.
    sentence_spans: Sentence break annotations for the text, as character-level
      Span objects that index into `text`.
    sentences: Sentences extracted from `text` according to `sentence_spans`.
      These TextSpan objects include the actual sentence text for added
      convenience. E.g., the first sentence's string is `sentences[0].text`.
    section_title: Optional title of the section under which `text` appeared.
  """
  document_title: str
  document_url: str
  document_id: str
  language: str
  text: str
  sentence_spans: Tuple[Span, ...]
  section_title: Optional[str] = None

  def __post_init__(self):
    self.validate()

  @property
  def sentences(self) -> Iterator[TextSpan]:
    for span in self.sentence_spans:
      yield TextSpan.from_context(span, self.text)

  def validate(self):
    for sentence_span in self.sentence_spans:
      sentence_span.validate_offsets_relative_to_context(self.text)

  @staticmethod
  def from_json(json_dict: JsonDict) -> Context:
    """Creates a new Context from the given JSON-dictionary."""
    return Context(
        document_title=json_dict["document_title"],
        section_title=json_dict.get("section_title"),
        document_url=json_dict["document_url"],
        document_id=json_dict["document_id"],
        language=json_dict["language"],
        text=json_dict["text"],
        sentence_spans=tuple(
            Span.from_json(t) for t in json_dict["sentence_spans"]),
    )

  def to_json(self, keep_text: bool = True) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    json_dict = dict(
        document_title=self.document_title,
        document_url=self.document_url,
        document_id=self.document_id,
        language=self.language,
        text=self.text if keep_text else "",
        sentence_spans=[t.to_json() for t in self.sentence_spans],
    )
    if self.section_title is not None:
      json_dict["section_title"] = self.section_title
    return json_dict

  def truncate(self, focus: int, window_size: int) -> Tuple[int, Context]:
    """Truncates the Context to window_size sentences each side of focus.

    This seeks to truncate the text and sentence_spans of `self` to
      self.sentence_spans[focus - window_size:focus + window_size + 1].

    When there are fewer than window_size sentences available before (after) the
    focus, this attempts to retain additional context sentences after (before)
    the focus.

    Args:
      focus: The index of the focus sentence in self.sentence_spans.
      window_size: Number of sentences to retain on each side of the focus.

    Returns:
      - c, the number of characters removed from the start of the text, which is
        useful for updating any Mention defined in relation to this Context.
      - new_context, a copy of the Context that is updated to contain the
        truncated text and sentence_spans.

    Raises:
      IndexError: if focus is not within the range of self.sentence_spans.
      ValueError: if window_size is negative.
    """
    if focus < 0 or focus >= len(self.sentence_spans):
      raise IndexError(f"Index {focus} invalid for {self.sentence_spans}")
    if window_size < 0:
      raise ValueError(f"Expected a positive window, but got {window_size}")

    snt_window = self._get_sentence_window(focus, window_size)
    relevant_sentences = self.sentence_spans[snt_window.start:snt_window.end]

    char_offset = relevant_sentences[0].start
    char_end = relevant_sentences[-1].end
    new_text = self.text[char_offset:char_end]

    new_sentences = [
        Span(old_sentence.start - char_offset, old_sentence.end - char_offset)
        for old_sentence in relevant_sentences
    ]
    new_context = dataclasses.replace(
        self, text=new_text, sentence_spans=tuple(new_sentences))
    return char_offset, new_context

  def _get_sentence_window(self, focus: int, window_size: int) -> Span:
    """Gets Span of sentence indices to cover window around the focus index."""
    # Add window to the left of focus. If there are fewer sentences before the
    # focus sentence, carry over the remainder.
    left_index = max(focus - window_size, 0)
    remainder_left = window_size - (focus - left_index)
    assert remainder_left >= 0, remainder_left

    # Add window to the right of focus, including carryover. (Note, right_index
    # is an inclusive index.) If there are fewer sentences after the focus
    # sentence, carry back the remainder.
    right_index = min(focus + window_size + remainder_left,
                      len(self.sentence_spans) - 1)
    remainder_right = window_size - (right_index - focus)

    if remainder_right > 0:
      # Extend further leftward.
      left_index = max(left_index - remainder_right, 0)

    return Span(left_index, right_index + 1)


@dataclasses.dataclass()
class ContextualMentions:
  """Multiple entity mentions in a shared context."""
  context: Context
  mentions: List[Mention]

  def __post_init__(self):
    self.validate()

  def validate(self):
    self.context.validate()
    for mention in self.mentions:
      mention.mention_span.validate_relative_to_context(self.context.text)

  @staticmethod
  def from_json(json_dict: JsonDict) -> ContextualMentions:
    """Creates a new ContextualMentions from the given JSON-dictionary."""
    return ContextualMentions(
        context=Context.from_json(json_dict["context"]),
        mentions=[Mention.from_json(m) for m in json_dict["mentions"]],
    )

  def to_json(self, keep_text: bool = True) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    json_dict = dict(
        context=self.context.to_json(keep_text=keep_text),
        mentions=[m.to_json() for m in self.mentions],
    )
    return json_dict

  def unnest_to_single_mention_per_context(self) -> Iterator[ContextualMention]:
    for mention in self.mentions:
      yield ContextualMention(
          context=copy.deepcopy(self.context), mention=copy.deepcopy(mention))

  @staticmethod
  def nest_mentions_by_shared_context(
      contextual_mentions: Iterable[ContextualMention]
  ) -> Iterator[ContextualMentions]:
    """Inverse of unnest_to_single_mention_per_context."""
    contexts = {}
    groups = collections.defaultdict(list)
    for cm in contextual_mentions:
      context = cm.context
      key = (context.document_id, context.section_title, context.text)
      if key in contexts:
        assert contexts[key] == context, key
      else:
        contexts[key] = context
      groups[key].append(cm.mention)

    for key, mentions in groups.items():
      yield ContextualMentions(contexts[key], mentions)


@dataclasses.dataclass()
class ContextualMention:
  """A single entity mention in context."""
  context: Context
  mention: Mention

  def __post_init__(self):
    self.validate()

  def validate(self):
    self.context.validate()
    self.mention.mention_span.validate_relative_to_context(self.context.text)

  @staticmethod
  def from_json(json_dict: JsonDict) -> ContextualMention:
    """Creates a new ContextualMention from the given JSON-dictionary."""
    return ContextualMention(
        context=Context.from_json(json_dict["context"]),
        mention=Mention.from_json(json_dict["mention"]),
    )

  def to_json(self, keep_text: bool = True) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    json_dict = dict(
        context=self.context.to_json(keep_text=keep_text),
        mention=self.mention.to_json(),
    )
    return json_dict

  def truncate(self, window_size: int) -> Optional[ContextualMention]:
    """Truncates the context to window_size sentences each side of the mention.

    Args:
      window_size: Number of sentences to retain on each side of the sentence
        containing the mention. See Context.truncate for more detail.

    Returns:
      Returns None if no sentence spans were present or if the mention crosses
      sentence boundaries. Otherwise, returns an update copy of the
      ContextualMention where `.context` contains the truncated text and
      sentences, and the character offsets in `.mention` updated accordingly.
    """
    focus_snt = self.mention.mention_span.locate_in(self.context.sentence_spans)
    if focus_snt is None:
      # The context has no sentences or the mention crosses sentence boundaries.
      return None

    offset, new_context = self.context.truncate(
        focus=focus_snt, window_size=window_size)

    # Internal consistency check.
    max_valid = window_size * 2 + 1
    assert len(new_context.sentence_spans) <= max_valid, (
        f"Got {len(new_context.sentence_spans)}>{max_valid} sentences for "
        f"window_size={window_size} in truncated Context: {new_context}")

    new_mention = dataclasses.replace(
        self.mention,
        mention_span=TextSpan(
            start=self.mention.mention_span.start - offset,
            end=self.mention.mention_span.end - offset,
            text=self.mention.mention_span.text))
    return ContextualMention(context=new_context, mention=new_mention)


@dataclasses.dataclass()
class MentionEntityPair:
  """A ContextualMention paired with the Entity it refers to."""
  contextual_mention: ContextualMention
  entity: Entity

  def __post_init__(self):
    self.validate()

  def validate(self):
    self.contextual_mention.validate()
    self.entity.validate()

  @staticmethod
  def from_json(json_dict: JsonDict) -> MentionEntityPair:
    """Creates a new MentionEntityPair from the given JSON-dictionary."""
    return MentionEntityPair(
        contextual_mention=ContextualMention.from_json(
            json_dict["contextual_mention"]),
        entity=Entity.from_json(json_dict["entity"]),
    )

  def to_json(self) -> JsonDict:
    """Returns instance as JSON-compatible nested dictionary."""
    json_dict = dict(
        contextual_mention=self.contextual_mention.to_json(),
        entity=self.entity.to_json(),
    )
    return json_dict


SchemaAnyT = TypeVar("SchemaAnyT", Entity, Context, ContextualMention,
                     ContextualMentions, MentionEntityPair)
SchemaAny = Union[ContextualMention, ContextualMentions, Entity,
                  MentionEntityPair]


def load_jsonl_as_dicts(path: StrOrPurePath) -> List[JsonDict]:
  """Returns dict-records from JSONL file (without parsing into dataclasses)."""
  with open(path) as input_file:
    return [json.loads(line) for line in input_file]


def load_jsonl(path: StrOrPurePath,
               schema_cls: Type[SchemaAnyT]) -> List[SchemaAnyT]:
  """Loads the designated type of schema dataclass items from a JSONL file.

  Args:
    path: File path to load. Each line in the file is a JSON-serialized object.
    schema_cls: The dataclass to parse into, e.g. `ContextualMention`, `Entity`,
      etc.

  Returns:
    A list of validated instances of `schema_cls`, one per input line.
  """
  result = []
  for json_dict in load_jsonl_as_dicts(path):
    result.append(schema_cls.from_json(json_dict))
  return result


def write_jsonl(path: StrOrPurePath, items: Iterable[SchemaAny]) -> None:
  """Writes a list of any of the schema dataclass items to JSONL file.

  Args:
    path: Output file path that will store each item as a JSON-serialized line.
    items: Items to output. Instances of a schema dataclass, e.g.
      `ContextualMention`, `Entity`, etc.
  """
  with open(path, "wt") as output_file:
    for item in items:
      print(to_jsonl(item.to_json()), file=output_file)


# Baseline preprocessing functions. Users are free to create other more nuanced
# approaches.


def preprocess_mention(contextual_mention: ContextualMention) -> str:
  """A baseline method for preprocessing a ContextualMention to string.

  Args:
    contextual_mention: The ContextualMention to preprocess for passing to a
      tokenizer or model.

  Returns:
    A string representing the mention in context. This baseline implementation
    uses one sentence of context, based on sentence annotations provided with
    the Mewsli-X data. The mention span is accentuated by enclosing it in marker
    symbols defined at the top of this module. As a simple scheme to prevent the
    mention span from getting truncated due to a maximum model sequence length,
    it is redundantly prepended. For example:
      Smith: The verdict came back for { Smith }, who stepped down as AG of
      Fictitious County in February, 2012.
  """

  # Take 1 sentence of context text.
  cm = contextual_mention.truncate(window_size=0)
  assert cm is not None, contextual_mention
  left = cm.context.text[:cm.mention.mention_span.start]
  right = cm.context.text[cm.mention.mention_span.end:]

  # Create a context markup that highlights the mention span, while escaping
  # any existing instances of the markers.
  replacements = 0
  left, n = _REGEX.subn(_REPLACEMENT, left)
  replacements += n
  right, n = _REGEX.subn(_REPLACEMENT, right)
  replacements += n

  context_markup = (
      f"{left} {_MARKER_L} {cm.mention.mention_span.text} {_MARKER_R} {right}")

  # Also prepend the mention span to prevent truncation due to limited model
  # sequence lengths.
  query_string = f"{cm.mention.mention_span.text}: {context_markup}"

  # Normalize away newlines and extra spaces.
  query_string = " ".join(query_string.splitlines()).replace("  ", " ").strip()

  if replacements > 0:
    # Escaping does not occur in the WikiNews portion of Mewlis-X, but does
    # occur a handful of times in the Wikipedia data.
    print(f"Applied marker escaping for example_id {cm.mention.example_id}: "
          f"{query_string}")

  return query_string


def preprocess_entity_description(entity: Entity) -> str:
  """Returns a lightly normalized string from an Entity's description."""
  sentences_text = " ".join(s.text for s in entity.sentences)
  # Normalize away newlines and extra spaces.
  return " ".join(sentences_text.splitlines()).replace("  ", " ").strip()


# Evaluation functions.


def mean_reciprocal_rank(golds: Sequence[str],
                         predictions: Sequence[str]) -> float:
  """Computes mean reciprocal rank.

  Args:
    golds: list of gold entity ids.
    predictions: list of prediction lists

  Returns:
    mean reciprocal rank
  """

  def _reciprocal_rank(labels):
    for rank, label in enumerate(labels, start=1):
      if label:
        return 1.0 / rank
    return 0.0

  assert len(golds) == len(predictions)

  reciprocal_ranks = []
  for gold, prediction_list in zip(golds, predictions):
    labels = [int(p == gold) for p in prediction_list]
    reciprocal_ranks.append(_reciprocal_rank(labels))
  if reciprocal_ranks:
    return sum(reciprocal_ranks) / len(reciprocal_ranks)
  return 0.0


def evaluate(
    gold_data: Mapping[str, Sequence[str]],
    predictions: Mapping[str, Sequence[str]],
    k: int = TOP_K,
    return_count_diff: bool = False) -> Union[float, Tuple[float, int, int]]:
  """Evaluates one set of entity linking predictions.

  Args:
    gold_data: dictionary that maps each unique example_id to a *singleton list*
      containing its gold entity ID.
    predictions: dictionary that maps each unique example_id to a list of
      predicted entity IDs. Partial credit may be obtained even if some
      instances are missing from this dictionary.
    k: Number of top predictions to evaluate per evaluation instance.
    return_count_diff: Whether to also return the number of missing and
      unexpected example_ids in predictions.

  Returns:
    mean reciprocal rank in the interval [0, 1] by default, otherwise if
    return_count_diff is True, returns the tuple
     (mean reciprocal rank, num missing example_ids, num extra example_ids).
  """
  # The dataset has a single gold label per instance, but the file provides
  # it as a list.
  gold_single_labels = {
      ex_id: labels[0].strip() for ex_id, labels in gold_data.items()
  }

  # Convert to parallel lists, and truncate to top-k predictions.
  gold_ids: List[str] = []
  pred_ids: List[List[str]] = []
  for example_id, gold in gold_single_labels.items():
    top_k_preds = predictions.get(example_id, [])[:k]
    gold_ids.append(gold)
    pred_ids.append(top_k_preds)
  assert len(gold_ids) == len(pred_ids), (len(gold_ids), len(pred_ids))

  mrr = mean_reciprocal_rank(golds=gold_ids, predictions=pred_ids)
  if return_count_diff:
    unpredicted_count = len(set(gold_single_labels) - set(predictions))
    unexpected_count = len(set(predictions) - set(gold_single_labels))
    return mrr, unpredicted_count, unexpected_count
  else:
    return mrr


def evaluate_all(gold_file_pattern: str,
                 pred_file_pattern: str,
                 output_path: Optional[str] = None,
                 k: int = TOP_K) -> float:
  """Evaluates entity linking predictions from per-language files.

  Args:
    gold_file_pattern: file pattern for per-language gold labels, specified as
      an f-string with argument "lang" for language, e.g. "gold-{lang}.json",
      containing a single dictionary that maps each unique example id to a
      *singleton list* with its gold entity ID. Assumes that files exist for all
      languages in MENTION_LANGUAGES.
    pred_file_pattern: file pattern for per-language predictions, specified as
      an f-string with argument "lang" for language, e.g. "preds-{lang}.json",
      containing a single dictionary that maps each unique example id to a list
      of predicted entity IDs. Scoring proceeds even if some predictions are
      missing, in which case an alert is printed.
    output_path: Path to write results to. If None, results are printed to
      standard output.
    k: Number of top predictions to evaluate.

  Returns:
    mean reciprocal rank in interval [0, 1], macro-averaged over languages.
  """
  outputs = []
  columns = ["", f"MRR/MAP@{k}"]
  outputs.append("\t".join(columns))

  unpredicted_count = 0
  unexpected_count = 0

  mrr_sum = 0.0
  for language in sorted(MENTION_LANGUAGES):
    # Read the data for the language into dictionaries keyed on example_id,
    # which allows evaluating incomplete predictions.
    with open(gold_file_pattern.format(lang=language)) as f:
      gold_data: Dict[str, List[str]] = json.load(f)

    predictions: Dict[str, List[str]] = {}
    pred_path = pathlib.Path(pred_file_pattern.format(lang=language))
    if pred_path.exists():
      with open(pred_path) as f:
        predictions = json.load(f)

    mrr, unpredicted, unexpected = evaluate(
        gold_data=gold_data,
        predictions=predictions,
        k=k,
        return_count_diff=True)
    mrr_sum += mrr
    columns = [language, f"{mrr * 100:.2f}"]
    outputs.append("\t".join(columns))

    unpredicted_count += unpredicted
    unexpected_count += unexpected

  macro_avg = mrr_sum / len(MENTION_LANGUAGES)
  columns = ["MACRO_AVG", f"{macro_avg * 100:.2f}"]
  outputs.append("\t".join(columns))

  report_text = "\n".join(outputs)
  if output_path is None:
    print(report_text)
  else:
    with open(output_path, "w") as f:
      f.write(report_text + "\n")

  if unpredicted_count:
    print(f"Gold examples without predictions: {unpredicted_count}")
  if unexpected_count:
    print(f"Predicted examples without gold: {unexpected_count}")

  return macro_avg