Score 1.6-3.1B models: SmolLM3-3B, Qwen3.5-2B, LFM3-1.7B, granite-1B

bench_deeparithmark.py

@@ -29,8 +29,10 @@ Usage
 from __future__ import annotations
 
 import argparse
+import functools
 import gc
 import hashlib
+import inspect
 import json
 import math
 import time
@@ -42,6 +44,72 @@ import torch.nn.functional as F
 from huggingface_hub import hf_hub_download
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
+# Some 2026 checkpoints ship remote modelling code written against transformers 4.x
+# (e.g. LiquidAI/LFM3, which decorates its convolution with a hub-kernel helper).
+# transformers 5 removed that helper, so the import fails before the model can load.
+# The decorator only swaps in an optional fused CUDA kernel; stubbing it out leaves
+# the pure-torch path, which is the same maths at the same dtype.
+def _accepts_layer_idx(fn) -> bool:
+    try:
+        return "layer_idx" in inspect.signature(fn).parameters
+    except (TypeError, ValueError):
+        return True
+
+
+def _install_kernel_decorator_shim() -> None:
+    try:
+        import transformers.integrations as ti
+
+        if not hasattr(ti, "use_kernel_func_from_hub_with_fallback"):
+            def _noop(*_args, **_kwargs):
+                return lambda fn: fn
+
+            ti.use_kernel_func_from_hub_with_fallback = _noop
+
+        import transformers.integrations.accelerate as tia
+
+        if not hasattr(tia, "force_accelerate_hooks"):
+            def _noop_hooks(*_args, **_kwargs):
+                return lambda fn: fn
+
+            tia.force_accelerate_hooks = _noop_hooks
+
+        import transformers.masking_utils as tmu
+
+        if not hasattr(tmu, "create_recurrent_attention_mask"):
+            # transformers 4.x used this to hand a conv/linear-attention layer the plain
+            # 2-D padding mask (1 = real token). It was deleted in 5.x; the contiguity
+            # logic LFM3 needs on top of it (`seq_idx`) is computed in the model itself.
+            def _recurrent_mask(config=None, inputs_embeds=None, attention_mask=None,
+                                past_key_values=None, position_ids=None, layer_idx=None,
+                                **_kwargs):
+                if attention_mask is None:
+                    return None
+                return attention_mask.to(torch.bool) if attention_mask.dtype != torch.bool else attention_mask
+
+            tmu.create_recurrent_attention_mask = _recurrent_mask
+
+        if not _accepts_layer_idx(tmu.create_causal_mask):
+            # 5.5 picks the layer's mask from the hybrid cache itself, so the explicit
+            # `layer_idx` LFM3 passes is redundant rather than meaningful: drop it.
+            def _wrap_drop_layer_idx(fn):
+                @functools.wraps(fn)
+                def wrapper(*args, layer_idx=None, **kwargs):
+                    del layer_idx
+                    return fn(*args, **kwargs)
+
+                return wrapper
+
+            tmu.create_causal_mask = _wrap_drop_layer_idx(tmu.create_causal_mask)
+            tmu.create_sliding_window_causal_mask = _wrap_drop_layer_idx(
+                tmu.create_sliding_window_causal_mask
+            )
+    except Exception:  # an old transformers that has the real helper is fine too
+        pass
+
+
+_install_kernel_decorator_shim()
+
 # Our own data is read from disk; this repo is not published under AxiomicLabs.
 DATA_DEFAULT = "deeparithmark-dataset/data/deeparithmark-1.jsonl"
 # The one AxiomicLabs reference that must stay: `--compare` downloads the upstream