mlx_lm_wrapper.py

# SPDX-License-Identifier: EUPL-1.2
"""Lighteval custom model backend — routes inference through mlx_lm.

Usage (CLI):
    lighteval custom \\
        "lthn/lemer" \\
        /Users/snider/Code/host-uk/core/.lek/lighteval_wrappers/mlx_lm_wrapper.py \\
        "mmlu_pro" \\
        --max-samples 10

Usage (Python API):
    from lighteval.models.custom.custom_model import CustomModelConfig
    config = CustomModelConfig(
        model_name="lthn/lemer",
        model_definition_file_path=".lek/lighteval_wrappers/mlx_lm_wrapper.py",
    )
    # Pipeline uses config.model_name as the HF repo ID passed to mlx_lm.load.

Design notes:
- Implements only ``greedy_until`` (generative). ``loglikelihood`` and
  ``loglikelihood_rolling`` raise NotImplementedError — generative tasks
  like MMLU-Pro (in lighteval's default config) don't use them.
- Uses Google's calibrated Gemma 4 sampling by default: temp=1.0, top_p=0.95,
  top_k=64. See reference_gemma4_sampling.md in the cladius memory.
- Supports ``num_samples > 1`` per Doc by generating N independent samples
  with the same sampler. 8-PAC methodology sets num_samples=8 at the task
  config level (via a task variant) and reads the resulting list of samples
  via ModelResponse.text.
- Max tokens defaults to 1024 if the Doc's ``generation_size`` is None,
  matching Google's stock Gemma 4 example. Override by setting
  ``generation_size`` on the task config.
"""

from typing import List

from lighteval.data import GenerativeTaskDataset
from lighteval.models.abstract_model import LightevalModel
from lighteval.models.model_output import ModelResponse
from lighteval.tasks.requests import Doc
from lighteval.utils.cache_management import SampleCache

from mlx_lm import load as mlx_load, generate as mlx_generate
from mlx_lm.sample_utils import make_sampler


# Google's calibrated Gemma 4 sampling — DO NOT change to greedy for eval.
# Greedy decoding measurably underperforms because Gemma 4 is trained for
# stochastic sampling; see reference_gemma4_sampling.md.
DEFAULT_TEMPERATURE = 1.0
DEFAULT_TOP_P = 0.95
DEFAULT_TOP_K = 64
DEFAULT_MAX_TOKENS = 4096  # <|think|> mode CoT on MMLU-Pro can run 2000-3500 tokens


class MLXLMModel(LightevalModel):
    """Lighteval custom backend that runs inference via mlx_lm on Apple Silicon.

    The ``config.model_name`` field is used as the HuggingFace repo ID (or
    local path) passed to ``mlx_lm.load``. Models must be in MLX format —
    use mlx-community conversions or run ``mlx_vlm.convert`` on a HF
    transformers checkpoint first.
    """

    def __init__(self, config) -> None:
        # LightevalModel's default __init__ takes no args (abstract base);
        # don't call super().__init__(config) — it will raise TypeError.
        self.config = config
        self.model_name = config.model_name
        print(f"[mlx_lm_wrapper] loading model: {self.model_name}")
        self._model, self._tokenizer = mlx_load(self.model_name)
        print(f"[mlx_lm_wrapper] model loaded")

        # Build the sampler once — Google's calibrated defaults.
        self._sampler = make_sampler(
            temp=DEFAULT_TEMPERATURE,
            top_p=DEFAULT_TOP_P,
            top_k=DEFAULT_TOP_K,
        )

        # Lighteval's pipeline expects a _cache on the model for memoisation.
        self._cache = SampleCache(config)

    @property
    def tokenizer(self):
        return self._tokenizer

    def tok_encode(self, text: str):
        return self._tokenizer.encode(text)

    @property
    def add_special_tokens(self) -> bool:
        return False

    @property
    def max_length(self) -> int:
        # Gemma 4 E2B/E4B: 128K; 31B and 26B MoE: 256K.
        # Generous default that fits all variants; tasks trim as needed.
        return 131072

    def greedy_until(self, requests: List[Doc]) -> List[ModelResponse]:
        """Generate text responses for a batch of prompts.

        Despite the name, this is NOT greedy decoding — it uses the Gemma 4
        calibrated sampler configured in __init__. Lighteval uses this method
        as the entry point for all generative tasks; actual sampling strategy
        is the model's choice.

        Note: Doc is a frozen dataclass, so we iterate requests directly
        rather than using GenerativeTaskDataset's splits_iterator (which
        mutates tokenized_context on each doc). Simple sequential loop; mlx_lm
        doesn't batch anyway.
        """
        results: List[ModelResponse] = []

        for r in requests:
            max_tokens = r.generation_size or DEFAULT_MAX_TOKENS
            n_samples = getattr(r, "num_samples", 1) or 1

            # CRITICAL: wrap the query in Gemma 4's chat template before
            # passing to mlx_lm. Without this, the model treats r.query as
            # raw text continuation rather than a user turn, and produces
            # degenerate completions (loops, prompt-echo, no CoT). The
            # tokenizer's apply_chat_template emits the proper turn markers.
            #
            # enable_thinking=True is LOAD-BEARING for LEK'd models. All
            # four Lemma family variants were LEK-2 trained with
            # enable_thinking=True, meaning the attractor basin is
            # conditioned on the <|think|> system anchor being present.
            # Running with enable_thinking=False forces the model into a
            # distribution it wasn't trained for — score drops, CoT style
            # degrades, answer quality falls. Base Gemma 4 supports
            # thinking natively too, so enabling it is fair both ways.
            messages = [{"role": "user", "content": r.query}]
            formatted_prompt = self._tokenizer.apply_chat_template(
                messages,
                tokenize=False,
                add_generation_prompt=True,
                enable_thinking=True,
            )
            input_tokens = self.tok_encode(formatted_prompt)

            # Generate N samples for this prompt. For n > 1, each sample
            # is independent — mlx_lm's sampler introduces stochasticity
            # via its internal PRNG state, so the same prompt produces
            # different outputs each call when sampling is active.
            samples: List[str] = []
            for _ in range(n_samples):
                output = mlx_generate(
                    self._model,
                    self._tokenizer,
                    prompt=formatted_prompt,
                    max_tokens=max_tokens,
                    sampler=self._sampler,
                    verbose=False,
                )
                samples.append(output)

            response = ModelResponse(
                text=samples,
                input_tokens=list(input_tokens),
                output_tokens=[[] for _ in samples],
                reasonings=[None for _ in samples],
                logprobs=[],
                argmax_logits_eq_gold=[],
            )
            results.append(response)

        return results

    def loglikelihood(self, requests: List[Doc]) -> List[ModelResponse]:
        """Not implemented — use generative metrics (e.g., maj_at_k) instead.

        For a full implementation, we would need to run a forward pass on
        ``context + continuation`` tokens and extract per-position log-probs
        from the logits at the continuation positions. mlx_lm's top-level
        API doesn't expose raw logits, so this requires direct model access
        via ``mlx_lm.utils.load``.
        """
        raise NotImplementedError(
            "mlx_lm_wrapper does not implement loglikelihood. "
            "Use a generative task variant with num_samples and maj_at_k."
        )

    def loglikelihood_rolling(self, requests: List[Doc]) -> List[ModelResponse]:
        """Not implemented — used for perplexity metrics we don't run."""
        raise NotImplementedError(
            "mlx_lm_wrapper does not implement loglikelihood_rolling. "
            "Perplexity-based metrics are not in our eval set."
        )