Upload folder using huggingface_hub

README.md

@@ -67,6 +67,7 @@ El resultado es una medida de **autoconocimiento del modelo**: no si es capaz de
 | `tasks.jsonl` | Las 14 tareas: `id`, `category`, `prompt`. |
 | `results.jsonl` | Una fila por par (modelo, tarea): estimación, tokens reales, texto completo de la respuesta, error si lo hubo. |
 | `estimate_bench.py` | El código exacto del runner para reproducir o extender el benchmark. |
+| `lm_eval_tasks/` | Adaptación del benchmark como tarea de [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) (ver su README). |
 
 Esquema de `results.jsonl`:
 
@@ -93,6 +94,15 @@ python estimate_bench.py --model openai/gpt-4o-mini --model qwen/qwen3-max
 
 El runner funciona con cualquier endpoint compatible con la API de OpenAI (OpenRouter por defecto). Cada par (modelo, tarea) hace dos llamadas independientes con temperatura 0: la de estimación (con la instrucción de no resolver la tarea) y la de ejecución (la tarea a secas). Los tokens reales son `usage.completion_tokens` devuelto por la API.
 
+También puedes correrlo como tarea de lm-evaluation-harness (ver `lm_eval_tasks/README.md`):
+
+```bash
+pip install "lm-eval[api]" transformers
+lm_eval --model local-chat-completions \
+  --model_args "model=qwen/qwen3-max,base_url=https://openrouter.ai/api/v1/chat/completions,tokenizer=Qwen/Qwen2.5-7B-Instruct" \
+  --apply_chat_template --tasks estimate_bench --include_path lm_eval_tasks
+```
+
 ## Limitaciones
 
 - **Una muestra por celda**: cada par (modelo, tarea) se ejecutó una vez (temperatura 0); la longitud real puede variar entre ejecuciones.

lm_eval_tasks/README.md

@@ -0,0 +1,47 @@
+# estimate-bench como tarea de lm-evaluation-harness
+
+Adaptación del benchmark para el [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) de EleutherAI.
+
+Por cada tarea se emiten **dos generaciones**: una de estimación (el modelo
+predice los tokens de su propia respuesta sin resolverla) y una de ejecución.
+Se comparan y se agregan cuatro métricas:
+
+| métrica | significado | mejor |
+|---|---|---|
+| `mape` | error porcentual medio estimado vs real | menor |
+| `log2_ratio` (agregado como `bias_agg`) | sesgo: factor medio estimado/real (1.0 = perfecto) | cercano a 1 |
+| `within_2x` | % de tareas con estimación entre 0.5x y 2x de la realidad | mayor |
+| `pair` (agregado como `spearman_agg`) | correlación de rangos estimado vs real | mayor |
+
+## Uso
+
+```bash
+pip install "lm-eval[api]" transformers
+
+# con cualquier endpoint OpenAI-compatible de chat (OpenRouter, vLLM, etc.)
+export OPENAI_API_KEY=sk-or-...
+lm_eval \
+  --model local-chat-completions \
+  --model_args "model=qwen/qwen3-max,base_url=https://openrouter.ai/api/v1/chat/completions,num_concurrent=4,tokenizer=Qwen/Qwen2.5-7B-Instruct" \
+  --apply_chat_template \
+  --tasks estimate_bench \
+  --include_path lm_eval_tasks \
+  --output_path results/
+```
+
+Notas:
+
+- `local-chat-completions` (no `local-completions`) es la clase para endpoints de chat.
+- `tokenizer=` solo se usa internamente para plantillas de chat; cualquier tokenizer de HF con chat template sirve.
+- Verificado end-to-end con `lm_eval 0.4.13` y OpenRouter.
+
+## Diferencias con el runner original (`estimate_bench.py`)
+
+- **Los tokens "reales" son una aproximación**: la API del harness no expone
+  `usage.completion_tokens`, así que la longitud real se estima tokenizando la
+  respuesta (~0.75 palabras/token). El runner original usa el conteo exacto
+  de la API.
+- Los modelos con razonamiento oculto (Kimi K2, o-series, R1) devuelven por
+  la API de chat solo el texto final: su razonamiento **no** se cuenta aquí,
+  mientras que en el runner original sí (va incluido en `completion_tokens`).
+  Los números de ambas vías no son directamente comparables para razonadores.

lm_eval_tasks/estimate_bench/estimate_bench.yaml

@@ -0,0 +1,29 @@
+task: estimate_bench
+class: !function task.EstimateBenchTask
+dataset_path: json
+dataset_kwargs:
+  data_files:
+    validation: tasks.jsonl
+test_split: null
+validation_split: validation
+doc_to_text: "{{prompt}}"
+doc_to_target: "0"
+output_type: generate_until
+generation_kwargs:
+  temperature: 0
+  until: []
+metric_list:
+  - metric: est_mape
+    aggregation: est_mape
+    higher_is_better: false
+  - metric: est_log2_ratio
+    aggregation: est_bias
+    higher_is_better: false
+  - metric: est_within_2x
+    aggregation: est_within_2x
+    higher_is_better: true
+  - metric: est_pair
+    aggregation: est_spearman
+    higher_is_better: true
+metadata:
+  version: 0.1

