failed run queue_fontfill__exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43

queue_fontfill__exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43.ipynb

@@ -0,0 +1,1395 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6ac12115",
+   "metadata": {
+    "tags": [
+     "papermill-error-cell-tag"
+    ]
+   },
+   "source": [
+    "<span style=\"color:red; font-family:Helvetica Neue, Helvetica, Arial, sans-serif; font-size:2em;\">An Exception was encountered at '<a href=\"#papermill-error-cell\">In [9]</a>'.</span>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7161cf4",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002279,
+     "end_time": "2026-10-22T19:07:44.363054+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:44.360775+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# exp39 / TrOCR-CTC trained on synthetic handwriting with a BANDIT DATA MIXER (2 arms: aggressive DiffusionPen words 20k vs aggressive cursive fonts 20k, same 20k texts, 10 participant styles, fitted to HHD geometry, LLMGen text), tested on HHD — training seed 43\n",
+    "\n",
+    "**Model (same as exp38/exp39):** the ViT encoder of `microsoft/trocr-base-handwritten` (768-dim, 12 layers) + **one linear classifier** over the\n",
+    "reading-order frames, trained with CTC. No augmentation, no frozen phase.\n",
+    "\n",
+    "**Arms (the same 20k texts, plan parts 1 + 2, drawn two ways; llmgen10k/build_join20k.py):**\n",
+    "- arm 0 `diffpen` — `cyttic/heb-llmgen20k-diffpenaug-hhdgeom`: 19,997 lines, every word generated by the aggressive-augmentation DiffusionPen word model\n",
+    "  `cyttic/diffusionpen-uni10aug-words100k` and kept only if exp35 read it with CER 0 (3 tries, otherwise removed); punctuation/digits from the participants' fonts.\n",
+    "- arm 1 `fonts` — `cyttic/heb-llmgen20k-uni10aug-hhdgeom`: 20,000 lines rendered from the same 10 unigram fonts in the aggressive cursive style.\n",
+    "\n",
+    "Both FITTED to the geometry of real HHD train lines (fit_hhd_geometry.py). The fixed-mix runs on the same texts: fonts 20k (0% DiffusionPen,\n",
+    "`cyttic/exp39-ctc-uni10aug20k-hhdgeom-llmgen`), joined 20k (50%, `cyttic/exp39-ctc-join20k-diffpenaug-uni10aug-hhdgeom-llmgen`),\n",
+    "DiffusionPen 20k (100%, `cyttic/exp39-ctc-diffpenaug20k-hhdgeom-llmgen`).\n",
+    "\n",
+    "**Bandit mixer (discounted EXP3, 2 arms).** Every training step one arm is drawn with probabilities `p`; the batch (32 lines) comes from that arm only\n",
+    "(each arm is an endless stream, reshuffled after every pass over it). After the backward pass the **reward** is the cosine between the batch gradient and\n",
+    "the gradient of the CTC loss on a **reward set** = a fixed half of the HHD dev writers (gradient refreshed every 50 steps on 64 rotating reward lines;\n",
+    "no update is ever taken on it). The reward is normalised by a running mean / std, clipped to [-1, 1], and the pulled arm's log-weight is updated with the\n",
+    "importance-weighted reward: `logw <- 0.99 * logw; logw[i] += 0.05 * r / p[i]`; `p = 0.85 * softmax(logw) + 0.15 / 2` (exploration floor: no arm drops below 7.5%).\n",
+    "The first 100 steps alternate the arms (reward statistics warm-up). The other half of the dev writers (**holdout**) is scored greedily after every epoch, only\n",
+    "for monitoring. Logged every step: arm, reward, `p`, loss → `bandit_log.tsv`, `bandit_p.png`, and `results.json[\"bandit\"]` (pulls and DiffusionPen share per epoch).\n",
+    "\n",
+    "**Budget = the fixed-mix 20k runs:** 4 epochs x 625 steps = 2,500 steps of batch 32, warm-up 5% + linear LR decay, training seed 43. Epoch count fixed\n",
+    "(= the joined/fonts/DiffusionPen 20k runs), no epoch search. **No HHD line is trained on;** the HHD dev labels enter only through the reward (which arm to\n",
+    "sample next), and the HHD test set (1,455 lines, 109 writers) is scored **once**: greedy, and beam search with the fixed character 6-gram LM (built from\n",
+    "LLMGen text only, no HHD text; alpha 1.5, beta 6.0 chosen on the HHD dev writers; beams 4 and 12), CER with and without punctuation, WER.\n",
+    "\n",
+    "**Colab:** Runtime → **L4 GPU**; Secrets → `HF_TOKEN` (write); **Run all**. Output: public HF repo `cyttic/exp39-ctc-bandit20k-diffpenaug-uni10aug-hhdgeom-llmgen-seed43`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a3afaa5",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001989,
+     "end_time": "2026-10-22T19:07:44.367480+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:44.365491+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 1. Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a2207eac",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:44.372067Z",
+     "iopub.status.busy": "2026-10-22T19:07:44.371903Z",
+     "iopub.status.idle": "2026-10-22T19:07:45.200369Z",
+     "shell.execute_reply": "2026-10-22T19:07:45.199603Z"
+    },
+    "papermill": {
+     "duration": 0.831459,
+     "end_time": "2026-10-22T19:07:45.200931+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:44.369472+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!pip install -q -U \"transformers==5.15.0\" datasets jiwer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "96e77c5d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:45.206799Z",
+     "iopub.status.busy": "2026-10-22T19:07:45.206623Z",
+     "iopub.status.idle": "2026-10-22T19:07:48.727558Z",
+     "shell.execute_reply": "2026-10-22T19:07:48.727023Z"
+    },
+    "papermill": {
+     "duration": 3.524291,
+     "end_time": "2026-10-22T19:07:48.728121+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:45.203830+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/romanva1/env/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HF user: cyttic\n",
+      "cuda NVIDIA RTX A5000 | amp torch.bfloat16\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os, io, re, json, math, time, random\n",
+    "import numpy as np, torch, torch.nn as nn, torch.nn.functional as F, jiwer\n",
+    "from PIL import Image, ImageOps\n",
+    "from datasets import load_dataset, concatenate_datasets\n",
+    "from transformers import VisionEncoderDecoderModel\n",
+    "from huggingface_hub import hf_hub_download, HfApi, login, whoami\n",
+    "try:\n",
+    "    from google.colab import userdata; login(userdata.get(\"HF_TOKEN\"))\n",
+    "except Exception:\n",
+    "    from huggingface_hub import get_token\n",
+    "    if get_token() is None:\n",
+    "        from huggingface_hub import notebook_login; notebook_login()\n",
+    "print(\"HF user:\", whoami()[\"name\"])\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "BF16 = device == \"cuda\" and torch.cuda.get_device_capability()[0] >= 8   # Ampere+ (L4/A100): bf16; T4: fp16\n",
+    "AMP_DTYPE = torch.bfloat16 if BF16 else torch.float16\n",
+    "print(device, torch.cuda.get_device_name(0) if device == \"cuda\" else \"\", \"| amp\", AMP_DTYPE)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "edf82c2a",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002004,
+     "end_time": "2026-10-22T19:07:48.732846+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.730842+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 2. Config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "517b2131",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:48.737908Z",
+     "iopub.status.busy": "2026-10-22T19:07:48.737632Z",
+     "iopub.status.idle": "2026-10-22T19:07:48.744177Z",
+     "shell.execute_reply": "2026-10-22T19:07:48.743649Z"
+    },
+    "papermill": {
+     "duration": 0.009848,
+     "end_time": "2026-10-22T19:07:48.744889+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.735041+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OUT /home/romanva1/work/queue_fontfill/exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43/exp39_run | {'enc': 'microsoft/trocr-base-handwritten', 'row_h': 64, 'sub': 2, 'batch': 32, 'lr_enc': 5e-05, 'lr_head': 0.0003, 'warmup': 0.05, 'aug': 0.0, 'seed': 43, 'max_epochs': 8, 'patience': 2, 'final_epochs': 4, 'bandit': {'arms': ['diffpen', 'fonts'], 'reward': 'cosine(batch grad, reward-set grad)', 'gamma': 0.15, 'eta': 0.05, 'decay': 0.99, 'explore_steps': 100, 'dev_every': 50, 'reward_batches': 2, 'stat_beta': 0.02}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "CFG = json.loads('{\"enc\": \"microsoft/trocr-base-handwritten\", \"row_h\": 64, \"sub\": 2, \"batch\": 32, \"lr_enc\": 5e-05, \"lr_head\": 0.0003, \"warmup\": 0.05, \"aug\": 0.0, \"seed\": 43, \"max_epochs\": 8, \"patience\": 2, \"final_epochs\": 4, \"bandit\": {\"arms\": [\"diffpen\", \"fonts\"], \"reward\": \"cosine(batch grad, reward-set grad)\", \"gamma\": 0.15, \"eta\": 0.05, \"decay\": 0.99, \"explore_steps\": 100, \"dev_every\": 50, \"reward_batches\": 2, \"stat_beta\": 0.02}}')\n",
+    "ENC_SRC, ROW_H, SUB, BATCH = CFG[\"enc\"], CFG[\"row_h\"], CFG[\"sub\"], CFG[\"batch\"]\n",
+    "LR_ENC, LR_HEAD, WARMUP_FRAC, SEED = CFG[\"lr_enc\"], CFG[\"lr_head\"], CFG[\"warmup\"], CFG[\"seed\"]\n",
+    "MAX_EPOCHS, PATIENCE = CFG[\"max_epochs\"], CFG[\"patience\"]   # phase 1 (skipped here)\n",
+    "FINAL_EPOCHS = CFG[\"final_epochs\"]                           # 4 = the fixed-mix 20k runs\n",
+    "AUGMENT = CFG[\"aug\"] > 0                                     # off\n",
+    "BAND = CFG[\"bandit\"]; ARM_NAMES = BAND[\"arms\"]; K = len(ARM_NAMES)\n",
+    "GAMMA, ETA, DECAY = BAND[\"gamma\"], BAND[\"eta\"], BAND[\"decay\"]          # exploration floor GAMMA/K per arm; EXP3 step; log-weight discount (horizon ~100 steps)\n",
+    "EXPLORE_STEPS, DEV_EVERY, REWARD_BATCHES, STAT_BETA = BAND[\"explore_steps\"], BAND[\"dev_every\"], BAND[\"reward_batches\"], BAND[\"stat_beta\"]\n",
+    "OUT_REPO = \"cyttic/exp39-ctc-bandit20k-diffpenaug-uni10aug-hhdgeom-llmgen-seed43\"   # public\n",
+    "ARM_IDS = [\"cyttic/heb-llmgen20k-diffpenaug-hhdgeom\", \"cyttic/heb-llmgen20k-uni10aug-hhdgeom\"]   # arm 0 = DiffusionPen words, arm 1 = cursive fonts; the same 20k texts\n",
+    "LM_REPO, LM_FILE = \"cyttic/exp38-char-lms\", \"exp38_char6_gen.npz\"   # character 6-gram LM, LLMGen (DictaGen, sentences_llm3) text ONLY; no HHD text (HHD test/dev lines removed)\n",
+    "LM_ALPHA, LM_BETA, LM_BEAMS = 1.5, 6.0, (4, 12)   # fixed decoding setting: chosen for this LM on the HHD dev writers (exp39/eval_lm_nohhd.py, lm_gen)\n",
+    "HHD_ID = \"cyttic/trocr-hebrew-matan\"\n",
+    "CHARSET_REPO = \"cyttic/exp35-trocr-large-en-ctc-seqhead-allreal-synpunct\"   # same 198 classes as exp32-37\n",
+    "SPLIT_SEED, TEST_FRAC, DEV_FRAC = 42, 0.20, 0.20             # FIXED: HHD dev/test writer split, identical to exp36/37\n",
+    "NUM_WORKERS, EVAL_BS = 8, 64\n",
+    "RUN_FINAL = True\n",
+    "PUSH = True\n",
+    "SMOKE = False                                                # True = tiny run to test the pipeline end to end\n",
+    "\n",
+    "random.seed(SEED); np.random.seed(SEED); torch.manual_seed(SEED)\n",
+    "OUT = \"/content/exp39\" if os.path.isdir(\"/content\") else os.path.abspath(\"exp39_run\")\n",
+    "os.makedirs(OUT, exist_ok=True); print(\"OUT\", OUT, \"|\", CFG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "473e8ee3",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001941,
+     "end_time": "2026-10-22T19:07:48.748943+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.747002+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 3. Charset (the 198 classes of exp32-37; class 0 = CTC blank)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3434ddd3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:48.753668Z",
+     "iopub.status.busy": "2026-10-22T19:07:48.753517Z",
+     "iopub.status.idle": "2026-10-22T19:07:48.919398Z",
+     "shell.execute_reply": "2026-10-22T19:07:48.918791Z"
+    },
+    "papermill": {
+     "duration": 0.168744,
+     "end_time": "2026-10-22T19:07:48.919811+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.751067+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "classes: 198\n"
+     ]
+    }
+   ],
+   "source": [
+    "CHARS = json.load(open(hf_hub_download(CHARSET_REPO, \"charset.json\")))[\"chars\"]   # CHARS[k] = class k; CHARS[0] = blank\n",
+    "assert CHARS[0] == \"\"\n",
+    "C2I = {c: i for i, c in enumerate(CHARS) if i}\n",
+    "N_CLASSES = len(CHARS)\n",
+    "def encode(text): return [C2I[c] for c in text if c in C2I]\n",
+    "def greedy(lp, n):\n",
+    "    best = lp[:n].argmax(-1).tolist(); out, prev = [], 0\n",
+    "    for k in best:\n",
+    "        if k != prev and k != 0: out.append(CHARS[k])\n",
+    "        prev = k\n",
+    "    return \"\".join(out)\n",
+    "print(\"classes:\", N_CLASSES)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9367fbec",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002172,
+     "end_time": "2026-10-22T19:07:48.924460+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.922288+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 4. Data: HHD split + tiling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7b37cefa",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:48.929390Z",
+     "iopub.status.busy": "2026-10-22T19:07:48.929236Z",
+     "iopub.status.idle": "2026-10-22T19:07:58.752590Z",
+     "shell.execute_reply": "2026-10-22T19:07:58.752266Z"
+    },
+    "papermill": {
+     "duration": 9.828442,
+     "end_time": "2026-10-22T19:07:58.755044+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:48.926602+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rows 6 | max columns 144 | max CTC steps 288\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "arm diffpen: 19997 lines; lines per style: {'participant_01': 2000, 'participant_02': 1999, 'participant_03': 2000, 'participant_04': 1998, 'participant_05': 2000, 'participant_06': 2000, 'participant_07': 2000, 'participant_08': 2000, 'participant_09': 2000, 'participant_10': 2000}\n",
+      "arm fonts: 20000 lines; lines per style: {'participant_01': 2000, 'participant_02': 2000, 'participant_03': 2000, 'participant_04': 2000, 'participant_05': 2000, 'participant_06': 2000, 'participant_07': 2000, 'participant_08': 2000, 'participant_09': 2000, 'participant_10': 2000}\n",
+      "HHD dev 1091 lines / 109 writers -> reward 559 lines / 54 writers, holdout 532 lines / 55 writers | HHD test 1455 lines / 109 writers (scored once)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "arm diffpen: CTC-feasible lines (first 400): 400/400\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "arm fonts: CTC-feasible lines (first 400): 400/400\n"
+     ]
+    }
+   ],
+   "source": [
+    "class Tiler:\n",
+    "    '''mirror (RTL->LTR) -> ROW_H px high -> wrapped into the 384x384 square in rows of 384 px (no overlap, no autocrop).\n",
+    "    Returns the image tensor + the number of 16 px columns that hold ink, in reading order.'''\n",
+    "    C, P = 384, 16\n",
+    "    def __init__(self, row_h):\n",
+    "        self.H = row_h; self.R = self.C // row_h; self.max_cols = self.R * (self.C // self.P)\n",
+    "    def __call__(self, image):\n",
+    "        image = ImageOps.mirror(image.convert(\"RGB\")); w, h = image.size\n",
+    "        nw = max(1, round(w * self.H / h)); image = image.resize((nw, self.H), Image.LANCZOS)\n",
+    "        cont = Image.new(\"RGB\", (self.C, self.C), (255, 255, 255)); arr = np.array(image)\n",
+    "        sx, r = 0, 0\n",
+    "        while sx < nw and r < self.R:\n",
+    "            seg = arr[:, sx:sx + self.C]; cont.paste(Image.fromarray(seg), (0, r * self.H)); sx += seg.shape[1]; r += 1\n",
+    "        used = min(nw, self.R * self.C)\n",
+    "        t = torch.tensor(np.array(cont), dtype=torch.float32).permute(2, 0, 1) / 255.0\n",
+    "        return (t - 0.5) / 0.5, min(self.max_cols, math.ceil(used / self.P))\n",
+    "tiler = Tiler(ROW_H)\n",
+    "print(\"rows\", tiler.R, \"| max columns\", tiler.max_cols, \"| max CTC steps\", tiler.max_cols * SUB)\n",
+    "\n",
+    "# ---- HHD: validation (dev writers) and test only; nothing of HHD is trained on. Split identical to exp36/37/38 ----\n",
+    "hhd = load_dataset(HHD_ID)\n",
+    "orig_test_w = set(\"hhd:\" + w for w in hhd[\"test\"][\"writer\"])\n",
+    "hhd_all = concatenate_datasets([hhd[\"train\"], hhd[\"test\"]])\n",
+    "hw = [\"hhd:\" + w for w in hhd_all[\"writer\"]]\n",
+    "wr = sorted(set(hw)); random.Random(SPLIT_SEED).shuffle(wr)\n",
+    "n_te, n_dev = int(len(wr) * TEST_FRAC), int(len(wr) * DEV_FRAC)\n",
+    "test_w, dev_w = set(wr[:n_te]), set(wr[n_te:n_te + n_dev])\n",
+    "assert test_w == orig_test_w, \"test writers differ from the original HHD test split\"\n",
+    "assert not (dev_w & orig_test_w)\n",
+    "test = hhd[\"test\"]\n",
+    "tw = [\"hhd:\" + w for w in hhd[\"train\"][\"writer\"]]\n",
+    "dev = hhd[\"train\"].select([i for i, w in enumerate(tw) if w in dev_w])\n",
+    "\n",
+    "# ---- the two arms: the same 20k texts, drawn by DiffusionPen (arm 0) and by the cursive fonts (arm 1) ----\n",
+    "_load = lambda r: load_dataset(r, data_files={\"train\": \"data/train-*.parquet\"}, split=\"train\").select_columns([\"image\", \"text\", \"style\"]).cast_column(\"image\", __import__(\"datasets\").Image())   # parquet written with plain pyarrow: declare the image feature\n",
+    "arms = [_load(r) for r in ARM_IDS]\n",
+    "import collections\n",
+    "for name, ds, n in zip(ARM_NAMES, arms, (19997, 20000)):\n",
+    "    _per = collections.Counter(ds[\"style\"]); print(f\"arm {name}: {len(ds)} lines; lines per style: {dict(sorted(_per.items()))}\")\n",
+    "    assert len(ds) == n and len(_per) == 10 and min(_per.values()) >= 1997\n",
+    "# ---- HHD dev writers -> reward half (bandit reward only) + holdout half (monitoring only); HHD test untouched ----\n",
+    "_dw = sorted(dev_w); random.Random(SPLIT_SEED + 1).shuffle(_dw); rew_w = set(_dw[:len(_dw) // 2])\n",
+    "_dvw = [\"hhd:\" + w for w in dev[\"writer\"]]\n",
+    "reward_set = dev.select([i for i, w in enumerate(_dvw) if w in rew_w]); holdout = dev.select([i for i, w in enumerate(_dvw) if w not in rew_w])\n",
+    "print(f\"HHD dev {len(dev)} lines / {len(dev_w)} writers -> reward {len(reward_set)} lines / {len(rew_w)} writers, holdout {len(holdout)} lines / {len(dev_w) - len(rew_w)} writers | HHD test {len(test)} lines / {len(orig_test_w)} writers (scored once)\")\n",
+    "STEPS_PER_EPOCH = math.ceil(sum(len(x) for x in arms) / K / BATCH)   # 625 = the fixed-mix 20k runs\n",
+    "if SMOKE:\n",
+    "    arms = [x.select(range(64)) for x in arms]; reward_set, holdout, test = reward_set.select(range(32)), holdout.select(range(32)), test.select(range(32))\n",
+    "    BATCH = 4; FINAL_EPOCHS = 2; LM_BEAMS = (4,); STEPS_PER_EPOCH = 30; EXPLORE_STEPS = 10; DEV_EVERY = 10\n",
+    "train_full = arms[0]   # (only for the feasibility check below)\n",
+    "\n",
+    "def collate(batch):\n",
+    "    px, cols, labels, texts = [], [], [], []\n",
+    "    for ex in batch:\n",
+    "        t, c = tiler(ex[\"image\"]); px.append(t); cols.append(c); labels.append(encode(ex[\"text\"])); texts.append(ex[\"text\"])\n",
+    "    return torch.stack(px), torch.tensor(cols), labels, texts\n",
+    "\n",
+    "def loader(split, shuffle, bs=None):\n",
+    "    return torch.utils.data.DataLoader(split, batch_size=bs or BATCH, shuffle=shuffle, num_workers=NUM_WORKERS,\n",
+    "                                       collate_fn=collate, drop_last=False, persistent_workers=False)\n",
+    "\n",
+    "# how many training lines cannot be aligned (label longer than the available CTC steps)?\n",
+    "for name, ds in zip(ARM_NAMES, arms):\n",
+    "    _chk = [(len(encode(ex[\"text\"])), tiler(ex[\"image\"])[1] * SUB) for ex in ds.select(range(min(len(ds), 400)))]\n",
+    "    print(f\"arm {name}: CTC-feasible lines (first {len(_chk)}): {sum(1 for l, T in _chk if 0 < l <= T)}/{len(_chk)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6388e24d",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002277,
+     "end_time": "2026-10-22T19:07:58.760522+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:58.758245+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 5. Model: TrOCR-base ViT encoder → reading-order frames → ONE linear classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "874fec2b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:58.765989Z",
+     "iopub.status.busy": "2026-10-22T19:07:58.765606Z",
+     "iopub.status.idle": "2026-10-22T19:07:59.647868Z",
+     "shell.execute_reply": "2026-10-22T19:07:59.647278Z"
+    },
+    "papermill": {
+     "duration": 0.885479,
+     "end_time": "2026-10-22T19:07:59.648333+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:58.762854+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "Loading weights:   0%|          | 0/478 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "Loading weights: 100%|██████████| 478/478 [00:00<00:00, 6858.81it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "[transformers] \u001b[1mVisionEncoderDecoderModel LOAD REPORT\u001b[0m from: microsoft/trocr-base-handwritten\n",
+      "Key                         | Status  | \n",
+      "----------------------------+---------+-\n",
+      "encoder.pooler.dense.weight | MISSING | \n",
+      "encoder.pooler.dense.bias   | MISSING | \n",
+      "\n",
+      "Notes:\n",
+      "- MISSING:\tthose params were newly initialized because missing from the checkpoint. Consider training on your downstream task.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "encoder 86.1M (vit, hidden 768) | classifier 1.217M\n"
+     ]
+    }
+   ],
+   "source": [
+    "class EncoderLinearCTC(nn.Module):\n",
+    "    '''ViT patch tokens (24x24 grid) -> reading-order frames (one per 16 px column, the ROW_H//16 patch rows of a text row\n",
+    "    concatenated) -> a single Linear giving SUB CTC steps per column. Nothing else.'''\n",
+    "    def __init__(self, vit, n_classes):\n",
+    "        super().__init__()\n",
+    "        self.vit = vit\n",
+    "        if getattr(self.vit, \"pooler\", None) is not None: self.vit.pooler = None\n",
+    "        self.Hd = vit.config.hidden_size; self.n_special = 2 if vit.config.model_type == \"deit\" else 1   # CLS (+ distillation)\n",
+    "        self.k = ROW_H // 16; self.n_classes = n_classes\n",
+    "        self.classifier = nn.Linear(self.k * self.Hd, SUB * n_classes)\n",
+    "        nn.init.trunc_normal_(self.classifier.weight, std=0.02); nn.init.zeros_(self.classifier.bias)\n",
+    "    def forward(self, px):\n",
+    "        tok = self.vit(pixel_values=px).last_hidden_state[:, self.n_special:]            # (B, 576, H)\n",
+    "        B, R = tok.shape[0], tiler.R\n",
+    "        g = tok.reshape(B, 24, 24, self.Hd)[:, :R * self.k]\n",
+    "        g = g.reshape(B, R, self.k, 24, self.Hd).permute(0, 1, 3, 2, 4).reshape(B, R * 24, self.k * self.Hd)   # (B, 144, k*H)\n",
+    "        y = self.classifier(g).reshape(B, R * 24 * SUB, self.n_classes)\n",
+    "        return F.log_softmax(y.float(), dim=-1)\n",
+    "\n",
+    "def build_model():\n",
+    "    '''a FRESH model: TrOCR-base encoder weights + a newly initialised classifier (called once per phase)'''\n",
+    "    torch.manual_seed(SEED)\n",
+    "    vit = VisionEncoderDecoderModel.from_pretrained(ENC_SRC).encoder\n",
+    "    return EncoderLinearCTC(vit, N_CLASSES).to(device)\n",
+    "\n",
+    "model = build_model()\n",
+    "n_enc = sum(p.numel() for p in model.vit.parameters()); n_head = sum(p.numel() for p in model.classifier.parameters())\n",
+    "print(f\"encoder {n_enc/1e6:.1f}M ({model.vit.config.model_type}, hidden {model.vit.config.hidden_size}) | classifier {n_head/1e6:.3f}M\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5e88ddf",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002348,
+     "end_time": "2026-10-22T19:07:59.653942+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:59.651594+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 6. Metrics + training function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1935e020",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:59.659620Z",
+     "iopub.status.busy": "2026-10-22T19:07:59.659463Z",
+     "iopub.status.idle": "2026-10-22T19:07:59.678340Z",
+     "shell.execute_reply": "2026-10-22T19:07:59.677764Z"
+    },
+    "papermill": {
+     "duration": 0.022442,
+     "end_time": "2026-10-22T19:07:59.678825+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:59.656383+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ready\n"
+     ]
+    }
+   ],
+   "source": [
+    "def scores(R, H):\n",
+    "    o = {}\n",
+    "    for v, f in {\"raw\": lambda t: t, \"let\": lambda t: re.sub(r\" +\", \" \", re.sub(r\"[^א-ת ]\", \" \", t)).strip()}.items():\n",
+    "        rr = [f(x) for x in R]; hh = [f(x) for x in H]; k = [i for i, x in enumerate(rr) if x]\n",
+    "        o[f\"cer_{v}\"] = jiwer.cer([rr[i] for i in k], [hh[i] for i in k]); o[f\"wer_{v}\"] = jiwer.wer([rr[i] for i in k], [hh[i] for i in k])\n",
+    "    return o\n",
+    "\n",
+    "@torch.no_grad()\n",
+    "def predict(model, split):\n",
+    "    model.eval(); H, R = [], []\n",
+    "    for px, cols, _, texts in loader(split, False, EVAL_BS):\n",
+    "        with torch.autocast(\"cuda\", dtype=AMP_DTYPE, enabled=device == \"cuda\"):\n",
+    "            lp = model(px.to(device))\n",
+    "        lp = lp.float().cpu().numpy()\n",
+    "        H += [greedy(lp[i], int(cols[i]) * SUB) for i in range(len(texts))]; R += texts\n",
+    "    return R, H\n",
+    "\n",
+    "def ctc(lp, cols, labels):\n",
+    "    return F.ctc_loss(lp.transpose(0, 1), torch.tensor(sum(labels, [])), cols * SUB,\n",
+    "                      torch.tensor([len(l) for l in labels]), blank=0, zero_infinity=True)\n",
+    "\n",
+    "class Stream:\n",
+    "    \"\"\"endless batches of one dataset (one arm, or the reward set): reshuffled after every pass over it; `passes` = how many passes were started\"\"\"\n",
+    "    def __init__(self, ds, seed, workers):\n",
+    "        self.ds, self.g, self.w, self.it, self.passes, self.batches = ds, torch.Generator().manual_seed(seed), workers, None, 0, 0\n",
+    "    def next(self):\n",
+    "        while True:\n",
+    "            if self.it is None:\n",
+    "                self.it = iter(torch.utils.data.DataLoader(self.ds, batch_size=BATCH, shuffle=True, generator=self.g, num_workers=self.w,\n",
+    "                                                           collate_fn=collate, drop_last=True)); self.passes += 1\n",
+    "            try:\n",
+    "                b = next(self.it); self.batches += 1; return b\n",
+    "            except StopIteration:\n",
+    "                self.it = None\n",
+    "\n",
+    "def flat_grad(model):\n",
+    "    return torch.cat([(p.grad.detach().float() if p.grad is not None else torch.zeros_like(p, dtype=torch.float32)).reshape(-1) for p in model.parameters()])\n",
+    "\n",
+    "def train_bandit(model, arms, epochs, tag, holdout=None):\n",
+    "    \"\"\"Same optimiser / LR schedule / clipping as train(); the batch of each step comes from ONE arm chosen by discounted EXP3 on the gradient-alignment reward.\"\"\"\n",
+    "    log = os.path.join(OUT, f\"train_log_{tag}.tsv\"); blog = os.path.join(OUT, \"bandit_log.tsv\")\n",
+    "    open(log, \"w\").write(\"epoch\\tstep\\ttrain_loss\\tholdout_cer\\tholdout_wer\\tdiffpen_share\\tsec\\n\")\n",
+    "    open(blog, \"w\").write(\"step\\tarm\\tloss\\treward\\treward_norm\\t\" + \"\\t\".join(f\"p_{n}\" for n in ARM_NAMES) + \"\\tlr_f\\n\")\n",
+    "    head_params, enc_params = list(model.classifier.parameters()), list(model.vit.parameters())\n",
+    "    opt = torch.optim.AdamW([{\"params\": enc_params, \"lr\": LR_ENC}, {\"params\": head_params, \"lr\": LR_HEAD}], weight_decay=0.01)\n",
+    "    base_lr = [g[\"lr\"] for g in opt.param_groups]\n",
+    "    scaler = torch.amp.GradScaler(\"cuda\", enabled=device == \"cuda\" and AMP_DTYPE == torch.float16)\n",
+    "    total = epochs * STEPS_PER_EPOCH; warm = max(1, int(WARMUP_FRAC * total))\n",
+    "    streams = [Stream(ds, SEED * 10 + k, max(1, NUM_WORKERS // 2)) for k, ds in enumerate(arms)]; rstream = Stream(reward_set, SEED * 10 + 9, 2)\n",
+    "    rng = np.random.default_rng(SEED); logw = np.zeros(K); mu, var = 0.0, 1e-4; g_dev = None\n",
+    "    pulls = np.zeros((epochs, K), int); rsum = np.zeros((epochs, K)); traj = []; t0 = time.time(); curve = []\n",
+    "    def probs():\n",
+    "        e = np.exp(logw - logw.max()); return (1 - GAMMA) * e / e.sum() + GAMMA / K\n",
+    "    def scale(): return scaler.get_scale() if scaler.is_enabled() else 1.0\n",
+    "    print(f\"[{tag}] arms {[len(a) for a in arms]} lines | {STEPS_PER_EPOCH} steps/epoch x {epochs} epochs = {total} steps of {BATCH}\")\n",
+    "    losses = []\n",
+    "    for step in range(total):\n",
+    "        ep = step // STEPS_PER_EPOCH\n",
+    "        if step % DEV_EVERY == 0:   # reward-set gradient (no optimiser step on it)\n",
+    "            model.eval(); rb = [rstream.next() for _ in range(REWARD_BATCHES)]\n",
+    "            for amp in (True, False):   # fp16 loss scaling can overflow (T4, first steps): then recompute in fp32\n",
+    "                opt.zero_grad(set_to_none=True)\n",
+    "                for px, cols, labels, _ in rb:\n",
+    "                    keep = [i for i, l in enumerate(labels) if 0 < len(l) <= int(cols[i]) * SUB]\n",
+    "                    with torch.autocast(\"cuda\", dtype=AMP_DTYPE, enabled=device == \"cuda\" and amp):\n",
+    "                        lp = model(px[keep].to(device))\n",
+    "                    l_ = ctc(lp, cols[keep], [labels[i] for i in keep]) / REWARD_BATCHES\n",
+    "                    (scaler.scale(l_) if amp else l_).backward()\n",
+    "                g_dev = flat_grad(model) / (scale() if amp else 1.0)\n",
+    "                if bool(torch.isfinite(g_dev).all()): break\n",
+    "            opt.zero_grad(set_to_none=True)\n",
+    "        p = probs(); i = step % K if step < EXPLORE_STEPS else int(rng.choice(K, p=p))\n",
+    "        px, cols, labels, _ = streams[i].next()\n",
+    "        keep = [j for j, l in enumerate(labels) if 0 < len(l) <= int(cols[j]) * SUB]\n",
+    "        if not keep: continue\n",
+    "        f = min(1.0, (step + 1) / warm) * max(0.0, (total - step) / max(1, total - warm))\n",
+    "        for g, b in zip(opt.param_groups, base_lr): g[\"lr\"] = b * f\n",
+    "        model.train()\n",
+    "        with torch.autocast(\"cuda\", dtype=AMP_DTYPE, enabled=device == \"cuda\"):\n",
+    "            lp = model(px[keep].to(device))\n",
+    "        loss = ctc(lp, cols[keep], [labels[j] for j in keep])\n",
+    "        opt.zero_grad(set_to_none=True); scaler.scale(loss).backward(); scaler.unscale_(opt)\n",
+    "        r = float(F.cosine_similarity(flat_grad(model), g_dev, dim=0))   # batch gradient vs reward-set gradient (before clipping)\n",
+    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0); scaler.step(opt); scaler.update()\n",
+    "        rn = float(\"nan\")\n",
+    "        if math.isfinite(r):\n",
+    "            mu = (1 - STAT_BETA) * mu + STAT_BETA * r; var = (1 - STAT_BETA) * var + STAT_BETA * (r - mu) ** 2\n",
+    "            rn = float(np.clip((r - mu) / math.sqrt(var + 1e-12), -3, 3) / 3)\n",
+    "            if step >= EXPLORE_STEPS: logw *= DECAY; logw[i] += ETA * rn / p[i]\n",
+    "            rsum[ep, i] += r\n",
+    "        pulls[ep, i] += 1; losses.append(float(loss)); traj.append((step, *probs()))\n",
+    "        open(blog, \"a\").write(f\"{step}\\t{ARM_NAMES[i]}\\t{float(loss):.4f}\\t{r:.5f}\\t{rn:.4f}\\t\" + \"\\t\".join(f\"{x:.4f}\" for x in probs()) + f\"\\t{f:.4f}\\n\")\n",
+    "        if step % 250 == 0: print(f\"  step {step}/{total} | arm {ARM_NAMES[i]} | reward {r:+.4f} | p {np.round(probs(), 3).tolist()} | loss {float(loss):.3f} | {time.time()-t0:.0f}s\", flush=True)\n",
+    "        if (step + 1) % STEPS_PER_EPOCH == 0 or step + 1 == total:\n",
+    "            tl = float(np.mean(losses)); losses = []; sh = pulls[ep, 0] / max(1, pulls[ep].sum()); s = {\"cer_raw\": float(\"nan\"), \"wer_raw\": float(\"nan\")}\n",
+    "            if holdout is not None: R, H = predict(model, holdout); s = scores(R, H)\n",
+    "            curve.append({\"epoch\": ep + 1, \"train_loss\": tl, \"diffpen_share\": sh, \"pulls\": pulls[ep].tolist(),\n",
+    "                          \"mean_reward\": (rsum[ep] / np.maximum(1, pulls[ep])).tolist(), \"p_end\": probs().tolist(), **s})\n",
+    "            open(log, \"a\").write(f\"{ep+1}\\t{step+1}\\t{tl:.4f}\\t{s['cer_raw']:.4f}\\t{s['wer_raw']:.4f}\\t{sh:.3f}\\t{time.time()-t0:.0f}\\n\")\n",
+    "            print(f\"[{tag} epoch {ep+1}/{epochs}] loss {tl:.3f} | DiffusionPen share {100*sh:.1f}% (pulls {pulls[ep].tolist()}) | mean reward {np.round(curve[-1]['mean_reward'], 4).tolist()} | holdout CER {100*s['cer_raw']:.2f} | {time.time()-t0:.0f}s\", flush=True)\n",
+    "    # trajectory plot of p\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    tr = np.array(traj); fig, ax = plt.subplots(figsize=(8, 3.2))\n",
+    "    ax.plot(tr[:, 0], tr[:, 1], lw=0.8, label=\"p(diffpen)\"); w = max(1, min(100, len(tr) // 5))\n",
+    "    ax.plot(tr[:, 0], np.convolve(tr[:, 1], np.ones(w) / w, mode=\"same\"), lw=2, label=f\"p(diffpen), {w}-step mean\")\n",
+    "    for e in range(1, epochs): ax.axvline(e * STEPS_PER_EPOCH, color=\"grey\", lw=0.5, ls=\":\")\n",
+    "    ax.axhline(0.5, color=\"k\", lw=0.5); ax.set_ylim(0, 1); ax.set_xlabel(\"step\"); ax.set_ylabel(\"probability of the DiffusionPen arm\"); ax.legend(loc=\"upper right\", fontsize=8)\n",
+    "    fig.tight_layout(); fig.savefig(os.path.join(OUT, \"bandit_p.png\"), dpi=130); plt.show()\n",
+    "    return {\"steps\": total, \"epochs\": epochs, \"pulls_total\": pulls.sum(0).tolist(), \"diffpen_share_total\": float(pulls[:, 0].sum() / max(1, pulls.sum())),\n",
+    "            \"arm_passes\": [s_.passes for s_ in streams], \"curve\": curve}\n",
+    "print(\"ready\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "971ac0dc",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002254,
+     "end_time": "2026-10-22T19:07:59.683545+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:59.681291+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 7. Phase 1 — SKIPPED (epoch count fixed to 4 = the fixed-mix 20k runs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd4d15bf",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:59.708778Z",
+     "iopub.status.busy": "2026-10-22T19:07:59.708551Z",
+     "iopub.status.idle": "2026-10-22T19:07:59.723399Z",
+     "shell.execute_reply": "2026-10-22T19:07:59.722847Z"
+    },
+    "papermill": {
+     "duration": 0.03786,
+     "end_time": "2026-10-22T19:07:59.723840+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:59.685980+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "phase 1 skipped; final epochs = 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "sel = {\"skipped\": True, \"best_epoch\": 4, \"epochs_run\": 0, \"epochs_from\": \"the fixed-mix 20k runs (joined / fonts / DiffusionPen 20k, 4 epochs)\"}\n",
+    "BEST_EPOCH = 4\n",
+    "json.dump({\"config\": CFG, \"arm_lines\": [len(a) for a in arms], \"reward_lines\": len(reward_set), \"holdout_lines\": len(holdout), **sel}, open(os.path.join(OUT, \"results_select.json\"), \"w\"), indent=1)\n",
+    "print(\"phase 1 skipped; final epochs =\", BEST_EPOCH)\n",
+    "del model; torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78a26b6f",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002421,
+     "end_time": "2026-10-22T19:07:59.729084+00:00",
+     "exception": false,
+     "start_time": "2026-10-22T19:07:59.726663+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 8. Final run with the bandit mixer (fresh model, 4 x 625 steps, LR decay; HHD test scored once)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81aec26e",
+   "metadata": {
+    "tags": [
+     "papermill-error-cell-tag"
+    ]
+   },
+   "source": [
+    "<span id=\"papermill-error-cell\" style=\"color:red; font-family:Helvetica Neue, Helvetica, Arial, sans-serif; font-size:2em;\">Execution using papermill encountered an exception here and stopped:</span>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9c7cf0c7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-22T19:07:59.735037Z",
+     "iopub.status.busy": "2026-10-22T19:07:59.734881Z",
+     "iopub.status.idle": "2026-10-22T19:19:46.719479Z",
+     "shell.execute_reply": "2026-10-22T19:19:46.718634Z"
+    },
+    "papermill": {
+     "duration": 706.988605,
+     "end_time": "2026-10-22T19:19:46.720201+00:00",
+     "exception": true,
+     "start_time": "2026-10-22T19:07:59.731596+00:00",
+     "status": "failed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "FINAL: re-initialising from TrOCR-base; bandit over ['diffpen', 'fonts'] for 4 epochs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "Loading weights:   0%|          | 0/478 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "Loading weights: 100%|██████████| 478/478 [00:00<00:00, 7590.55it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "[transformers] \u001b[1mVisionEncoderDecoderModel LOAD REPORT\u001b[0m from: microsoft/trocr-base-handwritten\n",
+      "Key                         | Status  | \n",
+      "----------------------------+---------+-\n",
+      "encoder.pooler.dense.weight | MISSING | \n",
+      "encoder.pooler.dense.bias   | MISSING | \n",
+      "\n",
+      "Notes:\n",
+      "- MISSING:\tthose params were newly initialized because missing from the checkpoint. Consider training on your downstream task.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[final] arms [19997, 20000] lines | 625 steps/epoch x 4 epochs = 2500 steps of 32\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 0/2500 | arm diffpen | reward +0.8238 | p [0.5, 0.5] | loss 13.776 | 1s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_5097/1488731010.py:91: UserWarning: Converting a tensor with requires_grad=True to a scalar may lead to unexpected behavior.\n",
+      "Consider using tensor.detach() first. (Triggered internally at /__w/pytorch/pytorch/torch/csrc/autograd/generated/python_variable_methods.cpp:820.)\n",
+      "  pulls[ep, i] += 1; losses.append(float(loss)); traj.append((step, *probs()))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 250/2500 | arm fonts | reward -0.0244 | p [0.471, 0.529] | loss 0.396 | 70s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 500/2500 | arm fonts | reward -0.1458 | p [0.639, 0.361] | loss 0.299 | 139s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/romanva1/env/lib/python3.12/site-packages/torch/utils/data/dataloader.py:431: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 4, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+      "  self.check_worker_number_rationality()\n",
+      "/home/romanva1/env/lib/python3.12/site-packages/torch/utils/data/dataloader.py:437: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 4, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+      "  self.check_worker_number_rationality()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[final epoch 1/4] loss 1.014 | DiffusionPen share 55.4% (pulls [346, 279]) | mean reward [0.0368, 0.0095] | holdout CER 30.10 | 176s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 750/2500 | arm diffpen | reward +0.2173 | p [0.634, 0.366] | loss 0.214 | 211s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 1000/2500 | arm fonts | reward -0.1770 | p [0.726, 0.274] | loss 0.134 | 281s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[final epoch 2/4] loss 0.154 | DiffusionPen share 66.6% (pulls [416, 209]) | mean reward [0.0226, -0.0397] | holdout CER 28.95 | 352s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 1250/2500 | arm diffpen | reward +0.1427 | p [0.656, 0.344] | loss 0.096 | 353s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 1500/2500 | arm fonts | reward -0.0915 | p [0.641, 0.359] | loss 0.073 | 423s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 1750/2500 | arm diffpen | reward +0.0103 | p [0.662, 0.338] | loss 0.088 | 493s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[final epoch 3/4] loss 0.087 | DiffusionPen share 63.0% (pulls [394, 231]) | mean reward [0.014, -0.0236] | holdout CER 29.45 | 529s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 2000/2500 | arm diffpen | reward +0.0499 | p [0.625, 0.375] | loss 0.068 | 564s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  step 2250/2500 | arm diffpen | reward +0.0635 | p [0.641, 0.359] | loss 0.027 | 635s\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[final epoch 4/4] loss 0.050 | DiffusionPen share 62.1% (pulls [388, 237]) | mean reward [0.0135, -0.0211] | holdout CER 27.47 | 706s\n"
+     ]
+    },
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'matplotlib'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mModuleNotFoundError\u001b[39m                       Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m RUN_FINAL:\n\u001b[32m      3\u001b[39m     n_final = FINAL_EPOCHS \u001b[38;5;28;01mor\u001b[39;00m BEST_EPOCH\n\u001b[32m      4\u001b[39m     print(\u001b[33m\"FINAL: re-initialising from TrOCR-base; bandit over\"\u001b[39m, ARM_NAMES, \u001b[33m\"for\"\u001b[39m, n_final, \u001b[33m\"epochs\"\u001b[39m)\n\u001b[32m      5\u001b[39m     model = build_model()\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m     fin = train_bandit(model, arms, n_final, \u001b[33m\"final\"\u001b[39m, holdout=holdout)\n\u001b[32m      7\u001b[39m     results[\u001b[33m\"bandit\"\u001b[39m] = fin\n\u001b[32m      8\u001b[39m     R, H = predict(model, test); test_scores = scores(R, H)\n\u001b[32m      9\u001b[39m     results[\u001b[33m\"final\"\u001b[39m] = {\u001b[33m\"epochs\"\u001b[39m: n_final, \u001b[33m\"steps\"\u001b[39m: fin[\u001b[33m\"steps\"\u001b[39m], \u001b[33m\"test\"\u001b[39m: test_scores}\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 102\u001b[39m, in \u001b[36mtrain_bandit\u001b[39m\u001b[34m(model, arms, epochs, tag, holdout)\u001b[39m\n\u001b[32m     98\u001b[39m                           \u001b[33m\"mean_reward\"\u001b[39m: (rsum[ep] / np.maximum(\u001b[32m1\u001b[39m, pulls[ep])).tolist(), \u001b[33m\"p_end\"\u001b[39m: probs().tolist(), **s})\n\u001b[32m     99\u001b[39m             open(log, \u001b[33m\"a\"\u001b[39m).write(f\"{ep+\u001b[32m1\u001b[39m}\\t{step+\u001b[32m1\u001b[39m}\\t{tl:.4f}\\t{s[\u001b[33m'cer_raw'\u001b[39m]:.4f}\\t{s[\u001b[33m'wer_raw'\u001b[39m]:.4f}\\t{sh:.3f}\\t{time.time()-t0:.0f}\\n\")\n\u001b[32m    100\u001b[39m             print(f\"[{tag} epoch {ep+\u001b[32m1\u001b[39m}/{epochs}] loss {tl:.3f} | DiffusionPen share {\u001b[32m100\u001b[39m*sh:.1f}% (pulls {pulls[ep].tolist()}) | mean reward {np.round(curve[-\u001b[32m1\u001b[39m][\u001b[33m'mean_reward'\u001b[39m], \u001b[32m4\u001b[39m).tolist()} | holdout CER {\u001b[32m100\u001b[39m*s[\u001b[33m'cer_raw'\u001b[39m]:.2f} | {time.time()-t0:.0f}s\", flush=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m    101\u001b[39m     \u001b[38;5;66;03m# trajectory plot of p\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m102\u001b[39m     \u001b[38;5;28;01mimport\u001b[39;00m matplotlib.pyplot \u001b[38;5;28;01mas\u001b[39;00m plt\n\u001b[32m    103\u001b[39m     tr = np.array(traj); fig, ax = plt.subplots(figsize=(\u001b[32m8\u001b[39m, \u001b[32m3.2\u001b[39m))\n\u001b[32m    104\u001b[39m     ax.plot(tr[:, \u001b[32m0\u001b[39m], tr[:, \u001b[32m1\u001b[39m], lw=\u001b[32m0.8\u001b[39m, label=\u001b[33m\"p(diffpen)\"\u001b[39m); w = max(\u001b[32m1\u001b[39m, min(\u001b[32m100\u001b[39m, len(tr) // \u001b[32m5\u001b[39m))\n\u001b[32m    105\u001b[39m     ax.plot(tr[:, \u001b[32m0\u001b[39m], np.convolve(tr[:, \u001b[32m1\u001b[39m], np.ones(w) / w, mode=\u001b[33m\"same\"\u001b[39m), lw=\u001b[32m2\u001b[39m, label=f\"p(diffpen), {w}-step mean\")\n",
+      "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'matplotlib'"
+     ]
+    }
+   ],
+   "source": [
+    "results = {\"config\": CFG, \"select\": sel}\n",
+    "if RUN_FINAL:\n",
+    "    n_final = FINAL_EPOCHS or BEST_EPOCH\n",
+    "    print(\"FINAL: re-initialising from TrOCR-base; bandit over\", ARM_NAMES, \"for\", n_final, \"epochs\")\n",
+    "    model = build_model()\n",
+    "    fin = train_bandit(model, arms, n_final, \"final\", holdout=holdout)\n",
+    "    results[\"bandit\"] = fin\n",
+    "    R, H = predict(model, test); test_scores = scores(R, H)\n",
+    "    results[\"final\"] = {\"epochs\": n_final, \"steps\": fin[\"steps\"], \"test\": test_scores}\n",
+    "    print(\"DiffusionPen share over the run:\", round(100 * fin[\"diffpen_share_total\"], 1), \"% | pulls\", fin[\"pulls_total\"], \"| passes per arm\", fin[\"arm_passes\"])\n",
+    "    print(\"HHD TEST (greedy, raw CER/WER and Hebrew-letters-only CER):\", {k: round(v, 4) for k, v in test_scores.items()})\n",
+    "    with open(os.path.join(OUT, \"test_predictions.tsv\"), \"w\", encoding=\"utf-8\") as fh:\n",
+    "        fh.write(\"ref\\thyp\\n\"); [fh.write(f\"{r}\\t{h}\\n\") for r, h in zip(R, H)]\n",
+    "    for i in range(3): print(\"REF\", R[i]); print(\"OUT\", H[i])\n",
+    "json.dump(results, open(os.path.join(OUT, \"results.json\"), \"w\"), indent=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84e49a66",
+   "metadata": {
+    "papermill": {
+     "duration": null,
+     "end_time": null,
+     "exception": null,
+     "start_time": null,
+     "status": "pending"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 8b. HHD test with a character LM (fixed setting) — CER with and without punctuation, WER"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "195c7a52",
+   "metadata": {
+    "papermill": {
+     "duration": null,
+     "end_time": null,
+     "exception": null,
+     "start_time": null,
+     "status": "pending"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile charlm.py\n",
+    "# -*- coding: utf-8 -*-\n",
+    "\"\"\"Character n-gram language model with interpolated Kneser-Ney smoothing -- our own\n",
+    "implementation (training + querying), used for shallow fusion in CTC beam search.\n",
+    "\n",
+    "Training is vectorised with numpy: every n-gram of order <= N is hashed into one int64 key\n",
+    "(base 256, one \"digit\" per character code), counted with np.unique, and turned into\n",
+    "interpolated-KN probabilities stored ARPA-style -- log P(w | h) for every kept n-gram and a log\n",
+    "back-off weight for every kept history. Querying walks from the longest context down:\n",
+    "    P(w | h) = P_n(w | h)                        if the n-gram (h, w) is stored\n",
+    "             = bow(h) * P(w | h[1:])             otherwise (bow = 1 if h is unseen)\n",
+    "Interpolated KN (Chen & Goodman 1999): the top order uses raw counts, lower orders use\n",
+    "continuation counts N1+(. g); one absolute discount per order, D = n1 / (n1 + 2 n2).\n",
+    "\n",
+    "Lines are left-padded with N-1 <s> symbols, so the first characters of a line have context and\n",
+    "every lower-order n-gram has a left extension. Saved as .npz (plain arrays, no pickle).\n",
+    "\"\"\"\n",
+    "\n",
+    "import functools\n",
+    "import math\n",
+    "import re\n",
+    "import unicodedata\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "B = 256                      # key base: one byte per character code\n",
+    "DICT_MAX = 2_000_000         # tables up to this size become Python dicts (fast); larger stay arrays\n",
+    "\n",
+    "\n",
+    "class _Table:\n",
+    "    \"\"\"key -> value lookup over sorted int64 keys: a dict for small tables, binary search else.\"\"\"\n",
+    "\n",
+    "    def __init__(self, keys, vals, as_dict):\n",
+    "        self.d = dict(zip(keys.tolist(), vals.tolist())) if as_dict else None\n",
+    "        self.k, self.v = keys, vals\n",
+    "\n",
+    "    def get(self, key, default=None):\n",
+    "        if self.d is not None:\n",
+    "            return self.d.get(key, default)\n",
+    "        i = int(np.searchsorted(self.k, key))\n",
+    "        return float(self.v[i]) if i < len(self.k) and int(self.k[i]) == key else default\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.k)\n",
+    "BOS = 255                    # <s> code; real characters are 1..len(alphabet)\n",
+    "\n",
+    "\n",
+    "# ---- text normalisation shared by training and decoding ------------------------------------\n",
+    "_MAP = str.maketrans({\"״\": '\"', \"׳\": \"'\", \"־\": \"-\", \"–\": \"-\", \"—\": \"-\", \"‒\": \"-\", \"―\": \"-\",\n",
+    "                      \"“\": '\"', \"”\": '\"', \"„\": '\"', \"‘\": \"'\", \"’\": \"'\", \" \": \" \"})\n",
+    "_NIQQUD = re.compile(r\"[֑-ׇ]\")\n",
+    "\n",
+    "\n",
+    "def normalize(text: str) -> str:\n",
+    "    \"\"\"NFC, Hebrew points and cantillation removed, gershayim/geresh/maqaf/typographic quotes and\n",
+    "    dashes mapped to ASCII, whitespace collapsed.\"\"\"\n",
+    "    t = _NIQQUD.sub(\"\", unicodedata.normalize(\"NFC\", text)).translate(_MAP)\n",
+    "    return re.sub(r\"\\s+\", \" \", t).strip()\n",
+    "\n",
+    "\n",
+    "class CharKN:\n",
+    "    def __init__(self, alphabet: str, order: int, logp: list, bow: list):\n",
+    "        self.alphabet, self.N = alphabet, order\n",
+    "        self.code = {c: i + 1 for i, c in enumerate(alphabet)}\n",
+    "        # per order n (index n-1): sorted keys + values (compact); small orders also as dicts\n",
+    "        self._arr_p = [(np.asarray(k, np.int64), np.asarray(v, np.float32)) for k, v in logp]\n",
+    "        self._arr_b = [(np.asarray(k, np.int64), np.asarray(v, np.float32)) for k, v in bow]\n",
+    "        self.logp = [_Table(k, v, as_dict=len(k) <= DICT_MAX) for k, v in self._arr_p]\n",
+    "        self.bow = [_Table(k, v, as_dict=len(k) <= DICT_MAX) for k, v in self._arr_b]\n",
+    "        # never-seen character: the unigram level's share for unseen symbols, spread uniformly\n",
+    "        self.unk = (float(self._arr_b[0][1][0]) if len(self._arr_b[0][1]) else 0.0) - math.log(max(1, len(alphabet)))\n",
+    "\n",
+    "    # ---- querying ------------------------------------------------------------------------\n",
+    "    def logprob(self, context: str, char: str) -> float:\n",
+    "        \"\"\"ln P(char | context); `context` is the text so far (any length).\"\"\"\n",
+    "        return self._lp(context[-(self.N - 1):] if self.N > 1 else \"\", char)\n",
+    "\n",
+    "    @functools.lru_cache(maxsize=200_000)\n",
+    "    def _lp(self, ctx: str, char: str) -> float:\n",
+    "        w = self.code.get(char)\n",
+    "        if w is None:\n",
+    "            return self.unk\n",
+    "        codes = [self.code.get(c, 0) for c in ctx]\n",
+    "        if 0 in codes:                                   # unknown char: context restarts after it\n",
+    "            codes = codes[len(codes) - codes[::-1].index(0):]\n",
+    "        codes = [BOS] * (self.N - 1 - len(codes)) + codes\n",
+    "        acc = 0.0\n",
+    "        for n in range(self.N, 0, -1):                   # longest context first\n",
+    "            h = codes[len(codes) - (n - 1):] if n > 1 else []\n",
+    "            hk = 0\n",
+    "            for c in h:\n",
+    "                hk = hk * B + c\n",
+    "            gk = hk * B + w\n",
+    "            lp = self.logp[n - 1].get(gk)\n",
+    "            if lp is not None:\n",
+    "                return acc + lp\n",
+    "            if n > 1:\n",
+    "                acc += self.bow[n - 1].get(hk, 0.0)\n",
+    "        return acc + self.unk                            # acc already holds every bow on the way down\n",
+    "\n",
+    "    # ---- persistence ---------------------------------------------------------------------\n",
+    "    def save(self, path):\n",
+    "        arrs = {\"alphabet\": np.array(self.alphabet), \"order\": np.array(self.N)}\n",
+    "        for n in range(self.N):\n",
+    "            for name, (k, v) in ((\"p\", self._arr_p[n]), (\"b\", self._arr_b[n])):\n",
+    "                arrs[f\"{name}{n+1}_k\"], arrs[f\"{name}{n+1}_v\"] = k, v\n",
+    "        np.savez_compressed(path, **arrs)\n",
+    "\n",
+    "    @classmethod\n",
+    "    def load(cls, path):\n",
+    "        z = np.load(path, allow_pickle=False)\n",
+    "        N = int(z[\"order\"])\n",
+    "        return cls(str(z[\"alphabet\"]), N,\n",
+    "                   [(z[f\"p{n}_k\"], z[f\"p{n}_v\"]) for n in range(1, N + 1)],\n",
+    "                   [(z[f\"b{n}_k\"], z[f\"b{n}_v\"]) for n in range(1, N + 1)])\n",
+    "\n",
+    "\n",
+    "# ---- training ------------------------------------------------------------------------------\n",
+    "def _encode(lines, code, N):\n",
+    "    \"\"\"-> one int16 array: each line = (N-1) x <s> + its codes, lines separated by 0.\"\"\"\n",
+    "    parts = []\n",
+    "    pad = [BOS] * (N - 1)\n",
+    "    for ln in lines:\n",
+    "        parts.append(np.array(pad + [code[c] for c in ln] + [0], np.int64))\n",
+    "    return np.concatenate(parts) if parts else np.zeros(0, np.int64)\n",
+    "\n",
+    "\n",
+    "def _count(arr, n):\n",
+    "    \"\"\"Unique n-gram keys (no separator inside, not ending in <s>) with their counts.\"\"\"\n",
+    "    L = len(arr) - n + 1\n",
+    "    if L <= 0:\n",
+    "        return np.zeros(0, np.int64), np.zeros(0, np.int64)\n",
+    "    key = np.zeros(L, np.int64); ok = np.ones(L, bool)\n",
+    "    for j in range(n):\n",
+    "        seg = arr[j:j + L]\n",
+    "        key = key * B + seg; ok &= seg != 0\n",
+    "    ok &= arr[n - 1:n - 1 + L] != BOS                 # never predict <s>\n",
+    "    return np.unique(key[ok], return_counts=True)\n",
+    "\n",
+    "\n",
+    "def train(lines, alphabet: str, order: int = 6, prune_min=(1, 1, 1, 2, 2, 2), chunk_chars=8_000_000, log=print):\n",
+    "    code = {c: i + 1 for i, c in enumerate(alphabet)}\n",
+    "    assert len(alphabet) < BOS\n",
+    "    # 1. raw counts per order, chunked, merged\n",
+    "    raw = [None] * order\n",
+    "    buf, size = [], 0\n",
+    "    def flush():\n",
+    "        arr = _encode(buf, code, order)\n",
+    "        for n in range(1, order + 1):\n",
+    "            k, c = _count(arr, n)\n",
+    "            if raw[n - 1] is None:\n",
+    "                raw[n - 1] = (k, c)\n",
+    "            else:\n",
+    "                kk = np.concatenate([raw[n - 1][0], k]); cc = np.concatenate([raw[n - 1][1], c])\n",
+    "                u, inv = np.unique(kk, return_inverse=True)\n",
+    "                raw[n - 1] = (u, np.bincount(inv, weights=cc).astype(np.int64))\n",
+    "    for ln in lines:\n",
+    "        buf.append(ln); size += len(ln)\n",
+    "        if size >= chunk_chars:\n",
+    "            flush(); buf, size = [], 0; log(f\"  counted ... {len(raw[-1][0]):,} distinct {order}-grams\")\n",
+    "    if buf:\n",
+    "        flush()\n",
+    "    # 2. KN \"counts\": raw at the top order, continuation counts below\n",
+    "    a = [None] * order\n",
+    "    a[order - 1] = raw[order - 1]\n",
+    "    for n in range(order - 1, 0, -1):\n",
+    "        k_up = raw[n][0]                               # distinct (n+1)-grams\n",
+    "        suf = k_up % (B ** n)                           # drop their first character\n",
+    "        u, c = np.unique(suf, return_counts=True)\n",
+    "        a[n - 1] = (u, c.astype(np.int64))\n",
+    "    # 3. interpolated KN probabilities, lowest order first\n",
+    "    V = len(alphabet)\n",
+    "    logp, bow = [], []\n",
+    "    P_prev = None                                       # (sorted keys, probs) of order n-1\n",
+    "    for n in range(1, order + 1):\n",
+    "        k, c = a[n - 1]\n",
+    "        n1, n2 = int((c == 1).sum()), int((c == 2).sum())\n",
+    "        D = n1 / (n1 + 2 * n2) if n1 + 2 * n2 > 0 else 0.5\n",
+    "        hist = k // B\n",
+    "        hu, hinv = np.unique(hist, return_inverse=True)\n",
+    "        denom = np.bincount(hinv, weights=c)\n",
+    "        nfollow = np.bincount(hinv)\n",
+    "        bw = D * nfollow / denom                        # interpolation weight per history\n",
+    "        if n == 1:\n",
+    "            lower = np.full(len(k), 1.0 / V)\n",
+    "        else:\n",
+    "            idx = np.searchsorted(P_prev[0], k % (B ** (n - 1)))\n",
+    "            lower = P_prev[1][idx]\n",
+    "        p = np.maximum(c - D, 0) / denom[hinv] + bw[hinv] * lower\n",
+    "        P_prev = (k, p)\n",
+    "        keep = c >= prune_min[n - 1]\n",
+    "        logp.append((k[keep], np.log(p[keep]).astype(np.float32)))\n",
+    "        hk = hu if n > 1 else np.array([0], np.int64)\n",
+    "        bow.append((hk, np.log(bw).astype(np.float32) if n > 1 else np.log(bw[:1]).astype(np.float32)))\n",
+    "        log(f\"  order {n}: D={D:.3f} | {len(k):,} n-grams ({int(keep.sum()):,} kept) | {len(hu):,} histories\")\n",
+    "    return CharKN(alphabet, order, logp, bow)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f1e7438",
+   "metadata": {
+    "papermill": {
+     "duration": null,
+     "end_time": null,
+     "exception": null,
+     "start_time": null,
+     "status": "pending"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# ---- test-set decoding with a character LM: CTC prefix beam search (identical to exp38/eval_ctc_wordlm.py, word term off) ----\n",
+    "import sys, multiprocessing as mp, unicodedata\n",
+    "sys.path.insert(0, os.getcwd())\n",
+    "import charlm\n",
+    "NEG = -1e30\n",
+    "LM = charlm.CharKN.load(hf_hub_download(LM_REPO, LM_FILE))\n",
+    "def _lse(a, b):\n",
+    "    if a < b: a, b = b, a\n",
+    "    return a if b <= NEG else a + math.log1p(math.exp(b - a))\n",
+    "GG = {\"chars\": CHARS, \"lm\": LM, \"beam\": 12}\n",
+    "def beam_search(args):\n",
+    "    logprobs_, length, alpha, beta = args\n",
+    "    chars, lm = GG[\"chars\"], GG[\"lm\"]; beam, top_k, min_logp, blank = GG[\"beam\"], 8, -12.0, 0\n",
+    "    lp = np.asarray(logprobs_[:length], np.float64); lm_cache = {}\n",
+    "    def fuse(prefix, c):\n",
+    "        key = (prefix[-12:], c); v = lm_cache.get(key)\n",
+    "        if v is None:\n",
+    "            v = alpha * lm.logprob(prefix, c) + beta; lm_cache[key] = v\n",
+    "        return v\n",
+    "    beams = {\"\": (0.0, NEG)}\n",
+    "    for t in range(lp.shape[0]):\n",
+    "        row = lp[t]; cand = np.argpartition(row, -top_k)[-top_k:]; cand = [int(k) for k in cand if row[k] > min_logp]; nxt = {}\n",
+    "        for prefix, (pb, pnb) in beams.items():\n",
+    "            ptot = _lse(pb, pnb)\n",
+    "            for k in cand:\n",
+    "                p = row[k]\n",
+    "                if k == blank:\n",
+    "                    b, nb = nxt.get(prefix, (NEG, NEG)); nxt[prefix] = (_lse(b, ptot + p), nb); continue\n",
+    "                c = chars[k]\n",
+    "                if prefix and c == prefix[-1]:\n",
+    "                    b, nb = nxt.get(prefix, (NEG, NEG)); nxt[prefix] = (b, _lse(nb, pnb + p)); src = pb\n",
+    "                else:\n",
+    "                    src = ptot\n",
+    "                if src <= NEG: continue\n",
+    "                ext = prefix + c; b, nb = nxt.get(ext, (NEG, NEG)); nxt[ext] = (b, _lse(nb, src + p + fuse(prefix, c)))\n",
+    "        beams = dict(sorted(nxt.items(), key=lambda kv: _lse(*kv[1]), reverse=True)[:beam]) or {\"\": (0.0, NEG)}\n",
+    "    return max(beams.items(), key=lambda kv: _lse(*kv[1]))[0]\n",
+    "\n",
+    "def scores_full(R, H):\n",
+    "    \"\"\"CER with punctuation (raw), CER without punctuation (every Unicode punctuation character removed from reference AND hypothesis),\n",
+    "    WER on the raw text. Lines whose reference is empty are skipped.\"\"\"\n",
+    "    nop = lambda t: re.sub(r\" +\", \" \", \"\".join(c for c in t if not unicodedata.category(c).startswith(\"P\"))).strip()\n",
+    "    def cer_of(f):\n",
+    "        k = [i for i in range(len(R)) if f(R[i]).strip()]\n",
+    "        return jiwer.cer([f(R[i]) for i in k], [f(H[i]) for i in k])\n",
+    "    k = [i for i, r in enumerate(R) if r.strip()]\n",
+    "    return {\"cer\": jiwer.cer([R[i] for i in k], [H[i] for i in k]), \"wer\": jiwer.wer([R[i] for i in k], [H[i] for i in k]), \"cer_nopunct\": cer_of(nop)}\n",
+    "\n",
+    "@torch.no_grad()\n",
+    "def test_logprobs(model, split):\n",
+    "    model.eval(); out, R = [], []\n",
+    "    for px, cols, _, texts in loader(split, False, EVAL_BS):\n",
+    "        with torch.autocast(\"cuda\", dtype=AMP_DTYPE, enabled=device == \"cuda\"):\n",
+    "            lp = model(px.to(device))\n",
+    "        lp = lp.float().cpu().numpy(); out += [(lp[i], int(cols[i]) * SUB) for i in range(len(texts))]; R += texts\n",
+    "    return out, R\n",
+    "\n",
+    "if RUN_FINAL:\n",
+    "    L, R = test_logprobs(model, test)\n",
+    "    final_decoding = {\"greedy (no LM)\": scores_full(R, [greedy(lp, n) for lp, n in L])}\n",
+    "    for bw in LM_BEAMS:\n",
+    "        GG[\"beam\"] = bw\n",
+    "        with mp.get_context(\"fork\").Pool(os.cpu_count()) as pool:\n",
+    "            H = pool.map(beam_search, [(lp, n, LM_ALPHA, LM_BETA) for lp, n in L], chunksize=8)\n",
+    "        final_decoding[f\"beam {bw} + LM (alpha {LM_ALPHA}, beta {LM_BETA})\"] = scores_full(R, H)\n",
+    "        with open(os.path.join(OUT, f\"test_predictions_beam{bw}.tsv\"), \"w\", encoding=\"utf-8\") as fh:\n",
+    "            fh.write(\"ref\\thyp\\n\"); [fh.write(f\"{r}\\t{h}\\n\") for r, h in zip(R, H)]\n",
+    "    results[\"final\"][\"test_decoding\"] = final_decoding\n",
+    "    print(\"HHD TEST\", \"(LM = \" + LM_REPO + \"/\" + LM_FILE + \")\")\n",
+    "    for name, s in final_decoding.items():\n",
+    "        print(f\"  {name:48s} CER {100*s['cer']:.2f} | CER w/o punct {100*s['cer_nopunct']:.2f} | WER {100*s['wer']:.2f}\")\n",
+    "    json.dump(results, open(os.path.join(OUT, \"results.json\"), \"w\"), indent=1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8927bff1",
+   "metadata": {
+    "papermill": {
+     "duration": null,
+     "end_time": null,
+     "exception": null,
+     "start_time": null,
+     "status": "pending"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 9. Save to the public HF repo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "612d1f05",
+   "metadata": {
+    "papermill": {
+     "duration": null,
+     "end_time": null,
+     "exception": null,
+     "start_time": null,
+     "status": "pending"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from safetensors.torch import save_file\n",
+    "json.dump({\"chars\": CHARS}, open(os.path.join(OUT, \"charset.json\"), \"w\"), ensure_ascii=False)\n",
+    "if RUN_FINAL:   # weights of the FINAL model (full train set, last epoch); the select-phase model is not kept\n",
+    "    save_file({k: v.contiguous() for k, v in model.state_dict().items()}, os.path.join(OUT, \"model.safetensors\"))\n",
+    "if PUSH and not SMOKE:\n",
+    "    api = HfApi(); api.create_repo(OUT_REPO, private=False, exist_ok=True)\n",
+    "    api.upload_folder(repo_id=OUT_REPO, folder_path=OUT, commit_message=\"exp39 TrOCR-CTC, bandit data mixer (DiffusionPen vs fonts, 20k texts), HHD test\")\n",
+    "    print(\"pushed -> https://huggingface.co/\" + OUT_REPO)\n",
+    "else:\n",
+    "    print(\"not pushed (SMOKE or PUSH=False); files in\", OUT)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 725.466766,
+   "end_time": "2026-10-22T19:19:49.438679+00:00",
+   "environment_variables": {},
+   "exception": true,
+   "input_path": "/home/romanva1/hwrt-exp-trocr-ctc/diffpen_words/exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43_colab.ipynb",
+   "output_path": "/home/romanva1/work/queue_fontfill/exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43/exp39_bandit20k_diffpenaug_uni10aug_hhdgeom_llmgen_seed43_colab.ipynb",
+   "parameters": {},
+   "start_time": "2026-10-22T19:07:43.971913+00:00",
+   "version": "2.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}