{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5044b4e9",
   "metadata": {},
   "source": [
    "# Models Comparison in the Calculation Domain\n",
    "\n",
    "We compare math models on the test set of the `pymlex/calculator` benchmark. The models are:\n",
    "\n",
    "- `Qwen/Qwen2.5-Math-7B-Instruct`,\n",
    "- `Qwen/Qwen2.5-Math-1.5B-Instruct`.\n",
    "\n",
    "For each model we compute exact-match accuracy broken down by the number of computation steps, generate a benchmark YAML file compatible with the Hugging Face Hub, and pick the best using a difficulty-weighted score that penalizes poor performance on longer chains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75aa6b01",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip install -U transformers datasets huggingface_hub pandas matplotlib nvidia-ml-py sentencepiece protobuf safetensors accelerate bitsandbytes scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92ae9a4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import json\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import time\n",
    "from pathlib import Path\n",
    "from datetime import date\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import pynvml\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b0ba9b67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU: NVIDIA GeForce RTX 5090\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig\n",
    "\n",
    "MAX_TOKES = 4096\n",
    "seed = 3407\n",
    "dataset_id = os.environ.get(\"CALC_BENCH_DATASET\", \"pymlex/calculator\")\n",
    "run_dir = Path(\"./teacher_compare_run\")\n",
    "run_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()\n",
    "pynvml.nvmlInit()\n",
    "print(\"GPU:\", torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "model_ids = [\n",
    "    \"Qwen/Qwen2.5-Math-1.5B-Instruct\",\n",
    "    \"Qwen/Qwen2.5-Math-7B-Instruct\",\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c081a6cf-6ae1-423a-84e4-f0a91151a4c7",
   "metadata": {},
   "source": [
    "The system prompt is taken from the official page of the models on HF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b76033a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "SYSTEM_PROMPT = \"Please reason step by step, and put your final answer within \\\\boxed{}.\"\n",
    "\n",
    "number_re = re.compile(r\"-?\\d+(?:,\\d{3})*(?:\\.\\d+)?\")\n",
    "boxed_re = re.compile(r\"\\\\boxed\\{([^}]+)\\}\", re.S)\n",
    "\n",
    "def canonicalize_answer(text):\n",
    "    s = str(text).strip().replace(\",\", \"\").replace(\"$\", \"\")\n",
    "    s = s.replace(\" \", \"\")\n",
    "    if s.endswith(\".0\"):\n",
    "        s = s[:-2]\n",
    "    if s.endswith(\".\"):\n",
    "        s = s[:-1]\n",
    "    return s\n",
    "\n",
    "def extract_gold_answer(answer_value):\n",
    "    return canonicalize_answer(answer_value)\n",
    "\n",
    "def extract_pred_answer(text):\n",
    "    matches = boxed_re.findall(text)\n",
    "    if matches:\n",
    "        return canonicalize_answer(matches[-1].strip())\n",
    "    nums = number_re.findall(text.replace(\",\", \"\"))\n",
    "    if nums:\n",
    "        return canonicalize_answer(nums[-1])\n",
    "    return canonicalize_answer(text)\n",
    "\n",
    "def build_prompt(tokenizer, prompt):\n",
    "    messages = [\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
    "        {\"role\": \"user\", \"content\": prompt.strip()},\n",
    "    ]\n",
    "    return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
    "\n",
    "def load_model_and_tokenizer(model_id):\n",
    "    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)\n",
    "    tokenizer.padding_side = \"left\"\n",
    "    if tokenizer.pad_token is None:\n",
    "        tokenizer.pad_token = tokenizer.eos_token\n",
    "\n",
    "    model = AutoModelForCausalLM.from_pretrained(\n",
    "        model_id,\n",
    "        device_map=\"auto\",\n",
    "        torch_dtype=torch.bfloat16 if bf16 else torch.float16,\n",
    "        trust_remote_code=True,\n",
    "        low_cpu_mem_usage=True,\n",
    "        attn_implementation=\"sdpa\",\n",
    "    )\n",
    "    model.generation_config.pad_token_id = tokenizer.pad_token_id\n",
    "    model.eval()\n",
    "    return model, tokenizer\n",
    "\n",
    "def generate_batch(model, tokenizer, prompts, max_new_tokens=MAX_TOKES):\n",
    "    device = next(model.parameters()).device\n",
    "    inputs = tokenizer(prompts, return_tensors=\"pt\", padding=True, truncation=True).to(device)\n",
    "    prompt_len = inputs[\"input_ids\"].shape[1]\n",
    "    with torch.inference_mode():\n",
    "        outputs = model.generate(\n",
    "            **inputs,\n",
    "            max_new_tokens=max_new_tokens,\n",
    "            do_sample=False,\n",
    "            eos_token_id=tokenizer.eos_token_id,\n",
    "            pad_token_id=tokenizer.pad_token_id,\n",
    "        )\n",
    "    decoded = []\n",
    "    for i in range(outputs.size(0)):\n",
    "        text = tokenizer.decode(outputs[i][prompt_len:], skip_special_tokens=False)\n",
    "        decoded.append(text)\n",
    "    return decoded\n",
    "\n",
    "def evaluate_exact_match(model, tokenizer, dataset, batch_size=4, max_new_tokens=MAX_TOKES):\n",
    "    rows = []\n",
    "    correct = 0\n",
    "    for start in tqdm(range(0, len(dataset), batch_size)):\n",
    "        batch = dataset.select(range(start, min(start + batch_size, len(dataset))))\n",
    "        prompts = [build_prompt(tokenizer, x) for x in batch[\"prompt\"]]\n",
    "        decoded = generate_batch(model, tokenizer, prompts, max_new_tokens=max_new_tokens)\n",
    "        for prompt_text, gold_answer_value, pred_text, steps in zip(batch[\"prompt\"], batch[\"answer\"], decoded, batch[\"steps\"]):\n",
    "            pred = extract_pred_answer(pred_text)\n",
    "            gold = extract_gold_answer(gold_answer_value)\n",
    "            is_correct = int(pred == gold)\n",
    "            correct += is_correct\n",
    "            rows.append({\n",
    "                \"prompt\": prompt_text,\n",
    "                \"gold_answer\": gold,\n",
    "                \"pred_answer\": pred,\n",
    "                \"correct\": is_correct,\n",
    "                \"pred_text\": pred_text,\n",
    "                \"steps\": int(steps),\n",
    "            })\n",
    "    df = pd.DataFrame(rows)\n",
    "    return df, correct / len(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "348876a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8f853b7844254a65be3698def9997779",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "README.md: 0.00B [00:00, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d18d60f9e32143ed8ed2793523b5e485",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "data/train-00000-of-00001.parquet:   0%|          | 0.00/4.98M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d488d1a6ed1a423b85f3c2d2ccd7d30d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "data/validation-00000-of-00001.parquet:   0%|          | 0.00/258k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "11b46655148140d683385238ac1fe7af",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "data/test-00000-of-00001.parquet:   0%|          | 0.00/1.01M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "002a66fa5a1a4b569dbd518b41b78455",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c76ceac6d72b45b1bbcf11e6c4c0951a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating validation split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e360177372344dd8a724b33830c53cac",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating test split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset({\n",
      "    features: ['prompt', 'completion', 'answer', 'expression', 'steps', 'text'],\n",
      "    num_rows: 3000\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "raw = load_dataset(dataset_id)\n",
    "test_ds = raw[\"test\"]\n",
    "print(test_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6d0c3f4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========================================================================================================================\n",
      "Loading Qwen/Qwen2.5-Math-1.5B-Instruct\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[transformers] `torch_dtype` is deprecated! Use `dtype` instead!\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b4f80675c73a44f69605b14cba7561c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading weights:   0%|          | 0/338 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1e680b025801409b8c5a846fc03522af",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/150 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[transformers] This is a friendly reminder - the current text generation call has exceeded the model's predefined maximum length (4096). Depending on the model, you may observe exceptions, performance degradation, or nothing at all.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========================================================================================================================\n",
      "Loading Qwen/Qwen2.5-Math-7B-Instruct\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dac9ac3ec6b14c17834536be3f318a0b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading weights:   0%|          | 0/339 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf99ad514bfa457981c566621f5c4dc2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/150 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_dfs = []\n",
    "\n",
    "for model_id in model_ids:\n",
    "    print(\"=\" * 120)\n",
    "    print(\"Loading\", model_id)\n",
    "    started = time.time()\n",
    "\n",
    "    model, tokenizer = load_model_and_tokenizer(model_id)\n",
    "    df, overall_acc = evaluate_exact_match(\n",
    "        model,\n",
    "        tokenizer,\n",
    "        test_ds,\n",
    "        batch_size=20,\n",
    "    )\n",
    "    df[\"model_id\"] = model_id\n",
    "    all_dfs.append(df)\n",
    "\n",
    "    step_acc = df.groupby(\"steps\")[\"correct\"].mean().sort_index()\n",
    "    weighted_score = sum(step_acc.get(step, 0.0) * step for step in range(1, 16)) / sum(range(1, 16))\n",
    "    acc_ge_8 = float(df[df[\"steps\"] >= 8][\"correct\"].mean())\n",
    "\n",
    "    safe_name = model_id.replace(\"/\", \"__\")\n",
    "    df.to_csv(run_dir / f\"{safe_name}.csv\", index=False)\n",
    "\n",
    "    del model\n",
    "    del tokenizer\n",
    "    torch.cuda.empty_cache()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4588af4f-0f16-4158-83d4-848c81bb7692",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "combined = pd.concat(all_dfs, ignore_index=True)\n",
    "pivot = combined.pivot_table(index=\"steps\", columns=\"model_id\", values=\"correct\", aggfunc=\"mean\").sort_index()\n",
    "\n",
    "ax = pivot.plot(kind=\"bar\", figsize=(10, 5))\n",
    "ax.set_title(\"Exact match by step on test split\")\n",
    "ax.set_xlabel(\"steps\")\n",
    "ax.set_ylabel(\"accuracy\")\n",
    "ax.set_ylim(0, 1)\n",
    "ax.legend(loc=\"upper right\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(run_dir / \"teacher_step_comparison.png\", dpi=180)\n",
    "plt.show()\n",
    "\n",
    "summary_rows = []\n",
    "for model_id in model_ids:\n",
    "    mdf = combined[combined[\"model_id\"] == model_id]\n",
    "    overall_acc = mdf[\"correct\"].mean()\n",
    "    weighted_score = sum(\n",
    "        mdf[mdf[\"steps\"] == s][\"correct\"].mean() * (s ** 2) for s in range(1, 16)\n",
    "    ) / sum(s ** 2 for s in range(1, 16))\n",
    "    summary_rows.append({\n",
    "        \"model_id\": model_id,\n",
    "        \"overall_acc\": overall_acc,\n",
    "        \"weighted_score\": weighted_score,\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "51d66f0f-786a-4e50-9f4e-30f0cdbdc6d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BEST_TEACHER = Qwen/Qwen2.5-Math-7B-Instruct\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model_id</th>\n",
       "      <th>overall_acc</th>\n",
       "      <th>weighted_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Qwen/Qwen2.5-Math-7B-Instruct</td>\n",
       "      <td>0.803667</td>\n",
       "      <td>0.651044</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Qwen/Qwen2.5-Math-1.5B-Instruct</td>\n",
       "      <td>0.758333</td>\n",
       "      <td>0.571052</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          model_id  overall_acc  weighted_score\n",
       "1    Qwen/Qwen2.5-Math-7B-Instruct     0.803667        0.651044\n",
       "0  Qwen/Qwen2.5-Math-1.5B-Instruct     0.758333        0.571052"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary = pd.DataFrame(summary_rows).sort_values([\"weighted_score\", \"overall_acc\"], ascending=False)\n",
    "print(\"BEST_TEACHER =\", summary.iloc[0][\"model_id\"])\n",
    "summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d7b6075e-a8a2-43a7-8802-0837866ea35a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import cm\n",
    "\n",
    "for model_id in model_ids:\n",
    "    mdf = combined[combined[\"model_id\"] == model_id].copy()\n",
    "    mdf[\"pred_text_len\"] = mdf[\"pred_text\"].astype(str).str.len()\n",
    "    steps_list = sorted(mdf[\"steps\"].unique())\n",
    "    colors = cm.plasma([s / max(steps_list) for s in steps_list])\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    for i, step in enumerate(steps_list):\n",
    "        subset = mdf[mdf[\"steps\"] == step]\n",
    "        if not subset.empty:\n",
    "            plt.hist(subset[\"pred_text_len\"], alpha=0.3, label=f\"Steps {step}\",\n",
    "                     density=True, color=colors[i], bins=20)\n",
    "    plt.title(f\"Distribution of pred_text length by steps - {model_id}\")\n",
    "    plt.xlabel(\"Length of pred_text\")\n",
    "    plt.ylabel(\"Density\")\n",
    "    plt.legend(loc=\"upper right\", bbox_to_anchor=(1.15, 1))\n",
    "    plt.grid(axis=\"y\", alpha=0.5)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(run_dir / f\"pred_len_by_steps_{model_id.replace('/', '__')}.png\", dpi=180)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a5e45581-1189-412d-8946-6a1453fad82a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 4))\n",
    "len_stats_rows = []\n",
    "for model_id in model_ids:\n",
    "    mdf = combined[combined[\"model_id\"] == model_id]\n",
    "    lengths = mdf[\"pred_text\"].astype(str).str.len()\n",
    "    plt.hist(lengths, alpha=0.5, label=model_id, bins=110, density=True)\n",
    "    median_val = lengths.median()\n",
    "    mode_val = lengths.mode().iloc[0] if not lengths.mode().empty else None\n",
    "    var_val = lengths.var()\n",
    "    len_stats_rows.append({\n",
    "        \"model_id\": model_id,\n",
    "        \"median\": median_val,\n",
    "        \"mode\": mode_val,\n",
    "        \"variance\": var_val,\n",
    "    })\n",
    "plt.title(\"Overall distribution of pred_text length (all models)\")\n",
    "plt.xlabel(\"Length of pred_text\")\n",
    "plt.ylabel(\"Density\")\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.grid(axis=\"y\", alpha=0.5)\n",
    "plt.tight_layout()\n",
    "plt.savefig(run_dir / \"pred_len_all_models.png\", dpi=180)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "46df0549",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model_id</th>\n",
       "      <th>median</th>\n",
       "      <th>mode</th>\n",
       "      <th>variance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Qwen/Qwen2.5-Math-1.5B-Instruct</td>\n",
       "      <td>3143.5</td>\n",
       "      <td>1343</td>\n",
       "      <td>1.133512e+08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Qwen/Qwen2.5-Math-7B-Instruct</td>\n",
       "      <td>3327.0</td>\n",
       "      <td>2039</td>\n",
       "      <td>5.541721e+07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          model_id  median  mode      variance\n",
       "0  Qwen/Qwen2.5-Math-1.5B-Instruct  3143.5  1343  1.133512e+08\n",
       "1    Qwen/Qwen2.5-Math-7B-Instruct  3327.0  2039  5.541721e+07"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len_stats = pd.DataFrame(len_stats_rows)\n",
    "len_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0a685fef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CommitInfo(commit_url='https://huggingface.co/datasets/pymlex/calculator/commit/f1f86b78f24ecbfc30fd81b1fdde043a1ef3d847', commit_message='Register as benchmark dataset', commit_description='', oid='f1f86b78f24ecbfc30fd81b1fdde043a1ef3d847', pr_url=None, repo_url=RepoUrl('https://huggingface.co/datasets/pymlex/calculator', endpoint='https://huggingface.co', repo_type='dataset', repo_id='pymlex/calculator'), pr_revision=None, pr_num=None)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from huggingface_hub import login, HfApi\n",
    "\n",
    "login()\n",
    "\n",
    "eval_yaml = \"\"\"name: Calculator\n",
    "description: \"Multi-step arithmetic with nested brackets. Models must reason step-by-step and output a single numeric answer.\"\n",
    "evaluation_framework: \"math-arena\"\n",
    "tasks:\n",
    "  - id: calculator_test\n",
    "    config: default\n",
    "    split: test\n",
    "\"\"\"\n",
    "\n",
    "api = HfApi()\n",
    "api.upload_file(\n",
    "    path_or_fileobj=eval_yaml.encode(\"utf-8\"),\n",
    "    path_in_repo=\"eval.yaml\",\n",
    "    repo_id=\"pymlex/calculator\",\n",
    "    repo_type=\"dataset\",\n",
    "    commit_message=\"Register as benchmark dataset\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e00d1de-8e73-4b6a-8379-d974d770d2f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for model_id in model_ids:\n",
    "    overall = acc_dict[model_id]\n",
    "    yaml_text = f\"\"\"- dataset:\n",
    "    id: pymlex/calculator\n",
    "    task_id: calculator_test\n",
    "  value: {overall:.6f}\n",
    "  date: \"{date.today().isoformat()}\"\n",
    "\"\"\"\n",
    "    api.upload_file(\n",
    "        path_or_fileobj=yaml_text.encode(\"utf-8\"),\n",
    "        path_in_repo=\".eval_results/calculator.yaml\",\n",
    "        repo_id=model_id,\n",
    "        repo_type=\"model\",\n",
    "        commit_message=\"Add Calculator benchmark result\",\n",
    "        create_pr=True,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "85f27da0-127f-47ae-88d7-1249543d75c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "McNemar statistic (with Yates correction): 30.5789\n",
      "p-value: 3.2056783116907184e-08\n",
      "The difference is statistically significant at the 0.05 level.\n",
      "Contingency table (rows: model A, cols: model B):\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>correct_b</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>correct_a</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>359</td>\n",
       "      <td>230</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>366</td>\n",
       "      <td>2045</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "correct_b    0     1\n",
       "correct_a           \n",
       "0          359   230\n",
       "1          366  2045"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import chi2\n",
    "import pandas as pd\n",
    "\n",
    "model_a = \"Qwen/Qwen2.5-Math-7B-Instruct\"\n",
    "model_b = \"Qwen/Qwen2.5-Math-1.5B-Instruct\"\n",
    "\n",
    "df_a = combined[combined[\"model_id\"] == model_a][[\"prompt\", \"correct\"]].copy()\n",
    "df_b = combined[combined[\"model_id\"] == model_b][[\"prompt\", \"correct\"]].copy()\n",
    "\n",
    "paired = df_a.merge(df_b, on=\"prompt\", suffixes=(\"_a\", \"_b\"))\n",
    "\n",
    "contingency = pd.crosstab(paired[\"correct_a\"], paired[\"correct_b\"])\n",
    "\n",
    "b = int(contingency.loc[1, 0]) if (1 in contingency.index and 0 in contingency.columns) else 0\n",
    "c = int(contingency.loc[0, 1]) if (0 in contingency.index and 1 in contingency.columns) else 0\n",
    "\n",
    "stat = (abs(b - c) - 1) ** 2 / (b + c) if (b + c) > 0 else 0.0\n",
    "p_value = 1.0 - chi2.cdf(stat, 1)\n",
    "\n",
    "print(f\"\\nMcNemar statistic (with Yates correction): {stat:.4f}\")\n",
    "print(f\"p-value: {p_value}\")\n",
    "if p_value < 0.05:\n",
    "    print(\"The difference is statistically significant at the 0.05 level.\")\n",
    "else:\n",
    "    print(\"No statistically significant difference detected (p >= 0.05).\")\n",
    "\n",
    "print(\"Contingency table (rows: model A, cols: model B):\")\n",
    "display(contingency)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}