lm_eval_tasks/estimate_bench/task.py

@@ -0,0 +1,186 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# estimate-bench — Copyright (C) 2026 David Coronel
+"""Tarea estimate-bench para lm-evaluation-harness.
+
+Mide la autoestimación de tokens de salida: por cada documento se emiten DOS
+peticiones de generación —una de estimación (predecir los tokens de la propia
+respuesta, sin resolver la tarea) y una de ejecución (resolverla)— y se
+comparan. Los "tokens reales" se cuentan tokenizando la respuesta generada
+(la API del harness no expone usage.completion_tokens), así que son una
+aproximación al tokenizer del modelo evaluado.
+
+Métricas agregadas: MAPE, sesgo (factor), % dentro de 2x y Spearman.
+"""
+
+import json
+import math
+import re
+import statistics
+from pathlib import Path
+
+from lm_eval.api.instance import Instance
+from lm_eval.api.registry import (register_aggregation, register_metric)
+from lm_eval.api.task import ConfigurableTask
+from lm_eval.models.api_models import JsonChatStr
+
+ESTIMATE_INSTRUCTION = (
+    "You will be given a task. Do NOT solve the task.\n"
+    "Instead, estimate how many tokens your own response would contain if you "
+    "did solve it.\n"
+    "Respond with a single integer and nothing else.\n\n"
+    "Task:\n\"\"\"\n{prompt}\n\"\"\""
+)
+
+
+def parse_estimate(text: str) -> int | None:
+    m = re.search(r'"estimated_tokens"\s*:\s*([\d,]+)', text)
+    if m:
+        return int(m.group(1).replace(",", ""))
+    nums = re.findall(r"[\d][\d,]*", text)
+    return int(nums[-1].replace(",", "")) if nums else None
+
+
+def _tokens(text: str) -> int:
+    """Aproximación de tokens sin acceso al tokenizer del modelo.
+
+    ~0.75 palabras/token es la media habitual en inglés para tokenizers BPE;
+    se documenta como limitación de la adaptación al harness.
+    """
+    return max(1, round(len(text.split()) / 0.75))
+
+
+class EstimateBenchTask(ConfigurableTask):
+    def __init__(self, config=None):
+        # el factory de lm-eval deja la clave "class" dentro del config
+        config = dict(config or {})
+        config.pop("class", None)
+        super().__init__(config=config)
+
+    def build_all_requests(self, *, limit=None, samples=None, rank=0,
+                           world_size=1, apply_chat_template=False, **kwargs):
+        # 2 instancias por documento: idx 0 = estimación, idx 1 = ejecución;
+        # el evaluator las agrupa por doc_id y las ordena por idx
+        def ctx(text: str):
+            # los modelos de chat de la API esperan los mensajes como
+            # JsonChatStr (JSON con list[dict]); modelos de texto plano, str
+            if apply_chat_template:
+                return JsonChatStr(prompt=json.dumps(
+                    [{"role": "user", "content": text}]))
+            return text
+
+        self._instances = []
+        for doc_id, doc in self.doc_iterator(rank=rank, limit=limit,
+                                             world_size=world_size,
+                                             samples=samples):
+            self._instances.append(Instance(
+                request_type="generate_until",
+                doc=doc,
+                arguments=(ctx(ESTIMATE_INSTRUCTION.format(prompt=doc["prompt"])),
+                           {"max_gen_toks": 64, "temperature": 0}),
+                idx=0,
+                metadata=(self.config.task, doc_id, 1),
+            ))
+            self._instances.append(Instance(
+                request_type="generate_until",
+                doc=doc,
+                arguments=(ctx(doc["prompt"]),
+                           {"max_gen_toks": 2048, "temperature": 0}),
+                idx=1,
+                metadata=(self.config.task, doc_id, 1),
+            ))
+
+    def process_results(self, doc, results):
+        # results llegan en orden de idx: [estimación, ejecución]
+        est_text = results[0][0] if isinstance(results[0], (list, tuple)) else results[0]
+        answer = results[1][0] if isinstance(results[1], (list, tuple)) else results[1]
+        est = parse_estimate(est_text or "")
+        actual = _tokens(answer or "")
+        if not est or not actual:
+            return {"est_mape": None, "est_log2_ratio": None,
+                    "est_within_2x": None, "est_pair": None}
+        return {
+            "est_mape": abs(est - actual) / actual,
+            "est_log2_ratio": math.log2(max(est, 1) / actual),
+            "est_within_2x": 1.0 if 0.5 <= est / actual <= 2 else 0.0,
+            "est_pair": (est, actual),
+        }
+
+
+# --- funciones de agregación (referenciadas desde el YAML) -------------------
+
+def _valid(items):
+    return [x for x in items if x is not None]
+
+
+@register_aggregation("est_mape")
+def mape_agg(items):
+    items = _valid(items)
+    return statistics.mean(items) if items else float("nan")
+
+
+@register_aggregation("est_bias")
+def bias_agg(items):
+    items = _valid(items)
+    return 2 ** statistics.mean(items) if items else float("nan")
+
+
+@register_aggregation("est_within_2x")
+def within_2x_agg(items):
+    items = _valid(items)
+    return statistics.mean(items) if items else float("nan")
+
+
+@register_aggregation("est_spearman")
+def spearman_agg(items):
+    items = _valid(items)
+    if len(items) < 3:
+        return float("nan")
+    est = [p[0] for p in items]
+    act = [p[1] for p in items]
+
+    def rank(v):
+        order = sorted(range(len(v)), key=lambda i: v[i])
+        ranks = [0.0] * len(v)
+        i = 0
+        while i < len(v):
+            j = i
+            while j + 1 < len(v) and v[order[j + 1]] == v[order[i]]:
+                j += 1
+            for k in range(i, j + 1):
+                ranks[order[k]] = (i + j) / 2 + 1
+            i = j + 1
+        return ranks
+
+    rx, ry = rank(est), rank(act)
+    mx, my = statistics.mean(rx), statistics.mean(ry)
+    cov = sum((a - mx) * (b - my) for a, b in zip(rx, ry))
+    vx = sum((a - mx) ** 2 for a in rx)
+    vy = sum((b - my) ** 2 for b in ry)
+    return cov / math.sqrt(vx * vy) if vx and vy else float("nan")
+
+
+# Registro de los nombres de métrica para que lm-eval no los busque en el
+# registro global ni en HF Evaluate. Las funciones per-doc no se llaman
+# nunca: los valores los calcula EstimateBenchTask.process_results.
+@register_metric(metric="est_mape", higher_is_better=False,
+                 aggregation="est_mape")
+def _metric_mape(references, predictions):
+    raise NotImplementedError
+
+
+@register_metric(metric="est_log2_ratio", higher_is_better=False,
+                 aggregation="est_bias")
+def _metric_log2_ratio(references, predictions):
+    raise NotImplementedError
+
+
+@register_metric(metric="est_within_2x", higher_is_better=True,
+                 aggregation="est_within_2x")
+def _metric_within_2x(references, predictions):
+    raise NotImplementedError
+
+
+@register_metric(metric="est_pair", higher_is_better=True,
+                 aggregation="est_spearman")
+def _metric_pair(references, predictions):
+    raise NotImplementedError

