Add the fine-tuned PP-OCRv6 weights (WiSE-FT soup, alpha=0.4)

README.md

@@ -1,233 +1,250 @@
----
-license: apache-2.0
-tags:
-- captcha
-- ocr
-- minecraft
-- anti-bot
-- pp-ocr
-- base_model:PaddlePaddle/PP-OCRv6_medium_rec_safetensors
----
-
-# CaptchaOCR PP-OCRv6 — a text recogniser for Minecraft anti-bot captchas
-
-> ## Status: the weights are **not published yet**. This repository holds the model card only.
->
-> The fine-tune on the [CaptchaOCR dataset](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset) has **not been run to completion**.
-> The main run reached **6 epochs of 30 planned
-> (240 of 1230 steps)** and was stopped by the author, so there is
-> **no checkpoint, no `config.json` and no weight file** in this repository. Nothing here is
-> invented: every number below is a measurement, and the file it was measured in is named
-> next to it.
->
-> **RU:** репозиторий модели пока **пуст по весам** — здесь только карточка. Основной прогон
-> дообучения отработал **6 эпох из 30** (шаг
-> **240 из 1230**) и был остановлен автором; обучение продолжается.
-> Пилотный прогон на 2 эпохи (`train/run_ppocr/smoke/`) — это отдельный прогон, его числа
-> не относятся к основному прогону и в таблицах ниже не подмешаны.
-
-## What it reads
-
-Frames from the [CaptchaOCR dataset](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset) — the kind of pictures the model is trained
-on. The caption gives the type and the **gold answer** from `labels.jsonl` (what the player has
-to type). The links are absolute: the pictures live in the dataset repository, not in this one.
-
-| | | |
-|---|---|---|
-| ![Minecraft map captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out/haq/mapcha/map/001.png) | ![Latin code captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out/LagBug/XProtect/code/001.png) | ![Cyrillic captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out_ru/LimboFilter/symbols/001.png) |
-| `haq/mapcha/map` — 128×128 map, 4 Latin characters · answer `s8TO` | `LagBug/XProtect/code` — 130×130, white background, noise · answer `EzhYNY` | `LimboFilter/symbols` — 128×128, 3 Cyrillic characters · answer `ЪМИ` |
-
-## What this model is
-
-A fine-tune of **PP-OCRv6 medium** (PaddleOCR's text recogniser) on the CaptchaOCR dataset: the
-captchas that open-source Minecraft anti-bot plugins draw, rendered by this project's own Java
-generators (46 captcha types, 4600 labelled PNG, 23 upstream plugins).
-
-* **Architecture:** PP-OCRv6 medium recogniser — PP-LCNetV4 backbone + CTC head,
-  `transformers` class `PPOCRV6SmallRecForTextRecognition`
-  (`model_type: pp_ocrv6_small_rec`), 19 134 326 parameters, hidden size 192.
-* **Dictionary:** the base model's own 18 710 classes (index 0 = CTC blank, space at the end).
-* **Input:** the captcha **text band** (the strip of pixels that carries the answer), not the whole
-  frame: resized to height 48, width scaled proportionally and right-padded to 320, BGR channel
-  order, normalised as `(x / 255 - 0.5) / 0.5`.
-* **Output:** per-timestep class probabilities; decoded greedily (CTC: collapse repeats, drop the
-  blank). Greedy decoding is the right decoder here — the answers are random strings, so a language
-  model has nothing to exploit.
-
-**The band is the whole game.** On the 29 dataset types that carry a band, the base model scores
-`acc_micro = 0.5517` on the band and `acc_micro = 0.0345` on the whole frame — about
-16× worse on the frame. A solver must crop first.
-
-## Provenance and licence
-
-* **Base model:** [`PaddlePaddle/PP-OCRv6_medium_rec_safetensors`](https://huggingface.co/PaddlePaddle/PP-OCRv6_medium_rec_safetensors) — Apache-2.0, by PaddlePaddle.
-* **This model:** that base, fine-tuned on the CaptchaOCR dataset published here:
-  [`Titlehhhh/captchaocr-dataset`](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset)
-  (46 captcha types · 4600 labelled PNG · 23 upstream plugins).
-* **Licence of the weights:** Apache-2.0, inherited from the base model. The fine-tuning code and
-  this card are released under the same terms.
-* **Licence of the dataset:** *not* Apache-2.0 — the dataset is split by the licence of the
-  upstream plugin of each captcha type. The dataset card has the per-type table, and the file
-  `LICENSE` in the dataset repository spells the same table out in full.
-
-## Measured results
-
-### This repository's weights
-
-**No weights, no metrics — the training run has not been completed.** This section will hold the
-exact match and CER per type and on the type-held-out split when a fine-tune that is actually
-better than the base model is finished. Until then, treat every number below as the **starting
-point**, not as a result of this repository.
-
-### The fine-tuning run that was measured (incomplete, stopped by the author)
-
-| | |
-|---|---|
-| command | `.venv-gpu\Scripts\python.exe train\finetune_ppocr.py --out train\run_ppocr\final --epochs 30 --batch-size 32 --lr 1e-4 --head-lr 1e-4 --workers 6 --eval-every 2 --save-every 100 --max-minutes 11` |
-| epochs completed | **6 of 30 planned** — stopped: by the author (the run was killed during epoch 5) |
-| steps completed | **240 of 1230** |
-| train loss | 1.0171 (epoch 0) → 0.0136 (epoch 5) |
-| speed | 101.3–119.2 img/s |
-| checkpoint (not published) | `train/run_ppocr/final/ckpt/step_000200.pt (model + optimiser + scheduler + GradScaler + step), best.pt (epoch 1)` |
-| source | `reports/TRAINING_PPOCR_V6.json` → `training_run` |
-
-### The base model, measured before fine-tuning (the zero step of that run)
-
-| held-out type | exact match | CER |
-|---|---|---|
-| `out/JSH32/Minecaptcha/map` | 0.93 | 0.02 |
-| `out/jonesdevelopment/sonar/complex` | 0.45 | 0.278 |
-| `out/jonesdevelopment/sonar/legacy` | 0.23 | 0.435 |
-| `out/jonesdevelopment/sonar/standard` | 0.6 | 0.158 |
-| `out/laforetbrut/are-you-sure/code` | 0.01 | 0.8 |
-| `out_ru/BotFilter/map` | 0.73 | 0.093 |
-| `out_ru/CaptchaVerifyZ/map` | 0.96 | 0.01 |
-| **median over 7 types** | **0.6** | **0.1575** |
-| **micro (700 images)** | **0.5586** | **0.2561** |
-
-### The base model on the whole dataset (archived benchmark)
-
-| measurement | value | source |
-|---|---|---|
-| exact match (micro) on the 29 band-carrying types, band crop | 0.5517 | `reports/bench_models/ppocrv6-medium.json` |
-| exact match (micro) on the same 29 types, whole frame | 0.0345 | `reports/bench_models/ppocrv6-medium.json` |
-| exact match (micro) on all 46 types, band crop | 0.4043 | `reports/bench_models/ppocrv6-medium.json` |
-
-Every number in this card comes from a file of the **CaptchaOCR** project repository — the
-measured results are in `reports/`, they are not typed by hand and nothing is extrapolated.
-
-**Why the weights are not here yet.** The measured run did **not** improve on the base model:
-the median exact match over the 7 held-out types fell from 0.6 (untouched base)
-to 0.41 at epoch 1 and to 0.24 at epoch 3, and
-one type out of seven got better while six got worse. A checkpoint like that is deliberately
-**not** published: shipping it as "the model" would misrepresent it. Training continues with a
-changed hypothesis (a much smaller learning rate, a frozen backbone, a larger and more diverse
-training set) — the plan and the measurements are in `reports/TRAINING_PPOCR_V6.md` §8.
-
-## How to use it
-
-> The snippet below is the **preprocessing the project itself uses** (`train/ppocr_data.py`), and it
-> was verified end-to-end against the base model on a real sample of the dataset (it decoded the
-> held-out sample `JSH32/Minecaptcha/map/001.png`, band `[25, 77, 79, 35]`, as `PTAY`, which is the
-> gold answer). It is written for the moment the weights are published — until then
-> `from_pretrained("Titlehhhh/captchaocr-ppocrv6")` has nothing to load.
-
-```python
-import json
-
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from transformers import PPOCRV6SmallRecForTextRecognition
-
-REPO_ID = "Titlehhhh/captchaocr-ppocrv6"
-
-model = PPOCRV6SmallRecForTextRecognition.from_pretrained(REPO_ID).eval()
-# the dictionary comes with the model repository (preprocessor_config.json)
-character_list = json.load(
-    open(hf_hub_download(REPO_ID, "preprocessor_config.json"), encoding="utf-8")
-)["character_list"]
-
-HEIGHT, MAX_WIDTH = 48, 320
-
-
-def prepare(band: Image.Image) -> torch.Tensor:
-    """band -> (1, 3, 48, 320) float tensor."""
-    scale = HEIGHT / max(1, band.height)
-    w = max(1, min(MAX_WIDTH, int(round(band.width * scale))))
-    small = band.convert("RGB").resize((w, HEIGHT), Image.BILINEAR)
-    a = np.asarray(small, dtype=np.float32) / 255.0
-    a = a[:, :, ::-1]            # BGR, as PP-OCRv6 expects
-    a = (a - 0.5) / 0.5         # paddle normalisation
-    canvas = np.zeros((3, HEIGHT, MAX_WIDTH), dtype=np.float32)
-    canvas[:, :, :w] = a.transpose(2, 0, 1)
-    return torch.from_numpy(canvas)[None]
-
-
-def greedy_decode(probs) -> str:
-    """CTC greedy decode: collapse repeats, drop the blank."""
-    best = probs.argmax(dim=-1)[0].tolist()
-    chars, prev = [], -1
-    for k in best:
-        if k != prev and k != 0:
-            chars.append(character_list[k])
-        prev = k
-    return "".join(chars)
-
-
-image = Image.open("captcha.png")
-x, y, w, h = (25, 77, 79, 35)        # the answer band: take it from labels.jsonl
-band = image.crop((x, y, x + w, y + h))
-
-with torch.no_grad():
-    probs = model(pixel_values=prepare(band)).last_hidden_state
-
-print(greedy_decode(probs))
-```
-
-The band (`roi`) is not optional: on scene-like captchas the answer is one line among several, and
-the whole frame makes the model read the wrong line.
-
-## Reproducing
-
-The training code lives in the **CaptchaOCR** project repository:
-
-```powershell
-.venv-gpu\Scripts\python.exe train\finetune_ppocr.py --epochs 30 --batch-size 32
-```
-
-`train/finetune_ppocr.py` fine-tunes `PaddlePaddle/PP-OCRv6_medium_rec_safetensors` on the dataset, holds out whole **plugins**
-(never a random image split: several captcha types have only a few distinct answers, so a random
-split lets the exact gold answer of a test image appear in the training half), and reports exact
-match and CER per type plus the median over types. `train/ppocr_data.py` holds the dataset loader
-and the preprocessing shown above.
-
-The measured report of the run quoted above is `reports/TRAINING_PPOCR_V6.json` (numbers) and
-`reports/TRAINING_PPOCR_V6.md` (the analysis), both in the project repository.
-
-## Repository metadata
-
-While the weights are absent, this repository declares **only** `license: Apache-2.0` and the
-tags above — there is deliberately **no** `library_name`, **no** `pipeline_tag` and **no**
-`base_model:` field, because those three fields make the Hub list the repository as a loadable
-`transformers` model. There is nothing to load yet. When the weights are published, the
-`library_name: transformers` and `pipeline_tag: image-to-text` fields will be added back together
-with the weight files, in the same commit.
-
-## Limitations
-
-* **Only the text band is read.** This is a recogniser, not a solver: it does not reverse strings,
-  does not turn Russian number words into digits and does not compute arithmetic.
-* **No Cyrillic in the dictionary.** The base model's 18 710 classes contain no Cyrillic at
-  all, so the Cyrillic captcha types of the dataset cannot be expressed in this model's alphabet.
-* **The data is synthetic.** Every image is a render of this project's own generators — faithful to
-  the upstream algorithms, but not a screenshot of a live server.
-* **Generalisation is the hard part.** A recogniser can memorise a plugin's style instead of
-  learning the characters; only the type-held-out numbers mean anything.
-
-## Citation
-
-This model is a fine-tune of PP-OCRv6 by PaddlePaddle (Apache-2.0). The dataset is the
-CaptchaOCR dataset, re-rendered from open-source Minecraft anti-bot plugins. See the dataset card
-for the provenance and the per-type licence of every captcha type.
+---
+license: apache-2.0
+library_name: transformers
+base_model: PaddlePaddle/PP-OCRv6_medium_rec_safetensors
+tags:
+- captcha
+- ocr
+- minecraft
+- anti-bot
+- pp-ocr
+- base_model:PaddlePaddle/PP-OCRv6_medium_rec_safetensors
+---
+
+# CaptchaOCR PP-OCRv6 — a text recogniser for Minecraft anti-bot captchas
+
+> ## The weights are published. Read this before you use them.
+>
+> This repository holds the **actual weights** of a fine-tune of
+> [`PaddlePaddle/PP-OCRv6_medium_rec_safetensors`](https://huggingface.co/PaddlePaddle/PP-OCRv6_medium_rec_safetensors),
+> trained by us on the [CaptchaOCR dataset](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset)
+> — our synthetic Minecraft anti-bot captchas. The published weights are the **weight
+> interpolation (WiSE-FT style "soup") with α = 0.4** between the fine-tuned checkpoint
+> (epoch 7 of a 20-epoch run) and the pretrained base model.
+>
+> **Measured on 7 captcha types that were never trained on** (whole plugins held out,
+> 3 500 images, exact match on the normalised `text`):
+>
+> | | exact match (median over the 7 types) | CER | exact match (micro, 3 500 images) |
+> |---|---|---|---|
+> | **the weights published here** (α = 0.4) | **0.638** | 0.1503 | **0.6123** |
+> | the untouched base model (α = 0) | 0.588 | 0.1657 | 0.5646 |
+> | the fine-tune on its own (α = 1) | 0.480 | 0.2233 | 0.5480 |
+>
+> **The published weights are better than the base model: +5.0 points of median exact match
+> and +4.8 points of micro.** Two honest caveats, both important:
+>
+> 1. **The best α was chosen on the same held-out set the result is measured on**, so the
+>    gain is optimistic — on new held-out plugin styles it will be smaller. The curve is
+>    smooth (the gain holds over the whole range α ∈ [0.25, 0.6]), so this is not a single
+>    lucky point.
+> 2. **The fine-tune on its own (α = 1) is *worse* than the base** (0.480 vs 0.588 median):
+>    on 13 training types it specialises and loses the base's generality. The interpolation
+>    is what makes the fine-tune a net win.
+>
+> Every number above is a measurement, and the file it was measured in is named next to it.
+
+> **RU:** веса опубликованы. Это **дообучение** PP-OCRv6 на нашем синтетическом датасете
+> капч; опубликована **интерполяция весов с базой, α = 0.4** (WiSE-FT). На 7 удержанных
+> типах (3 500 картинок): **0.638** exact (медиана) / 0.6123 micro против **0.588 / 0.5646**
+> у нетронутой базовой модели. Само дообучение без интерполяции — **0.480**, то есть хуже
+> базы. Оговорка: лучшее α выбрано на том же удержанном наборе, поэтому прирост оптимистичен.
+
+## What it reads
+
+Frames from the [CaptchaOCR dataset](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset) — the kind of pictures the model is trained
+on. The caption gives the type and the **gold answer** from `labels.jsonl` (what the player has
+to type). The links are absolute: the pictures live in the dataset repository, not in this one.
+
+| | | |
+|---|---|---|
+| ![Minecraft map captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out/haq/mapcha/map/001.png) | ![Latin code captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out/LagBug/XProtect/code/001.png) | ![Cyrillic captcha](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset/resolve/main/data/out_ru/LimboFilter/symbols/001.png) |
+| `haq/mapcha/map` — 128×128 map, 4 Latin characters · answer `s8TO` | `LagBug/XProtect/code` — 130×130, white background, noise · answer `EzhYNY` | `LimboFilter/symbols` — 128×128, 3 Cyrillic characters · answer `ЪМИ` |
+
+## What this model is
+
+A fine-tune of **PP-OCRv6 medium** (PaddleOCR's text recogniser) on the CaptchaOCR dataset: the
+captchas that open-source Minecraft anti-bot plugins draw, rendered by this project's own Java
+generators (46 captcha types, 23 upstream plugins).
+
+* **Architecture:** PP-OCRv6 medium recogniser — PP-LCNetV4 backbone + CTC head,
+  `transformers` class `PPOCRV6SmallRecForTextRecognition`
+  (`model_type: pp_ocrv6_small_rec`), 19 134 326 parameters, hidden size 192.
+* **Dictionary:** the base model's own 18 710 classes (index 0 = CTC blank, space at the end).
+* **Input:** the captcha **text band** (the strip of pixels that carries the answer), not the whole
+  frame: resized to height 48, width scaled proportionally and right-padded to 320, BGR channel
+  order, normalised as `(x / 255 - 0.5) / 0.5`.
+* **Output:** per-timestep class probabilities; decoded greedily (CTC: collapse repeats, drop the
+  blank). Greedy decoding is the right decoder here — the answers are random strings, so a language
+  model has nothing to exploit.
+
+**The band is the whole game.** On the 29 dataset types that carry a band, the base model scores
+`acc_micro = 0.5517` on the band and `acc_micro = 0.0345` on the whole frame — about
+16× worse on the frame. A solver must crop first.
+
+## Measured results
+
+### The weights published here
+
+The fine-tune ran for 20 epochs (4 080 steps) on 13 captcha types; the best checkpoint by
+held-out median exact match was **epoch 7 (step 1 632)**. The published weights are that
+checkpoint interpolated with the pretrained base model, **θ = 0.4 · θ_finetuned + 0.6 · θ_base**.
+
+| α | median exact (7 types) | median CER | micro exact (3 500) | micro CER |
+|---|---|---|---|---|
+| 0.00 — the pretrained base | 0.588 | 0.1657 | 0.5646 | 0.2446 |
+| 0.25 | 0.620 | 0.1483 | 0.5991 | 0.2132 |
+| **0.40 — published** | **0.638** | **0.1503** | **0.6123** | **0.2004** |
+| 0.50 | 0.614 | 0.1630 | 0.6123 | 0.1964 |
+| 0.60 | 0.592 | 0.1773 | 0.6100 | 0.1951 |
+| 0.75 | 0.542 | 0.2040 | 0.5949 | 0.1995 |
+| 1.00 — the fine-tune alone | 0.480 | 0.2233 | 0.5480 | 0.2181 |
+
+Per held-out type, at the published α = 0.40 (exact match / CER):
+
+| held-out type | base (α = 0) | **published (α = 0.4)** | fine-tune alone (α = 1) |
+|---|---|---|---|
+| `out/JSH32/Minecaptcha/map` | 0.938 / 0.015 | **0.950 / 0.013** | 0.954 / 0.012 |
+| `out/jonesdevelopment/sonar/complex` | 0.388 / 0.291 | **0.484 / 0.219** | 0.446 / 0.223 |
+| `out/jonesdevelopment/sonar/legacy` | 0.342 / 0.335 | **0.458 / 0.255** | 0.380 / 0.299 |
+| `out/jonesdevelopment/sonar/standard` | 0.588 / 0.166 | **0.638 / 0.150** | 0.480 / 0.238 |
+| `out/laforetbrut/are-you-sure/code` | 0.000 / 0.808 | **0.018 / 0.681** | 0.024 / 0.600 |
+| `out_ru/BotFilter/map` | 0.730 / 0.090 | **0.740 / 0.084** | 0.560 / 0.152 |
+| `out_ru/CaptchaVerifyZ/map` | 0.966 / 0.007 | **0.998 / 0.000** | 0.992 / 0.002 |
+| **median over the 7 types** | **0.588** | **0.638** | **0.480** |
+| **micro over 3 500 images** | **0.5646** | **0.6123** | **0.5480** |
+
+**How the split was made:** whole **plugins** were held out (5 plugins, 7 types, 3 500 images) —
+no image of a held-out type was ever trained on. Never a random image split: several captcha
+types have only a few distinct answers, so a random split lets the exact gold answer of a test
+image appear in the training half.
+
+**The training set:** 13 captcha types (~6 500 images) of the local generation of the
+CaptchaOCR dataset — the same 46 types and the same generators as the published dataset
+repository, but with 500 images per type instead of 100 (the generators are not seeded, so a
+regeneration is a different sample of the same types).
+
+### The base model on the whole dataset (archived benchmark)
+
+| measurement | value | source |
+|---|---|---|
+| exact match (micro) on the 29 band-carrying types, band crop | 0.5517 | `reports/bench_models/ppocrv6-medium.json` |
+| exact match (micro) on the same 29 types, whole frame | 0.0345 | `reports/bench_models/ppocrv6-medium.json` |
+| exact match (micro) on all 46 types, band crop | 0.4043 | `reports/bench_models/ppocrv6-medium.json` |
+
+Every number in this card comes from a file of the **CaptchaOCR** project repository — the
+measured results are in `reports/`, they are not typed by hand and nothing is extrapolated.
+
+## Provenance and licence
+
+* **Base model:** [`PaddlePaddle/PP-OCRv6_medium_rec_safetensors`](https://huggingface.co/PaddlePaddle/PP-OCRv6_medium_rec_safetensors) — Apache-2.0, by PaddlePaddle.
+* **This model:** that base, fine-tuned on the CaptchaOCR dataset published here:
+  [`Titlehhhh/captchaocr-dataset`](https://huggingface.co/datasets/Titlehhhh/captchaocr-dataset)
+  (46 captcha types · 23 upstream plugins).
+* **Licence of the weights:** Apache-2.0, inherited from the base model. The fine-tuning code and
+  this card are released under the same terms.
+* **Licence of the dataset:** *not* Apache-2.0 — the dataset is split by the licence of the
+  upstream plugin of each captcha type. The dataset card has the per-type table, and the file
+  `LICENSE` in the dataset repository spells the same table out in full.
+
+## How to use it
+
+The model is a plain `transformers` text recogniser. `transformers` 5.x has **no** `image-to-text`
+pipeline for a CTC recogniser any more (that task name now belongs to vision-language chat
+models), so load it directly:
+
+```python
+import torch
+from transformers import AutoModelForTextRecognition, AutoProcessor
+from PIL import Image
+
+REPO_ID = "Titlehhhh/captchaocr-ppocrv6"
+
+model = AutoModelForTextRecognition.from_pretrained(REPO_ID).eval()
+processor = AutoProcessor.from_pretrained(REPO_ID)   # preprocessor_config.json + the dictionary
+
+image = Image.open("captcha.png").convert("RGB")
+x, y, w, h = (25, 77, 79, 35)        # the answer band: take it from labels.jsonl
+band = image.crop((x, y, x + w, y + h))
+
+with torch.no_grad():
+    out = model(**processor(images=band, return_tensors="pt"))
+
+print(processor.post_process_text_recognition(out)[0]["text"])
+```
+
+The processor does the whole preprocessing: resize to height 48 (width scaled proportionally),
+right-pad to 320, RGB→BGR, normalise as `(x / 255 - 0.5) / 0.5`, and the greedy CTC decode that
+drops the blank and collapses repeats. The dictionary (18 710 characters) travels in
+`preprocessor_config.json` and is also readable as `character_list.txt`.
+
+> The normalisation `(x / 255 − 0.5) / 0.5` is written **explicitly** into
+> `preprocessor_config.json` (`image_mean = image_std = [0.5, 0.5, 0.5]`). The upstream file does
+> not mention it, and the `transformers` image processor would then fall back to the ImageNet
+> statistics — which is *not* what these weights were trained with.
+
+**The band (`roi`) is not optional:** on scene-like captchas the answer is one line among several,
+and the whole frame makes the model read the wrong line.
+
+## Reproducing
+
+The training code lives in the **CaptchaOCR** project repository:
+
+```powershell
+# 1. the fine-tune (13 training types, 5 plugins / 7 types held out)
+.venv-gpu\Scripts\python.exe train\finetune_ppocr.py --out train\run_ppocr\big --epochs 20 --batch-size 32 --lr 1e-5 --head-lr 1e-5 --workers 6 --eval-every 1 --save-every 100 --max-minutes 36
+# 2. the weight interpolation (7 values of alpha, the same evaluation)
+.venv-gpu\Scripts\python.exe train\run_ppocr\big\soup_eval.py
+# 3. the export into a Hugging Face folder
+.venv-gpu\Scripts\python.exe train\run_ppocr\export_hf.py --ckpt train\run_ppocr\big\soup_best.pt --out train\run_ppocr\big\export_soup
+```
+
+`train/finetune_ppocr.py` fine-tunes `PaddlePaddle/PP-OCRv6_medium_rec_safetensors` on the dataset, holds out whole **plugins**
+(never a random image split: several captcha types have only a few distinct answers, so a random
+split lets the exact gold answer of a test image appear in the training half), and reports exact
+match and CER per type plus the median over types. `train/ppocr_data.py` holds the dataset loader
+and the preprocessing shown above.
+
+The measured report of the run quoted above is `reports/TRAINING_PPOCR_V6_BIG.md` (the analysis)
+and `reports/TRAINING_PPOCR_V6_BIG.json` (the numbers), in the project repository.
+
+## Repository metadata
+
+| file | what |
+|---|---|
+| `model.safetensors` | the weights: θ = 0.4·θ_finetuned (epoch 7, step 1 632) + 0.6·θ_pretrained |
+| `config.json` | the architecture — copied from the base model, unchanged by the fine-tune |
+| `preprocessor_config.json` | the input geometry, the normalisation and the 18 710-character dictionary |
+| `processor_config.json` | which processor class `AutoProcessor` has to build |
+| `character_list.txt` | the same dictionary, one character per line, index 0 = `blank` |
+| `finetune_meta.json` | the provenance of this export (source checkpoint, epoch, step, α) |
+
+There is deliberately **no** `pipeline_tag`: `transformers` 5.x removed the `image-to-text`
+pipeline task (it belongs to vision-language chat models now), and a recogniser has to be called
+through `AutoModelForTextRecognition`, as in the snippet above. `library_name: transformers` is
+declared because the repository really is a `transformers` model.
+
+## Limitations
+
+* **Only the text band is read.** This is a recogniser, not a solver: it does not reverse strings,
+  does not turn Russian number words into digits and does not compute arithmetic.
+* **No Cyrillic in the dictionary.** The base model's 18 710 classes contain no Cyrillic at
+  all, so the Cyrillic captcha types of the dataset cannot be expressed in this model's alphabet.
+* **The data is synthetic.** Every image is a render of this project's own generators — faithful to
+  the upstream algorithms, but not a screenshot of a live server.
+* **Generalisation is the hard part.** A recogniser can memorise a plugin's style instead of
+  learning the characters; only the type-held-out numbers mean anything.
+* **The headline number is optimistic.** α = 0.4 was picked on the same 7 held-out types the
+  result is reported on, and the best checkpoint was picked the same way. Treat 0.638 as an upper
+  estimate on *new* plugin styles, not as a guarantee.
+* **One hard type stays hard.** `out/laforetbrut/are-you-sure/code` is at 1.8 % exact match
+  (CER 0.68): the answer band of that type does not carry a clean text line.
+* **The weights are an interpolation, not a clean fine-tune.** `model.safetensors` is
+  0.4·θ_finetuned + 0.6·θ_pretrained; the pure fine-tune is in the project repository
+  (`train/run_ppocr/big/best.pt`) and is *worse* on unseen plugin styles.
+
+## Citation
+
+This model is a fine-tune of PP-OCRv6 by PaddlePaddle (Apache-2.0). The dataset is the
+CaptchaOCR dataset, re-rendered from open-source Minecraft anti-bot plugins. See the dataset card
+for the provenance and the per-type licence of every captcha type.

config.json

@@ -0,0 +1,147 @@
+{
+  "model_type": "pp_ocrv6_small_rec",
+  "backbone_config": {
+    "model_type": "pp_lcnet_v4",
+    "stem_channels": [
+      3,
+      64,
+      128
+    ],
+    "stem_type": "large",
+    "out_features": [
+      "stage1",
+      "stage2",
+      "stage3",
+      "stage4"
+    ],
+    "out_indices": [
+      1,
+      2,
+      3,
+      4
+    ],
+    "block_configs": [
+      [
+        [
+          3,
+          128,
+          128,
+          1,
+          true
+        ]
+      ],
+      [
+        [
+          3,
+          128,
+          256,
+          1,
+          false
+        ],
+        [
+          3,
+          256,
+          256,
+          1,
+          false
+        ],
+        [
+          3,
+          256,
+          256,
+          1,
+          true
+        ]
+      ],
+      [
+        [
+          3,
+          256,
+          512,
+          [
+            2,
+            1
+          ],
+          false
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          true
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          false
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          true
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          false
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          true
+        ],
+        [
+          3,
+          512,
+          512,
+          1,
+          false
+        ]
+      ],
+      [
+        [
+          3,
+          512,
+          768,
+          [
+            2,
+            1
+          ],
+          false
+        ],
+        [
+          3,
+          768,
+          768,
+          1,
+          true
+        ],
+        [
+          3,
+          768,
+          768,
+          1,
+          false
+        ]
+      ]
+    ]
+  },
+  "hidden_act": "silu",
+  "hidden_size": 192,
+  "mlp_ratio": 4.0,
+  "depth": 2,
+  "head_out_channels": 18710,
+  "conv_kernel_size": [
+    1,
+    7
+  ]
+}

finetune_meta.json

@@ -0,0 +1,28 @@
+{
+ "base_model": "PaddlePaddle/PP-OCRv6_medium_rec_safetensors",
+ "checkpoint": "C:\\Users\\Title\\Projects\\CapthaModel\\train\\run_ppocr\\big\\soup_best.pt",
+ "epoch": 7,
+ "step": 1632,
+ "soup_alpha": 0.4,
+ "classes": 18710,
+ "parameters": 19176118,
+ "tensors": 308,
+ "normalisation": {
+  "mean": [
+   0.5,
+   0.5,
+   0.5
+  ],
+  "std": [
+   0.5,
+   0.5,
+   0.5
+  ]
+ },
+ "transformers_class": "PPOCRV6SmallRecForTextRecognition",
+ "recipe": "theta = alpha * theta_finetuned + (1 - alpha) * theta_pretrained",
+ "source_checkpoint": "C:\\Users\\Title\\Projects\\CapthaModel\\train\\run_ppocr\\big\\best.pt",
+ "source_epoch": 7,
+ "source_step": 1632,
+ "held_out_median_exact": 0.638
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20b25a3e38d2bc4b6379d9f58c284950cad1ee9e6ca60b1b384421c5dc4b04eb
+size 76747448

processor_config.json

@@ -0,0 +1,4 @@
+{
+  "image_processor_type": "PPOCRV6SmallRecImageProcessor",
+  "processor_class": "PPOCRV6SmallRecImageProcessor"
+}