lm_eval_tasks/estimate_bench/tasks.jsonl

@@ -0,0 +1,14 @@
+{"id": "factual-short", "category": "qa", "prompt": "What is the capital of Australia? Answer with a single word."}
+{"id": "definition", "category": "qa", "prompt": "Define the term \"photosynthesis\" in one sentence."}
+{"id": "list-20", "category": "generation", "prompt": "List 20 European capitals, one per line, with no extra commentary."}
+{"id": "poem", "category": "generation", "prompt": "Write a haiku about autumn rain."}
+{"id": "essay-500", "category": "long-form", "prompt": "Write an essay of approximately 500 words on the main causes of World War I."}
+{"id": "code-small", "category": "code", "prompt": "Write a Python function that checks whether a string is a palindrome. Include a docstring and two example calls."}
+{"id": "code-lru", "category": "code", "prompt": "Implement an LRU cache in Python with O(1) get and put operations. Use type hints and include a short usage example."}
+{"id": "math-short", "category": "math", "prompt": "Compute 17 * 23. Show your steps briefly."}
+{"id": "math-word", "category": "math", "prompt": "A train travels 300 km in 2.5 hours, then 180 km in 1.5 hours. What is its average speed for the whole journey? Explain your reasoning step by step."}
+{"id": "translation", "category": "translation", "prompt": "Translate the following paragraph into French: \"The library was quiet except for the soft rustling of pages. Outside, the rain traced silver lines down the windows, and the smell of old paper filled the air.\""}
+{"id": "summarize", "category": "summarization", "prompt": "Summarize the following passage in exactly 3 bullet points: \"The Industrial Revolution, beginning in Britain in the late 18th century, transformed economies that had been based on agriculture and handicrafts into economies based on large-scale industry, mechanized manufacturing, and the factory system. New machines, new power sources, and new ways of organizing work made existing industries more productive and efficient. The textile industry was among the first to use modern production methods. The revolution spread to other parts of Europe and North America over the following decades, and its social consequences included urbanization, the growth of a working class, and new patterns of labor that still shape modern life.\""}
+{"id": "json-extract", "category": "extraction", "prompt": "Extract structured data from this text and return ONLY valid JSON with keys name, role, company, start_year: \"Maria Chen joined Orbital Dynamics as a senior propulsion engineer in 2019, after five years at a rival firm.\""}
+{"id": "table-50", "category": "generation", "prompt": "Generate a markdown table of all 50 US states with their capital city and approximate population."}
+{"id": "explain-technical", "category": "long-form", "prompt": "Explain how a transformer neural network works, in technical detail, covering attention, positional encodings, and training. Aim for roughly 800 words."}