Publish verified OCR-aware MXFP8 checkpoint

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AutomatosX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,84 @@
+---
+license: mit
+base_model: baidu/Unlimited-OCR
+library_name: mlx-vlm
+pipeline_tag: image-text-to-text
+tags:
+- mlx
+- mlx-vlm
+- ocr
+- mxfp8
+- int8
+- apple-silicon
+---
+
+# AX Unlimited-OCR 3B MoE — MLX MXFP8
+
+This is an AutomatosX sensitivity-guided MLX conversion of
+[`baidu/Unlimited-OCR`](https://huggingface.co/baidu/Unlimited-OCR). It was
+created from the upstream BF16 weights. The
+[`sahilchachra/unlimited-ocr-mxfp8-mlx`](https://huggingface.co/sahilchachra/unlimited-ocr-mxfp8-mlx)
+checkpoint was used only as a comparison reference; these are not repackaged
+Sahil weights.
+
+## What was optimized
+
+Each supported module group was quantized independently and evaluated for OCR
+CER, digit CER, and table structure. Eligible language linear layers use MXFP8
+(8 data bits, group size 32). A joint calibration then selected affine INT8
+(group size 32) for the LM head because BF16 missed the throughput floor and
+MXFP8 missed the CER ceiling. OCR-critical or sensitive groups remain BF16.
+Retained groups: vision_encoder.
+
+The model uses mlx-vlm's native `model_type=unlimited-ocr` implementation and a
+sliding-window size of 128.
+
+## AutomatosX validation
+
+These are local release measurements, not upstream paper benchmark claims.
+The content-addressed evaluation set had 12 samples
+(12 with digits, 3 with
+CJK, and 3 with tables), digest
+`78ca3e7c9c7584aea30b04176716a6dadf49ccf0f2bead959cbaeb9aeac68f30`.
+
+| Checkpoint | Mean CER | Digit CER | Table score | Decode tok/s |
+|---|---:|---:|---:|---:|
+| Upstream BF16 | 0.239188 | 0.087340 | 1.000000 | — |
+| Sahil MXFP8 reference | 1.057249 | 0.209153 | 1.000000 | 312.73 |
+| AutomatosX candidate | 0.237384 | 0.085733 | 1.000000 | 297.20 |
+
+Weight size: 3.579 GiB  
+Aggregate weight SHA-256: `a4f6e9934f90564906f42929542ad68493f0c6187ad431128e447debbf52b6f4`
+
+## Release gates
+
+- ✅ `weights_are_distinct` — actual `a4f6e9934f90564906f42929542ad68493f0c6187ad431128e447debbf52b6f4`, limit `different from 439c6acfe5e277537dfe3368b94a145a6b0da4c39e4bd00582977d030f292ad1`
+- ✅ `weight_size_gb` — actual `3.5792221864685416`, limit `4.5`
+- ✅ `native_model_metadata` — actual `{'architecture': True, 'model_type': True, 'mxfp8': True, 'sliding_window': True, 'processor_class': True, 'sft_format': True}`, limit `True`
+- ✅ `evaluation_coverage` — actual `{'samples': 12, 'digit': 12, 'cjk': 3, 'table': 3}`, limit `all counts > 0`
+- ✅ `same_evaluation_samples` — actual `[12, 12, 12]`, limit `12`
+- ✅ `candidate_cer_vs_bf16` — actual `-0.0018033315701714847`, limit `0.01`
+- ✅ `candidate_cer_vs_reference` — actual `-0.8198643918447561`, limit `0.005`
+- ✅ `candidate_digit_cer_vs_bf16` — actual `-0.0016074315849917697`, limit `0.01`
+- ✅ `candidate_table_score_vs_bf16` — actual `0.0`, limit `0.01`
+- ✅ `candidate_tps_vs_reference` — actual `0.9503587809120344`, limit `0.9`
+- ✅ `rswa_8k_bounded` — actual `{'cache_bounded': True, 'tps_stable': True, '8k_test_passed': True}`, limit `True`
+
+Full per-sample evidence, sensitivity results, precision rules, PRD, ADR, and
+technical specification are included under `release/`, `quantization/`, and
+`docs/`.
+
+## Usage
+
+```bash
+pip install mlx-vlm
+python -m mlx_vlm.generate \
+  --model AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+  --image document.png \
+  --prompt '<image>document parsing.' \
+  --max-tokens 4096
+```
+
+Apple Silicon and a recent `mlx-vlm` release with native Unlimited-OCR support
+are required. This is quantization/conversion work, not foundation-model
+retraining or domain fine-tuning.

benchmarks/datasets.md

@@ -0,0 +1,57 @@
+# Benchmark Datasets
+
+## Evaluation Dataset Requirements
+
+The evaluation set must be separate from any calibration data used for quantization decisions.
+
+### Recommended Composition (minimum 500 samples)
+
+| Category                  | Minimum Samples |
+|---------------------------|----------------:|
+| English printed documents |              75 |
+| Simplified Chinese        |              50 |
+| Traditional Chinese       |              50 |
+| Chinese-English mixed     |              50 |
+| Tables                    |              75 |
+| Forms                     |              50 |
+| Invoices and receipts     |              50 |
+| Mathematical formulas     |              30 |
+| Multicolumn documents     |              40 |
+| Low-quality scans         |              50 |
+| Long text pages           |              30 |
+
+### Suggested Public Sources
+
+- **PubTabNet** — table structure recognition
+- **CORD** — consolidated receipt dataset
+- **SROIE** — scanned receipts OCR
+- **ICDAR 2019** — document images
+- **CASIA** — Chinese handwritten/printed
+- **Custom Traditional Chinese** — government forms, academic papers
+
+### Directory Structure
+
+```
+benchmarks/eval_data/
+├── images/           # Input document images (PNG/JPG)
+├── ground_truth/     # Reference text files (same stem as image)
+└── metadata.json     # Dataset composition and source info
+```
+
+### Ground Truth Format
+
+Each ground truth file is a plain `.txt` file containing the expected OCR output.
+For table evaluation, include the expected markdown table structure.
+
+### Evaluation Protocol
+
+1. All models compared using identical:
+   - Input images (no preprocessing unless explicitly testing preprocessing)
+   - Prompt: `<image>document parsing.`
+   - Max tokens: 8192
+   - Temperature: 0.0 (deterministic)
+   - Output normalization (via `normalize_output.py`)
+
+2. Report per-category results, not just aggregate.
+
+3. Separate raw-input and preprocessed-input results.

benchmarks/evaluate_cer.py

@@ -0,0 +1,279 @@
+"""Character and Word Error Rate evaluation for OCR output.
+
+Provides CER, WER, digit-specific CER, and normalized edit distance.
+
+Usage:
+    from benchmarks.evaluate_cer import compute_cer, compute_digit_cer, evaluate_file
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from pathlib import Path
+
+import numpy as np
+
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tiff", ".tif", ".webp", ".bmp"}
+
+
+def extract_cjk_characters(text: str) -> list[str]:
+    """Return Chinese, Japanese, and Korean script characters from text."""
+    ranges = (
+        (0x3400, 0x4DBF),    # CJK Extension A
+        (0x4E00, 0x9FFF),    # CJK Unified Ideographs
+        (0xF900, 0xFAFF),    # CJK Compatibility Ideographs
+        (0x20000, 0x2FA1F),  # CJK supplementary extensions
+        (0x30000, 0x323AF),  # CJK Extensions G and H
+        (0x3040, 0x309F),    # Hiragana
+        (0x30A0, 0x30FF),    # Katakana
+        (0x31F0, 0x31FF),    # Katakana phonetic extensions
+        (0xFF66, 0xFF9D),    # Half-width Katakana
+        (0x1B000, 0x1B16F),  # Kana supplements and small kana
+        (0x1100, 0x11FF),    # Hangul Jamo
+        (0x3130, 0x318F),    # Hangul compatibility Jamo
+        (0xA960, 0xA97F),    # Hangul Jamo Extended-A
+        (0xAC00, 0xD7AF),    # Hangul syllables
+        (0xD7B0, 0xD7FF),    # Hangul Jamo Extended-B
+    )
+    return [
+        char
+        for char in text
+        if any(start <= ord(char) <= end for start, end in ranges)
+    ]
+
+
+def normalize_text(text: str) -> str:
+    """Normalize text for fair comparison.
+
+    - Unicode NFC normalization
+    - Collapse whitespace
+    - Strip leading/trailing whitespace
+    """
+    text = unicodedata.normalize("NFC", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def edit_distance(ref: list, hyp: list) -> int:
+    """Compute Levenshtein edit distance between two sequences."""
+    n, m = len(ref), len(hyp)
+    if n == 0:
+        return m
+    if m == 0:
+        return n
+
+    # Use two rows for memory efficiency
+    prev = list(range(m + 1))
+    curr = [0] * (m + 1)
+
+    for i in range(1, n + 1):
+        curr[0] = i
+        for j in range(1, m + 1):
+            if ref[i - 1] == hyp[j - 1]:
+                curr[j] = prev[j - 1]
+            else:
+                curr[j] = 1 + min(prev[j], curr[j - 1], prev[j - 1])
+        prev, curr = curr, prev
+
+    return prev[m]
+
+
+def compute_cer(reference: str, hypothesis: str, normalize: bool = True) -> float:
+    """Compute Character Error Rate.
+
+    CER = edit_distance(ref_chars, hyp_chars) / len(ref_chars)
+    """
+    if normalize:
+        reference = normalize_text(reference)
+        hypothesis = normalize_text(hypothesis)
+
+    # Remove spaces for character-level comparison
+    ref_chars = list(reference.replace(" ", ""))
+    hyp_chars = list(hypothesis.replace(" ", ""))
+
+    if len(ref_chars) == 0:
+        return 0.0 if len(hyp_chars) == 0 else 1.0
+
+    dist = edit_distance(ref_chars, hyp_chars)
+    return dist / len(ref_chars)
+
+
+def compute_wer(reference: str, hypothesis: str, normalize: bool = True) -> float:
+    """Compute Word Error Rate.
+
+    WER = edit_distance(ref_words, hyp_words) / len(ref_words)
+    """
+    if normalize:
+        reference = normalize_text(reference)
+        hypothesis = normalize_text(hypothesis)
+
+    ref_words = reference.split()
+    hyp_words = hypothesis.split()
+
+    if len(ref_words) == 0:
+        return 0.0 if len(hyp_words) == 0 else 1.0
+
+    dist = edit_distance(ref_words, hyp_words)
+    return dist / len(ref_words)
+
+
+def compute_digit_cer(reference: str, hypothesis: str) -> float:
+    """Compute CER only on digit characters (0-9).
+
+    Critical for financial documents, invoices, and forms.
+    """
+    ref_digits = re.sub(r"[^0-9]", "", reference)
+    hyp_digits = re.sub(r"[^0-9]", "", hypothesis)
+
+    if len(ref_digits) == 0:
+        return 0.0 if len(hyp_digits) == 0 else 1.0
+
+    dist = edit_distance(list(ref_digits), list(hyp_digits))
+    return dist / len(ref_digits)
+
+
+def compute_cjk_cer(reference: str, hypothesis: str) -> float:
+    """Compute CER specifically for CJK characters."""
+    ref_cjk = extract_cjk_characters(reference)
+    hyp_cjk = extract_cjk_characters(hypothesis)
+
+    if len(ref_cjk) == 0:
+        return 0.0 if len(hyp_cjk) == 0 else 1.0
+
+    dist = edit_distance(ref_cjk, hyp_cjk)
+    return dist / len(ref_cjk)
+
+
+def detect_repetition(text: str, ngram_size: int = 35, threshold: int = 3) -> float:
+    """Detect repetition rate in generated text.
+
+    Returns the fraction of n-grams that appear more than `threshold` times.
+    """
+    if not isinstance(ngram_size, int) or isinstance(ngram_size, bool) or ngram_size < 1:
+        raise ValueError("ngram_size must be a positive integer")
+    if not isinstance(threshold, int) or isinstance(threshold, bool) or threshold < 0:
+        raise ValueError("threshold must be a non-negative integer")
+
+    words = text.split()
+    if len(words) < ngram_size:
+        return 0.0
+
+    ngrams = []
+    for i in range(len(words) - ngram_size + 1):
+        ngrams.append(tuple(words[i:i + ngram_size]))
+
+    if not ngrams:
+        return 0.0
+
+    from collections import Counter
+    counts = Counter(ngrams)
+    repeated = sum(1 for c in counts.values() if c > threshold)
+    return repeated / len(counts)
+
+
+def evaluate_text(reference: str, hypothesis: str) -> dict:
+    """Evaluate a reference/hypothesis text pair."""
+    return {
+        "cer": compute_cer(reference, hypothesis),
+        "wer": compute_wer(reference, hypothesis),
+        "digit_cer": compute_digit_cer(reference, hypothesis),
+        "cjk_cer": compute_cjk_cer(reference, hypothesis),
+        "repetition_rate": detect_repetition(hypothesis),
+        "ref_length": len(reference),
+        "hyp_length": len(hypothesis),
+        "ref_digit_count": sum(char.isascii() and char.isdigit() for char in reference),
+        "ref_cjk_count": len(extract_cjk_characters(reference)),
+    }
+
+
+def evaluate_file(reference_path: str | Path, hypothesis_path: str | Path) -> dict:
+    """Evaluate a single reference/hypothesis pair."""
+    reference = Path(reference_path).read_text(encoding="utf-8")
+    hypothesis = Path(hypothesis_path).read_text(encoding="utf-8")
+    return evaluate_text(reference, hypothesis)
+
+
+def evaluate_directory(
+    images_dir: str | Path,
+    ground_truth_dir: str | Path,
+    hypothesis_dir: str | Path,
+) -> dict:
+    """Evaluate all files in a directory.
+
+    Returns aggregate metrics.
+    """
+    image_dir = Path(images_dir)
+    gt_dir = Path(ground_truth_dir)
+    hyp_dir = Path(hypothesis_dir)
+
+    for label, directory in (
+        ("images", image_dir),
+        ("ground truth", gt_dir),
+        ("hypothesis", hyp_dir),
+    ):
+        if not directory.is_dir():
+            raise NotADirectoryError(f"{label.title()} directory not found: {directory}")
+
+    image_files = sorted(
+        path
+        for path in image_dir.iterdir()
+        if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+    )
+    image_stems = [path.stem for path in image_files]
+    duplicate_stems = sorted({stem for stem in image_stems if image_stems.count(stem) > 1})
+    if duplicate_stems:
+        raise ValueError(
+            "Multiple input images share the same stem: " + ", ".join(duplicate_stems)
+        )
+
+    results = []
+    missing_ground_truth = []
+    missing_hypotheses = []
+    for image_file in image_files:
+        gt_file = gt_dir / f"{image_file.stem}.txt"
+        if not gt_file.is_file():
+            missing_ground_truth.append(image_file.name)
+            continue
+        hyp_file = hyp_dir / gt_file.name
+        reference = gt_file.read_text(encoding="utf-8")
+        if hyp_file.is_file():
+            hypothesis = hyp_file.read_text(encoding="utf-8")
+        else:
+            # A missing prediction is an empty prediction, not a sample that
+            # can be silently removed from the accuracy denominator.
+            hypothesis = ""
+            missing_hypotheses.append(image_file.name)
+        result = evaluate_text(reference, hypothesis)
+        result["file"] = gt_file.stem
+        result["image"] = image_file.name
+        result["missing_hypothesis"] = not hyp_file.is_file()
+        results.append(result)
+
+    if not results:
+        return {
+            "error": "No images with matching ground-truth files found",
+            "num_images": len(image_files),
+            "num_samples": 0,
+            "missing_ground_truth": missing_ground_truth,
+            "missing_hypotheses": missing_hypotheses,
+        }
+
+    digit_results = [r["digit_cer"] for r in results if r["ref_digit_count"] > 0]
+    cjk_results = [r["cjk_cer"] for r in results if r["ref_cjk_count"] > 0]
+
+    return {
+        "num_images": len(image_files),
+        "num_samples": len(results),
+        "num_digit_samples": len(digit_results),
+        "num_cjk_samples": len(cjk_results),
+        "missing_ground_truth": missing_ground_truth,
+        "missing_hypotheses": missing_hypotheses,
+        "mean_cer": float(np.mean([r["cer"] for r in results])),
+        "mean_wer": float(np.mean([r["wer"] for r in results])),
+        "mean_digit_cer": float(np.mean(digit_results)) if digit_results else None,
+        "mean_cjk_cer": float(np.mean(cjk_results)) if cjk_results else None,
+        "mean_repetition_rate": float(np.mean([r["repetition_rate"] for r in results])),
+        "per_file": results,
+    }

benchmarks/evaluate_tables.py

@@ -0,0 +1,285 @@
+"""Table structure evaluation (TEDS-like scoring).
+
+Provides a simplified Tree-Edit-Distance-based Similarity score for tables
+by comparing HTML table structures.
+
+Usage:
+    from benchmarks.evaluate_tables import compute_table_score, evaluate_tables
+"""
+
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+from pathlib import Path
+
+
+def _split_markdown_row(line: str) -> list[str]:
+    """Split a Markdown row, honoring optional outer and escaped pipes."""
+    stripped = line.strip()
+    if stripped.startswith("|"):
+        stripped = stripped[1:]
+    if stripped.endswith("|") and not stripped.endswith(r"\|"):
+        stripped = stripped[:-1]
+    return [
+        cell.replace(r"\|", "|").strip()
+        for cell in re.split(r"(?<!\\)\|", stripped)
+    ]
+
+
+def _is_separator_row(line: str) -> bool:
+    cells = _split_markdown_row(line)
+    return bool(cells) and all(re.fullmatch(r":?-{3,}:?", cell) for cell in cells)
+
+
+def _extract_markdown_tables_with_positions(text: str) -> list[tuple[int, str]]:
+    """Extract Markdown tables together with their character offsets."""
+    lines = text.split("\n")
+    offsets = []
+    offset = 0
+    for line in lines:
+        offsets.append(offset)
+        offset += len(line) + 1
+
+    tables: list[tuple[int, str]] = []
+    index = 0
+    while index + 1 < len(lines):
+        table_start = index
+        header = lines[index].strip()
+        separator = lines[index + 1].strip()
+        if "|" not in header or not _is_separator_row(separator):
+            index += 1
+            continue
+
+        header_cells = _split_markdown_row(header)
+        separator_cells = _split_markdown_row(separator)
+        if len(header_cells) != len(separator_cells):
+            index += 1
+            continue
+
+        current_table = [header, separator]
+        index += 2
+        while index < len(lines):
+            row = lines[index].strip()
+            if not row or "|" not in row:
+                break
+            current_table.append(row)
+            index += 1
+        tables.append((offsets[table_start], "\n".join(current_table)))
+
+    return tables
+
+
+def extract_tables_from_markdown(text: str) -> list[str]:
+    """Extract markdown tables from OCR output."""
+    return [table for _, table in _extract_markdown_tables_with_positions(text)]
+
+
+def extract_tables_from_html(text: str) -> list[str]:
+    """Extract HTML tables from OCR output."""
+    return [table for _, table in _extract_html_tables_with_positions(text)]
+
+
+def _extract_html_tables_with_positions(text: str) -> list[tuple[int, str]]:
+    """Extract balanced outer HTML tables, preserving nested table markup."""
+    tag_pattern = re.compile(r"</?table\b[^>]*>", re.IGNORECASE)
+    tables: list[tuple[int, str]] = []
+    depth = 0
+    start: int | None = None
+    for match in tag_pattern.finditer(text):
+        if re.match(r"<\s*/", match.group(0)):
+            if depth == 0:
+                continue
+            depth -= 1
+            if depth == 0 and start is not None:
+                tables.append((start, text[start:match.end()]))
+                start = None
+        else:
+            if depth == 0:
+                start = match.start()
+            depth += 1
+    return tables
+
+
+def _extract_tables_in_document_order(text: str) -> list[str]:
+    """Extract Markdown and HTML tables without reordering their occurrences."""
+    html_tables = _extract_html_tables_with_positions(text)
+    html_ranges = [(start, start + len(table)) for start, table in html_tables]
+    located = [
+        (start, table)
+        for start, table in _extract_markdown_tables_with_positions(text)
+        if not any(begin <= start < end for begin, end in html_ranges)
+    ]
+    located.extend(html_tables)
+    located.sort(key=lambda item: item[0])
+    return [table for _, table in located]
+
+
+class _HTMLTableParser(HTMLParser):
+    """Collect rows and cells from one HTML table without external parsers."""
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.table_depth = 0
+        self.rows: list[list[str]] = []
+        self._row: list[str] | None = None
+        self._cell_parts: list[str] | None = None
+
+    def handle_starttag(self, tag: str, attrs):
+        tag = tag.lower()
+        if tag == "table":
+            self.table_depth += 1
+        elif self.table_depth == 1 and tag == "tr":
+            self._row = []
+        elif self.table_depth == 1 and tag in {"td", "th"} and self._row is not None:
+            self._cell_parts = []
+        elif self.table_depth == 1 and tag == "br" and self._cell_parts is not None:
+            self._cell_parts.append("\n")
+
+    def handle_data(self, data: str):
+        if self.table_depth == 1 and self._cell_parts is not None:
+            self._cell_parts.append(data)
+
+    def handle_endtag(self, tag: str):
+        tag = tag.lower()
+        if self.table_depth == 1 and tag in {"td", "th"}:
+            if self._row is not None and self._cell_parts is not None:
+                value = re.sub(r"\s+", " ", "".join(self._cell_parts)).strip()
+                self._row.append(value)
+            self._cell_parts = None
+        elif self.table_depth == 1 and tag == "tr":
+            if self._row is not None and self._row:
+                self.rows.append(self._row)
+            self._row = None
+            self._cell_parts = None
+        elif tag == "table" and self.table_depth:
+            self.table_depth -= 1
+
+
+def _normalize_html_table(table_text: str) -> dict:
+    parser = _HTMLTableParser()
+    parser.feed(table_text)
+    parser.close()
+    rows = parser.rows
+    if not rows:
+        return {"num_rows": 0, "num_cols": 0, "cells": []}
+    return {
+        "num_rows": len(rows),
+        "num_cols": max(len(row) for row in rows),
+        "cells": [cell for row in rows for cell in row],
+    }
+
+
+def normalize_table(table_text: str) -> dict:
+    """Parse a markdown table into a normalized structure.
+
+    Returns dict with: num_rows, num_cols, cells (flattened list).
+    """
+    if re.search(r"<table\b", table_text, re.IGNORECASE):
+        return _normalize_html_table(table_text)
+
+    lines = [l.strip() for l in table_text.strip().split("\n") if l.strip()]
+
+    # Filter out the Markdown header separator.
+    data_lines = [line for line in lines if not _is_separator_row(line)]
+
+    rows = []
+    for line in data_lines:
+        rows.append(_split_markdown_row(line))
+
+    if not rows:
+        return {"num_rows": 0, "num_cols": 0, "cells": []}
+
+    num_cols = max(len(r) for r in rows) if rows else 0
+    cells = []
+    for row in rows:
+        cells.extend(row)
+
+    return {
+        "num_rows": len(rows),
+        "num_cols": num_cols,
+        "cells": cells,
+    }
+
+
+def compute_table_score(reference_table: str, hypothesis_table: str) -> float:
+    """Compute a simplified TEDS-like score between two tables.
+
+    Score is based on:
+    - Structure match (rows x cols): 40% weight
+    - Cell content match: 60% weight
+
+    Returns score in [0, 1] where 1 = perfect match.
+    """
+    ref = normalize_table(reference_table)
+    hyp = normalize_table(hypothesis_table)
+
+    if ref["num_rows"] == 0 and hyp["num_rows"] == 0:
+        return 1.0
+    if ref["num_rows"] == 0 or hyp["num_rows"] == 0:
+        return 0.0
+
+    # Structure score
+    row_match = 1.0 - abs(ref["num_rows"] - hyp["num_rows"]) / max(ref["num_rows"], hyp["num_rows"])
+    col_match = 1.0 - abs(ref["num_cols"] - hyp["num_cols"]) / max(ref["num_cols"], hyp["num_cols"])
+    structure_score = (row_match + col_match) / 2
+
+    # Cell content score (compare flattened cells)
+    ref_cells = ref["cells"]
+    hyp_cells = hyp["cells"]
+
+    if not ref_cells:
+        return structure_score * 0.4
+
+    # Simple cell-by-cell comparison
+    max_len = max(len(ref_cells), len(hyp_cells))
+    matches = 0
+    for i in range(min(len(ref_cells), len(hyp_cells))):
+        # Normalize whitespace for comparison
+        rc = re.sub(r"\s+", " ", ref_cells[i]).strip().lower()
+        hc = re.sub(r"\s+", " ", hyp_cells[i]).strip().lower()
+        if rc == hc:
+            matches += 1
+        elif rc and hc and (rc in hc or hc in rc):
+            matches += 0.5
+
+    cell_score = matches / max_len if max_len > 0 else 0.0
+
+    # Weighted combination
+    return 0.4 * structure_score + 0.6 * cell_score
+
+
+def evaluate_tables(reference_text: str, hypothesis_text: str) -> dict:
+    """Evaluate table extraction quality between reference and hypothesis.
+
+    Returns dict with: num_ref_tables, num_hyp_tables, mean_score, per_table_scores.
+    """
+    ref_tables = _extract_tables_in_document_order(reference_text)
+    hyp_tables = _extract_tables_in_document_order(hypothesis_text)
+
+    if not ref_tables:
+        return {
+            "num_ref_tables": 0,
+            "num_hyp_tables": len(hyp_tables),
+            "mean_score": 1.0 if not hyp_tables else 0.0,
+            "per_table_scores": [0.0] * len(hyp_tables),
+        }
+
+    # Match tables by position (simplified)
+    scores = []
+    for i, ref_table in enumerate(ref_tables):
+        if i < len(hyp_tables):
+            score = compute_table_score(ref_table, hyp_tables[i])
+        else:
+            score = 0.0  # Missing table
+        scores.append(score)
+
+    # Hallucinated extra tables must count against the result as well.
+    scores.extend([0.0] * max(0, len(hyp_tables) - len(ref_tables)))
+
+    return {
+        "num_ref_tables": len(ref_tables),
+        "num_hyp_tables": len(hyp_tables),
+        "mean_score": float(sum(scores) / len(scores)) if scores else 0.0,
+        "per_table_scores": scores,
+    }

benchmarks/normalize_output.py

@@ -0,0 +1,128 @@
+"""Normalize OCR output for fair comparison.
+
+Strips model-specific artifacts, normalizes whitespace, and removes
+special tokens before evaluation.
+
+Usage:
+    python benchmarks/normalize_output.py input.txt output.txt
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import unicodedata
+from pathlib import Path
+
+
+def normalize_ocr_output(text: str) -> str:
+    """Normalize OCR output for evaluation.
+
+    Steps:
+    1. Remove special tokens (<|det|>, <|/det|>, <|grounding|>, etc.)
+    2. Unicode NFC normalization
+    3. Normalize whitespace (collapse multiple spaces/newlines)
+    4. Strip leading/trailing whitespace
+    5. Normalize common OCR artifacts
+    """
+    if not isinstance(text, str):
+        raise TypeError("text must be a string")
+
+    # Tokenizer-visible whitespace markers occasionally survive decoding.
+    text = text.replace("Ġ", " ").replace("Ċ", "\n")
+
+    # Remove grounding coordinates only when they are part of a detection
+    # span. A blanket ``[digits]`` removal corrupts legitimate text such as
+    # citations and list markers.
+    number = r"-?\d+(?:\.\d+)?"
+    coordinate_pattern = re.compile(
+        rf"\[\s*{number}\s*,\s*{number}\s*,\s*{number}\s*,\s*{number}\s*\]"
+    )
+
+    # In the older ref/det form, the ref span is recognized content and should
+    # be retained while the following coordinate-only det span is removed.
+    text = re.sub(
+        r"<\|ref\|>(.*?)<\|/ref\|>\s*<\|det\|>.*?<\|/det\|>",
+        lambda match: match.group(1),
+        text,
+        flags=re.DOTALL,
+    )
+
+    def clean_detection(match: re.Match) -> str:
+        inner = match.group(1)
+        # Current output uses ``<|det|>layout-label [box]<|/det|>content``.
+        # Both the layout label and coordinates are metadata, not OCR text.
+        return "" if coordinate_pattern.search(inner) else inner
+
+    text = re.sub(
+        r"<\|det\|>(.*?)<\|/det\|>",
+        clean_detection,
+        text,
+        flags=re.DOTALL,
+    )
+    # Some decoded outputs omit the first opening <|det|> token.
+    text = re.sub(
+        rf"(?m)(^|\n)[^\n<]*?{coordinate_pattern.pattern}"
+        rf"(?=\s*<\|/det\|>)",
+        lambda match: match.group(1),
+        text,
+    )
+
+    # Remove special tokens
+    text = re.sub(r"<\|[^|]*\|>", "", text)
+    text = re.sub(r"<｜[^｜]*｜>", "", text)
+    text = re.sub(r"<PAGE>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"<image>", "", text)
+
+    # Unicode normalization
+    text = unicodedata.normalize("NFC", text)
+
+    # Normalize different types of whitespace
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+    # Collapse multiple blank lines to max 2
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    # Collapse multiple spaces (but preserve single newlines)
+    text = re.sub(r"[^\S\n]+", " ", text)
+
+    # Strip each line
+    lines = [line.strip() for line in text.split("\n")]
+    text = "\n".join(lines)
+
+    # Whitespace-only lines become empty only after the per-line strip above,
+    # so enforce the blank-line limit again afterwards.
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    # Strip overall
+    text = text.strip()
+
+    return text
+
+
+def normalize_for_digit_comparison(text: str) -> str:
+    """Extract only digits and decimal points for numeric comparison."""
+    return re.sub(r"[^0-9.]", "", text)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Normalize OCR output for evaluation")
+    parser.add_argument("input", type=Path, help="Raw OCR text file")
+    parser.add_argument("output", type=Path, help="Normalized output file")
+    args = parser.parse_args()
+
+    input_path = args.input
+    output_path = args.output
+
+    text = input_path.read_text(encoding="utf-8")
+    normalized = normalize_ocr_output(text)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(normalized, encoding="utf-8")
+
+    print(f"Normalized: {input_path} -> {output_path}")
+    print(f"  Input:  {len(text)} chars")
+    print(f"  Output: {len(normalized)} chars")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/rswa_validation.py

@@ -0,0 +1,500 @@
+"""R-SWA (Reference Sliding Window Attention) cache validation.
+
+Instruments MLX KV-cache behavior at increasing output lengths to verify
+whether the model's R-SWA mechanism properly bounds cache growth.
+
+Usage:
+    python benchmarks/rswa_validation.py \
+        --model-path AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+        --image test_image.jpg \
+        --output benchmarks/results/rswa_results.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import platform
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+
+# Output lengths to test
+TEST_LENGTHS = [512, 2048, 4096, 8192, 16384]
+
+
+class MinGeneratedTokensProcessor:
+    """Suppress EOS until a requested number of new tokens has been sampled.
+
+    ``mlx-vlm`` passes prompt tokens to logits processors as well as generated
+    tokens.  The first observed token count is therefore recorded as the prompt
+    length, keeping this stress-test control independent of prompt tokenization.
+    A fresh processor must be constructed for every generation call.
+    """
+
+    def __init__(self, min_new_tokens: int, eos_token_ids: list[int]):
+        if (
+            not isinstance(min_new_tokens, int)
+            or isinstance(min_new_tokens, bool)
+            or min_new_tokens < 1
+        ):
+            raise ValueError("min_new_tokens must be a positive integer")
+        normalized_ids = sorted({
+            int(token_id)
+            for token_id in eos_token_ids
+            if isinstance(token_id, int) and not isinstance(token_id, bool)
+        })
+        if not normalized_ids:
+            raise ValueError("At least one integer EOS token ID is required")
+        self.min_new_tokens = min_new_tokens
+        self.eos_token_ids = normalized_ids
+        self._prompt_token_count: int | None = None
+
+    def __call__(self, tokens, logits):
+        sequence = tokens.tolist() if hasattr(tokens, "tolist") else list(tokens)
+        if sequence and isinstance(sequence[0], list):
+            sequence = sequence[0]
+        if self._prompt_token_count is None:
+            self._prompt_token_count = len(sequence)
+        generated_tokens = max(0, len(sequence) - self._prompt_token_count)
+        if generated_tokens < self.min_new_tokens:
+            logits[:, self.eos_token_ids] = float("-inf")
+        return logits
+
+
+def collect_eos_token_ids(model, processor) -> list[int]:
+    """Collect EOS IDs from model config and the loaded tokenizer wrapper."""
+    values = []
+    model_config = getattr(model, "config", None)
+    values.append(getattr(model_config, "eos_token_id", None))
+
+    tokenizer = getattr(processor, "tokenizer", processor)
+    values.append(getattr(tokenizer, "eos_token_ids", None))
+    values.append(getattr(tokenizer, "eos_token_id", None))
+    stopping_criteria = getattr(tokenizer, "stopping_criteria", None)
+    values.append(getattr(stopping_criteria, "eos_token_ids", None))
+
+    normalized: set[int] = set()
+    for value in values:
+        candidates = value if isinstance(value, (list, tuple, set)) else [value]
+        for candidate in candidates:
+            if isinstance(candidate, int) and not isinstance(candidate, bool):
+                normalized.add(candidate)
+    if not normalized:
+        raise ValueError("Could not determine EOS token IDs from model or processor")
+    return sorted(normalized)
+
+
+def detect_repetition_rate(text: str, ngram_size: int = 35, threshold: int = 3) -> float:
+    """Detect fraction of repeated n-grams in output."""
+    if not isinstance(ngram_size, int) or isinstance(ngram_size, bool) or ngram_size < 1:
+        raise ValueError("ngram_size must be a positive integer")
+    if not isinstance(threshold, int) or isinstance(threshold, bool) or threshold < 0:
+        raise ValueError("threshold must be a non-negative integer")
+    words = text.split()
+    if len(words) < ngram_size:
+        return 0.0
+
+    from collections import Counter
+    ngrams = [tuple(words[i:i+ngram_size]) for i in range(len(words) - ngram_size + 1)]
+    counts = Counter(ngrams)
+    repeated = sum(1 for c in counts.values() if c > threshold)
+    return repeated / len(counts) if counts else 0.0
+
+
+def analyze_cache_behavior(results: list[dict]) -> tuple[bool | None, str]:
+    """Conservatively classify cache growth from successful length-limited runs.
+
+    Returns ``None`` when the generated token counts do not span enough lengths
+    to distinguish a plateau from ordinary noise or linear growth.
+    """
+    successful = [
+        result
+        for result in results
+        if result.get("status") == "success"
+        and result.get("tokens_generated", 0) > 0
+        and result.get("tokens_generated_reliable", True)
+        and result.get("memory_growth_mb") is not None
+    ]
+    # Collapse duplicate actual token counts; raising max_tokens is not useful
+    # evidence when the model naturally stops at the same length each time.
+    by_tokens: dict[int, float] = {}
+    for result in successful:
+        tokens = int(result["tokens_generated"])
+        by_tokens[tokens] = max(by_tokens.get(tokens, 0.0), result["memory_growth_mb"])
+    points = sorted(by_tokens.items())
+
+    if len(points) < 3:
+        return None, "Need at least three distinct generated lengths"
+    if points[-1][0] < points[0][0] * 2:
+        return None, "Generated token counts span less than 2x"
+
+    # Peak-memory readings can fluctuate slightly, so enforce their cumulative
+    # maximum before comparing early and late slopes.
+    monotonic_memory = []
+    running_peak = 0.0
+    for tokens, memory in points:
+        running_peak = max(running_peak, float(memory))
+        monotonic_memory.append((tokens, running_peak))
+
+    midpoint = len(monotonic_memory) // 2
+    first_tokens, first_memory = monotonic_memory[0]
+    middle_tokens, middle_memory = monotonic_memory[midpoint]
+    last_tokens, last_memory = monotonic_memory[-1]
+    early_span = middle_tokens - first_tokens
+    late_span = last_tokens - middle_tokens
+    if early_span <= 0 or late_span <= 0:
+        return None, "Generated lengths are not sufficiently distinct"
+
+    total_memory_change = last_memory - first_memory
+    # A wide token span with <=64 MB of additional peak memory is direct
+    # plateau evidence even if the early slope is effectively zero.
+    if last_tokens >= first_tokens * 4 and total_memory_change <= 64.0:
+        return True, "Peak memory stayed within 64 MB across a >=4x token span"
+
+    early_slope = (middle_memory - first_memory) / early_span
+    late_slope = (last_memory - middle_memory) / late_span
+    if early_slope <= 0:
+        return None, "Memory variation is too small to estimate a growth trend"
+
+    if late_slope <= early_slope * 0.25:
+        return True, "Late memory-growth slope is <=25% of the early slope"
+    return False, "Memory growth does not plateau at longer generated lengths"
+
+
+def run_rswa_validation(
+    model_path: str,
+    image_path: str,
+    prompt: str = "<image>document parsing.",
+    test_lengths: list[int] | None = None,
+    force_min_tokens: int | None = None,
+) -> dict:
+    """Run R-SWA cache validation at increasing output lengths.
+
+    Measures:
+    - Peak memory at each output length
+    - Decode TPS in first vs last quarter
+    - Cache growth behavior
+    - Repetition rate
+    - Completion status
+    """
+    if test_lengths is None:
+        test_lengths = list(TEST_LENGTHS)
+    else:
+        test_lengths = list(test_lengths)
+    if not Path(image_path).is_file():
+        raise FileNotFoundError(f"Test image not found: {image_path}")
+    if not isinstance(prompt, str) or prompt.count("<image>") != 1:
+        raise ValueError("prompt must contain exactly one literal '<image>' token")
+    if not test_lengths or any(
+        not isinstance(length, int) or isinstance(length, bool) or length < 1
+        for length in test_lengths
+    ):
+        raise ValueError("test_lengths must contain positive integers")
+    if len(set(test_lengths)) != len(test_lengths):
+        raise ValueError("test_lengths must not contain duplicates")
+    if test_lengths != sorted(test_lengths):
+        raise ValueError("test_lengths must be in increasing order")
+    if len(test_lengths) < 3:
+        raise ValueError("test_lengths must contain at least three lengths")
+    if 8192 not in test_lengths:
+        raise ValueError("test_lengths must include 8192 for the required 8K check")
+    if test_lengths[-1] < test_lengths[0] * 2:
+        raise ValueError("test_lengths must span at least 2x")
+    if force_min_tokens is not None and (
+        not isinstance(force_min_tokens, int)
+        or isinstance(force_min_tokens, bool)
+        or force_min_tokens < 1
+    ):
+        raise ValueError("force_min_tokens must be a positive integer or None")
+
+    from mlx_vlm import load, generate
+    import mlx.core as mx
+
+    print(f"Loading model: {model_path}")
+    model, processor = load(model_path)
+    eos_token_ids = (
+        collect_eos_token_ids(model, processor)
+        if force_min_tokens is not None
+        else []
+    )
+
+    baseline_memory = mx.get_active_memory() / 1e6
+    print(f"Baseline memory: {baseline_memory:.0f} MB")
+
+    results = []
+
+    for max_tokens in test_lengths:
+        print(f"\n--- Testing max_tokens={max_tokens} ---")
+
+        mx.clear_cache()
+        mem_before = mx.get_active_memory() / 1e6
+        mx.reset_peak_memory()
+        start = time.perf_counter()
+
+        try:
+            forced_minimum = (
+                min(force_min_tokens, max_tokens)
+                if force_min_tokens is not None
+                else None
+            )
+            logits_processors = (
+                [MinGeneratedTokensProcessor(forced_minimum, eos_token_ids)]
+                if forced_minimum is not None
+                else None
+            )
+            response = generate(
+                model, processor,
+                prompt=prompt,
+                image=[image_path],
+                max_tokens=max_tokens,
+                temperature=0.0,
+                logits_processors=logits_processors,
+                verbose=False,
+            )
+            elapsed = time.perf_counter() - start
+            peak_memory = (
+                response.get("peak_memory")
+                if isinstance(response, dict)
+                else getattr(response, "peak_memory", None)
+            )
+            mem_after = (
+                float(peak_memory) * 1000
+                if peak_memory is not None and float(peak_memory) > 0
+                else mx.get_peak_memory() / 1e6
+            )
+
+            # Extract text
+            if isinstance(response, str):
+                text = response
+                tokens_generated = len(text.split())
+                token_count_source = "whitespace estimate"
+                tokens_reliable = False
+            elif hasattr(response, "text"):
+                text = response.text
+                if not isinstance(text, str):
+                    raise TypeError("mlx-vlm returned a non-string text field")
+                raw_tokens = getattr(
+                    response,
+                    "generation_tokens",
+                    getattr(response, "tokens_generated", None),
+                )
+                if raw_tokens is None:
+                    tokens_generated = len(text.split())
+                    token_count_source = "whitespace estimate"
+                    tokens_reliable = False
+                else:
+                    tokens_generated = raw_tokens
+                    token_count_source = "mlx-vlm token count"
+                    tokens_reliable = True
+            elif isinstance(response, dict):
+                text = response.get("text", "")
+                if not isinstance(text, str):
+                    raise TypeError("mlx-vlm returned a non-string text field")
+                raw_tokens = response.get(
+                    "generation_tokens", response.get("tokens_generated")
+                )
+                if raw_tokens is None:
+                    tokens_generated = len(text.split())
+                    token_count_source = "whitespace estimate"
+                    tokens_reliable = False
+                else:
+                    tokens_generated = raw_tokens
+                    token_count_source = "mlx-vlm token count"
+                    tokens_reliable = True
+            else:
+                text = str(response)
+                tokens_generated = len(text.split())
+                token_count_source = "whitespace estimate"
+                tokens_reliable = False
+
+            # Compute metrics
+            tokens_generated = int(tokens_generated or 0)
+            reported_tps = (
+                response.get("generation_tps", 0.0)
+                if isinstance(response, dict)
+                else getattr(response, "generation_tps", 0.0)
+            )
+            tps = float(reported_tps) if reported_tps else (
+                tokens_generated / elapsed if elapsed > 0 else 0
+            )
+            repetition = detect_repetition_rate(text)
+            memory_growth = max(0.0, mem_after - mem_before)
+            finish_reason = (
+                response.get("finish_reason")
+                if isinstance(response, dict)
+                else getattr(response, "finish_reason", None)
+            )
+            if finish_reason is not None:
+                completed = finish_reason != "length"
+            elif tokens_reliable:
+                completed = tokens_generated < max_tokens
+            else:
+                completed = None
+
+            result = {
+                "max_tokens": max_tokens,
+                "tokens_generated": tokens_generated,
+                "tokens_generated_source": token_count_source,
+                "tokens_generated_reliable": tokens_reliable,
+                "elapsed_seconds": elapsed,
+                "mean_tps": tps,
+                "tps_source": (
+                    "mlx-vlm generation_tps" if reported_tps else "end-to-end estimate"
+                ),
+                "peak_memory_mb": mem_after,
+                "memory_growth_mb": memory_growth,
+                "repetition_rate": repetition,
+                "completed_naturally": completed,
+                "finish_reason": finish_reason,
+                "forced_minimum_tokens": forced_minimum,
+                "status": "success",
+            }
+
+            print(f"  Tokens: {tokens_generated} | TPS: {tps:.1f} | "
+                  f"Memory: {mem_after:.0f} MB (+{memory_growth:.0f}) | "
+                  f"Repetition: {repetition:.4f}")
+
+        except Exception as e:
+            elapsed = time.perf_counter() - start
+            result = {
+                "max_tokens": max_tokens,
+                "status": "error",
+                "error": str(e),
+                "elapsed_seconds": elapsed,
+            }
+            print(f"  ERROR: {e}")
+
+        results.append(result)
+
+    # Analyze cache behavior
+    successful = [r for r in results if r["status"] == "success"]
+    reliable_successful = [
+        r for r in successful if r.get("tokens_generated_reliable", True)
+    ]
+    cache_bounded, cache_reason = analyze_cache_behavior(results)
+
+    # TPS degradation check
+    tps_stable: bool | None = None
+    distinct_tps_runs = sorted(
+        reliable_successful,
+        key=lambda result: result.get("tokens_generated", 0),
+    )
+    if (
+        len({r.get("tokens_generated", 0) for r in distinct_tps_runs}) >= 2
+        and distinct_tps_runs[-1].get("tokens_generated", 0)
+        >= distinct_tps_runs[0].get("tokens_generated", 0) * 2
+    ):
+        first_tps = distinct_tps_runs[0].get("mean_tps", 0)
+        last_tps = distinct_tps_runs[-1].get("mean_tps", 0)
+        if first_tps > 0:
+            tps_stable = last_tps >= first_tps * 0.7  # Within 30% degradation
+
+    test_8k = next((r for r in results if r.get("max_tokens") == 8192), None)
+    test_8k_passed = bool(
+        test_8k
+        and test_8k.get("status") == "success"
+        and test_8k.get("tokens_generated_reliable", True)
+        and test_8k.get("tokens_generated", 0) >= int(8192 * 0.95)
+    )
+
+    summary = {
+        "model_path": Path(model_path).name if Path(model_path).is_dir() else model_path,
+        "image_path": Path(image_path).name,
+        "prompt": prompt,
+        "force_min_tokens": force_min_tokens,
+        "forced_eos_token_ids": eos_token_ids,
+        "platform": platform.platform(),
+        "processor": platform.processor(),
+        "baseline_memory_mb": baseline_memory,
+        "test_results": results,
+        "analysis": {
+            "cache_appears_bounded": cache_bounded,
+            "cache_analysis_reason": cache_reason,
+            "tps_stable_over_length": tps_stable,
+            "max_successful_tokens": max(
+                (r["tokens_generated"] for r in reliable_successful), default=0
+            ),
+            "max_repetition_rate": max(
+                (r.get("repetition_rate", 0) for r in successful), default=0
+            ),
+        },
+        "pass_conditions": {
+            "cache_bounded": cache_bounded is True,
+            "tps_stable": tps_stable is True,
+            "8k_test_passed": test_8k_passed,
+        },
+    }
+    summary["passed"] = all(summary["pass_conditions"].values())
+
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="R-SWA cache validation")
+    parser.add_argument("--model-path", required=True)
+    parser.add_argument("--image", required=True, help="Test image (should produce long output)")
+    parser.add_argument("--output", type=Path, default=Path("benchmarks/results/rswa_results.json"))
+    parser.add_argument("--prompt", default="<image>document parsing.")
+    parser.add_argument("--lengths", type=int, nargs="+", default=None,
+                        help="Custom output lengths to test")
+    parser.add_argument(
+        "--force-min-tokens",
+        type=int,
+        default=None,
+        help=(
+            "Stress-test only: suppress EOS until this many new tokens "
+            "(capped at each --lengths value)"
+        ),
+    )
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("R-SWA Cache Validation — Unlimited-OCR MLX")
+    print("=" * 60)
+
+    results = run_rswa_validation(
+        model_path=args.model_path,
+        image_path=args.image,
+        prompt=args.prompt,
+        test_lengths=args.lengths,
+        force_min_tokens=args.force_min_tokens,
+    )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(results, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+    # Print summary
+    analysis = results["analysis"]
+    pass_cond = results["pass_conditions"]
+
+    print(f"\n{'='*60}")
+    print("R-SWA Validation Summary:")
+    cache_status = (
+        "PASS" if analysis["cache_appears_bounded"] is True
+        else "FAIL" if analysis["cache_appears_bounded"] is False
+        else "INCONCLUSIVE"
+    )
+    tps_status = (
+        "PASS" if analysis["tps_stable_over_length"] is True
+        else "FAIL" if analysis["tps_stable_over_length"] is False
+        else "INCONCLUSIVE"
+    )
+    print(f"  Cache bounded:     {cache_status}")
+    print(f"  TPS stable:        {tps_status}")
+    print(f"  8K test:           {'PASS' if pass_cond['8k_test_passed'] else 'FAIL'}")
+    print(f"  Max tokens:        {analysis['max_successful_tokens']}")
+    print(f"  Max repetition:    {analysis['max_repetition_rate']:.4f}")
+    print(f"\nSaved to: {args.output}")
+    if not results["passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

benchmarks/run_accuracy.py

@@ -0,0 +1,249 @@
+"""Run accuracy benchmarks on evaluation images.
+
+Usage:
+    python benchmarks/run_accuracy.py \
+        --model-path AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+        --eval-dir ./benchmarks/eval_data/ \
+        --output benchmarks/results/accuracy_results.json
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import json
+import sys
+import time
+from pathlib import Path
+
+# Add the project and src roots for both package and benchmark imports when the
+# file is executed directly (``python benchmarks/run_accuracy.py``).
+PROJECT_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(PROJECT_ROOT / "src"))
+
+from benchmarks.evaluate_cer import (
+    compute_cer, compute_wer, compute_digit_cer,
+    compute_cjk_cer, detect_repetition, extract_cjk_characters,
+)
+from benchmarks.normalize_output import normalize_ocr_output
+from benchmarks.evaluate_tables import evaluate_tables
+from unlimited_ocr.engine import SlidingWindowNoRepeatNGramProcessor
+from unlimited_ocr.profiles import get_profile
+
+
+def run_accuracy_benchmark(
+    model_path: str,
+    eval_dir: Path,
+    prompt: str = "<image>document parsing.",
+    max_tokens: int | None = None,
+    profile: str = "accurate",
+) -> dict:
+    """Run accuracy benchmark on evaluation dataset.
+
+    Expects eval_dir structure:
+        eval_dir/
+        ├── images/          # Input images
+        └── ground_truth/    # Reference .txt files (same stem)
+    """
+    images_dir = eval_dir / "images"
+    gt_dir = eval_dir / "ground_truth"
+
+    if not images_dir.is_dir():
+        raise FileNotFoundError(f"Images directory not found: {images_dir}")
+    if not gt_dir.is_dir():
+        raise FileNotFoundError(f"Ground truth directory not found: {gt_dir}")
+
+    if not isinstance(prompt, str) or prompt.count("<image>") != 1:
+        raise ValueError("prompt must contain exactly one literal '<image>' token")
+    generation_profile = get_profile(profile)
+    token_limit = generation_profile.max_tokens if max_tokens is None else max_tokens
+    if not isinstance(token_limit, int) or isinstance(token_limit, bool) or token_limit < 1:
+        raise ValueError("max_tokens must be a positive integer")
+
+    # Collect image files
+    image_files = sorted(
+        f for f in images_dir.iterdir()
+        if f.is_file() and f.suffix.lower() in {
+            ".jpg", ".jpeg", ".png", ".tiff", ".tif", ".webp", ".bmp"
+        }
+    )
+
+    print(f"Found {len(image_files)} images")
+    if not image_files:
+        raise ValueError(f"No supported images found in: {images_dir}")
+
+    duplicate_stems = sorted(
+        stem for stem, count in Counter(path.stem for path in image_files).items()
+        if count > 1
+    )
+    if duplicate_stems:
+        raise ValueError(
+            "Multiple input images share the same stem: "
+            + ", ".join(duplicate_stems)
+        )
+
+    missing_ground_truth = [
+        image_file.name
+        for image_file in image_files
+        if not (gt_dir / f"{image_file.stem}.txt").is_file()
+    ]
+    if missing_ground_truth:
+        raise FileNotFoundError(
+            "Missing ground-truth text for: " + ", ".join(missing_ground_truth)
+        )
+
+    evaluation_files = [
+        (image_file, gt_dir / f"{image_file.stem}.txt")
+        for image_file in image_files
+    ]
+
+    # Import and load only after validating the dataset and generation options.
+    from mlx_vlm import load, generate
+
+    print(f"Loading model: {model_path}")
+    model, processor = load(model_path)
+
+    results = []
+    total_time = 0.0
+
+    for i, (img_file, gt_file) in enumerate(evaluation_files):
+        reference = normalize_ocr_output(gt_file.read_text(encoding="utf-8"))
+
+        # Run inference
+        start = time.perf_counter()
+        response = generate(
+            model, processor,
+            prompt=prompt,
+            image=[str(img_file)],
+            max_tokens=token_limit,
+            temperature=generation_profile.temperature,
+            top_p=generation_profile.top_p,
+            repetition_penalty=generation_profile.repetition_penalty,
+            logits_processors=[SlidingWindowNoRepeatNGramProcessor(
+                generation_profile.no_repeat_ngram_size,
+                128,
+            )],
+            verbose=False,
+        )
+        elapsed = time.perf_counter() - start
+        total_time += elapsed
+
+        # Extract text
+        if isinstance(response, str):
+            hypothesis = response
+        elif hasattr(response, "text"):
+            hypothesis = response.text
+        else:
+            hypothesis = str(response)
+        hypothesis = normalize_ocr_output(hypothesis)
+
+        # Compute metrics
+        cer = compute_cer(reference, hypothesis)
+        wer = compute_wer(reference, hypothesis)
+        digit_cer = compute_digit_cer(reference, hypothesis)
+        cjk_cer = compute_cjk_cer(reference, hypothesis)
+        repetition = detect_repetition(hypothesis)
+        table_result = evaluate_tables(reference, hypothesis)
+        table_score = (
+            table_result["mean_score"]
+            if table_result["num_ref_tables"] > 0
+            else None
+        )
+
+        result = {
+            "file": img_file.name,
+            "cer": cer,
+            "wer": wer,
+            "digit_cer": digit_cer,
+            "cjk_cer": cjk_cer,
+            "repetition_rate": repetition,
+            "table_score": table_score,
+            "elapsed_seconds": elapsed,
+            "ref_length": len(reference),
+            "hyp_length": len(hypothesis),
+            "ref_digit_count": sum(
+                char.isascii() and char.isdigit() for char in reference
+            ),
+            "ref_cjk_count": len(extract_cjk_characters(reference)),
+        }
+        results.append(result)
+
+        print(f"  [{i+1}/{len(evaluation_files)}] {img_file.name}: CER={cer:.4f} "
+              f"DigitCER={digit_cer:.4f} ({elapsed:.1f}s)")
+
+    # Aggregate
+    import numpy as np
+    digit_scores = [r["digit_cer"] for r in results if r["ref_digit_count"] > 0]
+    cjk_scores = [r["cjk_cer"] for r in results if r["ref_cjk_count"] > 0]
+    table_scores = [r["table_score"] for r in results if r["table_score"] is not None]
+    summary = {
+        "model_path": Path(model_path).name if Path(model_path).is_dir() else model_path,
+        "prompt": prompt,
+        "max_tokens": token_limit,
+        "profile": profile,
+        "generation_settings": {
+            "temperature": generation_profile.temperature,
+            "top_p": generation_profile.top_p,
+            "repetition_penalty": generation_profile.repetition_penalty,
+            "no_repeat_ngram_size": generation_profile.no_repeat_ngram_size,
+            "ngram_window": 128,
+        },
+        "num_images": len(image_files),
+        "num_samples": len(results),
+        "total_time_seconds": total_time,
+        "mean_cer": float(np.mean([r["cer"] for r in results])) if results else 0,
+        "mean_wer": float(np.mean([r["wer"] for r in results])) if results else 0,
+        "num_digit_samples": len(digit_scores),
+        "num_cjk_samples": len(cjk_scores),
+        "mean_digit_cer": float(np.mean(digit_scores)) if digit_scores else None,
+        "mean_cjk_cer": float(np.mean(cjk_scores)) if cjk_scores else None,
+        "num_table_samples": len(table_scores),
+        "mean_table_score": float(np.mean(table_scores)) if table_scores else None,
+        "mean_repetition_rate": float(np.mean([r["repetition_rate"] for r in results])) if results else 0,
+        "per_file": results,
+    }
+
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run OCR accuracy benchmark")
+    parser.add_argument("--model-path", required=True)
+    parser.add_argument("--eval-dir", required=True, type=Path)
+    parser.add_argument("--output", type=Path, default=Path("benchmarks/results/accuracy_results.json"))
+    parser.add_argument("--prompt", default="<image>document parsing.")
+    parser.add_argument("--max-tokens", type=int, default=None,
+                        help="Override the selected profile's token limit")
+    parser.add_argument("--profile", default="accurate",
+                        choices=["accurate", "fast", "long-document", "plain-text", "markdown"])
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("Unlimited-OCR Accuracy Benchmark")
+    print("=" * 60)
+
+    results = run_accuracy_benchmark(
+        model_path=args.model_path,
+        eval_dir=args.eval_dir,
+        prompt=args.prompt,
+        max_tokens=args.max_tokens,
+        profile=args.profile,
+    )
+
+    # Save results
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(results, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    def metric(value):
+        return "N/A" if value is None else f"{value:.4f}"
+
+    print(f"\n{'='*60}")
+    print(f"Results: CER={results['mean_cer']:.4f} | "
+          f"DigitCER={metric(results['mean_digit_cer'])} | "
+          f"CJK={metric(results['mean_cjk_cer'])}")
+    print(f"Saved to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/run_performance.py

@@ -0,0 +1,280 @@
+"""Run performance benchmarks (decode TPS, end-to-end latency, and memory).
+
+Usage:
+    python benchmarks/run_performance.py \
+        --model-path AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+        --image test_image.jpg \
+        --output benchmarks/results/performance_results.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import os
+import platform
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+
+def get_memory_usage_mb() -> float:
+    """Get the process peak resident-set size in MB."""
+    try:
+        import resource
+        usage = resource.getrusage(resource.RUSAGE_SELF)
+        # macOS reports bytes; Linux and most BSD-derived Python builds report
+        # KiB. The benchmark is Apple-focused, but avoid nonsensical values
+        # when its reporting helpers are run elsewhere.
+        divisor = 1024 * 1024 if sys.platform == "darwin" else 1024
+        return usage.ru_maxrss / divisor
+    except Exception:
+        return 0.0
+
+
+def get_system_info() -> dict:
+    """Collect system information for reproducibility."""
+    info = {
+        "platform": platform.platform(),
+        "processor": platform.processor(),
+        "python_version": platform.python_version(),
+        "machine": platform.machine(),
+    }
+    for distribution, key in (("mlx", "mlx_version"), ("mlx-vlm", "mlx_vlm_version")):
+        try:
+            info[key] = importlib.metadata.version(distribution)
+        except importlib.metadata.PackageNotFoundError:
+            info[key] = None
+
+    # Try to get chip info on macOS
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["sysctl", "-n", "machdep.cpu.brand_string"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            info["chip"] = result.stdout.strip()
+    except Exception:
+        pass
+
+    # Try to get memory info
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["sysctl", "-n", "hw.memsize"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            info["total_memory_gb"] = int(result.stdout.strip()) / (1024**3)
+    except Exception:
+        pass
+
+    return info
+
+
+def run_performance_benchmark(
+    model_path: str,
+    image_path: str,
+    prompt: str = "<image>document parsing.",
+    max_tokens: int = 4096,
+    num_warmup: int = 1,
+    num_runs: int = 3,
+) -> dict:
+    """Run performance benchmark measuring TPS, memory, and latency."""
+    if not Path(image_path).is_file():
+        raise FileNotFoundError(f"Test image not found: {image_path}")
+    if not isinstance(prompt, str) or prompt.count("<image>") != 1:
+        raise ValueError("prompt must contain exactly one literal '<image>' token")
+    if not isinstance(max_tokens, int) or isinstance(max_tokens, bool) or max_tokens < 1:
+        raise ValueError("max_tokens must be a positive integer")
+    if not isinstance(num_warmup, int) or isinstance(num_warmup, bool) or num_warmup < 0:
+        raise ValueError("num_warmup must be a non-negative integer")
+    if not isinstance(num_runs, int) or isinstance(num_runs, bool) or num_runs < 1:
+        raise ValueError("num_runs must be a positive integer")
+
+    from mlx_vlm import load, generate
+
+    system_info = get_system_info()
+    total_memory = system_info.get("total_memory_gb")
+    memory_label = f"{total_memory:.0f} GB" if isinstance(total_memory, (int, float)) else "Unknown memory"
+    print(f"System: {system_info.get('chip', 'Unknown')} | {memory_label}")
+
+    # Measure model load time
+    load_start = time.perf_counter()
+    model, processor = load(model_path)
+    load_time = time.perf_counter() - load_start
+    mem_after_load = get_memory_usage_mb()
+
+    print(f"Model load time: {load_time:.2f}s")
+    print(f"Memory after load: {mem_after_load:.0f} MB")
+
+    # Warmup runs
+    print(f"\nWarmup ({num_warmup} run(s))...")
+    for _ in range(num_warmup):
+        generate(model, processor, prompt=prompt, image=[image_path],
+                 max_tokens=128, temperature=0.0, verbose=False)
+
+    import mlx.core as mx
+    mx.clear_cache()
+
+    # Benchmark runs
+    print(f"Benchmarking ({num_runs} runs, max_tokens={max_tokens})...")
+    runs = []
+
+    for i in range(num_runs):
+        active_memory_before_mb = mx.get_active_memory() / 1e6
+        mx.reset_peak_memory()
+        start = time.perf_counter()
+
+        response = generate(
+            model, processor,
+            prompt=prompt,
+            image=[image_path],
+            max_tokens=max_tokens,
+            temperature=0.0,
+            verbose=False,
+        )
+
+        elapsed = time.perf_counter() - start
+        process_peak_mb = get_memory_usage_mb()
+
+        # Extract token count
+        if isinstance(response, str):
+            text = response
+            tokens = len(text.split())
+            token_count_source = "whitespace estimate"
+        elif hasattr(response, "text"):
+            text = response.text
+            if not isinstance(text, str):
+                raise TypeError("mlx-vlm returned a non-string text field")
+            raw_tokens = getattr(
+                response,
+                "generation_tokens",
+                getattr(response, "tokens_generated", None),
+            )
+            if raw_tokens is None:
+                tokens = len(text.split())
+                token_count_source = "whitespace estimate"
+            else:
+                tokens = raw_tokens
+                token_count_source = "mlx-vlm token count"
+        elif isinstance(response, dict):
+            text = response.get("text", "")
+            if not isinstance(text, str):
+                raise TypeError("mlx-vlm returned a non-string text field")
+            raw_tokens = response.get(
+                "generation_tokens", response.get("tokens_generated")
+            )
+            if raw_tokens is None:
+                tokens = len(text.split())
+                token_count_source = "whitespace estimate"
+            else:
+                tokens = raw_tokens
+                token_count_source = "mlx-vlm token count"
+        else:
+            text = str(response)
+            tokens = len(text.split())
+            token_count_source = "whitespace estimate"
+        tokens = int(tokens or 0)
+
+        # Prefer mlx-vlm's decode-only rate; the fallback is end-to-end and is
+        # explicitly identified in each run.
+        reported_tps = getattr(response, "generation_tps", 0.0)
+        if reported_tps:
+            tps = float(reported_tps)
+            tps_source = "mlx-vlm generation_tps"
+        else:
+            tps = tokens / elapsed if elapsed > 0 and tokens > 0 else 0
+            tps_source = "end-to-end estimate"
+
+        reported_peak_gb = float(getattr(response, "peak_memory", 0.0) or 0.0)
+        mlx_peak_mb = (
+            reported_peak_gb * 1000
+            if reported_peak_gb > 0
+            else mx.get_peak_memory() / 1e6
+        )
+        run_result = {
+            "run": i + 1,
+            "elapsed_seconds": elapsed,
+            "tokens_generated": tokens,
+            "tokens_generated_source": token_count_source,
+            "tokens_per_second": tps,
+            "tokens_per_second_source": tps_source,
+            "peak_memory_mb": mlx_peak_mb,
+            "memory_delta_mb": max(0.0, mlx_peak_mb - active_memory_before_mb),
+            "process_peak_rss_mb": process_peak_mb,
+            "prompt_tokens": int(getattr(response, "prompt_tokens", 0) or 0),
+            "prompt_tokens_per_second": float(
+                getattr(response, "prompt_tps", 0.0) or 0.0
+            ),
+            "finish_reason": getattr(response, "finish_reason", None),
+        }
+        runs.append(run_result)
+        print(f"  Run {i+1}: {elapsed:.2f}s | {tokens} tokens | {tps:.1f} tok/s | "
+              f"{mlx_peak_mb:.0f} MB")
+
+    # Aggregate
+    import numpy as np
+    tps_values = [r["tokens_per_second"] for r in runs]
+    elapsed_values = [r["elapsed_seconds"] for r in runs]
+    mem_values = [r["peak_memory_mb"] for r in runs]
+
+    results = {
+        "model_path": Path(model_path).name if Path(model_path).is_dir() else model_path,
+        "image_path": Path(image_path).name,
+        "prompt": prompt,
+        "max_tokens": max_tokens,
+        "system": system_info,
+        "model_load_time_seconds": load_time,
+        "memory_after_load_mb": mem_after_load,
+        "num_warmup": num_warmup,
+        "num_runs": num_runs,
+        "mean_tps": float(np.mean(tps_values)) if tps_values else 0,
+        "std_tps": float(np.std(tps_values)) if tps_values else 0,
+        "mean_elapsed_seconds": float(np.mean(elapsed_values)),
+        "mean_peak_memory_mb": float(np.mean(mem_values)),
+        "runs": runs,
+    }
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run OCR performance benchmark")
+    parser.add_argument("--model-path", required=True)
+    parser.add_argument("--image", required=True, help="Test image path")
+    parser.add_argument("--output", type=Path, default=Path("benchmarks/results/performance_results.json"))
+    parser.add_argument("--prompt", default="<image>document parsing.")
+    parser.add_argument("--max-tokens", type=int, default=4096)
+    parser.add_argument("--warmup", type=int, default=1)
+    parser.add_argument("--runs", type=int, default=3)
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("Unlimited-OCR Performance Benchmark")
+    print("=" * 60)
+
+    results = run_performance_benchmark(
+        model_path=args.model_path,
+        image_path=args.image,
+        prompt=args.prompt,
+        max_tokens=args.max_tokens,
+        num_warmup=args.warmup,
+        num_runs=args.runs,
+    )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(results, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    print(f"\n{'='*60}")
+    print(f"Mean TPS: {results['mean_tps']:.1f} | "
+          f"Peak Memory: {results['mean_peak_memory_mb']:.0f} MB")
+    print(f"Saved to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

chat_template.jinja

@@ -0,0 +1 @@
+{% for message in messages %}{% if message['role'] == 'user' %}{% elif message['role'] == 'assistant' %}{% endif %}{{message['content']}} {% endfor %}{% if add_generation_prompt %}{% endif %}

config.json

@@ -0,0 +1,1321 @@
+{
+  "architectures": [
+    "UnlimitedOCRForCausalLM"
+  ],
+  "bos_token_id": 0,
+  "candidate_resolutions": [
+    [
+      1024,
+      1024
+    ]
+  ],
+  "eos_token_id": 1,
+  "first_k_dense_replace": 1,
+  "global_view_pos": "head",
+  "hidden_size": 1280,
+  "intermediate_size": 6848,
+  "kv_lora_rank": null,
+  "language_config": {
+    "architectures": [
+      "DeepseekOCRForCausalLM"
+    ],
+    "bos_token_id": 0,
+    "eos_token_id": 1,
+    "first_k_dense_replace": 1,
+    "hidden_size": 1280,
+    "intermediate_size": 6848,
+    "kv_lora_rank": null,
+    "lm_head": true,
+    "max_position_embeddings": 32768,
+    "moe_intermediate_size": 896,
+    "n_group": 1,
+    "n_routed_experts": 64,
+    "n_shared_experts": 2,
+    "num_attention_heads": 10,
+    "num_experts_per_tok": 6,
+    "num_hidden_layers": 12,
+    "num_key_value_heads": 10,
+    "q_lora_rank": null,
+    "qk_nope_head_dim": 0,
+    "qk_rope_head_dim": 0,
+    "rm_head": false,
+    "topk_group": 1,
+    "topk_method": "greedy",
+    "torch_dtype": "bfloat16",
+    "use_mla": false,
+    "v_head_dim": 128,
+    "vocab_size": 129280,
+    "sliding_window_size": 128,
+    "sliding_window": 128
+  },
+  "lm_head": true,
+  "max_position_embeddings": 32768,
+  "model_type": "unlimited-ocr",
+  "moe_intermediate_size": 896,
+  "n_group": 1,
+  "n_routed_experts": 64,
+  "n_shared_experts": 2,
+  "num_attention_heads": 10,
+  "num_experts_per_tok": 6,
+  "num_hidden_layers": 12,
+  "num_key_value_heads": 10,
+  "projector_config": {
+    "input_dim": 2048,
+    "model_type": "mlp_projector",
+    "n_embed": 1280,
+    "projector_type": "linear"
+  },
+  "q_lora_rank": null,
+  "qk_nope_head_dim": 0,
+  "qk_rope_head_dim": 0,
+  "quantization": {
+    "group_size": 32,
+    "bits": 8,
+    "mode": "mxfp8",
+    "language_model.model.embed_tokens": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.lm_head": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "affine"
+    },
+    "projector.layers": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    }
+  },
+  "quantization_config": {
+    "group_size": 32,
+    "bits": 8,
+    "mode": "mxfp8",
+    "language_model.model.embed_tokens": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.0.mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.1.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.2.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.3.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.4.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.5.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.6.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.7.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.8.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.9.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.10.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.q_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.k_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.v_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.self_attn.o_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.switch_mlp.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.gate_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.up_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.model.layers.11.mlp.shared_experts.down_proj": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    },
+    "language_model.lm_head": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "affine"
+    },
+    "projector.layers": {
+      "group_size": 32,
+      "bits": 8,
+      "mode": "mxfp8"
+    }
+  },
+  "rm_head": false,
+  "sliding_window": 128,
+  "sliding_window_size": 128,
+  "tile_tag": "2D",
+  "topk_group": 1,
+  "topk_method": "greedy",
+  "transformers_version": "4.46.3",
+  "use_mla": false,
+  "v_head_dim": 128,
+  "vision_config": {
+    "image_size": 1024,
+    "mlp_ratio": 3.7362,
+    "model_name": "deeplip_b_l",
+    "model_type": "vision",
+    "width": {
+      "clip-l-14-224": {
+        "heads": 16,
+        "image_size": 224,
+        "layers": 24,
+        "patch_size": 14,
+        "width": 1024
+      },
+      "sam_vit_b": {
+        "downsample_channels": [
+          512,
+          1024
+        ],
+        "global_attn_indexes": [
+          2,
+          5,
+          8,
+          11
+        ],
+        "heads": 12,
+        "layers": 12,
+        "width": 768
+      }
+    }
+  },
+  "vocab_size": 129280
+}

docs/PRD.md

@@ -0,0 +1,153 @@
+# Product Requirements Document: Verified OCR-Aware Unlimited-OCR for MLX
+
+Status: Approved for implementation  
+Owner: AutomatosX  
+Target release: `AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8`
+
+## 1. Problem
+
+The current project improves inference ergonomics around an existing third-party
+MXFP8 checkpoint, but it does not yet prove that AutomatosX produced distinct,
+OCR-aware model weights. The existing precision map has no measured sensitivity
+overrides, the evaluation dataset is empty, and the legacy upload path can
+republish source weights with only metadata changes.
+
+Users need an Apple Silicon checkpoint whose model-level optimization is
+reproducible, measurable, and clearly separated from application tooling.
+
+## 2. Product outcome
+
+Produce and publish a distinct Unlimited-OCR MLX checkpoint converted from the
+upstream Baidu BF16 model. Quantization decisions must be derived from OCR
+sensitivity measurements, and publication must be blocked unless quality,
+performance, provenance, and R-SWA checks pass.
+
+## 3. Users and jobs
+
+- Apple Silicon developers converting PDFs and images to text or Markdown.
+- RAG teams requiring local document ingestion with predictable memory use.
+- Model engineers who need reproducible quantization and benchmark evidence.
+- Reviewers who need to distinguish new weights from repackaged checkpoints.
+
+## 4. Goals
+
+1. Start from an unquantized BF16 `baidu/Unlimited-OCR` checkpoint.
+2. Measure BF16 baseline quality before quantization.
+3. Measure quantization sensitivity for each supported module group.
+4. Keep sensitive groups in BF16, quantize eligible groups to MXFP8, and allow
+   a measured 8-bit affine exception when it is the only configuration that
+   satisfies both quality and throughput gates.
+5. Produce a candidate checkpoint with a deterministic provenance manifest.
+6. Compare the candidate with both BF16 and the Sahil MXFP8 reference.
+7. Verify native Unlimited-OCR R-SWA behavior with an 8K-or-longer run.
+8. Publish atomically to the AutomatosX namespace only after all gates pass.
+
+## 5. Non-goals
+
+- Retraining the Baidu base model or claiming a new foundation model.
+- LoRA fine-tuning for a specific document domain.
+- Claiming upstream paper scores without reproducing them.
+- Publishing an unvalidated checkpoint merely because conversion completed.
+- Implementing true multi-image one-shot PDF inference in this release.
+
+## 6. Functional requirements
+
+### FR-1 Source verification
+
+- Reject an already quantized model as the sensitivity or conversion source.
+- Record source repository/path, revision when available, config digest, and
+  weight-file SHA-256 values.
+
+### FR-2 Evaluation data
+
+- Validate image/ground-truth pairs before allocating the model.
+- Record dataset manifest digest and category counts.
+- Release evaluation must include text, digits, tables, and CJK content.
+- Synthetic-only evaluation may be used for development, but not labelled as a
+  public accuracy benchmark.
+
+### FR-3 Sensitivity analysis
+
+- Evaluate BF16 once, then quantize one supported group at a time.
+- Record matched concrete module paths and CER, digit-CER, and table-score
+  deltas for every group.
+- Fail if any requested group cannot be evaluated.
+
+### FR-4 Precision-map generation
+
+- Generate executable top-level precision rules; metadata-only nested rules do
+  not count.
+- Promote a group to BF16 if any configured quality threshold is exceeded.
+- Preserve vision, projector, embeddings, normalisation, LM head, and MoE gate
+  in BF16 unless explicit evidence supports quantizing them.
+- Select any exception through a recorded multi-candidate calibration; a manual
+  precision-map edit is not sufficient release evidence.
+
+### FR-5 Conversion
+
+- Convert from BF16 in a staging directory.
+- Fail if no module is quantized, a requested rule matches nothing, or no model
+  weights are produced.
+- Write `precision_map.json` and `quantization_summary.json` beside the weights.
+- Record every quantized module's actual mode; the released configuration uses
+  MXFP8 for 119 modules and affine INT8 for the LM head.
+
+### FR-6 Comparative validation
+
+- Benchmark BF16, Sahil MXFP8, and the candidate with the same inputs, prompts,
+  token budgets, and software versions.
+- Store per-sample results as well as aggregates.
+
+### FR-7 Release gates
+
+Publication requires all of the following:
+
+- Candidate weight SHA-256 differs from the Sahil reference.
+- Candidate mean CER is no more than 0.01 absolute above BF16.
+- Candidate mean CER is no worse than the Sahil reference by more than 0.005.
+- Digit CER degradation versus BF16 is no more than 0.01 absolute.
+- Table score degradation versus BF16 is no more than 0.01 absolute.
+- Candidate decode throughput is at least 90% of the Sahil reference.
+- Candidate model weights are no larger than 4.5 GB.
+- R-SWA validation reaches at least 8192 generated tokens with bounded-cache
+  evidence, or explicitly reports an inconclusive gate and blocks release.
+- Every required artifact and digest is present.
+
+### FR-8 Publication
+
+- Create or update `AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8` atomically.
+- Upload only the validated candidate weights, metadata, model card, license,
+  inference package, benchmark summaries, and release manifest.
+- Never silently fall back to uploading Sahil weights.
+
+### FR-9 Claims
+
+- The model card must distinguish upstream paper results, third-party reference
+  results, and AutomatosX measurements.
+- Failed, skipped, estimated, and inconclusive measurements must be labelled.
+
+## 7. Success metrics
+
+- A public Hugging Face model repository contains distinct candidate weights.
+- `release_manifest.json` has `release_approved: true` and every gate result.
+- A clean environment can reproduce conversion from the recorded source.
+- The model loads through `mlx-vlm` using native `model_type=unlimited-ocr`.
+- CLI single-image OCR succeeds with the published model ID.
+
+## 8. Risks
+
+- Evaluation data may be too small or biased to identify fragile layers.
+- Group-level sensitivity can hide individual-layer outliers.
+- MXFP8 support or module paths may change between `mlx-vlm` versions.
+- Long-output documents may terminate naturally before the R-SWA test length.
+- Public benchmark licenses may restrict redistribution of evaluation images.
+
+Mitigations include pinned versions, digest-based provenance, fail-closed gates,
+per-sample results, and release notes that state dataset limitations.
+
+## 9. Rollout
+
+1. Development: unit tests and synthetic smoke data.
+2. Candidate: BF16 sensitivity, conversion, and private/local validation.
+3. Release: approve manifest, create public model repository, upload atomically.
+4. Post-release: load the exact remote revision and run a final OCR smoke test.

docs/TECHNICAL_SPEC.md

@@ -0,0 +1,260 @@
+# Technical Specification: OCR-Aware Mixed-Precision Release Pipeline
+
+Status: Implementation specification  
+Target repository: `AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8`
+
+## 1. System overview
+
+```text
+BF16 Baidu checkpoint
+        |
+        v
+source + dataset preflight
+        |
+        v
+BF16 baseline evaluation
+        |
+        v
+one-group-at-a-time MXFP8 sensitivity
+        |
+        v
+joint quality/throughput head calibration
+        |
+        v
+generated executable precision map
+        |
+        v
+staged BF16 -> mixed MXFP8 conversion
+        |
+        v
+candidate vs BF16 vs Sahil validation
+        |
+        v
+accuracy + performance + R-SWA release gates
+        |
+        v
+content-addressed release manifest
+        |
+        v
+atomic Hugging Face publication
+```
+
+## 2. Components
+
+### 2.1 Dataset validator
+
+Input layout:
+
+```text
+eval_dir/
+  manifest.json
+  images/<sample>.<ext>
+  ground_truth/<sample>.txt
+```
+
+The validator checks unique stems, complete pairs, non-empty ground truth,
+manifest consistency, category counts, and a SHA-256 digest over the manifest
+and referenced files. Validation occurs before importing MLX.
+
+### 2.2 Sensitivity runner
+
+`quantization/layer_sensitivity.py` loads the unquantized model and computes one
+BF16 baseline. For each module group it reloads BF16, quantizes only the group,
+and records:
+
+- matched concrete module paths;
+- sample count and task coverage;
+- CER, digit CER, and table score;
+- deltas from BF16;
+- elapsed time and status.
+
+The runner rejects a source config containing `quantization` or
+`quantization_config`.
+
+### 2.3 Precision-map generator
+
+The generator reads `layer_groups` from the sensitivity result and the approved
+calibration result. It starts from the conservative base map, promotes
+sensitive or failed groups to BF16, and applies only calibration overrides that
+were selected by existing release thresholds.
+Generated rules are top-level executable entries. Metadata is stored under keys
+beginning with `_`, which the converter ignores.
+
+Rule precedence is:
+
+1. exact concrete module path;
+2. more-specific wildcard path;
+3. general wildcard path;
+4. unlisted modules default to BF16.
+
+### 2.4 Converter
+
+`quantization/mixed_precision_convert.py` calls the pinned `mlx-vlm` converter
+with per-module quantization settings. The main model uses MXFP8 with eight data
+bits and group size 32; the calibrated LM head uses 8-bit affine quantization
+with group size 32. It writes into a new sibling staging directory and
+atomically renames it only after verifying:
+
+- at least one module was quantized;
+- every requested MXFP8 or affine8 rule matched;
+- at least one Safetensors file exists;
+- model metadata selects native Unlimited-OCR;
+- `precision_map.json` and `quantization_summary.json` were written.
+
+The requested final output directory must not exist.
+
+### 2.5 Comparative benchmark runner
+
+For each model (`bf16`, `reference_mxfp8`, `candidate`), use identical dataset,
+prompt, profile, max tokens, and preprocessing settings. Results are written to:
+
+```text
+artifacts/<run_id>/
+  provenance.json
+  sensitivity_results.json
+  calibration_results.json
+  generated_precision_map.json
+  bf16_accuracy.json
+  reference_accuracy.json
+  candidate_accuracy.json
+  reference_performance.json
+  candidate_performance.json
+  candidate_rswa.json
+  release_manifest.json
+```
+
+### 2.6 Release gate
+
+The release gate is a pure-data operation. It reads benchmark JSON and candidate
+artifacts without loading a model. Every gate records:
+
+```json
+{
+  "name": "candidate_cer_vs_bf16",
+  "passed": true,
+  "actual": 0.012,
+  "limit": 0.01,
+  "detail": "candidate - bf16 absolute CER"
+}
+```
+
+`release_approved` is true only when every required gate passes. Missing or
+inconclusive values fail the gate.
+
+### 2.7 Publisher
+
+The publisher accepts only a candidate directory containing:
+
+- model Safetensors and valid index when sharded;
+- tokenizer and processor metadata;
+- generated precision map;
+- quantization summary;
+- approved release manifest;
+- README/model card and license.
+
+Before upload it recomputes candidate hashes and compares them with the approved
+manifest. It then creates one Hugging Face commit. Source checkpoint download or
+fallback is forbidden in this path.
+
+## 3. CLI
+
+Primary orchestration command:
+
+```bash
+python quantization/run_pipeline.py \
+  --model-path reference/Unlimited-OCR \
+  --reference-model sahilchachra/unlimited-ocr-mxfp8-mlx \
+  --eval-dir eval_dataset \
+  --output-dir models/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+  --artifacts-dir artifacts/ocr-aware-v1 \
+  --image test_data/test_invoice.png
+```
+
+Publication command:
+
+```bash
+python scripts/publish_optimized_model.py \
+  --model-dir models/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8 \
+  --manifest artifacts/ocr-aware-v1/release_manifest.json \
+  --artifacts-dir artifacts/ocr-aware-v1 \
+  --repo-id AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8
+```
+
+Useful modes:
+
+- `--step preflight`
+- `--step sensitivity`
+- `--step precision-map`
+- `--step convert`
+- `--step validate`
+- `--step gate`
+- `--step publish`
+- `--step all`
+- `--dry-run`
+
+## 4. Provenance schema
+
+`provenance.json` includes:
+
+- UTC run ID and timestamps;
+- source and reference identifiers/revisions;
+- file SHA-256 and byte sizes;
+- dataset digest and category counts;
+- Python, macOS, MLX, mlx-vlm, and huggingface-hub versions;
+- Apple chip and unified memory;
+- generation parameters and artifact digests;
+- generated precision-map digest.
+
+## 5. Model metadata
+
+Published `config.json` must have:
+
+- architecture `UnlimitedOCRForCausalLM`;
+- `model_type: unlimited-ocr`;
+- a positive sliding-window size;
+- an MXFP8 quantization object generated by the converter.
+- per-module entries showing 119 MXFP8 modules and one affine8 LM head.
+
+Published `processor_config.json` must use:
+
+- `processor_class: UnlimitedOCRHFProcessor`;
+- `sft_format: unlimitedocr`.
+
+## 6. Error handling
+
+- Never delete or overwrite an existing output model directory.
+- Each subprocess failure stops the pipeline.
+- Missing metrics, zero samples, unmatched rules, natural short generations,
+  and unavailable Metal are explicit failures or inconclusive release blockers.
+- Partial candidate output remains only in a named staging directory until the
+  converter cleans it up.
+- Publication recomputes hashes immediately before creating the remote commit.
+
+## 7. Testing
+
+Unit tests cover:
+
+- source rejection for already quantized models;
+- sensitivity-result schema parsing;
+- objective calibration selection across BF16, MXFP8, and affine8 heads;
+- sensitive-group promotion to executable BF16 rules;
+- specificity precedence in the precision map;
+- output-directory lifecycle;
+- release-gate pass, fail, missing, and inconclusive cases;
+- hash mismatch rejection;
+- publisher refusal without an approved manifest;
+- publisher operation list containing candidate rather than source weights.
+
+Integration tests mock model conversion and Hugging Face APIs. Hardware smoke
+tests run BF16 and candidate inference on a real image. Full release validation
+runs only on a Metal-capable Apple Silicon host.
+
+## 8. Release verification
+
+After publication:
+
+1. Read remote file metadata and confirm all expected files exist.
+2. Compare remote LFS SHA-256 with the approved manifest.
+3. Load the exact remote revision with `mlx-vlm`.
+4. Run deterministic OCR on the smoke image.
+5. Record the final revision in the local release manifest and handoff report.

docs/adr/0001-verified-ocr-aware-quantization.md

@@ -0,0 +1,90 @@
+# ADR-0001: Build a Verified Checkpoint from BF16 and Publish Fail-Closed
+
+Status: Accepted  
+Date: 2026-07-20
+
+## Context
+
+The project currently references `sahilchachra/unlimited-ocr-mxfp8-mlx` as its
+weight source. That checkpoint is already MXFP8. Re-uploading it with different
+configuration or pipeline files improves runtime behavior but is not a new
+weight optimization.
+
+The existing repository also contains sensitivity and mixed-precision scripts,
+but measured overrides have not been generated and the legacy upload workflow
+does not require proof that candidate weights differ from the source.
+
+## Decision
+
+We will:
+
+1. Use the upstream Baidu BF16 checkpoint as the only valid source for
+   sensitivity analysis and final conversion.
+2. Use the Sahil MXFP8 checkpoint only as a comparative reference.
+3. Generate the precision map from measured group-level OCR deltas.
+4. Preserve high-risk optical and routing components in BF16 by default.
+5. Quantize eligible language-tower linear modules to block-float MXFP8 with
+   group size 32.
+6. Select the native `unlimited-ocr` MLX backend so R-SWA uses its bounded
+   ring/sliding cache rather than a legacy DeepSeek-OCR fallback.
+7. Generate a signed-by-content release manifest containing hashes, versions,
+   metrics, and explicit pass/fail gates.
+8. Make publication fail-closed: no approved manifest means no upload.
+9. Publish under a new, provenance-clear repository:
+   `AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8`.
+
+## Sensitivity policy
+
+A module group is retained in BF16 when any of these conditions is true:
+
+- CER delta is greater than 0.02 absolute.
+- Digit-CER delta is greater than 0.02 absolute.
+- Table-score degradation is greater than 0.01 absolute.
+- The group could not be measured reliably.
+- It belongs to the protected optical/routing set.
+
+Concrete exact-path overrides take precedence over wildcard MXFP8 rules.
+
+## Alternatives considered
+
+### Repackage the Sahil checkpoint
+
+Rejected as the primary release path. It is useful for runtime tooling, but its
+weights are not an AutomatosX optimization.
+
+### Re-quantize the Sahil checkpoint
+
+Rejected. Quantizing already quantized weights compounds error and prevents a
+clean BF16 comparison.
+
+### Uniform MXFP8 from BF16
+
+Rejected as the final product because it does not use OCR sensitivity evidence.
+It remains a useful control candidate.
+
+### Per-layer exhaustive search
+
+Deferred. It provides finer control but multiplies evaluation cost. Group-level
+analysis is the first release; the data contract keeps concrete module paths so
+a later release can promote individual layers.
+
+### Publish first and benchmark later
+
+Rejected. It would recreate the current ambiguity and allow unsupported claims.
+
+## Consequences
+
+Positive:
+
+- The published checkpoint is demonstrably distinct and reproducible.
+- Quality claims are tied to recorded evidence.
+- Runtime improvements and weight improvements are clearly separated.
+- A broken or incomplete benchmark cannot accidentally publish a model.
+
+Negative:
+
+- Release requires a representative evaluation dataset and Metal-capable Mac.
+- Sensitivity analysis is compute intensive.
+- Conservative BF16 retention may produce a larger model than uniform MXFP8.
+- A failed R-SWA or accuracy gate intentionally delays publication.
+

docs/adr/0002-calibrated-affine8-lm-head.md

@@ -0,0 +1,60 @@
+# ADR-0002: Use Affine INT8 for the LM Head
+
+Status: Accepted  
+Date: 2026-07-20  
+Amends: ADR-0001 for `language_model.lm_head` only
+
+## Context
+
+The group sensitivity run showed that the vision encoder must remain BF16, while
+the projector and token embedding could be quantized without degrading CER,
+digit CER, or table score. Joint validation then exposed a trade-off isolated
+group sensitivity could not predict:
+
+| LM-head mode | Mean CER | Digit CER | Decode tok/s | Release result |
+|---|---:|---:|---:|---|
+| BF16 | 0.231904 | 0.082224 | 271.1 | throughput failed |
+| MXFP8 | 0.260170 | 0.076961 | 307.4 | CER failed |
+| affine INT8 | 0.237384 | 0.085733 | 301.2 | all calibration gates passed |
+
+The common BF16 baseline CER was 0.239188 and digit CER was 0.087340. The
+Sahil-reference throughput was 312.7 tok/s. The selection procedure used the
+pre-existing quality and 90% throughput limits; thresholds were not changed
+after observing the results.
+
+## Decision
+
+Use MXFP8, group size 32, for 119 eligible modules. Use 8-bit affine
+quantization, group size 32, for `language_model.lm_head`. Keep the vision
+encoder and non-quantizable normalization/routing state in BF16.
+
+`quantization/calibrate_precision.py` selects the fastest candidate that passes
+every existing release constraint and records the decision in
+`calibration_results.json`. The generated precision map consumes that record,
+so the affine exception is reproducible and is not a manual release edit.
+
+## Alternatives considered
+
+### Keep the LM head in BF16
+
+Rejected for this release because measured throughput was 86.7% of the Sahil
+reference, below the approved 90% floor.
+
+### Quantize the LM head to MXFP8
+
+Rejected because mean CER degraded by 0.02098 absolute versus BF16, above the
+0.01 ceiling, even though throughput passed.
+
+### Lower the throughput or CER threshold
+
+Rejected. Changing a gate after seeing a failing candidate would invalidate the
+fail-closed release design.
+
+## Consequences
+
+- The checkpoint remains predominantly MXFP8 but is accurately described as a
+  mixed MXFP8/affine8 model.
+- The final formal rerun reached 297.2 tok/s, 95.0% of the Sahil reference,
+  while mean CER and digit CER remained slightly better than BF16.
+- Consumers must use a recent MLX/`mlx-vlm` version that supports per-module
+  affine and MXFP8 quantization metadata.

examples/batch_directory.py

@@ -0,0 +1,52 @@
+"""Example: Batch OCR processing of a directory of images."""
+
+from unlimited_ocr import OCRPipeline
+
+# Initialize the pipeline
+pipeline = OCRPipeline(
+    model_path="AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+    verbose=True,
+)
+
+# --- Process all images in a directory ---
+# Supports: .jpg, .jpeg, .png, .tiff, .tif, .webp, .bmp
+results = pipeline.run_batch(
+    "./scanned_documents/",
+    format="text",
+    show_progress=True,  # Rich progress bar
+)
+
+# Results is a dict: {filename: ocr_text}
+for filename, text in results.items():
+    print(f"\n{'='*60}")
+    print(f"FILE: {filename}")
+    print(f"{'='*60}")
+    print(text[:500])  # Print first 500 chars
+
+# --- Save each result to an output directory ---
+results = pipeline.run_batch(
+    "./scanned_documents/",
+    format="markdown",
+    output_dir="./ocr_results/",  # Creates .md files per image
+    show_progress=True,
+)
+print(f"\nProcessed {len(results)} files → ./ocr_results/")
+
+# --- With preprocessing for low-quality scans ---
+results = pipeline.run_batch(
+    "./low_quality_scans/",
+    format="text",
+    preprocess=True,  # deskew + contrast enhancement
+    output_dir="./cleaned_results/",
+)
+
+# --- JSON output with bounding boxes ---
+results = pipeline.run_batch(
+    "./forms/",
+    format="json",
+    grounding=True,  # Include bounding box coordinates
+    output_dir="./structured_results/",
+)
+
+# Clean up
+pipeline.cleanup()

examples/multi_page_pdf.py

@@ -0,0 +1,53 @@
+"""Example: OCR a multi-page PDF document."""
+
+from unlimited_ocr import OCRPipeline
+
+# Initialize the pipeline
+pipeline = OCRPipeline(
+    model_path="AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+    verbose=True,
+)
+
+# --- Basic PDF OCR (all pages) ---
+result = pipeline.run("your_document.pdf", format="text", dpi=300)
+print(result)
+
+# --- Save as Markdown with page headings ---
+result = pipeline.run(
+    "your_document.pdf",
+    format="markdown",
+    dpi=300,
+    output_path="output.md",
+)
+print("Saved to output.md")
+
+# --- JSON output with per-page structure ---
+result = pipeline.run(
+    "your_document.pdf",
+    format="json",
+    dpi=300,
+    output_path="output.json",
+)
+print("Saved to output.json")
+
+# --- With preprocessing for scanned PDFs ---
+result = pipeline.run(
+    "scanned_document.pdf",
+    format="text",
+    preprocess=True,  # deskew + contrast enhancement per page
+    dpi=300,
+)
+print(result)
+
+# --- With progress tracking ---
+def on_progress(current, total):
+    print(f"  Processing page {current}/{total}...")
+
+result = pipeline.run(
+    "long_document.pdf",
+    format="text",
+    progress_callback=on_progress,
+)
+
+# Clean up
+pipeline.cleanup()

examples/single_image.py

@@ -0,0 +1,36 @@
+"""Example: OCR a single image file."""
+
+from unlimited_ocr import OCRPipeline
+
+# Initialize the pipeline (model loads lazily on first inference)
+pipeline = OCRPipeline(
+    model_path="AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+    verbose=True,
+)
+
+# --- Basic document OCR ---
+result = pipeline.run("your_document.jpg", format="text")
+print(result)
+
+# --- Markdown output ---
+result = pipeline.run("your_document.jpg", format="markdown", output_path="output.md")
+print(f"Saved to output.md")
+
+# --- With bounding boxes (grounding mode) ---
+result = pipeline.run("your_document.jpg", format="json", grounding=True)
+print(result)
+
+# --- With image preprocessing (deskew + contrast enhancement) ---
+result = pipeline.run("scanned_page.png", format="text", preprocess=True)
+print(result)
+
+# --- Different task types ---
+# "document" — general document parsing (default)
+# "markdown" — convert to markdown structure
+# "figure"   — parse figures/diagrams
+# "free"     — free-form OCR
+result = pipeline.run("table.png", task="markdown", format="markdown")
+print(result)
+
+# Clean up temporary files
+pipeline.cleanup()

generation_config.json

@@ -0,0 +1,17 @@
+{
+  "do_sample": false,
+  "temperature": 0.0,
+  "top_p": 1.0,
+  "max_new_tokens": 8192,
+  "repetition_penalty": 1.0,
+  "no_repeat_ngram_size": 35,
+  "use_cache": true,
+  "_comment": "Tested default generation parameters for Unlimited-OCR MLX. Deterministic decoding recommended for OCR accuracy.",
+  "_profiles": {
+    "accurate": {"max_new_tokens": 8192, "temperature": 0.0, "no_repeat_ngram_size": 35},
+    "fast": {"max_new_tokens": 2048, "temperature": 0.0, "no_repeat_ngram_size": 35},
+    "long-document": {"max_new_tokens": 16384, "temperature": 0.0, "repetition_penalty": 1.05, "no_repeat_ngram_size": 25},
+    "plain-text": {"max_new_tokens": 4096, "temperature": 0.0, "no_repeat_ngram_size": 35},
+    "markdown": {"max_new_tokens": 8192, "temperature": 0.0, "no_repeat_ngram_size": 35}
+  }
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27568517565832e42daa563f6939e66a8ebb50cce0b01a24ecebb3ea6b4d0b10
+size 3843160559

model.safetensors.index.json

@@ -0,0 +1,759 @@
+{
+    "metadata": {
+        "total_size": 3843066880
+    },
+    "weight_map": {
+        "image_newline": "model.safetensors",
+        "language_model.lm_head.biases": "model.safetensors",
+        "language_model.lm_head.scales": "model.safetensors",
+        "language_model.lm_head.weight": "model.safetensors",
+        "language_model.model.embed_tokens.scales": "model.safetensors",
+        "language_model.model.embed_tokens.weight": "model.safetensors",
+        "language_model.model.layers.0.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.0.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.1.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.10.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.2.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.4.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.5.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.6.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.8.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.gate.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.shared_experts.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.switch_mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.9.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.norm.weight": "model.safetensors",
+        "projector.layers.bias": "model.safetensors",
+        "projector.layers.scales": "model.safetensors",
+        "projector.layers.weight": "model.safetensors",
+        "sam_model.blocks.0.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.0.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.0.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.0.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.0.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.0.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.0.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.0.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.0.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.0.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.0.norm1.bias": "model.safetensors",
+        "sam_model.blocks.0.norm1.weight": "model.safetensors",
+        "sam_model.blocks.0.norm2.bias": "model.safetensors",
+        "sam_model.blocks.0.norm2.weight": "model.safetensors",
+        "sam_model.blocks.1.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.1.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.1.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.1.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.1.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.1.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.1.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.1.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.1.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.1.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.1.norm1.bias": "model.safetensors",
+        "sam_model.blocks.1.norm1.weight": "model.safetensors",
+        "sam_model.blocks.1.norm2.bias": "model.safetensors",
+        "sam_model.blocks.1.norm2.weight": "model.safetensors",
+        "sam_model.blocks.10.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.10.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.10.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.10.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.10.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.10.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.10.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.10.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.10.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.10.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.10.norm1.bias": "model.safetensors",
+        "sam_model.blocks.10.norm1.weight": "model.safetensors",
+        "sam_model.blocks.10.norm2.bias": "model.safetensors",
+        "sam_model.blocks.10.norm2.weight": "model.safetensors",
+        "sam_model.blocks.11.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.11.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.11.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.11.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.11.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.11.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.11.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.11.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.11.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.11.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.11.norm1.bias": "model.safetensors",
+        "sam_model.blocks.11.norm1.weight": "model.safetensors",
+        "sam_model.blocks.11.norm2.bias": "model.safetensors",
+        "sam_model.blocks.11.norm2.weight": "model.safetensors",
+        "sam_model.blocks.2.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.2.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.2.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.2.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.2.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.2.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.2.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.2.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.2.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.2.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.2.norm1.bias": "model.safetensors",
+        "sam_model.blocks.2.norm1.weight": "model.safetensors",
+        "sam_model.blocks.2.norm2.bias": "model.safetensors",
+        "sam_model.blocks.2.norm2.weight": "model.safetensors",
+        "sam_model.blocks.3.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.3.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.3.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.3.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.3.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.3.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.3.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.3.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.3.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.3.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.3.norm1.bias": "model.safetensors",
+        "sam_model.blocks.3.norm1.weight": "model.safetensors",
+        "sam_model.blocks.3.norm2.bias": "model.safetensors",
+        "sam_model.blocks.3.norm2.weight": "model.safetensors",
+        "sam_model.blocks.4.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.4.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.4.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.4.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.4.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.4.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.4.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.4.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.4.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.4.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.4.norm1.bias": "model.safetensors",
+        "sam_model.blocks.4.norm1.weight": "model.safetensors",
+        "sam_model.blocks.4.norm2.bias": "model.safetensors",
+        "sam_model.blocks.4.norm2.weight": "model.safetensors",
+        "sam_model.blocks.5.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.5.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.5.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.5.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.5.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.5.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.5.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.5.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.5.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.5.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.5.norm1.bias": "model.safetensors",
+        "sam_model.blocks.5.norm1.weight": "model.safetensors",
+        "sam_model.blocks.5.norm2.bias": "model.safetensors",
+        "sam_model.blocks.5.norm2.weight": "model.safetensors",
+        "sam_model.blocks.6.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.6.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.6.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.6.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.6.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.6.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.6.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.6.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.6.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.6.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.6.norm1.bias": "model.safetensors",
+        "sam_model.blocks.6.norm1.weight": "model.safetensors",
+        "sam_model.blocks.6.norm2.bias": "model.safetensors",
+        "sam_model.blocks.6.norm2.weight": "model.safetensors",
+        "sam_model.blocks.7.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.7.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.7.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.7.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.7.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.7.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.7.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.7.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.7.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.7.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.7.norm1.bias": "model.safetensors",
+        "sam_model.blocks.7.norm1.weight": "model.safetensors",
+        "sam_model.blocks.7.norm2.bias": "model.safetensors",
+        "sam_model.blocks.7.norm2.weight": "model.safetensors",
+        "sam_model.blocks.8.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.8.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.8.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.8.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.8.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.8.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.8.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.8.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.8.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.8.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.8.norm1.bias": "model.safetensors",
+        "sam_model.blocks.8.norm1.weight": "model.safetensors",
+        "sam_model.blocks.8.norm2.bias": "model.safetensors",
+        "sam_model.blocks.8.norm2.weight": "model.safetensors",
+        "sam_model.blocks.9.attn.proj.bias": "model.safetensors",
+        "sam_model.blocks.9.attn.proj.weight": "model.safetensors",
+        "sam_model.blocks.9.attn.qkv.bias": "model.safetensors",
+        "sam_model.blocks.9.attn.qkv.weight": "model.safetensors",
+        "sam_model.blocks.9.attn.rel_pos_h": "model.safetensors",
+        "sam_model.blocks.9.attn.rel_pos_w": "model.safetensors",
+        "sam_model.blocks.9.mlp.lin1.bias": "model.safetensors",
+        "sam_model.blocks.9.mlp.lin1.weight": "model.safetensors",
+        "sam_model.blocks.9.mlp.lin2.bias": "model.safetensors",
+        "sam_model.blocks.9.mlp.lin2.weight": "model.safetensors",
+        "sam_model.blocks.9.norm1.bias": "model.safetensors",
+        "sam_model.blocks.9.norm1.weight": "model.safetensors",
+        "sam_model.blocks.9.norm2.bias": "model.safetensors",
+        "sam_model.blocks.9.norm2.weight": "model.safetensors",
+        "sam_model.neck.0.weight": "model.safetensors",
+        "sam_model.neck.1.bias": "model.safetensors",
+        "sam_model.neck.1.weight": "model.safetensors",
+        "sam_model.neck.2.weight": "model.safetensors",
+        "sam_model.neck.3.bias": "model.safetensors",
+        "sam_model.neck.3.weight": "model.safetensors",
+        "sam_model.net_2.weight": "model.safetensors",
+        "sam_model.net_3.weight": "model.safetensors",
+        "sam_model.patch_embed.proj.bias": "model.safetensors",
+        "sam_model.patch_embed.proj.weight": "model.safetensors",
+        "sam_model.pos_embed": "model.safetensors",
+        "view_separator": "model.safetensors",
+        "vision_model.embeddings.class_embedding": "model.safetensors",
+        "vision_model.embeddings.patch_embedding.weight": "model.safetensors",
+        "vision_model.embeddings.position_embedding.weight": "model.safetensors",
+        "vision_model.pre_layrnorm.bias": "model.safetensors",
+        "vision_model.pre_layrnorm.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.0.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.0.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.1.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.1.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.10.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.10.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.11.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.11.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.12.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.12.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.13.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.13.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.14.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.14.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.15.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.15.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.16.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.16.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.17.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.17.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.18.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.18.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.19.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.19.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.2.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.2.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.20.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.20.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.21.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.21.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.22.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.22.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.23.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.23.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.3.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.3.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.4.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.4.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.5.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.5.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.6.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.6.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.7.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.7.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.8.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.8.self_attn.qkv_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.layer_norm1.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.layer_norm1.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.layer_norm2.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.layer_norm2.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.mlp.fc1.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.mlp.fc1.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.mlp.fc2.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.mlp.fc2.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.self_attn.out_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.self_attn.out_proj.weight": "model.safetensors",
+        "vision_model.transformer.layers.9.self_attn.qkv_proj.bias": "model.safetensors",
+        "vision_model.transformer.layers.9.self_attn.qkv_proj.weight": "model.safetensors"
+    }
+}

precision_map.json

@@ -0,0 +1,110 @@
+{
+  "vision_model": "bfloat16",
+  "projector": "mxfp8",
+  "language_model.model.embed_tokens": "mxfp8",
+  "language_model.model.norm": "bfloat16",
+  "language_model.lm_head": "affine8",
+  "language_model.model.layers.*.input_layernorm": "bfloat16",
+  "language_model.model.layers.*.post_attention_layernorm": "bfloat16",
+  "language_model.model.layers.*.self_attn.q_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.k_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.v_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.o_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate": "bfloat16",
+  "sam_model": "bfloat16",
+  "_generated_from": {
+    "source_model": "baidu/Unlimited-OCR",
+    "thresholds": {
+      "cer_delta": 0.02,
+      "digit_cer_delta": 0.02,
+      "table_score_degradation": 0.01
+    },
+    "decisions": {
+      "vision_encoder": {
+        "precision": "bfloat16",
+        "reasons": [
+          "cer_delta=2.423686",
+          "digit_cer_delta=1.358023",
+          "table_score_degradation=1.000000",
+          "protected OCR-critical group"
+        ]
+      },
+      "vision_projector": {
+        "precision": "mxfp8",
+        "reasons": [
+          "all measured quality deltas were non-degrading"
+        ]
+      },
+      "token_embeddings": {
+        "precision": "mxfp8",
+        "reasons": [
+          "all measured quality deltas were non-degrading"
+        ]
+      },
+      "attention_q_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_k_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_v_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_o_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "dense_mlp": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "shared_experts": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "routed_experts": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "lm_head": {
+        "precision": "affine8",
+        "reasons": [
+          "selected by joint quality/throughput calibration: affine8-head"
+        ]
+      }
+    },
+    "calibration": {
+      "selected": {
+        "label": "affine8-head",
+        "precision": "affine8"
+      },
+      "selection_policy": "fastest candidate passing existing quality and throughput limits"
+    }
+  }
+}

preprocessing_config.json

@@ -0,0 +1,81 @@
+{
+  "default_mode": "document",
+  "modes": {
+    "none": {
+      "description": "No preprocessing (passthrough)",
+      "deskew": false,
+      "clahe": false,
+      "binarize": false,
+      "gamma_correction": false,
+      "sharpen": false,
+      "grayscale": false,
+      "target_size": null
+    },
+    "auto": {
+      "description": "Inspect image and apply needed fixes automatically",
+      "deskew": true,
+      "clahe": "auto",
+      "binarize": false,
+      "gamma_correction": "auto",
+      "sharpen": "auto",
+      "grayscale": false,
+      "target_size": 1024
+    },
+    "document": {
+      "description": "Deskew + CLAHE contrast enhancement (default for general documents)",
+      "deskew": true,
+      "clahe": true,
+      "binarize": false,
+      "gamma_correction": false,
+      "sharpen": false,
+      "grayscale": false,
+      "target_size": 1024,
+      "clahe_clip_limit": 2.0,
+      "clahe_grid_size": 8
+    },
+    "low-contrast": {
+      "description": "Aggressive CLAHE + gamma correction for faded scans",
+      "deskew": true,
+      "clahe": true,
+      "binarize": false,
+      "gamma_correction": true,
+      "sharpen": false,
+      "grayscale": false,
+      "target_size": 1024,
+      "clahe_clip_limit": 4.0,
+      "gamma_value": 1.5
+    },
+    "grayscale": {
+      "description": "Convert to grayscale + Otsu binarization",
+      "deskew": true,
+      "clahe": false,
+      "binarize": true,
+      "gamma_correction": false,
+      "sharpen": false,
+      "grayscale": true,
+      "target_size": 1024
+    },
+    "high-resolution": {
+      "description": "Resize longest side to 1024 with Lanczos + sharpen",
+      "deskew": false,
+      "clahe": true,
+      "binarize": false,
+      "gamma_correction": false,
+      "sharpen": true,
+      "grayscale": false,
+      "target_size": 1024
+    },
+    "table": {
+      "description": "Sharpen + edge enhancement for grid lines and table structure",
+      "deskew": true,
+      "clahe": true,
+      "binarize": false,
+      "gamma_correction": false,
+      "sharpen": true,
+      "grayscale": false,
+      "target_size": 1024,
+      "clahe_clip_limit": 3.0
+    }
+  },
+  "_note": "Preprocessing is always optional. The raw input path remains available for baseline comparison. Applied steps are recorded in output metadata."
+}

processor_config.json

@@ -0,0 +1,28 @@
+{
+  "add_special_token": false,
+  "candidate_resolutions": [
+    [
+      1024,
+      1024
+    ]
+  ],
+  "downsample_ratio": 4,
+  "ignore_id": -100,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_token": "<image>",
+  "mask_prompt": false,
+  "normalize": true,
+  "pad_token": "<｜▁pad▁｜>",
+  "patch_size": 16,
+  "processor_class": "UnlimitedOCRHFProcessor",
+  "sft_format": "unlimitedocr"
+}

pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "unlimited-ocr"
+version = "0.2.0"
+description = "Improved MLX inference pipeline for Unlimited-OCR — one-shot long-horizon document parsing on Apple Silicon"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "AutomatosX" },
+]
+keywords = ["ocr", "mlx", "apple-silicon", "document-parsing", "vision-language-model"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    # Unlimited-OCR support first shipped in mlx-vlm 0.6.4. Older releases
+    # cannot load the default model used by this package.
+    "mlx-vlm>=0.6.4",
+    "mlx>=0.31.2",
+    "Pillow>=10.0",
+    "numpy",
+    "pymupdf>=1.24",
+    # mlx-vlm already requires the non-headless OpenCV distribution. Requiring
+    # the headless wheel as well installs two distributions that own `cv2`.
+    "opencv-python>=4.12",
+    "click>=8.0",
+    "rich>=13.0",
+    "huggingface-hub>=0.20",
+]
+
+[project.optional-dependencies]
+server = ["fastapi>=0.100", "uvicorn[standard]>=0.20", "python-multipart>=0.0.5"]
+dev = ["pytest>=7.0", "pytest-asyncio>=0.21", "httpx>=0.24"]
+
+[project.scripts]
+unlimited-ocr = "unlimited_ocr.cli:main"
+
+[project.urls]
+Homepage = "https://huggingface.co/AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8"
+Repository = "https://huggingface.co/AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/unlimited_ocr"]

quantization/calibrate_precision.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Select a mixed-precision override from measured candidate experiments."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from quantization.release_gate import DEFAULT_THRESHOLDS, load_json_object
+
+
+SUPPORTED_HEAD_PRECISIONS = {"bfloat16", "mxfp8", "affine8"}
+
+
+def _number(payload: dict, key: str) -> float | None:
+    value = payload.get(key)
+    return float(value) if isinstance(value, (int, float)) and not isinstance(value, bool) else None
+
+
+def select_head_precision(
+    bf16_accuracy: dict,
+    reference_performance: dict,
+    experiments: list[dict],
+    thresholds: dict | None = None,
+) -> dict:
+    """Choose the fastest experiment that passes the existing release limits."""
+    limits = {**DEFAULT_THRESHOLDS, **(thresholds or {})}
+    bf16_cer = _number(bf16_accuracy, "mean_cer")
+    bf16_digit = _number(bf16_accuracy, "mean_digit_cer")
+    bf16_table = _number(bf16_accuracy, "mean_table_score")
+    reference_tps = _number(reference_performance, "mean_tps")
+    if None in (bf16_cer, bf16_digit, bf16_table, reference_tps) or reference_tps <= 0:
+        raise ValueError("Baseline accuracy and reference throughput must be complete")
+    if not experiments:
+        raise ValueError("At least one calibration experiment is required")
+
+    evaluated = []
+    for experiment in experiments:
+        label = experiment.get("label")
+        precision = experiment.get("precision")
+        accuracy = experiment.get("accuracy")
+        performance = experiment.get("performance")
+        if not isinstance(label, str) or not label:
+            raise ValueError("Each calibration experiment needs a label")
+        if precision not in SUPPORTED_HEAD_PRECISIONS:
+            raise ValueError(f"Unsupported head precision for {label}: {precision}")
+        if not isinstance(accuracy, dict) or not isinstance(performance, dict):
+            raise ValueError(f"Calibration metrics are missing for {label}")
+        candidate_cer = _number(accuracy, "mean_cer")
+        candidate_digit = _number(accuracy, "mean_digit_cer")
+        candidate_table = _number(accuracy, "mean_table_score")
+        candidate_tps = _number(performance, "mean_tps")
+        metrics_complete = None not in (
+            candidate_cer, candidate_digit, candidate_table, candidate_tps
+        )
+        deltas = {
+            "cer_vs_bf16": candidate_cer - bf16_cer if metrics_complete else None,
+            "digit_cer_vs_bf16": candidate_digit - bf16_digit if metrics_complete else None,
+            "table_degradation_vs_bf16": bf16_table - candidate_table if metrics_complete else None,
+            "tps_ratio_vs_reference": candidate_tps / reference_tps if metrics_complete else None,
+        }
+        checks = {
+            "cer": metrics_complete and deltas["cer_vs_bf16"] <= limits["max_cer_delta_vs_bf16"],
+            "digit_cer": metrics_complete and deltas["digit_cer_vs_bf16"] <= limits["max_digit_cer_delta_vs_bf16"],
+            "table_score": metrics_complete and deltas["table_degradation_vs_bf16"] <= limits["max_table_score_degradation_vs_bf16"],
+            "throughput": metrics_complete and deltas["tps_ratio_vs_reference"] >= limits["min_tps_ratio_vs_reference"],
+        }
+        evaluated.append({
+            "label": label,
+            "precision": precision,
+            "passed": all(checks.values()),
+            "checks": checks,
+            "metrics": {
+                "mean_cer": candidate_cer,
+                "mean_digit_cer": candidate_digit,
+                "mean_table_score": candidate_table,
+                "mean_tps": candidate_tps,
+            },
+            "deltas": deltas,
+        })
+
+    passing = [experiment for experiment in evaluated if experiment["passed"]]
+    if not passing:
+        raise RuntimeError("No LM-head calibration experiment passed every release limit")
+    selected = max(passing, key=lambda experiment: experiment["metrics"]["mean_tps"])
+    return {
+        "schema_version": 1,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "target_pattern": "language_model.lm_head",
+        "selection_policy": "fastest candidate passing existing quality and throughput limits",
+        "thresholds": limits,
+        "experiments": evaluated,
+        "selected": {
+            "label": selected["label"],
+            "precision": selected["precision"],
+        },
+        "precision_overrides": {
+            "language_model.lm_head": selected["precision"],
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--bf16-accuracy", required=True, type=Path)
+    parser.add_argument("--reference-performance", required=True, type=Path)
+    parser.add_argument(
+        "--experiment",
+        action="append",
+        nargs=4,
+        metavar=("LABEL", "PRECISION", "ACCURACY_JSON", "PERFORMANCE_JSON"),
+        required=True,
+    )
+    parser.add_argument("--output", required=True, type=Path)
+    args = parser.parse_args()
+    experiments = [
+        {
+            "label": label,
+            "precision": precision,
+            "accuracy": load_json_object(accuracy_path),
+            "performance": load_json_object(performance_path),
+        }
+        for label, precision, accuracy_path, performance_path in args.experiment
+    ]
+    result = select_head_precision(
+        load_json_object(args.bf16_accuracy),
+        load_json_object(args.reference_performance),
+        experiments,
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps(result["selected"], ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

quantization/layer_sensitivity.py

@@ -0,0 +1,402 @@
+"""Layer sensitivity analysis for OCR-aware mixed-precision quantization.
+
+This script quantizes one layer group at a time, runs inference on a small
+evaluation set, and measures the quality delta (CER, digit error, table structure)
+relative to the BF16 baseline.
+
+Usage:
+    python quantization/layer_sensitivity.py \
+        --model-path baidu/Unlimited-OCR \
+        --eval-dir ./eval_images/ \
+        --output sensitivity_results.json
+
+Requires: mlx-vlm, mlx, Pillow, numpy
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import gc
+import json
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+PROJECT_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(PROJECT_ROOT / "src"))
+
+from benchmarks.evaluate_cer import compute_cer as _compute_cer
+from benchmarks.evaluate_cer import compute_digit_cer as _compute_digit_cer
+from benchmarks.evaluate_tables import evaluate_tables
+from benchmarks.normalize_output import normalize_ocr_output
+from quantization.mixed_precision_convert import matches_pattern
+from unlimited_ocr.engine import SlidingWindowNoRepeatNGramProcessor
+
+
+# Quantizable MLX module groups to test independently. Normalization and the
+# MoE router are raw arrays rather than quantizable MLX layers, so they remain
+# BF16 by construction and are not presented as runnable sensitivity groups.
+LAYER_GROUPS: dict[str, tuple[str, ...]] = {
+    "vision_encoder": ("vision_model", "sam_model"),
+    "vision_projector": ("projector",),
+    "token_embeddings": ("language_model.model.embed_tokens",),
+    "attention_q_proj": ("language_model.model.layers.*.self_attn.q_proj",),
+    "attention_k_proj": ("language_model.model.layers.*.self_attn.k_proj",),
+    "attention_v_proj": ("language_model.model.layers.*.self_attn.v_proj",),
+    "attention_o_proj": ("language_model.model.layers.*.self_attn.o_proj",),
+    "dense_mlp": (
+        "language_model.model.layers.*.mlp.gate_proj",
+        "language_model.model.layers.*.mlp.up_proj",
+        "language_model.model.layers.*.mlp.down_proj",
+    ),
+    "shared_experts": ("language_model.model.layers.*.mlp.shared_experts",),
+    "routed_experts": ("language_model.model.layers.*.mlp.switch_mlp",),
+    "lm_head": ("language_model.lm_head",),
+}
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tiff", ".tif", ".webp", ".bmp"}
+
+
+def collect_evaluation_files(
+    eval_dir: Path,
+    prompt: str = "<image>document parsing.",
+    max_tokens: int = 4096,
+) -> list[tuple[Path, Path]]:
+    """Validate an evaluation dataset and return complete image/text pairs."""
+    images_dir = eval_dir / "images"
+    gt_dir = eval_dir / "ground_truth"
+    if not images_dir.is_dir():
+        raise FileNotFoundError(f"Images directory not found: {images_dir}")
+    if not gt_dir.is_dir():
+        raise FileNotFoundError(f"Ground-truth directory not found: {gt_dir}")
+    if not isinstance(prompt, str) or prompt.count("<image>") != 1:
+        raise ValueError("prompt must contain exactly one literal '<image>' token")
+    if not isinstance(max_tokens, int) or isinstance(max_tokens, bool) or max_tokens < 1:
+        raise ValueError("max_tokens must be a positive integer")
+
+    image_files = sorted(
+        path for path in images_dir.iterdir()
+        if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+    )
+    if not image_files:
+        raise ValueError(f"No supported images found in {images_dir}")
+
+    duplicate_stems = sorted(
+        stem for stem, count in Counter(path.stem for path in image_files).items()
+        if count > 1
+    )
+    if duplicate_stems:
+        raise ValueError(
+            "Multiple input images share the same stem: "
+            + ", ".join(duplicate_stems)
+        )
+
+    missing = [
+        path.name for path in image_files
+        if not (gt_dir / f"{path.stem}.txt").is_file()
+    ]
+    if missing:
+        raise FileNotFoundError(
+            "Missing ground-truth text for: " + ", ".join(missing)
+        )
+    return [(path, gt_dir / f"{path.stem}.txt") for path in image_files]
+
+
+def compute_cer(reference: str, hypothesis: str) -> float:
+    """Compute Character Error Rate with the shared memory-efficient metric."""
+    return _compute_cer(reference, hypothesis)
+
+
+def compute_digit_cer(reference: str, hypothesis: str) -> float:
+    """Compute CER only on digit characters."""
+    return _compute_digit_cer(reference, hypothesis)
+
+
+def run_inference(model, processor, image_path: str, prompt: str, max_tokens: int = 4096) -> str:
+    """Run a single inference and return the text output."""
+    from mlx_vlm import generate
+
+    response = generate(
+        model, processor,
+        prompt=prompt,
+        image=[image_path],
+        max_tokens=max_tokens,
+        temperature=0.0,
+        logits_processors=[SlidingWindowNoRepeatNGramProcessor(35, 128)],
+        verbose=False,
+    )
+
+    if isinstance(response, str):
+        return response
+    elif hasattr(response, "text"):
+        return response.text
+    return str(response)
+
+
+def evaluate_model(
+    model,
+    processor,
+    eval_dir: Path,
+    prompt: str = "<image>document parsing.",
+    max_tokens: int = 4096,
+) -> dict:
+    """Evaluate model on a directory of images with ground truth.
+
+    Expects eval_dir to contain:
+      - images/ subdirectory with input images
+      - ground_truth/ subdirectory with .txt files (same stem as image)
+    """
+    evaluation_files = collect_evaluation_files(eval_dir, prompt, max_tokens)
+
+    cer_scores = []
+    digit_cer_scores = []
+    table_scores = []
+    total_time = 0.0
+
+    for img_file, gt_file in evaluation_files:
+        reference = normalize_ocr_output(gt_file.read_text(encoding="utf-8"))
+
+        start = time.perf_counter()
+        hypothesis = normalize_ocr_output(run_inference(
+            model,
+            processor,
+            str(img_file),
+            prompt,
+            max_tokens=max_tokens,
+        ))
+        elapsed = time.perf_counter() - start
+
+        cer = compute_cer(reference, hypothesis)
+        digit_cer = compute_digit_cer(reference, hypothesis)
+
+        cer_scores.append(cer)
+        if any(char.isascii() and char.isdigit() for char in reference):
+            digit_cer_scores.append(digit_cer)
+        table_result = evaluate_tables(reference, hypothesis)
+        if table_result["num_ref_tables"] > 0:
+            table_scores.append(table_result["mean_score"])
+        total_time += elapsed
+
+    return {
+        "num_samples": len(cer_scores),
+        "num_digit_samples": len(digit_cer_scores),
+        "num_table_samples": len(table_scores),
+        "mean_cer": float(np.mean(cer_scores)) if cer_scores else 0.0,
+        "mean_digit_cer": float(np.mean(digit_cer_scores)) if digit_cer_scores else None,
+        "mean_table_score": float(np.mean(table_scores)) if table_scores else None,
+        "total_inference_time": total_time,
+        "avg_time_per_image": total_time / max(len(cer_scores), 1),
+    }
+
+
+def quantize_layer_group(model, config: dict, group_name: str) -> list[str]:
+    """Quantize one configured MLX module group to MXFP8 in place.
+
+    Returns the concrete module paths that were converted.
+    """
+    if group_name not in LAYER_GROUPS:
+        available = ", ".join(LAYER_GROUPS)
+        raise ValueError(f"Unknown layer group '{group_name}'. Available: {available}")
+
+    from mlx_vlm.quant_utils import quantize_model
+
+    patterns = LAYER_GROUPS[group_name]
+    matched: list[str] = []
+
+    def predicate(path, module):
+        if any(matches_pattern(path, pattern) for pattern in patterns):
+            matched.append(path)
+            return {"group_size": 32, "bits": 8, "mode": "mxfp8"}
+        return False
+
+    quantize_model(
+        model,
+        config,
+        group_size=32,
+        bits=8,
+        mode="mxfp8",
+        quant_predicate=predicate,
+    )
+    if not matched:
+        raise RuntimeError(
+            f"Layer group '{group_name}' matched no quantizable MLX modules"
+        )
+    return sorted(set(matched))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Layer sensitivity analysis for OCR-aware quantization"
+    )
+    parser.add_argument("--model-path", required=True,
+                        help="Path to BF16 model (baidu/Unlimited-OCR or local)")
+    parser.add_argument(
+        "--source-id",
+        default=None,
+        help="Public source identifier recorded in results (defaults to repo ID or local name)",
+    )
+    parser.add_argument("--eval-dir", required=True, type=Path,
+                        help="Evaluation directory with images/ and ground_truth/")
+    parser.add_argument("--output", type=Path, default=Path("sensitivity_results.json"),
+                        help="Output JSON file for results")
+    parser.add_argument("--prompt", default="<image>document parsing.",
+                        help="OCR prompt to use")
+    parser.add_argument("--max-tokens", type=int, default=4096)
+    parser.add_argument(
+        "--groups",
+        nargs="+",
+        choices=list(LAYER_GROUPS),
+        default=list(LAYER_GROUPS),
+        help="Layer groups to test (default: all)",
+    )
+    args = parser.parse_args()
+    if args.max_tokens < 1:
+        parser.error("--max-tokens must be positive")
+
+    # Fail before importing MLX or allocating the model for dataset mistakes.
+    collect_evaluation_files(args.eval_dir, args.prompt, args.max_tokens)
+
+    print("=" * 60)
+    print("Layer Sensitivity Analysis for Unlimited-OCR MLX")
+    print("=" * 60)
+
+    # Step 1: Load BF16 baseline
+    print("\n[1/3] Loading BF16 baseline model...")
+    from mlx_vlm import load
+    from mlx_vlm.utils import load_config
+    import mlx.core as mx
+
+    base_config = load_config(args.model_path)
+    if base_config.get("quantization") or base_config.get("quantization_config"):
+        raise ValueError(
+            "Layer sensitivity requires an unquantized BF16 source model"
+        )
+    model, processor = load(args.model_path)
+
+    # Step 2: Evaluate baseline
+    print("\n[2/3] Evaluating BF16 baseline...")
+    baseline = evaluate_model(
+        model,
+        processor,
+        args.eval_dir,
+        args.prompt,
+        max_tokens=args.max_tokens,
+    )
+    print(f"  Baseline CER: {baseline['mean_cer']:.4f}")
+    digit_label = (
+        f"{baseline['mean_digit_cer']:.4f}"
+        if baseline["mean_digit_cer"] is not None
+        else "N/A"
+    )
+    print(f"  Baseline Digit CER: {digit_label}")
+    print(f"  Samples: {baseline['num_samples']}")
+    model = None
+    processor = None
+    gc.collect()
+    mx.clear_cache()
+
+    # Step 3: Per-group sensitivity
+    print("\n[3/3] Testing per-group quantization sensitivity...")
+    results = {
+        "baseline": baseline,
+        "model_path": args.source_id or (
+            Path(args.model_path).name if Path(args.model_path).is_dir() else args.model_path
+        ),
+        "eval_dir": args.eval_dir.name,
+        "prompt": args.prompt,
+        "max_tokens": args.max_tokens,
+        "groups_tested": args.groups,
+        "layer_groups": {},
+    }
+
+    for group in args.groups:
+        print(f"\n  Testing: {group}")
+        group_model = None
+        group_processor = None
+        try:
+            group_model, group_processor = load(args.model_path)
+            matched_modules = quantize_layer_group(
+                group_model,
+                dict(base_config),
+                group,
+            )
+            metrics = evaluate_model(
+                group_model,
+                group_processor,
+                args.eval_dir,
+                args.prompt,
+                max_tokens=args.max_tokens,
+            )
+            digit_delta = (
+                metrics["mean_digit_cer"] - baseline["mean_digit_cer"]
+                if metrics["mean_digit_cer"] is not None
+                and baseline["mean_digit_cer"] is not None
+                else None
+            )
+            table_delta = (
+                baseline["mean_table_score"] - metrics["mean_table_score"]
+                if metrics["mean_table_score"] is not None
+                and baseline["mean_table_score"] is not None
+                else None
+            )
+            results["layer_groups"][group] = {
+                "status": "success",
+                "matched_module_count": len(matched_modules),
+                "matched_modules": matched_modules,
+                "metrics": metrics,
+                "cer_delta": metrics["mean_cer"] - baseline["mean_cer"],
+                "digit_cer_delta": digit_delta,
+                "table_score_degradation": table_delta,
+                "sensitivity_rank": None,
+            }
+            print(
+                f"    CER={metrics['mean_cer']:.4f} "
+                f"(delta={metrics['mean_cer'] - baseline['mean_cer']:+.4f})"
+            )
+        except Exception as exc:
+            results["layer_groups"][group] = {
+                "status": "error",
+                "error": str(exc),
+                "sensitivity_rank": None,
+            }
+            print(f"    ERROR: {exc}")
+        finally:
+            group_model = None
+            group_processor = None
+            gc.collect()
+            mx.clear_cache()
+
+    successful_groups = [
+        (name, data)
+        for name, data in results["layer_groups"].items()
+        if data["status"] == "success"
+    ]
+    successful_groups.sort(
+        key=lambda item: (
+            item[1]["cer_delta"],
+            item[1]["digit_cer_delta"]
+            if item[1]["digit_cer_delta"] is not None
+            else float("-inf"),
+        ),
+        reverse=True,
+    )
+    for rank, (_, data) in enumerate(successful_groups, start=1):
+        data["sensitivity_rank"] = rank
+
+    # Save results
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(results, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+    print(f"\nResults saved to: {args.output}")
+    if any(data["status"] == "error" for data in results["layer_groups"].values()):
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

quantization/mixed_precision_convert.py

@@ -0,0 +1,323 @@
+"""Mixed-precision conversion script for OCR-aware quantization.
+
+Applies a precision map to produce enhanced model weights where OCR-sensitive
+layers remain at BF16 while less sensitive layers use MXFP8.
+
+Usage:
+    python quantization/mixed_precision_convert.py \
+        --model-path baidu/Unlimited-OCR \
+        --precision-map quantization/precision_map.json \
+        --output-dir ./enhanced_model/
+
+Requires: mlx, mlx-vlm
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import tempfile
+from pathlib import Path
+
+
+SUPPORTED_PRECISIONS = {"bfloat16", "mxfp8", "affine8"}
+QUANTIZATION_CONFIGS = {
+    "mxfp8": {"group_size": 32, "bits": 8, "mode": "mxfp8"},
+    "affine8": {"group_size": 32, "bits": 8, "mode": "affine"},
+}
+
+
+def _json_digest(value: dict) -> str:
+    payload = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def normalize_unlimited_ocr_metadata(model_dir: Path) -> None:
+    """Select mlx-vlm's native backend and validate MXFP8/R-SWA metadata.
+
+    ``mlx-vlm convert`` always emits ``config.json`` (and usually
+    ``processor_config.json``). Missing configs mean conversion did not finish
+    and must not be published.
+    """
+    config_path = model_dir / "config.json"
+    processor_path = model_dir / "processor_config.json"
+    if not config_path.is_file():
+        raise ValueError(
+            "Converted model is missing config.json — mlx-vlm conversion incomplete"
+        )
+    try:
+        config = json.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise ValueError("Converted model has invalid config.json") from exc
+    if not isinstance(config, dict):
+        raise ValueError("Converted config.json must contain a JSON object")
+
+    architectures = config.get("architectures")
+    if not isinstance(architectures, list) or "UnlimitedOCRForCausalLM" not in architectures:
+        raise ValueError("Converted checkpoint is not UnlimitedOCRForCausalLM")
+    quantization = config.get("quantization") or config.get("quantization_config")
+    if not isinstance(quantization, dict) or quantization.get("mode") != "mxfp8":
+        raise ValueError("Converted checkpoint does not declare MXFP8 quantization")
+    text_config = config.get("language_config") or config.get("text_config") or config
+    window_size = None
+    if isinstance(text_config, dict):
+        window_size = text_config.get("sliding_window_size", text_config.get("sliding_window"))
+    if window_size is None:
+        window_size = config.get("sliding_window_size", config.get("sliding_window"))
+    if not isinstance(window_size, int) or isinstance(window_size, bool) or window_size < 1:
+        raise ValueError("Converted checkpoint is missing a positive sliding-window size")
+
+    config["model_type"] = "unlimited-ocr"
+    config.pop("auto_map", None)
+    # Keep R-SWA fields consistent at the top level and under language_config.
+    config["sliding_window"] = int(window_size)
+    config["sliding_window_size"] = int(window_size)
+    language_config = config.get("language_config")
+    if isinstance(language_config, dict):
+        language_config.pop("auto_map", None)
+        language_config["sliding_window"] = int(window_size)
+        language_config["sliding_window_size"] = int(window_size)
+
+    if processor_path.is_file():
+        try:
+            processor = json.loads(processor_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+            raise ValueError("Converted model has invalid processor_config.json") from exc
+        if not isinstance(processor, dict):
+            raise ValueError("Converted processor_config.json must contain a JSON object")
+    else:
+        # Some convert paths only emit tokenizer assets; still mark the processor
+        # class so mlx-vlm loads the Unlimited-OCR handler.
+        processor = {}
+
+    processor["processor_class"] = "UnlimitedOCRHFProcessor"
+    processor["sft_format"] = "unlimitedocr"
+    config_path.write_text(
+        json.dumps(config, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    processor_path.write_text(
+        json.dumps(processor, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def load_precision_map(path: Path) -> dict:
+    """Load the precision map JSON."""
+    with open(path, encoding="utf-8") as f:
+        precision_map = json.load(f)
+    validate_precision_map(precision_map)
+    return precision_map
+
+
+def validate_precision_map(precision_map: dict) -> None:
+    """Validate precision-map structure and supported precision values."""
+    if not isinstance(precision_map, dict):
+        raise ValueError("precision map must be a JSON object")
+    rules = {
+        pattern: precision
+        for pattern, precision in precision_map.items()
+        if not pattern.startswith("_")
+    }
+    if not rules:
+        raise ValueError("precision map has no module rules")
+    invalid = {
+        pattern: precision
+        for pattern, precision in rules.items()
+        if not isinstance(precision, str) or precision not in SUPPORTED_PRECISIONS
+    }
+    if invalid:
+        details = ", ".join(f"{pattern}={precision!r}" for pattern, precision in invalid.items())
+        raise ValueError(f"unsupported precision-map values: {details}")
+    if "mxfp8" not in rules.values():
+        raise ValueError("precision map does not select any modules for MXFP8")
+
+
+def matches_pattern(param_name: str, pattern: str) -> bool:
+    """Check if a parameter name matches a precision map pattern.
+
+    Supports wildcard '*' for layer indices.
+    Example: ``model.layers.*.self_attn.q_proj`` matches layer 5's q_proj.
+    """
+    regex = re.escape(pattern).replace(r"\*", r"\d+")
+    # Precision-map entries name complete module-path segments but parameter
+    # names may contain a model prefix and a trailing ``.weight``.
+    return bool(re.search(rf"(?:^|\.){regex}(?=\.|$)", param_name))
+
+
+def get_precision_for_param(param_name: str, precision_map: dict) -> str:
+    """Determine the target precision for a given parameter name."""
+    matching_rules = [
+        (index, pattern, precision)
+        for index, (pattern, precision) in enumerate(precision_map.items())
+        if not pattern.startswith("_") and matches_pattern(param_name, pattern)
+    ]
+    if matching_rules:
+        # Exact per-layer sensitivity overrides must beat an earlier wildcard
+        # group rule. More literal path segments are more specific; insertion
+        # order is only a tie breaker.
+        _, _, precision = max(
+            matching_rules,
+            key=lambda item: (
+                len([segment for segment in item[1].split(".") if segment != "*"]),
+                len(item[1].split(".")),
+                item[0],
+            ),
+        )
+        return precision
+    # Unlisted modules are preserved. Quantizing by a loose name heuristic can
+    # accidentally include the vision tower or projector.
+    return "bfloat16"
+
+
+def convert_model(
+    model_path: str,
+    precision_map: dict,
+    output_dir: Path,
+    verbose: bool = True,
+) -> Path:
+    """Apply mixed-precision quantization according to the precision map.
+
+    The conversion is staged in a temporary sibling directory and moved into
+    place only after quantized weights and all requested rule matches exist.
+    """
+    validate_precision_map(precision_map)
+    output_dir = Path(output_dir)
+    if output_dir.exists():
+        raise FileExistsError(
+            f"Output directory already exists; choose a new path: {output_dir}"
+        )
+    output_dir.parent.mkdir(parents=True, exist_ok=True)
+
+    from mlx_vlm.convert import convert
+
+    if verbose:
+        print(f"Loading and converting model from: {model_path}")
+
+    quantized_modules: list[str] = []
+    quantized_precisions: dict[str, str] = {}
+    preserved_modules: list[str] = []
+
+    def quantization_predicate(path, module):
+        precision = get_precision_for_param(path, precision_map)
+        if precision in QUANTIZATION_CONFIGS:
+            quantized_modules.append(path)
+            quantized_precisions[path] = precision
+            return dict(QUANTIZATION_CONFIGS[precision])
+        preserved_modules.append(path)
+        return False
+
+    if verbose:
+        print(f"\nPrecision map summary:")
+        for pattern, precision in precision_map.items():
+            if not pattern.startswith("_"):
+                print(f"  {pattern}: {precision}")
+
+    staging_dir = Path(tempfile.mkdtemp(
+        prefix=f".{output_dir.name}_staging_",
+        dir=output_dir.parent,
+    ))
+    try:
+        convert(
+            hf_path=model_path,
+            mlx_path=str(staging_dir),
+            quantize=True,
+            q_group_size=32,
+            q_bits=8,
+            q_mode="mxfp8",
+            quant_predicate=quantization_predicate,
+        )
+
+        if not quantized_modules:
+            raise RuntimeError(
+                "Precision map matched no quantizable MLX modules; refusing to save a BF16-only model"
+            )
+        requested_patterns = [
+            pattern
+            for pattern, precision in precision_map.items()
+            if not pattern.startswith("_") and precision in QUANTIZATION_CONFIGS
+        ]
+        unmatched_patterns = [
+            pattern
+            for pattern in requested_patterns
+            if not any(matches_pattern(path, pattern) for path in quantized_modules)
+        ]
+        if unmatched_patterns:
+            raise RuntimeError(
+                "MXFP8 precision rules matched no modules: " + ", ".join(unmatched_patterns)
+            )
+        if not list(staging_dir.glob("*.safetensors")):
+            raise RuntimeError("mlx-vlm conversion produced no safetensors weights")
+
+        normalize_unlimited_ocr_metadata(staging_dir)
+
+        (staging_dir / "precision_map.json").write_text(
+            json.dumps(precision_map, indent=2),
+            encoding="utf-8",
+        )
+        (staging_dir / "quantization_summary.json").write_text(
+            json.dumps({
+                "method": "mxfp8",
+                "group_size": 32,
+                "bits": 8,
+                "source_model": (
+                    Path(model_path).name if Path(model_path).is_dir() else model_path
+                ),
+                "precision_map_sha256": _json_digest(precision_map),
+                "quantized_module_count": len(set(quantized_modules)),
+                "quantized_precision_counts": {
+                    precision: sum(
+                        selected == precision
+                        for selected in quantized_precisions.values()
+                    )
+                    for precision in sorted(set(quantized_precisions.values()))
+                },
+                "preserved_quantizable_module_count": len(set(preserved_modules)),
+                "quantized_modules": sorted(set(quantized_modules)),
+                "quantized_module_precisions": dict(sorted(quantized_precisions.items())),
+            }, indent=2),
+            encoding="utf-8",
+        )
+        staging_dir.replace(output_dir)
+    finally:
+        if staging_dir.exists():
+            shutil.rmtree(staging_dir)
+
+    if verbose:
+        print(f"\nQuantized {len(set(quantized_modules))} module(s).")
+        print(f"Model saved to: {output_dir}")
+    return output_dir
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Apply OCR-aware mixed-precision quantization"
+    )
+    parser.add_argument("--model-path", required=True,
+                        help="Source model (baidu/Unlimited-OCR or local path)")
+    parser.add_argument("--precision-map", type=Path,
+                        default=Path(__file__).parent / "precision_map.json",
+                        help="Path to precision_map.json")
+    parser.add_argument("--output-dir", type=Path, default=Path("./enhanced_model"),
+                        help="Output directory for enhanced model")
+    parser.add_argument(
+        "--verbose",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Show conversion progress (use --no-verbose to suppress)",
+    )
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("Unlimited-OCR Mixed-Precision Conversion")
+    print("=" * 60)
+
+    precision_map = load_precision_map(args.precision_map)
+    convert_model(args.model_path, precision_map, args.output_dir, args.verbose)
+
+
+if __name__ == "__main__":
+    main()

quantization/precision_map.json

@@ -0,0 +1,31 @@
+{
+  "vision_model": "bfloat16",
+  "projector": "bfloat16",
+  "language_model.model.embed_tokens": "bfloat16",
+  "language_model.model.norm": "bfloat16",
+  "language_model.lm_head": "bfloat16",
+  "language_model.model.layers.*.input_layernorm": "bfloat16",
+  "language_model.model.layers.*.post_attention_layernorm": "bfloat16",
+  "language_model.model.layers.*.self_attn.q_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.k_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.v_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.o_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate": "bfloat16",
+  "_comment": "MLX module paths for DeepseekOCR. Refine via layer_sensitivity.py before final release.",
+  "_sensitivity_override": {
+    "_description": "Layers identified as OCR-sensitive by sensitivity analysis should be promoted to bfloat16. Run layer_sensitivity.py to populate this section.",
+    "examples": [
+      "language_model.model.layers.11.self_attn.q_proj -> bfloat16 (if digit CER degrades >2%)",
+      "language_model.model.layers.1.mlp.switch_mlp -> bfloat16 (if table score degrades >1%)"
+    ]
+  }
+}

quantization/release_gate.py

@@ -0,0 +1,584 @@
+#!/usr/bin/env python3
+"""Create a content-addressed, fail-closed model release manifest."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import platform
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tiff", ".tif", ".webp", ".bmp"}
+HARD_PROTECTED_GROUPS = {"vision_encoder", "lm_head"}
+EVIDENCE_PROTECTED_GROUPS = {"vision_projector", "token_embeddings"}
+DEFAULT_THRESHOLDS = {
+    "max_cer_delta_vs_bf16": 0.01,
+    "max_cer_delta_vs_reference": 0.005,
+    "max_digit_cer_delta_vs_bf16": 0.01,
+    "max_table_score_degradation_vs_bf16": 0.01,
+    "min_tps_ratio_vs_reference": 0.90,
+    "max_weight_size_gb": 4.5,
+}
+
+
+def load_json_object(path: str | Path) -> dict:
+    """Load a JSON object and reject malformed release evidence."""
+    path = Path(path)
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"Invalid JSON file: {path}") from exc
+    if not isinstance(value, dict):
+        raise ValueError(f"JSON file must contain an object: {path}")
+    return value
+
+
+def sha256_file(path: str | Path, chunk_size: int = 8 * 1024 * 1024) -> str:
+    """Return the SHA-256 digest of a file without loading it into memory."""
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        while chunk := handle.read(chunk_size):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def model_weight_manifest(model_dir: str | Path) -> dict:
+    """Hash Safetensors files and create a stable aggregate digest."""
+    model_dir = Path(model_dir)
+    weight_paths = sorted(path for path in model_dir.glob("*.safetensors") if path.is_file())
+    if not weight_paths:
+        raise FileNotFoundError(f"No Safetensors weights found in: {model_dir}")
+
+    aggregate = hashlib.sha256()
+    files = []
+    total_size = 0
+    for path in weight_paths:
+        size = path.stat().st_size
+        digest = sha256_file(path)
+        total_size += size
+        aggregate.update(path.name.encode("utf-8"))
+        aggregate.update(b"\0")
+        aggregate.update(str(size).encode("ascii"))
+        aggregate.update(b"\0")
+        aggregate.update(digest.encode("ascii"))
+        aggregate.update(b"\n")
+        files.append({"name": path.name, "size": size, "sha256": digest})
+
+    return {
+        "files": files,
+        "total_size_bytes": total_size,
+        "total_size_gb": total_size / (1024**3),
+        "aggregate_sha256": aggregate.hexdigest(),
+    }
+
+
+def dataset_manifest(eval_dir: str | Path) -> dict:
+    """Validate and content-hash an OCR image/ground-truth dataset."""
+    eval_dir = Path(eval_dir)
+    images_dir = eval_dir / "images"
+    ground_truth_dir = eval_dir / "ground_truth"
+    manifest_path = eval_dir / "manifest.json"
+    if not images_dir.is_dir() or not ground_truth_dir.is_dir():
+        raise FileNotFoundError("Evaluation dataset requires images/ and ground_truth/")
+    declared = load_json_object(manifest_path)
+
+    image_paths = sorted(
+        path for path in images_dir.iterdir()
+        if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+    )
+    if not image_paths:
+        raise ValueError(f"Evaluation dataset contains no images: {images_dir}")
+    duplicate_stems = sorted(
+        stem for stem, count in Counter(path.stem for path in image_paths).items()
+        if count > 1
+    )
+    if duplicate_stems:
+        raise ValueError("Duplicate image stems: " + ", ".join(duplicate_stems))
+
+    declared_samples = declared.get("samples", [])
+    if not isinstance(declared_samples, list) or not declared_samples:
+        raise ValueError("manifest.json must declare at least one sample")
+    samples_by_image = {
+        sample.get("image"): sample
+        for sample in declared_samples
+        if isinstance(sample, dict) and isinstance(sample.get("image"), str)
+    }
+
+    content_digest = hashlib.sha256()
+    files = []
+    category_counts: Counter[str] = Counter()
+    digit_samples = 0
+    cjk_samples = 0
+    table_samples = 0
+    for image_path in image_paths:
+        relative_image = image_path.relative_to(eval_dir).as_posix()
+        sample = samples_by_image.get(relative_image)
+        if sample is None:
+            raise ValueError(f"Image is missing from manifest.json: {relative_image}")
+        gt_path = ground_truth_dir / f"{image_path.stem}.txt"
+        if not gt_path.is_file():
+            raise FileNotFoundError(f"Missing ground truth for: {image_path.name}")
+        ground_truth = gt_path.read_text(encoding="utf-8")
+        if not ground_truth.strip():
+            raise ValueError(f"Ground truth is empty: {gt_path}")
+
+        category_counts[str(sample.get("category", "uncategorized"))] += 1
+        digit_samples += int(any(character.isascii() and character.isdigit() for character in ground_truth))
+        cjk_samples += int(any(
+            "\u3040" <= character <= "\u30ff"
+            or "\u3400" <= character <= "\u9fff"
+            or "\uac00" <= character <= "\ud7af"
+            for character in ground_truth
+        ))
+        table_samples += int("<table" in ground_truth.lower() or "| ---" in ground_truth)
+
+        for path in (image_path, gt_path):
+            relative = path.relative_to(eval_dir).as_posix()
+            digest = sha256_file(path)
+            size = path.stat().st_size
+            content_digest.update(relative.encode("utf-8"))
+            content_digest.update(b"\0")
+            content_digest.update(digest.encode("ascii"))
+            content_digest.update(b"\n")
+            files.append({"path": relative, "size": size, "sha256": digest})
+
+    declared_images = set(samples_by_image)
+    actual_images = {path.relative_to(eval_dir).as_posix() for path in image_paths}
+    extra = sorted(declared_images - actual_images)
+    if extra:
+        raise FileNotFoundError("Manifest references missing images: " + ", ".join(extra))
+
+    content_digest.update(manifest_path.read_bytes())
+    return {
+        "name": eval_dir.name,
+        "num_samples": len(image_paths),
+        "num_digit_samples": digit_samples,
+        "num_cjk_samples": cjk_samples,
+        "num_table_samples": table_samples,
+        "category_counts": dict(sorted(category_counts.items())),
+        "manifest_sha256": sha256_file(manifest_path),
+        "content_sha256": content_digest.hexdigest(),
+        "files": files,
+    }
+
+
+def _pattern_is_within(child: str, parent: str) -> bool:
+    """Return whether a precision rule is the parent itself or a descendant."""
+    return child == parent or child.startswith(parent + ".")
+
+
+def generate_precision_map(
+    base_map: dict,
+    sensitivity_results: dict,
+    *,
+    calibration_results: dict | None = None,
+    cer_threshold: float = 0.02,
+    digit_cer_threshold: float = 0.02,
+    table_degradation_threshold: float = 0.01,
+) -> dict:
+    """Turn group sensitivity measurements into executable top-level rules."""
+    from quantization.layer_sensitivity import LAYER_GROUPS
+
+    groups = sensitivity_results.get("layer_groups")
+    if not isinstance(groups, dict) or not groups:
+        raise ValueError("Sensitivity results contain no layer_groups")
+    generated = {
+        pattern: precision
+        for pattern, precision in base_map.items()
+        if not pattern.startswith("_")
+    }
+    decisions = {}
+    for group_name, patterns in LAYER_GROUPS.items():
+        result = groups.get(group_name)
+        if not isinstance(result, dict):
+            raise ValueError(f"Sensitivity result missing group: {group_name}")
+        reasons = []
+        if result.get("status") != "success":
+            reasons.append(f"status={result.get('status', 'missing')}")
+        for key, threshold in (
+            ("cer_delta", cer_threshold),
+            ("digit_cer_delta", digit_cer_threshold),
+            ("table_score_degradation", table_degradation_threshold),
+        ):
+            value = result.get(key)
+            if isinstance(value, (int, float)) and not isinstance(value, bool) and value > threshold:
+                reasons.append(f"{key}={value:.6f}")
+        measured_values = [
+            result.get("cer_delta"),
+            result.get("digit_cer_delta"),
+            result.get("table_score_degradation"),
+        ]
+        explicit_non_degradation = (
+            result.get("status") == "success"
+            and all(
+                value is None
+                or (
+                    isinstance(value, (int, float))
+                    and not isinstance(value, bool)
+                    and value <= 0
+                )
+                for value in measured_values
+            )
+        )
+        if group_name in HARD_PROTECTED_GROUPS:
+            reasons.append("protected OCR-critical group")
+        elif group_name in EVIDENCE_PROTECTED_GROUPS and not explicit_non_degradation:
+            reasons.append("protected unless all measured quality deltas are non-degrading")
+
+        retain_bf16 = bool(reasons)
+        if retain_bf16:
+            for group_pattern in patterns:
+                for existing_pattern in list(generated):
+                    if _pattern_is_within(existing_pattern, group_pattern):
+                        generated[existing_pattern] = "bfloat16"
+                generated[group_pattern] = "bfloat16"
+        elif group_name in EVIDENCE_PROTECTED_GROUPS and explicit_non_degradation:
+            for group_pattern in patterns:
+                for existing_pattern in list(generated):
+                    if _pattern_is_within(existing_pattern, group_pattern):
+                        generated[existing_pattern] = "mxfp8"
+                generated[group_pattern] = "mxfp8"
+        decisions[group_name] = {
+            "precision": (
+                "bfloat16" if retain_bf16
+                else "mxfp8" if group_name in EVIDENCE_PROTECTED_GROUPS
+                else "base-map"
+            ),
+            "reasons": reasons or (
+                ["all measured quality deltas were non-degrading"]
+                if group_name in EVIDENCE_PROTECTED_GROUPS
+                else ["within thresholds"]
+            ),
+        }
+
+    calibration_summary = None
+    if calibration_results is not None:
+        overrides = calibration_results.get("precision_overrides")
+        if not isinstance(overrides, dict) or not overrides:
+            raise ValueError("Calibration results contain no precision_overrides")
+        allowed_precisions = {"bfloat16", "mxfp8", "affine8"}
+        for pattern, precision in overrides.items():
+            if not isinstance(pattern, str) or precision not in allowed_precisions:
+                raise ValueError(f"Invalid calibrated precision override: {pattern}={precision}")
+            generated[pattern] = precision
+            for group_name, patterns in LAYER_GROUPS.items():
+                if pattern in patterns:
+                    decisions[group_name] = {
+                        "precision": precision,
+                        "reasons": [
+                            "selected by joint quality/throughput calibration: "
+                            + str(calibration_results.get("selected", {}).get("label"))
+                        ],
+                    }
+        calibration_summary = {
+            "selected": calibration_results.get("selected"),
+            "selection_policy": calibration_results.get("selection_policy"),
+        }
+
+    generated["_generated_from"] = {
+        "source_model": sensitivity_results.get("model_path"),
+        "thresholds": {
+            "cer_delta": cer_threshold,
+            "digit_cer_delta": digit_cer_threshold,
+            "table_score_degradation": table_degradation_threshold,
+        },
+        "decisions": decisions,
+        "calibration": calibration_summary,
+    }
+    return generated
+
+
+def validate_candidate_metadata(model_dir: str | Path) -> dict:
+    """Validate native Unlimited-OCR MXFP8 metadata."""
+    model_dir = Path(model_dir)
+    config = load_json_object(model_dir / "config.json")
+    processor = load_json_object(model_dir / "processor_config.json")
+    architectures = config.get("architectures")
+    quantization = config.get("quantization") or config.get("quantization_config")
+    text_config = config.get("text_config") or config.get("language_config") or config
+    window = text_config.get("sliding_window_size") if isinstance(text_config, dict) else None
+    if window is None and isinstance(text_config, dict):
+        window = text_config.get("sliding_window")
+    checks = {
+        "architecture": isinstance(architectures, list) and "UnlimitedOCRForCausalLM" in architectures,
+        "model_type": config.get("model_type") == "unlimited-ocr",
+        "mxfp8": isinstance(quantization, dict) and quantization.get("mode") == "mxfp8",
+        "sliding_window": isinstance(window, int) and not isinstance(window, bool) and window > 0,
+        "processor_class": processor.get("processor_class") == "UnlimitedOCRHFProcessor",
+        "sft_format": processor.get("sft_format") == "unlimitedocr",
+    }
+    return {"passed": all(checks.values()), "checks": checks, "sliding_window": window}
+
+
+def _number(payload: dict, key: str) -> float | None:
+    value = payload.get(key)
+    return float(value) if isinstance(value, (int, float)) and not isinstance(value, bool) else None
+
+
+def _gate(name: str, actual: Any, limit: Any, passed: bool, detail: str) -> dict:
+    return {"name": name, "passed": bool(passed), "actual": actual, "limit": limit, "detail": detail}
+
+
+def evaluate_release_gates(
+    *,
+    candidate_weights: dict,
+    reference_weights: dict,
+    dataset: dict,
+    metadata: dict,
+    bf16_accuracy: dict,
+    reference_accuracy: dict,
+    candidate_accuracy: dict,
+    reference_performance: dict,
+    candidate_performance: dict,
+    rswa: dict,
+    thresholds: dict | None = None,
+) -> list[dict]:
+    """Evaluate every required release gate; missing values fail closed."""
+    limits = {**DEFAULT_THRESHOLDS, **(thresholds or {})}
+    gates = []
+    candidate_digest = candidate_weights.get("aggregate_sha256")
+    reference_digest = reference_weights.get("aggregate_sha256")
+    gates.append(_gate(
+        "weights_are_distinct", candidate_digest, f"different from {reference_digest}",
+        bool(candidate_digest and reference_digest and candidate_digest != reference_digest),
+        "Candidate aggregate digest must differ from the Sahil reference",
+    ))
+    candidate_size = _number(candidate_weights, "total_size_gb")
+    gates.append(_gate(
+        "weight_size_gb", candidate_size, limits["max_weight_size_gb"],
+        candidate_size is not None and candidate_size <= limits["max_weight_size_gb"],
+        "Candidate Safetensors size",
+    ))
+    gates.append(_gate(
+        "native_model_metadata", metadata.get("checks"), True,
+        metadata.get("passed") is True, "Native Unlimited-OCR, MXFP8, and R-SWA metadata",
+    ))
+
+    coverage = {
+        "samples": dataset.get("num_samples", 0),
+        "digit": dataset.get("num_digit_samples", 0),
+        "cjk": dataset.get("num_cjk_samples", 0),
+        "table": dataset.get("num_table_samples", 0),
+    }
+    gates.append(_gate(
+        "evaluation_coverage", coverage, "all counts > 0",
+        all(isinstance(value, int) and value > 0 for value in coverage.values()),
+        "Dataset must cover ordinary text, digits, CJK, and tables",
+    ))
+    sample_counts = [
+        bf16_accuracy.get("num_samples"),
+        reference_accuracy.get("num_samples"),
+        candidate_accuracy.get("num_samples"),
+    ]
+    gates.append(_gate(
+        "same_evaluation_samples", sample_counts, dataset.get("num_samples"),
+        all(count == dataset.get("num_samples") for count in sample_counts),
+        "All three checkpoints must run the complete evaluation set",
+    ))
+
+    bf16_cer = _number(bf16_accuracy, "mean_cer")
+    reference_cer = _number(reference_accuracy, "mean_cer")
+    candidate_cer = _number(candidate_accuracy, "mean_cer")
+    delta_bf16 = candidate_cer - bf16_cer if candidate_cer is not None and bf16_cer is not None else None
+    delta_reference = candidate_cer - reference_cer if candidate_cer is not None and reference_cer is not None else None
+    gates.append(_gate(
+        "candidate_cer_vs_bf16", delta_bf16, limits["max_cer_delta_vs_bf16"],
+        delta_bf16 is not None and delta_bf16 <= limits["max_cer_delta_vs_bf16"],
+        "Candidate minus BF16 absolute mean CER",
+    ))
+    gates.append(_gate(
+        "candidate_cer_vs_reference", delta_reference, limits["max_cer_delta_vs_reference"],
+        delta_reference is not None and delta_reference <= limits["max_cer_delta_vs_reference"],
+        "Candidate minus Sahil-reference absolute mean CER",
+    ))
+
+    bf16_digit = _number(bf16_accuracy, "mean_digit_cer")
+    candidate_digit = _number(candidate_accuracy, "mean_digit_cer")
+    digit_delta = candidate_digit - bf16_digit if candidate_digit is not None and bf16_digit is not None else None
+    gates.append(_gate(
+        "candidate_digit_cer_vs_bf16", digit_delta, limits["max_digit_cer_delta_vs_bf16"],
+        digit_delta is not None and digit_delta <= limits["max_digit_cer_delta_vs_bf16"],
+        "Candidate minus BF16 digit CER",
+    ))
+
+    bf16_table = _number(bf16_accuracy, "mean_table_score")
+    candidate_table = _number(candidate_accuracy, "mean_table_score")
+    table_degradation = bf16_table - candidate_table if bf16_table is not None and candidate_table is not None else None
+    gates.append(_gate(
+        "candidate_table_score_vs_bf16", table_degradation,
+        limits["max_table_score_degradation_vs_bf16"],
+        table_degradation is not None and table_degradation <= limits["max_table_score_degradation_vs_bf16"],
+        "BF16 minus candidate mean table score",
+    ))
+
+    reference_tps = _number(reference_performance, "mean_tps")
+    candidate_tps = _number(candidate_performance, "mean_tps")
+    tps_ratio = candidate_tps / reference_tps if candidate_tps is not None and reference_tps and reference_tps > 0 else None
+    gates.append(_gate(
+        "candidate_tps_vs_reference", tps_ratio, limits["min_tps_ratio_vs_reference"],
+        tps_ratio is not None and tps_ratio >= limits["min_tps_ratio_vs_reference"],
+        "Candidate decode throughput divided by Sahil-reference throughput",
+    ))
+    gates.append(_gate(
+        "rswa_8k_bounded", rswa.get("pass_conditions"), True,
+        rswa.get("passed") is True, "8K generation, bounded cache, and stable throughput",
+    ))
+    return gates
+
+
+def _metric_summary(payload: dict) -> dict:
+    keys = (
+        "model_path", "num_samples", "mean_cer", "mean_digit_cer",
+        "mean_cjk_cer", "mean_table_score", "mean_tps",
+        "mean_peak_memory_mb", "max_tokens", "profile",
+    )
+    return {key: payload.get(key) for key in keys if key in payload}
+
+
+def _runtime_versions() -> dict:
+    versions = {}
+    for distribution in ("mlx", "mlx-vlm", "huggingface-hub", "numpy", "Pillow"):
+        try:
+            versions[distribution] = importlib.metadata.version(distribution)
+        except importlib.metadata.PackageNotFoundError:
+            versions[distribution] = None
+    return versions
+
+
+def build_release_manifest(
+    *,
+    candidate_dir: str | Path,
+    reference_dir: str | Path,
+    source_dir: str | Path,
+    eval_dir: str | Path,
+    evidence_paths: dict[str, str | Path],
+    repo_id: str,
+    source_id: str,
+    reference_id: str,
+    thresholds: dict | None = None,
+) -> dict:
+    """Build a complete release decision from on-disk evidence."""
+    evidence = {name: load_json_object(path) for name, path in evidence_paths.items()}
+    required = {
+        "bf16_accuracy", "reference_accuracy", "candidate_accuracy",
+        "reference_performance", "candidate_performance", "candidate_rswa",
+        "sensitivity_results", "calibration_results", "generated_precision_map", "provenance",
+    }
+    missing = sorted(required - set(evidence))
+    if missing:
+        raise ValueError("Missing release evidence: " + ", ".join(missing))
+
+    candidate_weights = model_weight_manifest(candidate_dir)
+    reference_weights = model_weight_manifest(reference_dir)
+    source_weights = model_weight_manifest(source_dir)
+    dataset = dataset_manifest(eval_dir)
+    metadata = validate_candidate_metadata(candidate_dir)
+    gates = evaluate_release_gates(
+        candidate_weights=candidate_weights,
+        reference_weights=reference_weights,
+        dataset=dataset,
+        metadata=metadata,
+        bf16_accuracy=evidence["bf16_accuracy"],
+        reference_accuracy=evidence["reference_accuracy"],
+        candidate_accuracy=evidence["candidate_accuracy"],
+        reference_performance=evidence["reference_performance"],
+        candidate_performance=evidence["candidate_performance"],
+        rswa=evidence["candidate_rswa"],
+        thresholds=thresholds,
+    )
+    artifact_hashes = {
+        name: {
+            "filename": Path(path).name,
+            "size": Path(path).stat().st_size,
+            "sha256": sha256_file(path),
+        }
+        for name, path in evidence_paths.items()
+    }
+    limits = {**DEFAULT_THRESHOLDS, **(thresholds or {})}
+    return {
+        "schema_version": 1,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "release_approved": all(gate["passed"] for gate in gates),
+        "repo_id": repo_id,
+        "source": {"id": source_id, "weights": source_weights},
+        "reference": {"id": reference_id, "weights": reference_weights},
+        "candidate": {
+            "name": Path(candidate_dir).name,
+            "weights": candidate_weights,
+            "metadata": metadata,
+        },
+        "dataset": dataset,
+        "thresholds": limits,
+        "metrics": {
+            name: _metric_summary(evidence[name])
+            for name in (
+                "bf16_accuracy", "reference_accuracy", "candidate_accuracy",
+                "reference_performance", "candidate_performance",
+            )
+        },
+        "rswa": evidence["candidate_rswa"],
+        "sensitivity": {
+            "baseline": evidence["sensitivity_results"].get("baseline"),
+            "groups": evidence["sensitivity_results"].get("layer_groups"),
+        },
+        "calibration": evidence["calibration_results"],
+        "precision_map": evidence["generated_precision_map"],
+        "artifacts": artifact_hashes,
+        "gates": gates,
+        "environment": {
+            "platform": platform.platform(),
+            "machine": platform.machine(),
+            "python": platform.python_version(),
+            "versions": _runtime_versions(),
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build a fail-closed release manifest")
+    parser.add_argument("--candidate-dir", required=True, type=Path)
+    parser.add_argument("--reference-dir", required=True, type=Path)
+    parser.add_argument("--source-dir", required=True, type=Path)
+    parser.add_argument("--eval-dir", required=True, type=Path)
+    parser.add_argument("--artifacts-dir", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--repo-id", required=True)
+    parser.add_argument("--source-id", default="baidu/Unlimited-OCR")
+    parser.add_argument("--reference-id", default="sahilchachra/unlimited-ocr-mxfp8-mlx")
+    args = parser.parse_args()
+
+    evidence_paths = {
+        name: args.artifacts_dir / f"{name}.json"
+        for name in (
+            "bf16_accuracy", "reference_accuracy", "candidate_accuracy",
+            "reference_performance", "candidate_performance", "candidate_rswa",
+            "sensitivity_results", "calibration_results", "generated_precision_map", "provenance",
+        )
+    }
+    manifest = build_release_manifest(
+        candidate_dir=args.candidate_dir,
+        reference_dir=args.reference_dir,
+        source_dir=args.source_dir,
+        eval_dir=args.eval_dir,
+        evidence_paths=evidence_paths,
+        repo_id=args.repo_id,
+        source_id=args.source_id,
+        reference_id=args.reference_id,
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    for gate in manifest["gates"]:
+        print(f"[{'PASS' if gate['passed'] else 'FAIL'}] {gate['name']}: {gate['actual']}")
+    print(f"Release approved: {manifest['release_approved']}")
+    if not manifest["release_approved"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

quantization/run_pipeline.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""Orchestrate verified OCR-aware quantization, validation, and publication."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import platform
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+QUANT_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = QUANT_DIR.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(PROJECT_ROOT / "src"))
+
+from quantization.release_gate import (  # noqa: E402
+    dataset_manifest,
+    generate_precision_map,
+    load_json_object,
+    sha256_file,
+)
+
+
+DEFAULT_SOURCE = PROJECT_ROOT / "reference" / "Unlimited-OCR"
+DEFAULT_SOURCE_ID = "baidu/Unlimited-OCR"
+DEFAULT_REFERENCE = "sahilchachra/unlimited-ocr-mxfp8-mlx"
+DEFAULT_OUTPUT = PROJECT_ROOT / "models" / "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8"
+DEFAULT_ARTIFACTS = PROJECT_ROOT / "artifacts" / "ocr-aware-v1"
+DEFAULT_REPO = "AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8"
+BASE_PRECISION_MAP = QUANT_DIR / "precision_map.json"
+
+
+def run_command(cmd: list[str], description: str, *, dry_run: bool = False) -> bool:
+    """Run one subprocess and stop the pipeline on any non-zero result."""
+    print("\n" + "=" * 72)
+    print(f"STEP: {description}")
+    print("CMD:  " + " ".join(str(part) for part in cmd))
+    print("=" * 72)
+    if dry_run:
+        print("[DRY RUN] Command not executed")
+        return True
+    started = time.perf_counter()
+    result = subprocess.run(cmd, cwd=str(PROJECT_ROOT))
+    elapsed = time.perf_counter() - started
+    print(f"[{'OK' if result.returncode == 0 else 'FAIL'}] {description} ({elapsed:.1f}s)")
+    return result.returncode == 0
+
+
+def _config_path(model_path: str) -> Path:
+    local = Path(model_path)
+    if local.is_dir():
+        return local / "config.json"
+    from huggingface_hub import hf_hub_download
+    return Path(hf_hub_download(model_path, filename="config.json"))
+
+
+def assert_unquantized_source(model_path: str) -> dict:
+    """Reject an already quantized source before expensive work."""
+    config_path = _config_path(model_path)
+    config = load_json_object(config_path)
+    if config.get("quantization") or config.get("quantization_config"):
+        raise ValueError("Source is already quantized; use the upstream BF16 checkpoint")
+    architectures = config.get("architectures")
+    if not isinstance(architectures, list) or "UnlimitedOCRForCausalLM" not in architectures:
+        raise ValueError("Source is not an UnlimitedOCRForCausalLM checkpoint")
+    return {"path": config_path.name, "sha256": sha256_file(config_path)}
+
+
+def system_provenance() -> dict:
+    versions = {}
+    for distribution in ("mlx", "mlx-vlm", "huggingface-hub", "numpy", "Pillow"):
+        try:
+            versions[distribution] = importlib.metadata.version(distribution)
+        except importlib.metadata.PackageNotFoundError:
+            versions[distribution] = None
+    return {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "python": platform.python_version(),
+        "platform": platform.platform(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+        "versions": versions,
+    }
+
+
+def preflight(args: argparse.Namespace) -> bool:
+    """Validate source, dataset, and release inputs before Metal allocation."""
+    try:
+        source_config = assert_unquantized_source(args.model_path)
+        dataset = dataset_manifest(args.eval_dir)
+        if not args.image.is_file():
+            raise FileNotFoundError(f"Performance/R-SWA image not found: {args.image}")
+        if args.output_dir.exists() and args.step in {"all", "convert"}:
+            raise FileExistsError(f"Output model directory already exists: {args.output_dir}")
+        args.artifacts_dir.mkdir(parents=True, exist_ok=True)
+        provenance = {
+            **system_provenance(),
+            "source_model": args.source_id,
+            "source_local_name": Path(args.model_path).name,
+            "source_config": source_config,
+            "reference_model": args.reference_model,
+            "target_repo": args.repo_id,
+            "dataset": dataset,
+            "smoke_image": {
+                "name": args.image.name,
+                "sha256": sha256_file(args.image),
+            },
+            "parameters": {
+                "accuracy_tokens": args.accuracy_tokens,
+                "performance_tokens": args.performance_tokens,
+                "performance_warmup": args.performance_warmup,
+                "performance_runs": args.performance_runs,
+                "rswa_lengths": args.rswa_lengths,
+            },
+        }
+        (args.artifacts_dir / "provenance.json").write_text(
+            json.dumps(provenance, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+        print(f"[OK] Unquantized source: {args.model_path}")
+        print(f"[OK] Evaluation samples: {dataset['num_samples']}")
+        print(f"[OK] Dataset digest: {dataset['content_sha256']}")
+        return True
+    except Exception as exc:
+        print(f"[FAIL] Preflight: {exc}")
+        return False
+
+
+def sensitivity(args: argparse.Namespace) -> bool:
+    cmd = [
+        sys.executable,
+        str(QUANT_DIR / "layer_sensitivity.py"),
+        "--model-path", args.model_path,
+        "--source-id", args.source_id,
+        "--eval-dir", str(args.eval_dir),
+        "--output", str(args.artifacts_dir / "sensitivity_results.json"),
+        "--max-tokens", str(args.accuracy_tokens),
+    ]
+    return run_command(cmd, "Layer sensitivity analysis", dry_run=args.dry_run)
+
+
+def precision_map(args: argparse.Namespace) -> bool:
+    sensitivity_path = args.artifacts_dir / "sensitivity_results.json"
+    output_path = args.artifacts_dir / "generated_precision_map.json"
+    if args.dry_run:
+        print(f"[DRY RUN] Generate {output_path} from {sensitivity_path}")
+        return True
+    try:
+        calibration_path = args.artifacts_dir / "calibration_results.json"
+        generated = generate_precision_map(
+            load_json_object(BASE_PRECISION_MAP),
+            load_json_object(sensitivity_path),
+            calibration_results=(
+                load_json_object(calibration_path)
+                if calibration_path.is_file()
+                else None
+            ),
+        )
+        output_path.write_text(
+            json.dumps(generated, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+        print(f"[OK] Generated executable precision map: {output_path}")
+        return True
+    except Exception as exc:
+        print(f"[FAIL] Precision-map generation: {exc}")
+        return False
+
+
+def convert(args: argparse.Namespace) -> bool:
+    cmd = [
+        sys.executable,
+        str(QUANT_DIR / "mixed_precision_convert.py"),
+        "--model-path", args.model_path,
+        "--precision-map", str(args.artifacts_dir / "generated_precision_map.json"),
+        "--output-dir", str(args.output_dir),
+    ]
+    return run_command(cmd, "BF16 to OCR-aware MXFP8 conversion", dry_run=args.dry_run)
+
+
+def _accuracy_command(model: str, output: Path, args: argparse.Namespace) -> list[str]:
+    return [
+        sys.executable,
+        str(PROJECT_ROOT / "benchmarks" / "run_accuracy.py"),
+        "--model-path", model,
+        "--eval-dir", str(args.eval_dir),
+        "--output", str(output),
+        "--max-tokens", str(args.accuracy_tokens),
+        "--profile", "accurate",
+    ]
+
+
+def _performance_command(model: str, output: Path, args: argparse.Namespace) -> list[str]:
+    return [
+        sys.executable,
+        str(PROJECT_ROOT / "benchmarks" / "run_performance.py"),
+        "--model-path", model,
+        "--image", str(args.image),
+        "--output", str(output),
+        "--max-tokens", str(args.performance_tokens),
+        "--warmup", str(args.performance_warmup),
+        "--runs", str(args.performance_runs),
+    ]
+
+
+def validate(args: argparse.Namespace) -> bool:
+    """Benchmark BF16, Sahil reference, candidate, then stress candidate R-SWA."""
+    jobs = [
+        (_accuracy_command(args.model_path, args.artifacts_dir / "bf16_accuracy.json", args), "BF16 accuracy"),
+        (_accuracy_command(args.reference_model, args.artifacts_dir / "reference_accuracy.json", args), "Sahil-reference accuracy"),
+        (_accuracy_command(str(args.output_dir), args.artifacts_dir / "candidate_accuracy.json", args), "Candidate accuracy"),
+        (_performance_command(args.reference_model, args.artifacts_dir / "reference_performance.json", args), "Sahil-reference performance"),
+        (_performance_command(str(args.output_dir), args.artifacts_dir / "candidate_performance.json", args), "Candidate performance"),
+        ([
+            sys.executable,
+            str(PROJECT_ROOT / "benchmarks" / "rswa_validation.py"),
+            "--model-path", str(args.output_dir),
+            "--image", str(args.image),
+            "--output", str(args.artifacts_dir / "candidate_rswa.json"),
+            "--lengths", *[str(length) for length in args.rswa_lengths],
+            "--force-min-tokens", str(max(args.rswa_lengths)),
+        ], "Candidate R-SWA stress validation"),
+    ]
+    return all(run_command(cmd, description, dry_run=args.dry_run) for cmd, description in jobs)
+
+
+def resolve_reference_dir(reference_model: str) -> Path:
+    local = Path(reference_model)
+    if local.is_dir():
+        return local
+    from huggingface_hub import snapshot_download
+    return Path(snapshot_download(
+        reference_model,
+        allow_patterns=[
+            "*.safetensors", "model.safetensors.index.json", "config.json",
+            "processor_config.json", "tokenizer*.json", "special_tokens_map.json",
+            "chat_template.jinja",
+        ],
+    ))
+
+
+def gate(args: argparse.Namespace) -> bool:
+    if args.dry_run:
+        reference_dir = Path("<resolved-reference>")
+    else:
+        try:
+            reference_dir = resolve_reference_dir(args.reference_model)
+        except Exception as exc:
+            print(f"[FAIL] Reference download: {exc}")
+            return False
+    cmd = [
+        sys.executable,
+        str(QUANT_DIR / "release_gate.py"),
+        "--candidate-dir", str(args.output_dir),
+        "--reference-dir", str(reference_dir),
+        "--source-dir", args.model_path,
+        "--eval-dir", str(args.eval_dir),
+        "--artifacts-dir", str(args.artifacts_dir),
+        "--output", str(args.artifacts_dir / "release_manifest.json"),
+        "--repo-id", args.repo_id,
+        "--source-id", args.source_id,
+        "--reference-id", args.reference_model,
+    ]
+    return run_command(cmd, "Fail-closed release gate", dry_run=args.dry_run)
+
+
+def publish(args: argparse.Namespace) -> bool:
+    cmd = [
+        sys.executable,
+        str(PROJECT_ROOT / "scripts" / "publish_optimized_model.py"),
+        "--model-dir", str(args.output_dir),
+        "--manifest", str(args.artifacts_dir / "release_manifest.json"),
+        "--artifacts-dir", str(args.artifacts_dir),
+        "--repo-id", args.repo_id,
+    ]
+    if args.dry_run:
+        cmd.append("--dry-run")
+    return run_command(cmd, "Publish approved candidate to Hugging Face")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Verified OCR-aware model release pipeline")
+    parser.add_argument("--model-path", default=str(DEFAULT_SOURCE))
+    parser.add_argument("--source-id", default=DEFAULT_SOURCE_ID)
+    parser.add_argument("--reference-model", default=DEFAULT_REFERENCE)
+    parser.add_argument("--eval-dir", type=Path, default=PROJECT_ROOT / "eval_dataset")
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT)
+    parser.add_argument("--artifacts-dir", type=Path, default=DEFAULT_ARTIFACTS)
+    parser.add_argument("--image", type=Path, default=PROJECT_ROOT / "test_data" / "test_invoice.png")
+    parser.add_argument("--repo-id", default=DEFAULT_REPO)
+    parser.add_argument("--accuracy-tokens", type=int, default=2048)
+    parser.add_argument("--performance-tokens", type=int, default=256)
+    parser.add_argument("--performance-warmup", type=int, default=1)
+    parser.add_argument("--performance-runs", type=int, default=3)
+    parser.add_argument("--rswa-lengths", type=int, nargs="+", default=[512, 2048, 8192])
+    parser.add_argument(
+        "--step",
+        choices=["all", "preflight", "sensitivity", "precision-map", "convert", "validate", "gate", "publish"],
+        default="all",
+    )
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+    positive = ("accuracy_tokens", "performance_tokens", "performance_runs")
+    for name in positive:
+        if getattr(args, name) < 1:
+            parser.error(f"--{name.replace('_', '-')} must be positive")
+    if args.performance_warmup < 0:
+        parser.error("--performance-warmup must be non-negative")
+    if len(args.rswa_lengths) < 3 or args.rswa_lengths != sorted(set(args.rswa_lengths)) or 8192 not in args.rswa_lengths:
+        parser.error("--rswa-lengths must be sorted, unique, include 8192, and contain at least three values")
+    return args
+
+
+def main() -> None:
+    args = parse_args()
+    steps = {
+        "preflight": lambda: preflight(args),
+        "sensitivity": lambda: sensitivity(args),
+        "precision-map": lambda: precision_map(args),
+        "convert": lambda: convert(args),
+        "validate": lambda: validate(args),
+        "gate": lambda: gate(args),
+        "publish": lambda: publish(args),
+    }
+    selected = list(steps) if args.step == "all" else [args.step]
+    for step_name in selected:
+        if not steps[step_name]():
+            print(f"[ABORT] Pipeline stopped at: {step_name}")
+            raise SystemExit(1)
+    print("[DONE] Requested pipeline steps completed successfully")
+
+
+if __name__ == "__main__":
+    main()

quantization_config.json

@@ -0,0 +1,26 @@
+{
+  "quantization_method": "mxfp8",
+  "description": "Block-float MX FP8 quantization (~9.19 effective bits/weight) applied to language tower linear weights. Vision encoder and embeddings remain in bfloat16.",
+  "base_model": "baidu/Unlimited-OCR",
+  "reference_quantization": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+  "quantized_components": {
+    "language_model.linear": "mxfp8",
+    "language_model.moe.experts": "mxfp8"
+  },
+  "preserved_bf16_components": {
+    "vision_encoder": "bfloat16",
+    "vision_projector": "bfloat16",
+    "token_embeddings": "bfloat16",
+    "normalization_layers": "bfloat16",
+    "position_embeddings": "bfloat16"
+  },
+  "effective_bits_per_weight": 9.19,
+  "model_size_gb": 3.83,
+  "conversion_tool": "mlx-vlm quantizers",
+  "notes": [
+    "mlx-vlm quantizers only touch the language tower's linear weights",
+    "The vision encoder and embeddings remain bf16",
+    "On-disk size (~3.6 GB) averages both precision levels",
+    "Published config.json uses model_type 'unlimited-ocr' to select mlx-vlm's native R-SWA implementation"
+  ]
+}

quantization_summary.json

@@ -0,0 +1,257 @@
+{
+  "method": "mxfp8",
+  "group_size": 32,
+  "bits": 8,
+  "source_model": "baidu/Unlimited-OCR",
+  "precision_map_sha256": "2c0bfbd58fcbb22e17927f3c5e8214e4933a3675a6d1a87e8b3b87b4fbb37b33",
+  "quantized_module_count": 120,
+  "quantized_precision_counts": {
+    "affine8": 1,
+    "mxfp8": 119
+  },
+  "preserved_quantizable_module_count": 145,
+  "quantized_modules": [
+    "language_model.lm_head",
+    "language_model.model.embed_tokens",
+    "language_model.model.layers.0.mlp.down_proj",
+    "language_model.model.layers.0.mlp.gate_proj",
+    "language_model.model.layers.0.mlp.up_proj",
+    "language_model.model.layers.0.self_attn.k_proj",
+    "language_model.model.layers.0.self_attn.o_proj",
+    "language_model.model.layers.0.self_attn.q_proj",
+    "language_model.model.layers.0.self_attn.v_proj",
+    "language_model.model.layers.1.mlp.shared_experts.down_proj",
+    "language_model.model.layers.1.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.1.mlp.shared_experts.up_proj",
+    "language_model.model.layers.1.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.1.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.1.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.1.self_attn.k_proj",
+    "language_model.model.layers.1.self_attn.o_proj",
+    "language_model.model.layers.1.self_attn.q_proj",
+    "language_model.model.layers.1.self_attn.v_proj",
+    "language_model.model.layers.10.mlp.shared_experts.down_proj",
+    "language_model.model.layers.10.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.10.mlp.shared_experts.up_proj",
+    "language_model.model.layers.10.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.10.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.10.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.10.self_attn.k_proj",
+    "language_model.model.layers.10.self_attn.o_proj",
+    "language_model.model.layers.10.self_attn.q_proj",
+    "language_model.model.layers.10.self_attn.v_proj",
+    "language_model.model.layers.11.mlp.shared_experts.down_proj",
+    "language_model.model.layers.11.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.11.mlp.shared_experts.up_proj",
+    "language_model.model.layers.11.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.11.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.11.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.11.self_attn.k_proj",
+    "language_model.model.layers.11.self_attn.o_proj",
+    "language_model.model.layers.11.self_attn.q_proj",
+    "language_model.model.layers.11.self_attn.v_proj",
+    "language_model.model.layers.2.mlp.shared_experts.down_proj",
+    "language_model.model.layers.2.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.2.mlp.shared_experts.up_proj",
+    "language_model.model.layers.2.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.2.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.2.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.2.self_attn.k_proj",
+    "language_model.model.layers.2.self_attn.o_proj",
+    "language_model.model.layers.2.self_attn.q_proj",
+    "language_model.model.layers.2.self_attn.v_proj",
+    "language_model.model.layers.3.mlp.shared_experts.down_proj",
+    "language_model.model.layers.3.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.3.mlp.shared_experts.up_proj",
+    "language_model.model.layers.3.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.3.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.3.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.3.self_attn.k_proj",
+    "language_model.model.layers.3.self_attn.o_proj",
+    "language_model.model.layers.3.self_attn.q_proj",
+    "language_model.model.layers.3.self_attn.v_proj",
+    "language_model.model.layers.4.mlp.shared_experts.down_proj",
+    "language_model.model.layers.4.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.4.mlp.shared_experts.up_proj",
+    "language_model.model.layers.4.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.4.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.4.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.4.self_attn.k_proj",
+    "language_model.model.layers.4.self_attn.o_proj",
+    "language_model.model.layers.4.self_attn.q_proj",
+    "language_model.model.layers.4.self_attn.v_proj",
+    "language_model.model.layers.5.mlp.shared_experts.down_proj",
+    "language_model.model.layers.5.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.5.mlp.shared_experts.up_proj",
+    "language_model.model.layers.5.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.5.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.5.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.5.self_attn.k_proj",
+    "language_model.model.layers.5.self_attn.o_proj",
+    "language_model.model.layers.5.self_attn.q_proj",
+    "language_model.model.layers.5.self_attn.v_proj",
+    "language_model.model.layers.6.mlp.shared_experts.down_proj",
+    "language_model.model.layers.6.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.6.mlp.shared_experts.up_proj",
+    "language_model.model.layers.6.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.6.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.6.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.6.self_attn.k_proj",
+    "language_model.model.layers.6.self_attn.o_proj",
+    "language_model.model.layers.6.self_attn.q_proj",
+    "language_model.model.layers.6.self_attn.v_proj",
+    "language_model.model.layers.7.mlp.shared_experts.down_proj",
+    "language_model.model.layers.7.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.7.mlp.shared_experts.up_proj",
+    "language_model.model.layers.7.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.7.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.7.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.7.self_attn.k_proj",
+    "language_model.model.layers.7.self_attn.o_proj",
+    "language_model.model.layers.7.self_attn.q_proj",
+    "language_model.model.layers.7.self_attn.v_proj",
+    "language_model.model.layers.8.mlp.shared_experts.down_proj",
+    "language_model.model.layers.8.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.8.mlp.shared_experts.up_proj",
+    "language_model.model.layers.8.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.8.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.8.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.8.self_attn.k_proj",
+    "language_model.model.layers.8.self_attn.o_proj",
+    "language_model.model.layers.8.self_attn.q_proj",
+    "language_model.model.layers.8.self_attn.v_proj",
+    "language_model.model.layers.9.mlp.shared_experts.down_proj",
+    "language_model.model.layers.9.mlp.shared_experts.gate_proj",
+    "language_model.model.layers.9.mlp.shared_experts.up_proj",
+    "language_model.model.layers.9.mlp.switch_mlp.down_proj",
+    "language_model.model.layers.9.mlp.switch_mlp.gate_proj",
+    "language_model.model.layers.9.mlp.switch_mlp.up_proj",
+    "language_model.model.layers.9.self_attn.k_proj",
+    "language_model.model.layers.9.self_attn.o_proj",
+    "language_model.model.layers.9.self_attn.q_proj",
+    "language_model.model.layers.9.self_attn.v_proj",
+    "projector.layers"
+  ],
+  "quantized_module_precisions": {
+    "language_model.lm_head": "affine8",
+    "language_model.model.embed_tokens": "mxfp8",
+    "language_model.model.layers.0.mlp.down_proj": "mxfp8",
+    "language_model.model.layers.0.mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.0.mlp.up_proj": "mxfp8",
+    "language_model.model.layers.0.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.0.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.0.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.0.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.1.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.1.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.1.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.1.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.1.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.10.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.10.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.10.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.10.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.10.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.11.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.11.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.11.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.11.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.11.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.2.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.2.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.2.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.2.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.2.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.3.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.3.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.3.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.3.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.3.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.4.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.4.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.4.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.4.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.4.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.5.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.5.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.5.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.5.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.5.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.6.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.6.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.6.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.6.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.6.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.7.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.7.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.7.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.7.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.7.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.8.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.8.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.8.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.8.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.8.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.9.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.9.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.9.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.9.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.9.self_attn.v_proj": "mxfp8",
+    "projector.layers": "mxfp8"
+  }
+}

release/bf16_accuracy.json

@@ -0,0 +1,195 @@
+{
+  "model_path": "Unlimited-OCR",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 1024,
+  "profile": "accurate",
+  "generation_settings": {
+    "temperature": 0.0,
+    "top_p": 1.0,
+    "repetition_penalty": 1.0,
+    "no_repeat_ngram_size": 35,
+    "ngram_window": 128
+  },
+  "num_images": 12,
+  "num_samples": 12,
+  "total_time_seconds": 36.51101154302887,
+  "mean_cer": 0.2391877132924964,
+  "mean_wer": 0.5784543844272946,
+  "num_digit_samples": 12,
+  "num_cjk_samples": 3,
+  "mean_digit_cer": 0.08733996757027829,
+  "mean_cjk_cer": 0.3333333333333333,
+  "num_table_samples": 3,
+  "mean_table_score": 1.0,
+  "mean_repetition_rate": 0.0,
+  "per_file": [
+    {
+      "file": "0001.png",
+      "cer": 0.02315227070347284,
+      "wer": 0.19282511210762332,
+      "digit_cer": 0.03488372093023256,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.554586291997111,
+      "ref_length": 1345,
+      "hyp_length": 1348,
+      "ref_digit_count": 86,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0002.png",
+      "cer": 0.9133034379671151,
+      "wer": 0.46107784431137727,
+      "digit_cer": 0.12631578947368421,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 6.1484525830019265,
+      "ref_length": 835,
+      "hyp_length": 1378,
+      "ref_digit_count": 95,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0003.png",
+      "cer": 0.3923145665773012,
+      "wer": 0.3317757009345794,
+      "digit_cer": 0.18518518518518517,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.549903999999515,
+      "ref_length": 1332,
+      "hyp_length": 1719,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0004.png",
+      "cer": 0.37906137184115524,
+      "wer": 0.36486486486486486,
+      "digit_cer": 0.1016949152542373,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.64588491700124,
+      "ref_length": 1329,
+      "hyp_length": 1710,
+      "ref_digit_count": 59,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0005.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 3.0224843750038417,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0006.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 2.906020250011352,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0007.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 2.9044155000010505,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0008.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.5957032919977792,
+      "ref_length": 92,
+      "hyp_length": 92,
+      "ref_digit_count": 26,
+      "ref_cjk_count": 41
+    },
+    {
+      "file": "0009.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.5902405830129283,
+      "ref_length": 93,
+      "hyp_length": 93,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 42
+    },
+    {
+      "file": "0010.png",
+      "cer": 0.6309523809523809,
+      "wer": 1.0909090909090908,
+      "digit_cer": 0.0,
+      "cjk_cer": 1.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.6077932920015883,
+      "ref_length": 105,
+      "hyp_length": 117,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 44
+    },
+    {
+      "file": "0011.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.4870185839972692,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0012.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.4985078750032699,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    }
+  ]
+}

release/calibration_results.json

@@ -0,0 +1,92 @@
+{
+  "schema_version": 1,
+  "created_at": "2026-07-20T23:25:55.306169+00:00",
+  "target_pattern": "language_model.lm_head",
+  "selection_policy": "fastest candidate passing existing quality and throughput limits",
+  "thresholds": {
+    "max_cer_delta_vs_bf16": 0.01,
+    "max_cer_delta_vs_reference": 0.005,
+    "max_digit_cer_delta_vs_bf16": 0.01,
+    "max_table_score_degradation_vs_bf16": 0.01,
+    "min_tps_ratio_vs_reference": 0.9,
+    "max_weight_size_gb": 4.5
+  },
+  "experiments": [
+    {
+      "label": "bf16-head",
+      "precision": "bfloat16",
+      "passed": false,
+      "checks": {
+        "cer": true,
+        "digit_cer": true,
+        "table_score": true,
+        "throughput": false
+      },
+      "metrics": {
+        "mean_cer": 0.23190356458231498,
+        "mean_digit_cer": 0.08222376405546196,
+        "mean_table_score": 1.0,
+        "mean_tps": 271.0950821181683
+      },
+      "deltas": {
+        "cer_vs_bf16": -0.007284148710181432,
+        "digit_cer_vs_bf16": -0.005116203514816328,
+        "table_degradation_vs_bf16": 0.0,
+        "tps_ratio_vs_reference": 0.8668704848166195
+      }
+    },
+    {
+      "label": "mxfp8-head",
+      "precision": "mxfp8",
+      "passed": false,
+      "checks": {
+        "cer": false,
+        "digit_cer": true,
+        "table_score": true,
+        "throughput": true
+      },
+      "metrics": {
+        "mean_cer": 0.26017003915600867,
+        "mean_digit_cer": 0.0769606061607251,
+        "mean_table_score": 1.0,
+        "mean_tps": 307.3938836867251
+      },
+      "deltas": {
+        "cer_vs_bf16": 0.020982325863512258,
+        "digit_cer_vs_bf16": -0.010379361409553187,
+        "table_degradation_vs_bf16": 0.0,
+        "tps_ratio_vs_reference": 0.9829417889071937
+      }
+    },
+    {
+      "label": "affine8-head",
+      "precision": "affine8",
+      "passed": true,
+      "checks": {
+        "cer": true,
+        "digit_cer": true,
+        "table_score": true,
+        "throughput": true
+      },
+      "metrics": {
+        "mean_cer": 0.23738438172232493,
+        "mean_digit_cer": 0.08573253598528652,
+        "mean_table_score": 1.0,
+        "mean_tps": 301.24796539578256
+      },
+      "deltas": {
+        "cer_vs_bf16": -0.0018033315701714847,
+        "digit_cer_vs_bf16": -0.0016074315849917697,
+        "table_degradation_vs_bf16": 0.0,
+        "tps_ratio_vs_reference": 0.9632892185732532
+      }
+    }
+  ],
+  "selected": {
+    "label": "affine8-head",
+    "precision": "affine8"
+  },
+  "precision_overrides": {
+    "language_model.lm_head": "affine8"
+  }
+}

release/candidate_accuracy.json

@@ -0,0 +1,195 @@
+{
+  "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 1024,
+  "profile": "accurate",
+  "generation_settings": {
+    "temperature": 0.0,
+    "top_p": 1.0,
+    "repetition_penalty": 1.0,
+    "no_repeat_ngram_size": 35,
+    "ngram_window": 128
+  },
+  "num_images": 12,
+  "num_samples": 12,
+  "total_time_seconds": 31.473419997957535,
+  "mean_cer": 0.23738438172232493,
+  "mean_wer": 0.5707107552516416,
+  "num_digit_samples": 12,
+  "num_cjk_samples": 3,
+  "mean_digit_cer": 0.08573253598528652,
+  "mean_cjk_cer": 0.3333333333333333,
+  "num_table_samples": 3,
+  "mean_table_score": 1.0,
+  "mean_repetition_rate": 0.0,
+  "per_file": [
+    {
+      "file": "0001.png",
+      "cer": 0.020480854853072127,
+      "wer": 0.18385650224215247,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 3.815771791996667,
+      "ref_length": 1345,
+      "hyp_length": 1349,
+      "ref_digit_count": 86,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0002.png",
+      "cer": 0.9327354260089686,
+      "wer": 0.5089820359281437,
+      "digit_cer": 0.17894736842105263,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.953415083000436,
+      "ref_length": 835,
+      "hyp_length": 1310,
+      "ref_digit_count": 95,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0003.png",
+      "cer": 0.3512064343163539,
+      "wer": 0.3317757009345794,
+      "digit_cer": 0.14814814814814814,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 3.5391229999950156,
+      "ref_length": 1332,
+      "hyp_length": 1672,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0004.png",
+      "cer": 0.38176895306859204,
+      "wer": 0.36936936936936937,
+      "digit_cer": 0.1016949152542373,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 3.735332540993113,
+      "ref_length": 1329,
+      "hyp_length": 1705,
+      "ref_digit_count": 59,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0005.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 2.769828624994261,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0006.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 2.7706372079992434,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0007.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 2.726061583001865,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0008.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.4497268339910079,
+      "ref_length": 92,
+      "hyp_length": 92,
+      "ref_digit_count": 26,
+      "ref_cjk_count": 41
+    },
+    {
+      "file": "0009.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.4638195829902543,
+      "ref_length": 93,
+      "hyp_length": 93,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 42
+    },
+    {
+      "file": "0010.png",
+      "cer": 0.6309523809523809,
+      "wer": 0.9545454545454546,
+      "digit_cer": 0.0,
+      "cjk_cer": 1.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.4698359579924727,
+      "ref_length": 105,
+      "hyp_length": 110,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 44
+    },
+    {
+      "file": "0011.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.3830854999978328,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0012.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.3967822910053656,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    }
+  ]
+}

release/candidate_performance.json

@@ -0,0 +1,68 @@
+{
+  "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+  "image_path": "test_invoice.png",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 256,
+  "system": {
+    "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+    "processor": "arm",
+    "python_version": "3.14.6",
+    "machine": "arm64",
+    "mlx_version": "0.32.0",
+    "mlx_vlm_version": "0.6.6",
+    "chip": "Apple M3 Max",
+    "total_memory_gb": 128.0
+  },
+  "model_load_time_seconds": 0.8421083340072073,
+  "memory_after_load_mb": 4008.296875,
+  "num_warmup": 1,
+  "num_runs": 3,
+  "mean_tps": 297.2042493840031,
+  "std_tps": 3.7161843770763436,
+  "mean_elapsed_seconds": 1.2716583613364492,
+  "mean_peak_memory_mb": 5181.5234390000005,
+  "runs": [
+    {
+      "run": 1,
+      "elapsed_seconds": 1.283014083004673,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 293.6595631095472,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.347799,
+      "memory_delta_mb": 1337.1867550000002,
+      "process_peak_rss_mb": 4021.109375,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1793.8031467011067,
+      "finish_reason": "length"
+    },
+    {
+      "run": 2,
+      "elapsed_seconds": 1.276783292007167,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 295.6163188867776,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.611259,
+      "memory_delta_mb": 1337.188071,
+      "process_peak_rss_mb": 4021.640625,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1787.3186918039762,
+      "finish_reason": "length"
+    },
+    {
+      "run": 3,
+      "elapsed_seconds": 1.2551777089975076,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 302.3368661556844,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.611259,
+      "memory_delta_mb": 1337.188071,
+      "process_peak_rss_mb": 4021.90625,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1798.8601642526962,
+      "finish_reason": "length"
+    }
+  ]
+}

release/candidate_rswa.json

@@ -0,0 +1,75 @@
+{
+  "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+  "image_path": "test_invoice.png",
+  "prompt": "<image>document parsing.",
+  "force_min_tokens": 8192,
+  "forced_eos_token_ids": [
+    1
+  ],
+  "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+  "processor": "arm",
+  "baseline_memory_mb": 3844.161032,
+  "test_results": [
+    {
+      "max_tokens": 512,
+      "tokens_generated": 512,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_generated_reliable": true,
+      "elapsed_seconds": 2.4322984160098713,
+      "mean_tps": 264.34124967086365,
+      "tps_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.350593,
+      "memory_growth_mb": 1337.1895610000001,
+      "repetition_rate": 0.0,
+      "completed_naturally": false,
+      "finish_reason": "length",
+      "forced_minimum_tokens": 512,
+      "status": "success"
+    },
+    {
+      "max_tokens": 2048,
+      "tokens_generated": 2048,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_generated_reliable": true,
+      "elapsed_seconds": 8.234726583992597,
+      "mean_tps": 261.8525825264912,
+      "tps_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.612737,
+      "memory_growth_mb": 1337.1895490000002,
+      "repetition_rate": 0.09565217391304348,
+      "completed_naturally": false,
+      "finish_reason": "length",
+      "forced_minimum_tokens": 2048,
+      "status": "success"
+    },
+    {
+      "max_tokens": 8192,
+      "tokens_generated": 8192,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_generated_reliable": true,
+      "elapsed_seconds": 31.729143417003797,
+      "mean_tps": 261.56365755570715,
+      "tps_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5181.612737,
+      "memory_growth_mb": 1337.1895490000002,
+      "repetition_rate": 0.09565217391304348,
+      "completed_naturally": false,
+      "finish_reason": "length",
+      "forced_minimum_tokens": 8192,
+      "status": "success"
+    }
+  ],
+  "analysis": {
+    "cache_appears_bounded": true,
+    "cache_analysis_reason": "Peak memory stayed within 64 MB across a >=4x token span",
+    "tps_stable_over_length": true,
+    "max_successful_tokens": 8192,
+    "max_repetition_rate": 0.09565217391304348
+  },
+  "pass_conditions": {
+    "cache_bounded": true,
+    "tps_stable": true,
+    "8k_test_passed": true
+  },
+  "passed": true
+}

release/generated_precision_map.json

@@ -0,0 +1,110 @@
+{
+  "vision_model": "bfloat16",
+  "projector": "mxfp8",
+  "language_model.model.embed_tokens": "mxfp8",
+  "language_model.model.norm": "bfloat16",
+  "language_model.lm_head": "affine8",
+  "language_model.model.layers.*.input_layernorm": "bfloat16",
+  "language_model.model.layers.*.post_attention_layernorm": "bfloat16",
+  "language_model.model.layers.*.self_attn.q_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.k_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.v_proj": "mxfp8",
+  "language_model.model.layers.*.self_attn.o_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.shared_experts.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.gate_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.up_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.switch_mlp.down_proj": "mxfp8",
+  "language_model.model.layers.*.mlp.gate": "bfloat16",
+  "sam_model": "bfloat16",
+  "_generated_from": {
+    "source_model": "baidu/Unlimited-OCR",
+    "thresholds": {
+      "cer_delta": 0.02,
+      "digit_cer_delta": 0.02,
+      "table_score_degradation": 0.01
+    },
+    "decisions": {
+      "vision_encoder": {
+        "precision": "bfloat16",
+        "reasons": [
+          "cer_delta=2.423686",
+          "digit_cer_delta=1.358023",
+          "table_score_degradation=1.000000",
+          "protected OCR-critical group"
+        ]
+      },
+      "vision_projector": {
+        "precision": "mxfp8",
+        "reasons": [
+          "all measured quality deltas were non-degrading"
+        ]
+      },
+      "token_embeddings": {
+        "precision": "mxfp8",
+        "reasons": [
+          "all measured quality deltas were non-degrading"
+        ]
+      },
+      "attention_q_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_k_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_v_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "attention_o_proj": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "dense_mlp": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "shared_experts": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "routed_experts": {
+        "precision": "base-map",
+        "reasons": [
+          "within thresholds"
+        ]
+      },
+      "lm_head": {
+        "precision": "affine8",
+        "reasons": [
+          "selected by joint quality/throughput calibration: affine8-head"
+        ]
+      }
+    },
+    "calibration": {
+      "selected": {
+        "label": "affine8-head",
+        "precision": "affine8"
+      },
+      "selection_policy": "fastest candidate passing existing quality and throughput limits"
+    }
+  }
+}

release/provenance.json

@@ -0,0 +1,174 @@
+{
+  "created_at": "2026-07-20T23:05:17.950531+00:00",
+  "python": "3.14.6",
+  "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+  "machine": "arm64",
+  "processor": "arm",
+  "versions": {
+    "mlx": "0.32.0",
+    "mlx-vlm": "0.6.6",
+    "huggingface-hub": "1.24.0",
+    "numpy": "2.5.1",
+    "Pillow": "12.3.0"
+  },
+  "source_model": "baidu/Unlimited-OCR",
+  "source_local_name": "Unlimited-OCR",
+  "source_config": {
+    "path": "config.json",
+    "sha256": "27246d03fd670904ec9601b1cb0861fbb79ec076830771daa8d943d6229946f9"
+  },
+  "reference_model": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+  "target_repo": "AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+  "dataset": {
+    "name": "eval_dataset",
+    "num_samples": 12,
+    "num_digit_samples": 12,
+    "num_cjk_samples": 3,
+    "num_table_samples": 3,
+    "category_counts": {
+      "cjk_document": 3,
+      "english_document": 4,
+      "low_quality_scan": 2,
+      "table_numeric": 3
+    },
+    "manifest_sha256": "94d96ec344b02b8c4b413eafe524d6844bddcb00705af4b3fccea4c297c22509",
+    "content_sha256": "78ca3e7c9c7584aea30b04176716a6dadf49ccf0f2bead959cbaeb9aeac68f30",
+    "files": [
+      {
+        "path": "images/0001.png",
+        "size": 243645,
+        "sha256": "8fad74c7e8f314075f34d5b3b3e6272a2c22a90e960dcf8074039b1f065895b4"
+      },
+      {
+        "path": "ground_truth/0001.txt",
+        "size": 1346,
+        "sha256": "a6f35a418836e8ba0667dc42d663219b07b65cbbf7a4627b2319f0fa44d11f8e"
+      },
+      {
+        "path": "images/0002.png",
+        "size": 208699,
+        "sha256": "31f2d9c651112e963366e5e39f3da4ff8198ec41e2187c3c8fb5fec0edd2f64c"
+      },
+      {
+        "path": "ground_truth/0002.txt",
+        "size": 838,
+        "sha256": "a05196b747f6898102fc56e23cae31c32754b985bc3eab0abe60d955bfadff68"
+      },
+      {
+        "path": "images/0003.png",
+        "size": 181040,
+        "sha256": "40330138b25a7ce9bf142a672ad0a6253517bf076af66591c4431490eff1ecfc"
+      },
+      {
+        "path": "ground_truth/0003.txt",
+        "size": 1333,
+        "sha256": "517ab5af1c090227d4dc2473ac422ecd9301e2e21ba0cc1c54d08476b1903d7e"
+      },
+      {
+        "path": "images/0004.png",
+        "size": 220208,
+        "sha256": "4316ba5ebe86c62331361e6d23329adede5e9eecf50a70db16b5439d95f5e23e"
+      },
+      {
+        "path": "ground_truth/0004.txt",
+        "size": 1330,
+        "sha256": "df3b4afaee0f3ffe0984c2f1d1201c1762bc70f4ffbc1bfe9b1242e17d794148"
+      },
+      {
+        "path": "images/0005.png",
+        "size": 38984,
+        "sha256": "1532b86fe28d7331379c73b62cfb0b0ae1448824566684021df262e4741b06a4"
+      },
+      {
+        "path": "ground_truth/0005.txt",
+        "size": 449,
+        "sha256": "fb8ebea089dacff057d98feb6450436f3f6db65f0bac29513d3417e94451686e"
+      },
+      {
+        "path": "images/0006.png",
+        "size": 38512,
+        "sha256": "8c1bf51f86f0f22c8898cec8c77049b6f023b77aab77f55be40f75b477ab6383"
+      },
+      {
+        "path": "ground_truth/0006.txt",
+        "size": 449,
+        "sha256": "f60ff098ac431b1021fb85f810dd6264c1c021fab0810ab97ce304c5eb802598"
+      },
+      {
+        "path": "images/0007.png",
+        "size": 38911,
+        "sha256": "a87e7f53196e9d3f72af611394297ec64e9eb222d2872b62f0c5a2014d83ecfc"
+      },
+      {
+        "path": "ground_truth/0007.txt",
+        "size": 449,
+        "sha256": "0381ec16f8895290dfc2b81f97933f5568a68bfe731cc4791272ff8269e57c0e"
+      },
+      {
+        "path": "images/0008.png",
+        "size": 45665,
+        "sha256": "d9ff0cc9ffa639e485b0d445e1f4856f479ed9e2e485b1ca1ece9a9a043bc6c8"
+      },
+      {
+        "path": "ground_truth/0008.txt",
+        "size": 185,
+        "sha256": "2dbeb40c0172dc618c7298a87e131153f51682dcaa33efefa67b7e50ecd7a8d1"
+      },
+      {
+        "path": "images/0009.png",
+        "size": 40784,
+        "sha256": "f93ea216d77bfdb23f6c8c113e33c946318d6eac6ef3bdaf2e2f2c0d86c154c9"
+      },
+      {
+        "path": "ground_truth/0009.txt",
+        "size": 188,
+        "sha256": "957232168770c2a15efeb33126a7d2d8141ce34782106b979e4b31acfa4f9bee"
+      },
+      {
+        "path": "images/0010.png",
+        "size": 20512,
+        "sha256": "5ff52fd340da20784c4c934cbac3ae9a0788b7d1654d71934100624842ddf764"
+      },
+      {
+        "path": "ground_truth/0010.txt",
+        "size": 194,
+        "sha256": "2f9054687e5eb369e35d985bc2fe9d2d37ffeb8cafe204c3e81830f4431f5793"
+      },
+      {
+        "path": "images/0011.png",
+        "size": 486656,
+        "sha256": "74e878d54295c224481f0f1b51a670459b855b16492c246c27636d71f4666e68"
+      },
+      {
+        "path": "ground_truth/0011.txt",
+        "size": 119,
+        "sha256": "8f8bc16447a12c17e4036c4c5fd936faef227310a564de983ebe2f4f22742d83"
+      },
+      {
+        "path": "images/0012.png",
+        "size": 515472,
+        "sha256": "9a6e49af19e893000b8e96bece22fe99fedd3741e7ac3dede04a112ea77b5b5c"
+      },
+      {
+        "path": "ground_truth/0012.txt",
+        "size": 119,
+        "sha256": "1ccf00fe53da00ba3a2340dbe95e1692e87efccdc04b191c0f1d52dab23169a7"
+      }
+    ]
+  },
+  "smoke_image": {
+    "name": "test_invoice.png",
+    "sha256": "6f2c3a686d13604b6721b1e9596408ec3b3eb38227b6d5f2d930a0ce05c8cb14"
+  },
+  "parameters": {
+    "accuracy_tokens": 1024,
+    "performance_tokens": 256,
+    "performance_warmup": 1,
+    "performance_runs": 3,
+    "rswa_lengths": [
+      512,
+      2048,
+      8192
+    ]
+  }
+}

release/reference_accuracy.json

@@ -0,0 +1,195 @@
+{
+  "model_path": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 1024,
+  "profile": "accurate",
+  "generation_settings": {
+    "temperature": 0.0,
+    "top_p": 1.0,
+    "repetition_penalty": 1.0,
+    "no_repeat_ngram_size": 35,
+    "ngram_window": 128
+  },
+  "num_images": 12,
+  "num_samples": 12,
+  "total_time_seconds": 26.09562641500088,
+  "mean_cer": 1.057248773567081,
+  "mean_wer": 0.9346679608165291,
+  "num_digit_samples": 12,
+  "num_cjk_samples": 3,
+  "mean_digit_cer": 0.20915311607827292,
+  "mean_cjk_cer": 1.0,
+  "num_table_samples": 3,
+  "mean_table_score": 1.0,
+  "mean_repetition_rate": 0.00026371308016877635,
+  "per_file": [
+    {
+      "file": "0001.png",
+      "cer": 0.06144256455921639,
+      "wer": 0.20179372197309417,
+      "digit_cer": 0.3023255813953488,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 3.459972665994428,
+      "ref_length": 1345,
+      "hyp_length": 1382,
+      "ref_digit_count": 86,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0002.png",
+      "cer": 0.47234678624813153,
+      "wer": 0.5988023952095808,
+      "digit_cer": 0.5578947368421052,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.406020459005958,
+      "ref_length": 835,
+      "hyp_length": 771,
+      "ref_digit_count": 95,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0003.png",
+      "cer": 1.1751563896336015,
+      "wer": 1.439252336448598,
+      "digit_cer": 0.48148148148148145,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0031645569620253164,
+      "table_score": null,
+      "elapsed_seconds": 4.409982333003427,
+      "ref_length": 1332,
+      "hyp_length": 2457,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0004.png",
+      "cer": 0.7319494584837545,
+      "wer": 0.6216216216216216,
+      "digit_cer": 0.288135593220339,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 4.450652749990695,
+      "ref_length": 1329,
+      "hyp_length": 1794,
+      "ref_digit_count": 59,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0005.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 1.2356766660086578,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0006.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 1.2516661249974277,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0007.png",
+      "cer": 0.17715617715617715,
+      "wer": 1.5,
+      "digit_cer": 0.2,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": 1.0,
+      "elapsed_seconds": 1.274972874991363,
+      "ref_length": 436,
+      "hyp_length": 508,
+      "ref_digit_count": 70,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0008.png",
+      "cer": 1.6867469879518073,
+      "wer": 0.9,
+      "digit_cer": 0.0,
+      "cjk_cer": 1.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.1017809159966419,
+      "ref_length": 92,
+      "hyp_length": 187,
+      "ref_digit_count": 26,
+      "ref_cjk_count": 41
+    },
+    {
+      "file": "0009.png",
+      "cer": 5.670731707317073,
+      "wer": 1.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 1.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.35718295800325,
+      "ref_length": 93,
+      "hyp_length": 509,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 42
+    },
+    {
+      "file": "0010.png",
+      "cer": 2.357142857142857,
+      "wer": 1.9545454545454546,
+      "digit_cer": 0.28,
+      "cjk_cer": 1.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.1220285840099677,
+      "ref_length": 105,
+      "hyp_length": 269,
+      "ref_digit_count": 25,
+      "ref_cjk_count": 44
+    },
+    {
+      "file": "0011.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.0181266669969773,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    },
+    {
+      "file": "0012.png",
+      "cer": 0.0,
+      "wer": 0.0,
+      "digit_cer": 0.0,
+      "cjk_cer": 0.0,
+      "repetition_rate": 0.0,
+      "table_score": null,
+      "elapsed_seconds": 1.0075634160020854,
+      "ref_length": 118,
+      "hyp_length": 118,
+      "ref_digit_count": 27,
+      "ref_cjk_count": 0
+    }
+  ]
+}

release/reference_performance.json

@@ -0,0 +1,68 @@
+{
+  "model_path": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+  "image_path": "test_invoice.png",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 256,
+  "system": {
+    "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+    "processor": "arm",
+    "python_version": "3.14.6",
+    "machine": "arm64",
+    "mlx_version": "0.32.0",
+    "mlx_vlm_version": "0.6.6",
+    "chip": "Apple M3 Max",
+    "total_memory_gb": 128.0
+  },
+  "model_load_time_seconds": 5.561058167004376,
+  "memory_after_load_mb": 3994.34375,
+  "num_warmup": 1,
+  "num_runs": 3,
+  "mean_tps": 312.7284719764298,
+  "std_tps": 0.9770038029028864,
+  "mean_elapsed_seconds": 1.2253679166703175,
+  "mean_peak_memory_mb": 5165.991419999999,
+  "runs": [
+    {
+      "run": 1,
+      "elapsed_seconds": 1.226103625012911,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 311.86183520486986,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5165.81578,
+      "memory_delta_mb": 1337.186768,
+      "process_peak_rss_mb": 4015.96875,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1816.7391562081139,
+      "finish_reason": "length"
+    },
+    {
+      "run": 2,
+      "elapsed_seconds": 1.2276696659973823,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 312.2298514286067,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5166.07924,
+      "memory_delta_mb": 1337.188084,
+      "process_peak_rss_mb": 4022.953125,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1801.9665867511062,
+      "finish_reason": "length"
+    },
+    {
+      "run": 3,
+      "elapsed_seconds": 1.2223304590006592,
+      "tokens_generated": 256,
+      "tokens_generated_source": "mlx-vlm token count",
+      "tokens_per_second": 314.0937292958128,
+      "tokens_per_second_source": "mlx-vlm generation_tps",
+      "peak_memory_mb": 5166.07924,
+      "memory_delta_mb": 1337.188084,
+      "process_peak_rss_mb": 4023.265625,
+      "prompt_tokens": 697,
+      "prompt_tokens_per_second": 1800.5791804452258,
+      "finish_reason": "length"
+    }
+  ]
+}

release/release_manifest.json

@@ -0,0 +1,1191 @@
+{
+  "schema_version": 1,
+  "created_at": "2026-07-20T23:31:41.909496+00:00",
+  "release_approved": true,
+  "repo_id": "AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+  "source": {
+    "id": "baidu/Unlimited-OCR",
+    "weights": {
+      "files": [
+        {
+          "name": "model-00001-of-000001.safetensors",
+          "size": 6672547120,
+          "sha256": "2bc48a7a110061ea58fff65d3169367eebe3aee371ca6968dc2219c1b2855fc6"
+        }
+      ],
+      "total_size_bytes": 6672547120,
+      "total_size_gb": 6.214293763041496,
+      "aggregate_sha256": "ede2e0c0a6261543dd0e2eb249c337a3409b2b69b8f9ed73fa604ac409bdf8f2"
+    }
+  },
+  "reference": {
+    "id": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+    "weights": {
+      "files": [
+        {
+          "name": "model.safetensors",
+          "size": 3827646853,
+          "sha256": "eef3e920d4ef9429ef6353b4b98c34ed8935f678f91ff3bcf7de8ed73a7530db"
+        }
+      ],
+      "total_size_bytes": 3827646853,
+      "total_size_gb": 3.564773921854794,
+      "aggregate_sha256": "439c6acfe5e277537dfe3368b94a145a6b0da4c39e4bd00582977d030f292ad1"
+    }
+  },
+  "candidate": {
+    "name": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+    "weights": {
+      "files": [
+        {
+          "name": "model.safetensors",
+          "size": 3843160559,
+          "sha256": "27568517565832e42daa563f6939e66a8ebb50cce0b01a24ecebb3ea6b4d0b10"
+        }
+      ],
+      "total_size_bytes": 3843160559,
+      "total_size_gb": 3.5792221864685416,
+      "aggregate_sha256": "a4f6e9934f90564906f42929542ad68493f0c6187ad431128e447debbf52b6f4"
+    },
+    "metadata": {
+      "passed": true,
+      "checks": {
+        "architecture": true,
+        "model_type": true,
+        "mxfp8": true,
+        "sliding_window": true,
+        "processor_class": true,
+        "sft_format": true
+      },
+      "sliding_window": 128
+    }
+  },
+  "dataset": {
+    "name": "eval_dataset",
+    "num_samples": 12,
+    "num_digit_samples": 12,
+    "num_cjk_samples": 3,
+    "num_table_samples": 3,
+    "category_counts": {
+      "cjk_document": 3,
+      "english_document": 4,
+      "low_quality_scan": 2,
+      "table_numeric": 3
+    },
+    "manifest_sha256": "94d96ec344b02b8c4b413eafe524d6844bddcb00705af4b3fccea4c297c22509",
+    "content_sha256": "78ca3e7c9c7584aea30b04176716a6dadf49ccf0f2bead959cbaeb9aeac68f30",
+    "files": [
+      {
+        "path": "images/0001.png",
+        "size": 243645,
+        "sha256": "8fad74c7e8f314075f34d5b3b3e6272a2c22a90e960dcf8074039b1f065895b4"
+      },
+      {
+        "path": "ground_truth/0001.txt",
+        "size": 1346,
+        "sha256": "a6f35a418836e8ba0667dc42d663219b07b65cbbf7a4627b2319f0fa44d11f8e"
+      },
+      {
+        "path": "images/0002.png",
+        "size": 208699,
+        "sha256": "31f2d9c651112e963366e5e39f3da4ff8198ec41e2187c3c8fb5fec0edd2f64c"
+      },
+      {
+        "path": "ground_truth/0002.txt",
+        "size": 838,
+        "sha256": "a05196b747f6898102fc56e23cae31c32754b985bc3eab0abe60d955bfadff68"
+      },
+      {
+        "path": "images/0003.png",
+        "size": 181040,
+        "sha256": "40330138b25a7ce9bf142a672ad0a6253517bf076af66591c4431490eff1ecfc"
+      },
+      {
+        "path": "ground_truth/0003.txt",
+        "size": 1333,
+        "sha256": "517ab5af1c090227d4dc2473ac422ecd9301e2e21ba0cc1c54d08476b1903d7e"
+      },
+      {
+        "path": "images/0004.png",
+        "size": 220208,
+        "sha256": "4316ba5ebe86c62331361e6d23329adede5e9eecf50a70db16b5439d95f5e23e"
+      },
+      {
+        "path": "ground_truth/0004.txt",
+        "size": 1330,
+        "sha256": "df3b4afaee0f3ffe0984c2f1d1201c1762bc70f4ffbc1bfe9b1242e17d794148"
+      },
+      {
+        "path": "images/0005.png",
+        "size": 38984,
+        "sha256": "1532b86fe28d7331379c73b62cfb0b0ae1448824566684021df262e4741b06a4"
+      },
+      {
+        "path": "ground_truth/0005.txt",
+        "size": 449,
+        "sha256": "fb8ebea089dacff057d98feb6450436f3f6db65f0bac29513d3417e94451686e"
+      },
+      {
+        "path": "images/0006.png",
+        "size": 38512,
+        "sha256": "8c1bf51f86f0f22c8898cec8c77049b6f023b77aab77f55be40f75b477ab6383"
+      },
+      {
+        "path": "ground_truth/0006.txt",
+        "size": 449,
+        "sha256": "f60ff098ac431b1021fb85f810dd6264c1c021fab0810ab97ce304c5eb802598"
+      },
+      {
+        "path": "images/0007.png",
+        "size": 38911,
+        "sha256": "a87e7f53196e9d3f72af611394297ec64e9eb222d2872b62f0c5a2014d83ecfc"
+      },
+      {
+        "path": "ground_truth/0007.txt",
+        "size": 449,
+        "sha256": "0381ec16f8895290dfc2b81f97933f5568a68bfe731cc4791272ff8269e57c0e"
+      },
+      {
+        "path": "images/0008.png",
+        "size": 45665,
+        "sha256": "d9ff0cc9ffa639e485b0d445e1f4856f479ed9e2e485b1ca1ece9a9a043bc6c8"
+      },
+      {
+        "path": "ground_truth/0008.txt",
+        "size": 185,
+        "sha256": "2dbeb40c0172dc618c7298a87e131153f51682dcaa33efefa67b7e50ecd7a8d1"
+      },
+      {
+        "path": "images/0009.png",
+        "size": 40784,
+        "sha256": "f93ea216d77bfdb23f6c8c113e33c946318d6eac6ef3bdaf2e2f2c0d86c154c9"
+      },
+      {
+        "path": "ground_truth/0009.txt",
+        "size": 188,
+        "sha256": "957232168770c2a15efeb33126a7d2d8141ce34782106b979e4b31acfa4f9bee"
+      },
+      {
+        "path": "images/0010.png",
+        "size": 20512,
+        "sha256": "5ff52fd340da20784c4c934cbac3ae9a0788b7d1654d71934100624842ddf764"
+      },
+      {
+        "path": "ground_truth/0010.txt",
+        "size": 194,
+        "sha256": "2f9054687e5eb369e35d985bc2fe9d2d37ffeb8cafe204c3e81830f4431f5793"
+      },
+      {
+        "path": "images/0011.png",
+        "size": 486656,
+        "sha256": "74e878d54295c224481f0f1b51a670459b855b16492c246c27636d71f4666e68"
+      },
+      {
+        "path": "ground_truth/0011.txt",
+        "size": 119,
+        "sha256": "8f8bc16447a12c17e4036c4c5fd936faef227310a564de983ebe2f4f22742d83"
+      },
+      {
+        "path": "images/0012.png",
+        "size": 515472,
+        "sha256": "9a6e49af19e893000b8e96bece22fe99fedd3741e7ac3dede04a112ea77b5b5c"
+      },
+      {
+        "path": "ground_truth/0012.txt",
+        "size": 119,
+        "sha256": "1ccf00fe53da00ba3a2340dbe95e1692e87efccdc04b191c0f1d52dab23169a7"
+      }
+    ]
+  },
+  "thresholds": {
+    "max_cer_delta_vs_bf16": 0.01,
+    "max_cer_delta_vs_reference": 0.005,
+    "max_digit_cer_delta_vs_bf16": 0.01,
+    "max_table_score_degradation_vs_bf16": 0.01,
+    "min_tps_ratio_vs_reference": 0.9,
+    "max_weight_size_gb": 4.5
+  },
+  "metrics": {
+    "bf16_accuracy": {
+      "model_path": "Unlimited-OCR",
+      "num_samples": 12,
+      "mean_cer": 0.2391877132924964,
+      "mean_digit_cer": 0.08733996757027829,
+      "mean_cjk_cer": 0.3333333333333333,
+      "mean_table_score": 1.0,
+      "max_tokens": 1024,
+      "profile": "accurate"
+    },
+    "reference_accuracy": {
+      "model_path": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+      "num_samples": 12,
+      "mean_cer": 1.057248773567081,
+      "mean_digit_cer": 0.20915311607827292,
+      "mean_cjk_cer": 1.0,
+      "mean_table_score": 1.0,
+      "max_tokens": 1024,
+      "profile": "accurate"
+    },
+    "candidate_accuracy": {
+      "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+      "num_samples": 12,
+      "mean_cer": 0.23738438172232493,
+      "mean_digit_cer": 0.08573253598528652,
+      "mean_cjk_cer": 0.3333333333333333,
+      "mean_table_score": 1.0,
+      "max_tokens": 1024,
+      "profile": "accurate"
+    },
+    "reference_performance": {
+      "model_path": "sahilchachra/unlimited-ocr-mxfp8-mlx",
+      "mean_tps": 312.7284719764298,
+      "mean_peak_memory_mb": 5165.991419999999,
+      "max_tokens": 256
+    },
+    "candidate_performance": {
+      "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+      "mean_tps": 297.2042493840031,
+      "mean_peak_memory_mb": 5181.5234390000005,
+      "max_tokens": 256
+    }
+  },
+  "rswa": {
+    "model_path": "AX-Unlimited-OCR-3B-MoE-MLX-MXFP8",
+    "image_path": "test_invoice.png",
+    "prompt": "<image>document parsing.",
+    "force_min_tokens": 8192,
+    "forced_eos_token_ids": [
+      1
+    ],
+    "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+    "processor": "arm",
+    "baseline_memory_mb": 3844.161032,
+    "test_results": [
+      {
+        "max_tokens": 512,
+        "tokens_generated": 512,
+        "tokens_generated_source": "mlx-vlm token count",
+        "tokens_generated_reliable": true,
+        "elapsed_seconds": 2.4322984160098713,
+        "mean_tps": 264.34124967086365,
+        "tps_source": "mlx-vlm generation_tps",
+        "peak_memory_mb": 5181.350593,
+        "memory_growth_mb": 1337.1895610000001,
+        "repetition_rate": 0.0,
+        "completed_naturally": false,
+        "finish_reason": "length",
+        "forced_minimum_tokens": 512,
+        "status": "success"
+      },
+      {
+        "max_tokens": 2048,
+        "tokens_generated": 2048,
+        "tokens_generated_source": "mlx-vlm token count",
+        "tokens_generated_reliable": true,
+        "elapsed_seconds": 8.234726583992597,
+        "mean_tps": 261.8525825264912,
+        "tps_source": "mlx-vlm generation_tps",
+        "peak_memory_mb": 5181.612737,
+        "memory_growth_mb": 1337.1895490000002,
+        "repetition_rate": 0.09565217391304348,
+        "completed_naturally": false,
+        "finish_reason": "length",
+        "forced_minimum_tokens": 2048,
+        "status": "success"
+      },
+      {
+        "max_tokens": 8192,
+        "tokens_generated": 8192,
+        "tokens_generated_source": "mlx-vlm token count",
+        "tokens_generated_reliable": true,
+        "elapsed_seconds": 31.729143417003797,
+        "mean_tps": 261.56365755570715,
+        "tps_source": "mlx-vlm generation_tps",
+        "peak_memory_mb": 5181.612737,
+        "memory_growth_mb": 1337.1895490000002,
+        "repetition_rate": 0.09565217391304348,
+        "completed_naturally": false,
+        "finish_reason": "length",
+        "forced_minimum_tokens": 8192,
+        "status": "success"
+      }
+    ],
+    "analysis": {
+      "cache_appears_bounded": true,
+      "cache_analysis_reason": "Peak memory stayed within 64 MB across a >=4x token span",
+      "tps_stable_over_length": true,
+      "max_successful_tokens": 8192,
+      "max_repetition_rate": 0.09565217391304348
+    },
+    "pass_conditions": {
+      "cache_bounded": true,
+      "tps_stable": true,
+      "8k_test_passed": true
+    },
+    "passed": true
+  },
+  "sensitivity": {
+    "baseline": {
+      "num_samples": 12,
+      "num_digit_samples": 12,
+      "num_table_samples": 3,
+      "mean_cer": 0.2391877132924964,
+      "mean_digit_cer": 0.08733996757027829,
+      "mean_table_score": 1.0,
+      "total_inference_time": 37.96379516503657,
+      "avg_time_per_image": 3.163649597086381
+    },
+    "groups": {
+      "vision_encoder": {
+        "status": "success",
+        "matched_module_count": 145,
+        "matched_modules": [
+          "sam_model.blocks.0.attn.proj",
+          "sam_model.blocks.0.attn.qkv",
+          "sam_model.blocks.0.mlp.lin1",
+          "sam_model.blocks.0.mlp.lin2",
+          "sam_model.blocks.1.attn.proj",
+          "sam_model.blocks.1.attn.qkv",
+          "sam_model.blocks.1.mlp.lin1",
+          "sam_model.blocks.1.mlp.lin2",
+          "sam_model.blocks.10.attn.proj",
+          "sam_model.blocks.10.attn.qkv",
+          "sam_model.blocks.10.mlp.lin1",
+          "sam_model.blocks.10.mlp.lin2",
+          "sam_model.blocks.11.attn.proj",
+          "sam_model.blocks.11.attn.qkv",
+          "sam_model.blocks.11.mlp.lin1",
+          "sam_model.blocks.11.mlp.lin2",
+          "sam_model.blocks.2.attn.proj",
+          "sam_model.blocks.2.attn.qkv",
+          "sam_model.blocks.2.mlp.lin1",
+          "sam_model.blocks.2.mlp.lin2",
+          "sam_model.blocks.3.attn.proj",
+          "sam_model.blocks.3.attn.qkv",
+          "sam_model.blocks.3.mlp.lin1",
+          "sam_model.blocks.3.mlp.lin2",
+          "sam_model.blocks.4.attn.proj",
+          "sam_model.blocks.4.attn.qkv",
+          "sam_model.blocks.4.mlp.lin1",
+          "sam_model.blocks.4.mlp.lin2",
+          "sam_model.blocks.5.attn.proj",
+          "sam_model.blocks.5.attn.qkv",
+          "sam_model.blocks.5.mlp.lin1",
+          "sam_model.blocks.5.mlp.lin2",
+          "sam_model.blocks.6.attn.proj",
+          "sam_model.blocks.6.attn.qkv",
+          "sam_model.blocks.6.mlp.lin1",
+          "sam_model.blocks.6.mlp.lin2",
+          "sam_model.blocks.7.attn.proj",
+          "sam_model.blocks.7.attn.qkv",
+          "sam_model.blocks.7.mlp.lin1",
+          "sam_model.blocks.7.mlp.lin2",
+          "sam_model.blocks.8.attn.proj",
+          "sam_model.blocks.8.attn.qkv",
+          "sam_model.blocks.8.mlp.lin1",
+          "sam_model.blocks.8.mlp.lin2",
+          "sam_model.blocks.9.attn.proj",
+          "sam_model.blocks.9.attn.qkv",
+          "sam_model.blocks.9.mlp.lin1",
+          "sam_model.blocks.9.mlp.lin2",
+          "vision_model.embeddings.position_embedding",
+          "vision_model.transformer.layers.0.mlp.fc1",
+          "vision_model.transformer.layers.0.mlp.fc2",
+          "vision_model.transformer.layers.0.self_attn.out_proj",
+          "vision_model.transformer.layers.0.self_attn.qkv_proj",
+          "vision_model.transformer.layers.1.mlp.fc1",
+          "vision_model.transformer.layers.1.mlp.fc2",
+          "vision_model.transformer.layers.1.self_attn.out_proj",
+          "vision_model.transformer.layers.1.self_attn.qkv_proj",
+          "vision_model.transformer.layers.10.mlp.fc1",
+          "vision_model.transformer.layers.10.mlp.fc2",
+          "vision_model.transformer.layers.10.self_attn.out_proj",
+          "vision_model.transformer.layers.10.self_attn.qkv_proj",
+          "vision_model.transformer.layers.11.mlp.fc1",
+          "vision_model.transformer.layers.11.mlp.fc2",
+          "vision_model.transformer.layers.11.self_attn.out_proj",
+          "vision_model.transformer.layers.11.self_attn.qkv_proj",
+          "vision_model.transformer.layers.12.mlp.fc1",
+          "vision_model.transformer.layers.12.mlp.fc2",
+          "vision_model.transformer.layers.12.self_attn.out_proj",
+          "vision_model.transformer.layers.12.self_attn.qkv_proj",
+          "vision_model.transformer.layers.13.mlp.fc1",
+          "vision_model.transformer.layers.13.mlp.fc2",
+          "vision_model.transformer.layers.13.self_attn.out_proj",
+          "vision_model.transformer.layers.13.self_attn.qkv_proj",
+          "vision_model.transformer.layers.14.mlp.fc1",
+          "vision_model.transformer.layers.14.mlp.fc2",
+          "vision_model.transformer.layers.14.self_attn.out_proj",
+          "vision_model.transformer.layers.14.self_attn.qkv_proj",
+          "vision_model.transformer.layers.15.mlp.fc1",
+          "vision_model.transformer.layers.15.mlp.fc2",
+          "vision_model.transformer.layers.15.self_attn.out_proj",
+          "vision_model.transformer.layers.15.self_attn.qkv_proj",
+          "vision_model.transformer.layers.16.mlp.fc1",
+          "vision_model.transformer.layers.16.mlp.fc2",
+          "vision_model.transformer.layers.16.self_attn.out_proj",
+          "vision_model.transformer.layers.16.self_attn.qkv_proj",
+          "vision_model.transformer.layers.17.mlp.fc1",
+          "vision_model.transformer.layers.17.mlp.fc2",
+          "vision_model.transformer.layers.17.self_attn.out_proj",
+          "vision_model.transformer.layers.17.self_attn.qkv_proj",
+          "vision_model.transformer.layers.18.mlp.fc1",
+          "vision_model.transformer.layers.18.mlp.fc2",
+          "vision_model.transformer.layers.18.self_attn.out_proj",
+          "vision_model.transformer.layers.18.self_attn.qkv_proj",
+          "vision_model.transformer.layers.19.mlp.fc1",
+          "vision_model.transformer.layers.19.mlp.fc2",
+          "vision_model.transformer.layers.19.self_attn.out_proj",
+          "vision_model.transformer.layers.19.self_attn.qkv_proj",
+          "vision_model.transformer.layers.2.mlp.fc1",
+          "vision_model.transformer.layers.2.mlp.fc2",
+          "vision_model.transformer.layers.2.self_attn.out_proj",
+          "vision_model.transformer.layers.2.self_attn.qkv_proj",
+          "vision_model.transformer.layers.20.mlp.fc1",
+          "vision_model.transformer.layers.20.mlp.fc2",
+          "vision_model.transformer.layers.20.self_attn.out_proj",
+          "vision_model.transformer.layers.20.self_attn.qkv_proj",
+          "vision_model.transformer.layers.21.mlp.fc1",
+          "vision_model.transformer.layers.21.mlp.fc2",
+          "vision_model.transformer.layers.21.self_attn.out_proj",
+          "vision_model.transformer.layers.21.self_attn.qkv_proj",
+          "vision_model.transformer.layers.22.mlp.fc1",
+          "vision_model.transformer.layers.22.mlp.fc2",
+          "vision_model.transformer.layers.22.self_attn.out_proj",
+          "vision_model.transformer.layers.22.self_attn.qkv_proj",
+          "vision_model.transformer.layers.23.mlp.fc1",
+          "vision_model.transformer.layers.23.mlp.fc2",
+          "vision_model.transformer.layers.23.self_attn.out_proj",
+          "vision_model.transformer.layers.23.self_attn.qkv_proj",
+          "vision_model.transformer.layers.3.mlp.fc1",
+          "vision_model.transformer.layers.3.mlp.fc2",
+          "vision_model.transformer.layers.3.self_attn.out_proj",
+          "vision_model.transformer.layers.3.self_attn.qkv_proj",
+          "vision_model.transformer.layers.4.mlp.fc1",
+          "vision_model.transformer.layers.4.mlp.fc2",
+          "vision_model.transformer.layers.4.self_attn.out_proj",
+          "vision_model.transformer.layers.4.self_attn.qkv_proj",
+          "vision_model.transformer.layers.5.mlp.fc1",
+          "vision_model.transformer.layers.5.mlp.fc2",
+          "vision_model.transformer.layers.5.self_attn.out_proj",
+          "vision_model.transformer.layers.5.self_attn.qkv_proj",
+          "vision_model.transformer.layers.6.mlp.fc1",
+          "vision_model.transformer.layers.6.mlp.fc2",
+          "vision_model.transformer.layers.6.self_attn.out_proj",
+          "vision_model.transformer.layers.6.self_attn.qkv_proj",
+          "vision_model.transformer.layers.7.mlp.fc1",
+          "vision_model.transformer.layers.7.mlp.fc2",
+          "vision_model.transformer.layers.7.self_attn.out_proj",
+          "vision_model.transformer.layers.7.self_attn.qkv_proj",
+          "vision_model.transformer.layers.8.mlp.fc1",
+          "vision_model.transformer.layers.8.mlp.fc2",
+          "vision_model.transformer.layers.8.self_attn.out_proj",
+          "vision_model.transformer.layers.8.self_attn.qkv_proj",
+          "vision_model.transformer.layers.9.mlp.fc1",
+          "vision_model.transformer.layers.9.mlp.fc2",
+          "vision_model.transformer.layers.9.self_attn.out_proj",
+          "vision_model.transformer.layers.9.self_attn.qkv_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 2.6628739674476654,
+          "mean_digit_cer": 1.445363129900987,
+          "mean_table_score": 0.0,
+          "total_inference_time": 82.4734385000047,
+          "avg_time_per_image": 6.872786541667058
+        },
+        "cer_delta": 2.423686254155169,
+        "digit_cer_delta": 1.3580231623307086,
+        "table_score_degradation": 1.0,
+        "sensitivity_rank": 1
+      },
+      "vision_projector": {
+        "status": "success",
+        "matched_module_count": 1,
+        "matched_modules": [
+          "projector.layers"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23591319611894124,
+          "mean_digit_cer": 0.08425354781719185,
+          "mean_table_score": 1.0,
+          "total_inference_time": 37.98282545800612,
+          "avg_time_per_image": 3.165235454833843
+        },
+        "cer_delta": -0.003274517173555175,
+        "digit_cer_delta": -0.0030864197530864335,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 7
+      },
+      "token_embeddings": {
+        "status": "success",
+        "matched_module_count": 1,
+        "matched_modules": [
+          "language_model.model.embed_tokens"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.2326891302977425,
+          "mean_digit_cer": 0.08249916185227958,
+          "mean_table_score": 1.0,
+          "total_inference_time": 38.66650962494896,
+          "avg_time_per_image": 3.222209135412413
+        },
+        "cer_delta": -0.006498582994753921,
+        "digit_cer_delta": -0.004840805717998706,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 10
+      },
+      "attention_q_proj": {
+        "status": "success",
+        "matched_module_count": 12,
+        "matched_modules": [
+          "language_model.model.layers.0.self_attn.q_proj",
+          "language_model.model.layers.1.self_attn.q_proj",
+          "language_model.model.layers.10.self_attn.q_proj",
+          "language_model.model.layers.11.self_attn.q_proj",
+          "language_model.model.layers.2.self_attn.q_proj",
+          "language_model.model.layers.3.self_attn.q_proj",
+          "language_model.model.layers.4.self_attn.q_proj",
+          "language_model.model.layers.5.self_attn.q_proj",
+          "language_model.model.layers.6.self_attn.q_proj",
+          "language_model.model.layers.7.self_attn.q_proj",
+          "language_model.model.layers.8.self_attn.q_proj",
+          "language_model.model.layers.9.self_attn.q_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.21507560490000377,
+          "mean_digit_cer": 0.09653424957157782,
+          "mean_table_score": 1.0,
+          "total_inference_time": 38.38538125100604,
+          "avg_time_per_image": 3.19878177091717
+        },
+        "cer_delta": -0.024112108392492643,
+        "digit_cer_delta": 0.009194282001299528,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 11
+      },
+      "attention_k_proj": {
+        "status": "success",
+        "matched_module_count": 12,
+        "matched_modules": [
+          "language_model.model.layers.0.self_attn.k_proj",
+          "language_model.model.layers.1.self_attn.k_proj",
+          "language_model.model.layers.10.self_attn.k_proj",
+          "language_model.model.layers.11.self_attn.k_proj",
+          "language_model.model.layers.2.self_attn.k_proj",
+          "language_model.model.layers.3.self_attn.k_proj",
+          "language_model.model.layers.4.self_attn.k_proj",
+          "language_model.model.layers.5.self_attn.k_proj",
+          "language_model.model.layers.6.self_attn.k_proj",
+          "language_model.model.layers.7.self_attn.k_proj",
+          "language_model.model.layers.8.self_attn.k_proj",
+          "language_model.model.layers.9.self_attn.k_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23424214947533464,
+          "mean_digit_cer": 0.08425354781719185,
+          "mean_table_score": 1.0,
+          "total_inference_time": 38.175402873021085,
+          "avg_time_per_image": 3.181283572751757
+        },
+        "cer_delta": -0.004945563817161769,
+        "digit_cer_delta": -0.0030864197530864335,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 9
+      },
+      "attention_v_proj": {
+        "status": "success",
+        "matched_module_count": 12,
+        "matched_modules": [
+          "language_model.model.layers.0.self_attn.v_proj",
+          "language_model.model.layers.1.self_attn.v_proj",
+          "language_model.model.layers.10.self_attn.v_proj",
+          "language_model.model.layers.11.self_attn.v_proj",
+          "language_model.model.layers.2.self_attn.v_proj",
+          "language_model.model.layers.3.self_attn.v_proj",
+          "language_model.model.layers.4.self_attn.v_proj",
+          "language_model.model.layers.5.self_attn.v_proj",
+          "language_model.model.layers.6.self_attn.v_proj",
+          "language_model.model.layers.7.self_attn.v_proj",
+          "language_model.model.layers.8.self_attn.v_proj",
+          "language_model.model.layers.9.self_attn.v_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23642534441989824,
+          "mean_digit_cer": 0.08425354781719185,
+          "mean_table_score": 1.0,
+          "total_inference_time": 41.72621229101787,
+          "avg_time_per_image": 3.477184357584823
+        },
+        "cer_delta": -0.0027623688725981754,
+        "digit_cer_delta": -0.0030864197530864335,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 5
+      },
+      "attention_o_proj": {
+        "status": "success",
+        "matched_module_count": 12,
+        "matched_modules": [
+          "language_model.model.layers.0.self_attn.o_proj",
+          "language_model.model.layers.1.self_attn.o_proj",
+          "language_model.model.layers.10.self_attn.o_proj",
+          "language_model.model.layers.11.self_attn.o_proj",
+          "language_model.model.layers.2.self_attn.o_proj",
+          "language_model.model.layers.3.self_attn.o_proj",
+          "language_model.model.layers.4.self_attn.o_proj",
+          "language_model.model.layers.5.self_attn.o_proj",
+          "language_model.model.layers.6.self_attn.o_proj",
+          "language_model.model.layers.7.self_attn.o_proj",
+          "language_model.model.layers.8.self_attn.o_proj",
+          "language_model.model.layers.9.self_attn.o_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.2359826017166606,
+          "mean_digit_cer": 0.07714420469193685,
+          "mean_table_score": 1.0,
+          "total_inference_time": 41.9442965429771,
+          "avg_time_per_image": 3.4953580452480915
+        },
+        "cer_delta": -0.003205111575835806,
+        "digit_cer_delta": -0.010195762878341438,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 6
+      },
+      "dense_mlp": {
+        "status": "success",
+        "matched_module_count": 3,
+        "matched_modules": [
+          "language_model.model.layers.0.mlp.down_proj",
+          "language_model.model.layers.0.mlp.gate_proj",
+          "language_model.model.layers.0.mlp.up_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23568756434998817,
+          "mean_digit_cer": 0.08425354781719185,
+          "mean_table_score": 1.0,
+          "total_inference_time": 41.424109207015135,
+          "avg_time_per_image": 3.4520091005845948
+        },
+        "cer_delta": -0.0035001489425082466,
+        "digit_cer_delta": -0.0030864197530864335,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 8
+      },
+      "shared_experts": {
+        "status": "success",
+        "matched_module_count": 33,
+        "matched_modules": [
+          "language_model.model.layers.1.mlp.shared_experts.down_proj",
+          "language_model.model.layers.1.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.1.mlp.shared_experts.up_proj",
+          "language_model.model.layers.10.mlp.shared_experts.down_proj",
+          "language_model.model.layers.10.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.10.mlp.shared_experts.up_proj",
+          "language_model.model.layers.11.mlp.shared_experts.down_proj",
+          "language_model.model.layers.11.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.11.mlp.shared_experts.up_proj",
+          "language_model.model.layers.2.mlp.shared_experts.down_proj",
+          "language_model.model.layers.2.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.2.mlp.shared_experts.up_proj",
+          "language_model.model.layers.3.mlp.shared_experts.down_proj",
+          "language_model.model.layers.3.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.3.mlp.shared_experts.up_proj",
+          "language_model.model.layers.4.mlp.shared_experts.down_proj",
+          "language_model.model.layers.4.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.4.mlp.shared_experts.up_proj",
+          "language_model.model.layers.5.mlp.shared_experts.down_proj",
+          "language_model.model.layers.5.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.5.mlp.shared_experts.up_proj",
+          "language_model.model.layers.6.mlp.shared_experts.down_proj",
+          "language_model.model.layers.6.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.6.mlp.shared_experts.up_proj",
+          "language_model.model.layers.7.mlp.shared_experts.down_proj",
+          "language_model.model.layers.7.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.7.mlp.shared_experts.up_proj",
+          "language_model.model.layers.8.mlp.shared_experts.down_proj",
+          "language_model.model.layers.8.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.8.mlp.shared_experts.up_proj",
+          "language_model.model.layers.9.mlp.shared_experts.down_proj",
+          "language_model.model.layers.9.mlp.shared_experts.gate_proj",
+          "language_model.model.layers.9.mlp.shared_experts.up_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23649792801080774,
+          "mean_digit_cer": 0.09592829886362793,
+          "mean_table_score": 1.0,
+          "total_inference_time": 37.84185174998129,
+          "avg_time_per_image": 3.153487645831774
+        },
+        "cer_delta": -0.0026897852816886725,
+        "digit_cer_delta": 0.00858833129334964,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 4
+      },
+      "routed_experts": {
+        "status": "success",
+        "matched_module_count": 33,
+        "matched_modules": [
+          "language_model.model.layers.1.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.1.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.1.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.10.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.10.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.10.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.11.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.11.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.11.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.2.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.2.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.2.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.3.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.3.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.3.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.4.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.4.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.4.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.5.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.5.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.5.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.6.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.6.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.6.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.7.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.7.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.7.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.8.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.8.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.8.mlp.switch_mlp.up_proj",
+          "language_model.model.layers.9.mlp.switch_mlp.down_proj",
+          "language_model.model.layers.9.mlp.switch_mlp.gate_proj",
+          "language_model.model.layers.9.mlp.switch_mlp.up_proj"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.23911822127011442,
+          "mean_digit_cer": 0.08452479009169811,
+          "mean_table_score": 1.0,
+          "total_inference_time": 36.668351295011234,
+          "avg_time_per_image": 3.0556959412509364
+        },
+        "cer_delta": -6.949202238198948e-05,
+        "digit_cer_delta": -0.0028151774785801775,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 3
+      },
+      "lm_head": {
+        "status": "success",
+        "matched_module_count": 1,
+        "matched_modules": [
+          "language_model.lm_head"
+        ],
+        "metrics": {
+          "num_samples": 12,
+          "num_digit_samples": 12,
+          "num_table_samples": 3,
+          "mean_cer": 0.25282999056583605,
+          "mean_digit_cer": 0.12301897991595728,
+          "mean_table_score": 1.0,
+          "total_inference_time": 37.152046875009546,
+          "avg_time_per_image": 3.0960039062507954
+        },
+        "cer_delta": 0.013642277273339637,
+        "digit_cer_delta": 0.035679012345678995,
+        "table_score_degradation": 0.0,
+        "sensitivity_rank": 2
+      }
+    }
+  },
+  "calibration": {
+    "schema_version": 1,
+    "created_at": "2026-07-20T23:25:55.306169+00:00",
+    "target_pattern": "language_model.lm_head",
+    "selection_policy": "fastest candidate passing existing quality and throughput limits",
+    "thresholds": {
+      "max_cer_delta_vs_bf16": 0.01,
+      "max_cer_delta_vs_reference": 0.005,
+      "max_digit_cer_delta_vs_bf16": 0.01,
+      "max_table_score_degradation_vs_bf16": 0.01,
+      "min_tps_ratio_vs_reference": 0.9,
+      "max_weight_size_gb": 4.5
+    },
+    "experiments": [
+      {
+        "label": "bf16-head",
+        "precision": "bfloat16",
+        "passed": false,
+        "checks": {
+          "cer": true,
+          "digit_cer": true,
+          "table_score": true,
+          "throughput": false
+        },
+        "metrics": {
+          "mean_cer": 0.23190356458231498,
+          "mean_digit_cer": 0.08222376405546196,
+          "mean_table_score": 1.0,
+          "mean_tps": 271.0950821181683
+        },
+        "deltas": {
+          "cer_vs_bf16": -0.007284148710181432,
+          "digit_cer_vs_bf16": -0.005116203514816328,
+          "table_degradation_vs_bf16": 0.0,
+          "tps_ratio_vs_reference": 0.8668704848166195
+        }
+      },
+      {
+        "label": "mxfp8-head",
+        "precision": "mxfp8",
+        "passed": false,
+        "checks": {
+          "cer": false,
+          "digit_cer": true,
+          "table_score": true,
+          "throughput": true
+        },
+        "metrics": {
+          "mean_cer": 0.26017003915600867,
+          "mean_digit_cer": 0.0769606061607251,
+          "mean_table_score": 1.0,
+          "mean_tps": 307.3938836867251
+        },
+        "deltas": {
+          "cer_vs_bf16": 0.020982325863512258,
+          "digit_cer_vs_bf16": -0.010379361409553187,
+          "table_degradation_vs_bf16": 0.0,
+          "tps_ratio_vs_reference": 0.9829417889071937
+        }
+      },
+      {
+        "label": "affine8-head",
+        "precision": "affine8",
+        "passed": true,
+        "checks": {
+          "cer": true,
+          "digit_cer": true,
+          "table_score": true,
+          "throughput": true
+        },
+        "metrics": {
+          "mean_cer": 0.23738438172232493,
+          "mean_digit_cer": 0.08573253598528652,
+          "mean_table_score": 1.0,
+          "mean_tps": 301.24796539578256
+        },
+        "deltas": {
+          "cer_vs_bf16": -0.0018033315701714847,
+          "digit_cer_vs_bf16": -0.0016074315849917697,
+          "table_degradation_vs_bf16": 0.0,
+          "tps_ratio_vs_reference": 0.9632892185732532
+        }
+      }
+    ],
+    "selected": {
+      "label": "affine8-head",
+      "precision": "affine8"
+    },
+    "precision_overrides": {
+      "language_model.lm_head": "affine8"
+    }
+  },
+  "precision_map": {
+    "vision_model": "bfloat16",
+    "projector": "mxfp8",
+    "language_model.model.embed_tokens": "mxfp8",
+    "language_model.model.norm": "bfloat16",
+    "language_model.lm_head": "affine8",
+    "language_model.model.layers.*.input_layernorm": "bfloat16",
+    "language_model.model.layers.*.post_attention_layernorm": "bfloat16",
+    "language_model.model.layers.*.self_attn.q_proj": "mxfp8",
+    "language_model.model.layers.*.self_attn.k_proj": "mxfp8",
+    "language_model.model.layers.*.self_attn.v_proj": "mxfp8",
+    "language_model.model.layers.*.self_attn.o_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.up_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.down_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.shared_experts.gate_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.shared_experts.up_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.shared_experts.down_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.switch_mlp.gate_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.switch_mlp.up_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.switch_mlp.down_proj": "mxfp8",
+    "language_model.model.layers.*.mlp.gate": "bfloat16",
+    "sam_model": "bfloat16",
+    "_generated_from": {
+      "source_model": "baidu/Unlimited-OCR",
+      "thresholds": {
+        "cer_delta": 0.02,
+        "digit_cer_delta": 0.02,
+        "table_score_degradation": 0.01
+      },
+      "decisions": {
+        "vision_encoder": {
+          "precision": "bfloat16",
+          "reasons": [
+            "cer_delta=2.423686",
+            "digit_cer_delta=1.358023",
+            "table_score_degradation=1.000000",
+            "protected OCR-critical group"
+          ]
+        },
+        "vision_projector": {
+          "precision": "mxfp8",
+          "reasons": [
+            "all measured quality deltas were non-degrading"
+          ]
+        },
+        "token_embeddings": {
+          "precision": "mxfp8",
+          "reasons": [
+            "all measured quality deltas were non-degrading"
+          ]
+        },
+        "attention_q_proj": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "attention_k_proj": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "attention_v_proj": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "attention_o_proj": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "dense_mlp": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "shared_experts": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "routed_experts": {
+          "precision": "base-map",
+          "reasons": [
+            "within thresholds"
+          ]
+        },
+        "lm_head": {
+          "precision": "affine8",
+          "reasons": [
+            "selected by joint quality/throughput calibration: affine8-head"
+          ]
+        }
+      },
+      "calibration": {
+        "selected": {
+          "label": "affine8-head",
+          "precision": "affine8"
+        },
+        "selection_policy": "fastest candidate passing existing quality and throughput limits"
+      }
+    }
+  },
+  "artifacts": {
+    "bf16_accuracy": {
+      "filename": "bf16_accuracy.json",
+      "size": 4857,
+      "sha256": "0de8511f1ba98f362d3ab712522115e534d7f129a8b587751ba5d5d8c95f272d"
+    },
+    "reference_accuracy": {
+      "filename": "reference_accuracy.json",
+      "size": 4923,
+      "sha256": "354d3c17451bc9e1c6ec645d36ba2e133cd1b2393dae2d7825628832e11dc365"
+    },
+    "candidate_accuracy": {
+      "filename": "candidate_accuracy.json",
+      "size": 4863,
+      "sha256": "20dbd578c93afa885a2b98627b5e8335b3c68ef14e84afa66bc9392f7e6c5daf"
+    },
+    "reference_performance": {
+      "filename": "reference_performance.json",
+      "size": 2211,
+      "sha256": "74a5983677fcedab1cfe8193cc4138abfb011c6e9f2fa90d954cf3b52086888a"
+    },
+    "candidate_performance": {
+      "filename": "candidate_performance.json",
+      "size": 2219,
+      "sha256": "52a7760cfcc1ce1f588fbce0642951874800fcb7952bed53644d81d91170862c"
+    },
+    "candidate_rswa": {
+      "filename": "candidate_rswa.json",
+      "size": 2374,
+      "sha256": "612e0250c99eae03d4746f3687af57ab4ee43500fab376cd59d69be460ffa429"
+    },
+    "sensitivity_results": {
+      "filename": "sensitivity_results.json",
+      "size": 22710,
+      "sha256": "63435bddcfe5d8e96921ed53eb1741ca731c9d362ab549391a436342b147d415"
+    },
+    "calibration_results": {
+      "filename": "calibration_results.json",
+      "size": 2542,
+      "sha256": "416c1f8e332d69d9a753bea140e264a5573875f283c9eadc79b3ea61addc3d7b"
+    },
+    "generated_precision_map": {
+      "filename": "generated_precision_map.json",
+      "size": 3315,
+      "sha256": "df9d9f6b2490d75e8589350b481fb1916a6dbf8a141c5f6958b0525d72fb1a46"
+    },
+    "provenance": {
+      "filename": "provenance.json",
+      "size": 5389,
+      "sha256": "03c82c24826fdd6fdc0f5031ba67394979753584ff8949482a739dfef1719b47"
+    }
+  },
+  "gates": [
+    {
+      "name": "weights_are_distinct",
+      "passed": true,
+      "actual": "a4f6e9934f90564906f42929542ad68493f0c6187ad431128e447debbf52b6f4",
+      "limit": "different from 439c6acfe5e277537dfe3368b94a145a6b0da4c39e4bd00582977d030f292ad1",
+      "detail": "Candidate aggregate digest must differ from the Sahil reference"
+    },
+    {
+      "name": "weight_size_gb",
+      "passed": true,
+      "actual": 3.5792221864685416,
+      "limit": 4.5,
+      "detail": "Candidate Safetensors size"
+    },
+    {
+      "name": "native_model_metadata",
+      "passed": true,
+      "actual": {
+        "architecture": true,
+        "model_type": true,
+        "mxfp8": true,
+        "sliding_window": true,
+        "processor_class": true,
+        "sft_format": true
+      },
+      "limit": true,
+      "detail": "Native Unlimited-OCR, MXFP8, and R-SWA metadata"
+    },
+    {
+      "name": "evaluation_coverage",
+      "passed": true,
+      "actual": {
+        "samples": 12,
+        "digit": 12,
+        "cjk": 3,
+        "table": 3
+      },
+      "limit": "all counts > 0",
+      "detail": "Dataset must cover ordinary text, digits, CJK, and tables"
+    },
+    {
+      "name": "same_evaluation_samples",
+      "passed": true,
+      "actual": [
+        12,
+        12,
+        12
+      ],
+      "limit": 12,
+      "detail": "All three checkpoints must run the complete evaluation set"
+    },
+    {
+      "name": "candidate_cer_vs_bf16",
+      "passed": true,
+      "actual": -0.0018033315701714847,
+      "limit": 0.01,
+      "detail": "Candidate minus BF16 absolute mean CER"
+    },
+    {
+      "name": "candidate_cer_vs_reference",
+      "passed": true,
+      "actual": -0.8198643918447561,
+      "limit": 0.005,
+      "detail": "Candidate minus Sahil-reference absolute mean CER"
+    },
+    {
+      "name": "candidate_digit_cer_vs_bf16",
+      "passed": true,
+      "actual": -0.0016074315849917697,
+      "limit": 0.01,
+      "detail": "Candidate minus BF16 digit CER"
+    },
+    {
+      "name": "candidate_table_score_vs_bf16",
+      "passed": true,
+      "actual": 0.0,
+      "limit": 0.01,
+      "detail": "BF16 minus candidate mean table score"
+    },
+    {
+      "name": "candidate_tps_vs_reference",
+      "passed": true,
+      "actual": 0.9503587809120344,
+      "limit": 0.9,
+      "detail": "Candidate decode throughput divided by Sahil-reference throughput"
+    },
+    {
+      "name": "rswa_8k_bounded",
+      "passed": true,
+      "actual": {
+        "cache_bounded": true,
+        "tps_stable": true,
+        "8k_test_passed": true
+      },
+      "limit": true,
+      "detail": "8K generation, bounded cache, and stable throughput"
+    }
+  ],
+  "environment": {
+    "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O",
+    "machine": "arm64",
+    "python": "3.14.6",
+    "versions": {
+      "mlx": "0.32.0",
+      "mlx-vlm": "0.6.6",
+      "huggingface-hub": "1.24.0",
+      "numpy": "2.5.1",
+      "Pillow": "12.3.0"
+    }
+  }
+}

release/sensitivity_results.json

@@ -0,0 +1,516 @@
+{
+  "baseline": {
+    "num_samples": 12,
+    "num_digit_samples": 12,
+    "num_table_samples": 3,
+    "mean_cer": 0.2391877132924964,
+    "mean_digit_cer": 0.08733996757027829,
+    "mean_table_score": 1.0,
+    "total_inference_time": 37.96379516503657,
+    "avg_time_per_image": 3.163649597086381
+  },
+  "model_path": "baidu/Unlimited-OCR",
+  "eval_dir": "eval_dataset",
+  "prompt": "<image>document parsing.",
+  "max_tokens": 1024,
+  "groups_tested": [
+    "vision_encoder",
+    "vision_projector",
+    "token_embeddings",
+    "attention_q_proj",
+    "attention_k_proj",
+    "attention_v_proj",
+    "attention_o_proj",
+    "dense_mlp",
+    "shared_experts",
+    "routed_experts",
+    "lm_head"
+  ],
+  "layer_groups": {
+    "vision_encoder": {
+      "status": "success",
+      "matched_module_count": 145,
+      "matched_modules": [
+        "sam_model.blocks.0.attn.proj",
+        "sam_model.blocks.0.attn.qkv",
+        "sam_model.blocks.0.mlp.lin1",
+        "sam_model.blocks.0.mlp.lin2",
+        "sam_model.blocks.1.attn.proj",
+        "sam_model.blocks.1.attn.qkv",
+        "sam_model.blocks.1.mlp.lin1",
+        "sam_model.blocks.1.mlp.lin2",
+        "sam_model.blocks.10.attn.proj",
+        "sam_model.blocks.10.attn.qkv",
+        "sam_model.blocks.10.mlp.lin1",
+        "sam_model.blocks.10.mlp.lin2",
+        "sam_model.blocks.11.attn.proj",
+        "sam_model.blocks.11.attn.qkv",
+        "sam_model.blocks.11.mlp.lin1",
+        "sam_model.blocks.11.mlp.lin2",
+        "sam_model.blocks.2.attn.proj",
+        "sam_model.blocks.2.attn.qkv",
+        "sam_model.blocks.2.mlp.lin1",
+        "sam_model.blocks.2.mlp.lin2",
+        "sam_model.blocks.3.attn.proj",
+        "sam_model.blocks.3.attn.qkv",
+        "sam_model.blocks.3.mlp.lin1",
+        "sam_model.blocks.3.mlp.lin2",
+        "sam_model.blocks.4.attn.proj",
+        "sam_model.blocks.4.attn.qkv",
+        "sam_model.blocks.4.mlp.lin1",
+        "sam_model.blocks.4.mlp.lin2",
+        "sam_model.blocks.5.attn.proj",
+        "sam_model.blocks.5.attn.qkv",
+        "sam_model.blocks.5.mlp.lin1",
+        "sam_model.blocks.5.mlp.lin2",
+        "sam_model.blocks.6.attn.proj",
+        "sam_model.blocks.6.attn.qkv",
+        "sam_model.blocks.6.mlp.lin1",
+        "sam_model.blocks.6.mlp.lin2",
+        "sam_model.blocks.7.attn.proj",
+        "sam_model.blocks.7.attn.qkv",
+        "sam_model.blocks.7.mlp.lin1",
+        "sam_model.blocks.7.mlp.lin2",
+        "sam_model.blocks.8.attn.proj",
+        "sam_model.blocks.8.attn.qkv",
+        "sam_model.blocks.8.mlp.lin1",
+        "sam_model.blocks.8.mlp.lin2",
+        "sam_model.blocks.9.attn.proj",
+        "sam_model.blocks.9.attn.qkv",
+        "sam_model.blocks.9.mlp.lin1",
+        "sam_model.blocks.9.mlp.lin2",
+        "vision_model.embeddings.position_embedding",
+        "vision_model.transformer.layers.0.mlp.fc1",
+        "vision_model.transformer.layers.0.mlp.fc2",
+        "vision_model.transformer.layers.0.self_attn.out_proj",
+        "vision_model.transformer.layers.0.self_attn.qkv_proj",
+        "vision_model.transformer.layers.1.mlp.fc1",
+        "vision_model.transformer.layers.1.mlp.fc2",
+        "vision_model.transformer.layers.1.self_attn.out_proj",
+        "vision_model.transformer.layers.1.self_attn.qkv_proj",
+        "vision_model.transformer.layers.10.mlp.fc1",
+        "vision_model.transformer.layers.10.mlp.fc2",
+        "vision_model.transformer.layers.10.self_attn.out_proj",
+        "vision_model.transformer.layers.10.self_attn.qkv_proj",
+        "vision_model.transformer.layers.11.mlp.fc1",
+        "vision_model.transformer.layers.11.mlp.fc2",
+        "vision_model.transformer.layers.11.self_attn.out_proj",
+        "vision_model.transformer.layers.11.self_attn.qkv_proj",
+        "vision_model.transformer.layers.12.mlp.fc1",
+        "vision_model.transformer.layers.12.mlp.fc2",
+        "vision_model.transformer.layers.12.self_attn.out_proj",
+        "vision_model.transformer.layers.12.self_attn.qkv_proj",
+        "vision_model.transformer.layers.13.mlp.fc1",
+        "vision_model.transformer.layers.13.mlp.fc2",
+        "vision_model.transformer.layers.13.self_attn.out_proj",
+        "vision_model.transformer.layers.13.self_attn.qkv_proj",
+        "vision_model.transformer.layers.14.mlp.fc1",
+        "vision_model.transformer.layers.14.mlp.fc2",
+        "vision_model.transformer.layers.14.self_attn.out_proj",
+        "vision_model.transformer.layers.14.self_attn.qkv_proj",
+        "vision_model.transformer.layers.15.mlp.fc1",
+        "vision_model.transformer.layers.15.mlp.fc2",
+        "vision_model.transformer.layers.15.self_attn.out_proj",
+        "vision_model.transformer.layers.15.self_attn.qkv_proj",
+        "vision_model.transformer.layers.16.mlp.fc1",
+        "vision_model.transformer.layers.16.mlp.fc2",
+        "vision_model.transformer.layers.16.self_attn.out_proj",
+        "vision_model.transformer.layers.16.self_attn.qkv_proj",
+        "vision_model.transformer.layers.17.mlp.fc1",
+        "vision_model.transformer.layers.17.mlp.fc2",
+        "vision_model.transformer.layers.17.self_attn.out_proj",
+        "vision_model.transformer.layers.17.self_attn.qkv_proj",
+        "vision_model.transformer.layers.18.mlp.fc1",
+        "vision_model.transformer.layers.18.mlp.fc2",
+        "vision_model.transformer.layers.18.self_attn.out_proj",
+        "vision_model.transformer.layers.18.self_attn.qkv_proj",
+        "vision_model.transformer.layers.19.mlp.fc1",
+        "vision_model.transformer.layers.19.mlp.fc2",
+        "vision_model.transformer.layers.19.self_attn.out_proj",
+        "vision_model.transformer.layers.19.self_attn.qkv_proj",
+        "vision_model.transformer.layers.2.mlp.fc1",
+        "vision_model.transformer.layers.2.mlp.fc2",
+        "vision_model.transformer.layers.2.self_attn.out_proj",
+        "vision_model.transformer.layers.2.self_attn.qkv_proj",
+        "vision_model.transformer.layers.20.mlp.fc1",
+        "vision_model.transformer.layers.20.mlp.fc2",
+        "vision_model.transformer.layers.20.self_attn.out_proj",
+        "vision_model.transformer.layers.20.self_attn.qkv_proj",
+        "vision_model.transformer.layers.21.mlp.fc1",
+        "vision_model.transformer.layers.21.mlp.fc2",
+        "vision_model.transformer.layers.21.self_attn.out_proj",
+        "vision_model.transformer.layers.21.self_attn.qkv_proj",
+        "vision_model.transformer.layers.22.mlp.fc1",
+        "vision_model.transformer.layers.22.mlp.fc2",
+        "vision_model.transformer.layers.22.self_attn.out_proj",
+        "vision_model.transformer.layers.22.self_attn.qkv_proj",
+        "vision_model.transformer.layers.23.mlp.fc1",
+        "vision_model.transformer.layers.23.mlp.fc2",
+        "vision_model.transformer.layers.23.self_attn.out_proj",
+        "vision_model.transformer.layers.23.self_attn.qkv_proj",
+        "vision_model.transformer.layers.3.mlp.fc1",
+        "vision_model.transformer.layers.3.mlp.fc2",
+        "vision_model.transformer.layers.3.self_attn.out_proj",
+        "vision_model.transformer.layers.3.self_attn.qkv_proj",
+        "vision_model.transformer.layers.4.mlp.fc1",
+        "vision_model.transformer.layers.4.mlp.fc2",
+        "vision_model.transformer.layers.4.self_attn.out_proj",
+        "vision_model.transformer.layers.4.self_attn.qkv_proj",
+        "vision_model.transformer.layers.5.mlp.fc1",
+        "vision_model.transformer.layers.5.mlp.fc2",
+        "vision_model.transformer.layers.5.self_attn.out_proj",
+        "vision_model.transformer.layers.5.self_attn.qkv_proj",
+        "vision_model.transformer.layers.6.mlp.fc1",
+        "vision_model.transformer.layers.6.mlp.fc2",
+        "vision_model.transformer.layers.6.self_attn.out_proj",
+        "vision_model.transformer.layers.6.self_attn.qkv_proj",
+        "vision_model.transformer.layers.7.mlp.fc1",
+        "vision_model.transformer.layers.7.mlp.fc2",
+        "vision_model.transformer.layers.7.self_attn.out_proj",
+        "vision_model.transformer.layers.7.self_attn.qkv_proj",
+        "vision_model.transformer.layers.8.mlp.fc1",
+        "vision_model.transformer.layers.8.mlp.fc2",
+        "vision_model.transformer.layers.8.self_attn.out_proj",
+        "vision_model.transformer.layers.8.self_attn.qkv_proj",
+        "vision_model.transformer.layers.9.mlp.fc1",
+        "vision_model.transformer.layers.9.mlp.fc2",
+        "vision_model.transformer.layers.9.self_attn.out_proj",
+        "vision_model.transformer.layers.9.self_attn.qkv_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 2.6628739674476654,
+        "mean_digit_cer": 1.445363129900987,
+        "mean_table_score": 0.0,
+        "total_inference_time": 82.4734385000047,
+        "avg_time_per_image": 6.872786541667058
+      },
+      "cer_delta": 2.423686254155169,
+      "digit_cer_delta": 1.3580231623307086,
+      "table_score_degradation": 1.0,
+      "sensitivity_rank": 1
+    },
+    "vision_projector": {
+      "status": "success",
+      "matched_module_count": 1,
+      "matched_modules": [
+        "projector.layers"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23591319611894124,
+        "mean_digit_cer": 0.08425354781719185,
+        "mean_table_score": 1.0,
+        "total_inference_time": 37.98282545800612,
+        "avg_time_per_image": 3.165235454833843
+      },
+      "cer_delta": -0.003274517173555175,
+      "digit_cer_delta": -0.0030864197530864335,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 7
+    },
+    "token_embeddings": {
+      "status": "success",
+      "matched_module_count": 1,
+      "matched_modules": [
+        "language_model.model.embed_tokens"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.2326891302977425,
+        "mean_digit_cer": 0.08249916185227958,
+        "mean_table_score": 1.0,
+        "total_inference_time": 38.66650962494896,
+        "avg_time_per_image": 3.222209135412413
+      },
+      "cer_delta": -0.006498582994753921,
+      "digit_cer_delta": -0.004840805717998706,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 10
+    },
+    "attention_q_proj": {
+      "status": "success",
+      "matched_module_count": 12,
+      "matched_modules": [
+        "language_model.model.layers.0.self_attn.q_proj",
+        "language_model.model.layers.1.self_attn.q_proj",
+        "language_model.model.layers.10.self_attn.q_proj",
+        "language_model.model.layers.11.self_attn.q_proj",
+        "language_model.model.layers.2.self_attn.q_proj",
+        "language_model.model.layers.3.self_attn.q_proj",
+        "language_model.model.layers.4.self_attn.q_proj",
+        "language_model.model.layers.5.self_attn.q_proj",
+        "language_model.model.layers.6.self_attn.q_proj",
+        "language_model.model.layers.7.self_attn.q_proj",
+        "language_model.model.layers.8.self_attn.q_proj",
+        "language_model.model.layers.9.self_attn.q_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.21507560490000377,
+        "mean_digit_cer": 0.09653424957157782,
+        "mean_table_score": 1.0,
+        "total_inference_time": 38.38538125100604,
+        "avg_time_per_image": 3.19878177091717
+      },
+      "cer_delta": -0.024112108392492643,
+      "digit_cer_delta": 0.009194282001299528,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 11
+    },
+    "attention_k_proj": {
+      "status": "success",
+      "matched_module_count": 12,
+      "matched_modules": [
+        "language_model.model.layers.0.self_attn.k_proj",
+        "language_model.model.layers.1.self_attn.k_proj",
+        "language_model.model.layers.10.self_attn.k_proj",
+        "language_model.model.layers.11.self_attn.k_proj",
+        "language_model.model.layers.2.self_attn.k_proj",
+        "language_model.model.layers.3.self_attn.k_proj",
+        "language_model.model.layers.4.self_attn.k_proj",
+        "language_model.model.layers.5.self_attn.k_proj",
+        "language_model.model.layers.6.self_attn.k_proj",
+        "language_model.model.layers.7.self_attn.k_proj",
+        "language_model.model.layers.8.self_attn.k_proj",
+        "language_model.model.layers.9.self_attn.k_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23424214947533464,
+        "mean_digit_cer": 0.08425354781719185,
+        "mean_table_score": 1.0,
+        "total_inference_time": 38.175402873021085,
+        "avg_time_per_image": 3.181283572751757
+      },
+      "cer_delta": -0.004945563817161769,
+      "digit_cer_delta": -0.0030864197530864335,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 9
+    },
+    "attention_v_proj": {
+      "status": "success",
+      "matched_module_count": 12,
+      "matched_modules": [
+        "language_model.model.layers.0.self_attn.v_proj",
+        "language_model.model.layers.1.self_attn.v_proj",
+        "language_model.model.layers.10.self_attn.v_proj",
+        "language_model.model.layers.11.self_attn.v_proj",
+        "language_model.model.layers.2.self_attn.v_proj",
+        "language_model.model.layers.3.self_attn.v_proj",
+        "language_model.model.layers.4.self_attn.v_proj",
+        "language_model.model.layers.5.self_attn.v_proj",
+        "language_model.model.layers.6.self_attn.v_proj",
+        "language_model.model.layers.7.self_attn.v_proj",
+        "language_model.model.layers.8.self_attn.v_proj",
+        "language_model.model.layers.9.self_attn.v_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23642534441989824,
+        "mean_digit_cer": 0.08425354781719185,
+        "mean_table_score": 1.0,
+        "total_inference_time": 41.72621229101787,
+        "avg_time_per_image": 3.477184357584823
+      },
+      "cer_delta": -0.0027623688725981754,
+      "digit_cer_delta": -0.0030864197530864335,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 5
+    },
+    "attention_o_proj": {
+      "status": "success",
+      "matched_module_count": 12,
+      "matched_modules": [
+        "language_model.model.layers.0.self_attn.o_proj",
+        "language_model.model.layers.1.self_attn.o_proj",
+        "language_model.model.layers.10.self_attn.o_proj",
+        "language_model.model.layers.11.self_attn.o_proj",
+        "language_model.model.layers.2.self_attn.o_proj",
+        "language_model.model.layers.3.self_attn.o_proj",
+        "language_model.model.layers.4.self_attn.o_proj",
+        "language_model.model.layers.5.self_attn.o_proj",
+        "language_model.model.layers.6.self_attn.o_proj",
+        "language_model.model.layers.7.self_attn.o_proj",
+        "language_model.model.layers.8.self_attn.o_proj",
+        "language_model.model.layers.9.self_attn.o_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.2359826017166606,
+        "mean_digit_cer": 0.07714420469193685,
+        "mean_table_score": 1.0,
+        "total_inference_time": 41.9442965429771,
+        "avg_time_per_image": 3.4953580452480915
+      },
+      "cer_delta": -0.003205111575835806,
+      "digit_cer_delta": -0.010195762878341438,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 6
+    },
+    "dense_mlp": {
+      "status": "success",
+      "matched_module_count": 3,
+      "matched_modules": [
+        "language_model.model.layers.0.mlp.down_proj",
+        "language_model.model.layers.0.mlp.gate_proj",
+        "language_model.model.layers.0.mlp.up_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23568756434998817,
+        "mean_digit_cer": 0.08425354781719185,
+        "mean_table_score": 1.0,
+        "total_inference_time": 41.424109207015135,
+        "avg_time_per_image": 3.4520091005845948
+      },
+      "cer_delta": -0.0035001489425082466,
+      "digit_cer_delta": -0.0030864197530864335,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 8
+    },
+    "shared_experts": {
+      "status": "success",
+      "matched_module_count": 33,
+      "matched_modules": [
+        "language_model.model.layers.1.mlp.shared_experts.down_proj",
+        "language_model.model.layers.1.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.1.mlp.shared_experts.up_proj",
+        "language_model.model.layers.10.mlp.shared_experts.down_proj",
+        "language_model.model.layers.10.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.10.mlp.shared_experts.up_proj",
+        "language_model.model.layers.11.mlp.shared_experts.down_proj",
+        "language_model.model.layers.11.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.11.mlp.shared_experts.up_proj",
+        "language_model.model.layers.2.mlp.shared_experts.down_proj",
+        "language_model.model.layers.2.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.2.mlp.shared_experts.up_proj",
+        "language_model.model.layers.3.mlp.shared_experts.down_proj",
+        "language_model.model.layers.3.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.3.mlp.shared_experts.up_proj",
+        "language_model.model.layers.4.mlp.shared_experts.down_proj",
+        "language_model.model.layers.4.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.4.mlp.shared_experts.up_proj",
+        "language_model.model.layers.5.mlp.shared_experts.down_proj",
+        "language_model.model.layers.5.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.5.mlp.shared_experts.up_proj",
+        "language_model.model.layers.6.mlp.shared_experts.down_proj",
+        "language_model.model.layers.6.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.6.mlp.shared_experts.up_proj",
+        "language_model.model.layers.7.mlp.shared_experts.down_proj",
+        "language_model.model.layers.7.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.7.mlp.shared_experts.up_proj",
+        "language_model.model.layers.8.mlp.shared_experts.down_proj",
+        "language_model.model.layers.8.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.8.mlp.shared_experts.up_proj",
+        "language_model.model.layers.9.mlp.shared_experts.down_proj",
+        "language_model.model.layers.9.mlp.shared_experts.gate_proj",
+        "language_model.model.layers.9.mlp.shared_experts.up_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23649792801080774,
+        "mean_digit_cer": 0.09592829886362793,
+        "mean_table_score": 1.0,
+        "total_inference_time": 37.84185174998129,
+        "avg_time_per_image": 3.153487645831774
+      },
+      "cer_delta": -0.0026897852816886725,
+      "digit_cer_delta": 0.00858833129334964,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 4
+    },
+    "routed_experts": {
+      "status": "success",
+      "matched_module_count": 33,
+      "matched_modules": [
+        "language_model.model.layers.1.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.1.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.1.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.10.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.10.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.10.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.11.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.11.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.11.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.2.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.2.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.2.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.3.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.3.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.3.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.4.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.4.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.4.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.5.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.5.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.5.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.6.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.6.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.6.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.7.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.7.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.7.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.8.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.8.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.8.mlp.switch_mlp.up_proj",
+        "language_model.model.layers.9.mlp.switch_mlp.down_proj",
+        "language_model.model.layers.9.mlp.switch_mlp.gate_proj",
+        "language_model.model.layers.9.mlp.switch_mlp.up_proj"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.23911822127011442,
+        "mean_digit_cer": 0.08452479009169811,
+        "mean_table_score": 1.0,
+        "total_inference_time": 36.668351295011234,
+        "avg_time_per_image": 3.0556959412509364
+      },
+      "cer_delta": -6.949202238198948e-05,
+      "digit_cer_delta": -0.0028151774785801775,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 3
+    },
+    "lm_head": {
+      "status": "success",
+      "matched_module_count": 1,
+      "matched_modules": [
+        "language_model.lm_head"
+      ],
+      "metrics": {
+        "num_samples": 12,
+        "num_digit_samples": 12,
+        "num_table_samples": 3,
+        "mean_cer": 0.25282999056583605,
+        "mean_digit_cer": 0.12301897991595728,
+        "mean_table_score": 1.0,
+        "total_inference_time": 37.152046875009546,
+        "avg_time_per_image": 3.0960039062507954
+      },
+      "cer_delta": 0.013642277273339637,
+      "digit_cer_delta": 0.035679012345678995,
+      "table_score_degradation": 0.0,
+      "sensitivity_rank": 2
+    }
+  }
+}

special_tokens_map.json

@@ -0,0 +1,39 @@
+{
+  "additional_special_tokens": [
+    {
+      "content": "<|User|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|Assistant|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    }
+  ],
+  "bos_token": {
+    "content": "<｜begin▁of▁sentence｜>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<｜end▁of▁sentence｜>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<｜▁pad▁｜>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

src/unlimited_ocr/__init__.py

@@ -0,0 +1,17 @@
+"""Unlimited-OCR MLX — Improved inference pipeline for Apple Silicon."""
+
+__version__ = "0.2.0"
+
+from unlimited_ocr.pipeline import BatchProcessingError, OCRPipeline
+from unlimited_ocr.engine import OCREngine
+from unlimited_ocr.profiles import get_profile, list_profiles, PROFILES
+
+__all__ = [
+    "OCRPipeline",
+    "BatchProcessingError",
+    "OCREngine",
+    "get_profile",
+    "list_profiles",
+    "PROFILES",
+    "__version__",
+]

src/unlimited_ocr/adapter_registry.json

@@ -0,0 +1,17 @@
+{
+  "version": "1.0",
+  "description": "LoRA adapter registry for Unlimited-OCR",
+  "adapters": {
+    "table": {
+      "path": "adapters/table-v1",
+      "hf_repo": "AutomatosX/unlimited-ocr-lora-table",
+      "description": "Table structure recognition adapter"
+    },
+    "receipt": {
+      "path": "adapters/receipt-v1",
+      "hf_repo": "AutomatosX/unlimited-ocr-lora-receipt",
+      "description": "Receipt and invoice parsing adapter"
+    }
+  },
+  "default": null
+}

src/unlimited_ocr/cli.py

@@ -0,0 +1,368 @@
+"""Command-line interface for Unlimited-OCR MLX."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from unlimited_ocr import __version__
+from unlimited_ocr.engine import DEFAULT_MODEL
+from unlimited_ocr.pdf import DEFAULT_PDF_DPI
+from unlimited_ocr.preprocessing import PREPROCESS_MODES
+from unlimited_ocr.profiles import PROFILES
+
+console = Console()
+status_console = Console(stderr=True)
+
+PROFILE_NAMES = list(PROFILES.keys())
+
+
+def _resolve_adapter(name_or_path: str) -> str:
+    """Resolve an adapter name to a path using the registry."""
+    import json
+
+    # If it's already a path that exists, use directly
+    p = Path(name_or_path).expanduser()
+    if p.is_dir():
+        return str(p)
+    if p.exists():
+        raise click.ClickException(f"Adapter path is not a directory: {p}")
+
+    # Try registry lookup
+    registry_paths = (
+        Path(__file__).with_name("adapter_registry.json"),
+        Path(__file__).parent.parent.parent / "adapters" / "registry.json",
+    )
+    registry_path = next((path for path in registry_paths if path.is_file()), None)
+    if registry_path is not None:
+        try:
+            registry = json.loads(registry_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+            raise click.ClickException(
+                f"Cannot read adapter registry: {registry_path}"
+            ) from exc
+        adapters = registry.get("adapters", {})
+        if name_or_path in adapters:
+            entry = adapters[name_or_path]
+            if not isinstance(entry, dict):
+                raise click.ClickException(
+                    f"Invalid registry entry for adapter '{name_or_path}'"
+                )
+            relative_path = entry.get("path")
+            adapter_path = (
+                Path(__file__).parent.parent.parent / relative_path
+                if isinstance(relative_path, str)
+                else None
+            )
+            if adapter_path is not None and adapter_path.is_dir():
+                return str(adapter_path)
+            # Try HF download
+            hf_repo = entry.get("hf_repo")
+            if hf_repo:
+                try:
+                    from huggingface_hub import snapshot_download
+                    return snapshot_download(
+                        hf_repo,
+                        allow_patterns=["adapter_config.json", "adapters.safetensors"],
+                    )
+                except Exception as exc:
+                    raise click.ClickException(
+                        f"Could not download adapter '{name_or_path}' from {hf_repo}: {exc}"
+                    ) from exc
+            raise click.ClickException(
+                f"Adapter '{name_or_path}' has no local files or download repository"
+            )
+
+    raise click.ClickException(
+        f"Unknown adapter or missing adapter directory: {name_or_path}"
+    )
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.version_option(version=__version__, prog_name="unlimited-ocr")
+def main(ctx):
+    """Unlimited-OCR MLX — One-shot document parsing on Apple Silicon.
+
+    Run OCR on images, PDFs, or entire directories using the Unlimited-OCR
+    vision-language model optimized for MLX (MX FP8 quantized, ~3.6 GB).
+
+    \b
+    Examples:
+      unlimited-ocr run image.jpg
+      unlimited-ocr run document.pdf --format markdown -o output.md
+      unlimited-ocr run ./scans/ --format json --preprocess -o results/
+      unlimited-ocr run image.jpg --grounding --format json
+    """
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@main.command()
+@click.argument("input_path", type=click.Path(exists=True))
+@click.option("-o", "--output", "output_path", type=click.Path(), default=None,
+              help="Output file or directory path.")
+@click.option("-f", "--format", "fmt", type=click.Choice(["text", "markdown", "json", "structured"]),
+              default="text", help="Output format.")
+@click.option("-t", "--task", type=click.Choice([
+    "document", "markdown", "figure", "free", "multi_page",
+]),
+              default="document", help="OCR task type.")
+@click.option("-p", "--profile", type=click.Choice(PROFILE_NAMES),
+              default="accurate", help="Generation profile.")
+@click.option("--grounding", is_flag=True, default=False,
+              help="Enable bounding box detection.")
+@click.option("--preprocess", is_flag=True, default=False,
+              help="Enable image preprocessing.")
+@click.option("--preprocess-mode", type=click.Choice(PREPROCESS_MODES),
+              default="document", help="Preprocessing mode.")
+@click.option("--dpi", type=click.IntRange(min=1), default=DEFAULT_PDF_DPI,
+              show_default=True,
+              help="DPI for PDF rendering (150 is usually enough; model input is 1024px).")
+@click.option("--max-tokens", type=click.IntRange(min=1), default=None,
+              help="Maximum tokens per page (overrides profile default).")
+@click.option("--model-path", type=str, default=DEFAULT_MODEL,
+              help="Model path (HF repo ID or local directory).")
+@click.option("--verbose", is_flag=True, default=False,
+              help="Enable verbose output.")
+@click.option("--stream", is_flag=True, default=False,
+              help="Stream output token-by-token (single image only).")
+@click.option("--jobs", type=click.IntRange(min=1), default=1,
+              help="Parallel preprocessing workers for batch mode.")
+@click.option("--adapter", type=str, default=None,
+              help="LoRA adapter name or path (e.g. 'table' or 'adapters/table-v1').")
+def run(input_path, output_path, fmt, task, profile, grounding, preprocess,
+        preprocess_mode, dpi, max_tokens, model_path, verbose, stream, jobs, adapter):
+    """Run OCR on an image, PDF, or directory of images.
+
+    INPUT_PATH can be an image file, a PDF file, or a directory of images.
+    """
+    from unlimited_ocr.pipeline import OCRPipeline
+
+    input_path = Path(input_path)
+
+    if stream:
+        if input_path.is_dir():
+            raise click.UsageError("--stream only supports a single image")
+        if output_path is not None:
+            raise click.UsageError("--stream writes to stdout and cannot be used with --output")
+        if fmt != "text":
+            raise click.UsageError("--stream only supports --format text")
+        if input_path.suffix.lower() == ".pdf":
+            raise click.UsageError("--stream does not support PDF files")
+        if jobs != 1:
+            raise click.UsageError("--jobs only applies to directory batch processing")
+    elif not input_path.is_dir() and jobs != 1:
+        raise click.UsageError("--jobs only applies to directory batch processing")
+
+    if verbose:
+        status_console.print(f"[bold]Unlimited-OCR MLX[/] v{__version__}")
+        status_console.print(f"[dim]Model:[/] {model_path}")
+        status_console.print(f"[dim]Input:[/] {input_path}")
+        status_console.print(f"[dim]Profile:[/] {profile} | Format: {fmt} | Task: {task}")
+        if preprocess:
+            status_console.print(f"[dim]Preprocessing:[/] {preprocess_mode}")
+        if adapter:
+            status_console.print(f"[dim]Adapter:[/] {adapter}")
+        status_console.print()
+
+    pipeline = None
+    try:
+        # Resolve adapter path from registry if name given
+        adapter_path = _resolve_adapter(adapter) if adapter else None
+
+        pipeline = OCRPipeline(
+            model_path=model_path,
+            verbose=verbose,
+            preprocess=preprocess,
+            preprocess_mode=preprocess_mode,
+            profile=profile,
+            adapter_path=adapter_path,
+        )
+        if input_path.is_dir():
+            # Batch mode
+            _run_batch(pipeline, input_path, output_path, fmt, task,
+                       grounding, max_tokens, profile, jobs)
+        elif stream:
+            # Streaming mode (single file, stdout only)
+            _run_stream(pipeline, input_path, task, grounding, dpi, max_tokens, profile)
+        else:
+            # Single file mode (image or PDF)
+            _run_single(pipeline, input_path, output_path, fmt, task,
+                        grounding, dpi, max_tokens, profile)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        if verbose:
+            raise
+        raise click.ClickException(str(exc)) from exc
+    finally:
+        if pipeline is not None:
+            pipeline.cleanup()
+
+
+def _run_stream(pipeline, input_path, task, grounding, dpi, max_tokens, profile):
+    """Handle streaming output for a single file."""
+    import sys
+    for chunk, result in pipeline.run_stream(
+        input_path=input_path,
+        task=task,
+        grounding=grounding,
+        dpi=dpi,
+        max_tokens=max_tokens,
+        profile=profile,
+    ):
+        if result is None:
+            sys.stdout.write(chunk)
+            sys.stdout.flush()
+        else:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+
+
+def _run_single(pipeline, input_path, output_path, fmt, task, grounding, dpi, max_tokens, profile):
+    """Handle single file (image or PDF) processing."""
+    result = pipeline.run(
+        input_path=input_path,
+        task=task,
+        format=fmt,
+        grounding=grounding,
+        dpi=dpi,
+        max_tokens=max_tokens,
+        output_path=output_path,
+        profile=profile,
+    )
+
+    if output_path:
+        status_console.print(f"[green]Result saved to:[/] {output_path}")
+    else:
+        # Print to stdout
+        click.echo(result)
+
+
+def _run_batch(pipeline, input_dir, output_path, fmt, task, grounding, max_tokens, profile, jobs=1):
+    """Handle batch directory processing."""
+    results = pipeline.run_batch(
+        input_dir=input_dir,
+        task=task,
+        format=fmt,
+        grounding=grounding,
+        max_tokens=max_tokens,
+        output_dir=output_path,
+        show_progress=True,
+        profile=profile,
+        raise_on_error=True,
+        jobs=jobs,
+    )
+
+    if output_path:
+        status_console.print(f"\n[green]Processed {len(results)} file(s) → {output_path}[/]")
+    elif fmt in {"json", "structured"}:
+        import json
+
+        click.echo(json.dumps(
+            {filename: json.loads(output) for filename, output in results.items()},
+            indent=2,
+            ensure_ascii=False,
+        ))
+    else:
+        # Print all results to stdout
+        for filename, text in results.items():
+            click.echo(f"\n═══ {filename} ═══\n")
+            click.echo(text)
+
+
+@main.command()
+@click.argument("pdf_path", type=click.Path(exists=True))
+def info(pdf_path):
+    """Show information about a PDF file (page count, sizes, metadata)."""
+    from unlimited_ocr.pdf import get_pdf_info
+
+    try:
+        pdf_info = get_pdf_info(pdf_path)
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+    console.print(f"[bold]PDF Info:[/] {pdf_path}")
+    console.print(f"  Pages: {pdf_info['num_pages']}")
+
+    if pdf_info["page_sizes"]:
+        first = pdf_info["page_sizes"][0]
+        console.print(f"  Page size: {first['width']:.0f} × {first['height']:.0f} pts")
+
+    meta = pdf_info.get("metadata", {})
+    if meta.get("title"):
+        console.print(f"  Title: {meta['title']}")
+    if meta.get("author"):
+        console.print(f"  Author: {meta['author']}")
+
+
+@main.command()
+def models():
+    """Show available model information."""
+    console.print("[bold]Available Models:[/]\n")
+    console.print(f"  [green]•[/] {DEFAULT_MODEL}")
+    console.print("    MX FP8 quantized (~3.6 GB) — recommended for Apple Silicon")
+    console.print()
+    console.print("[dim]Use --model-path to specify a different model.[/]")
+
+
+@main.command()
+def profiles():
+    """Show available generation profiles."""
+    from unlimited_ocr.profiles import list_profiles
+
+    console.print("[bold]Generation Profiles:[/]\n")
+    for p in list_profiles():
+        console.print(f"  [green]•[/] [bold]{p['name']}[/]")
+        console.print(f"    {p['description']}")
+        console.print(f"    [dim]max_tokens={p['max_tokens']}, temp={p['temperature']}, "
+                      f"ngram={p['no_repeat_ngram_size']}[/]")
+        console.print()
+
+
+@main.command()
+@click.option("--host", type=str, default="127.0.0.1", show_default=True,
+              help="Bind host. Use 0.0.0.0 only to expose the API on your network.")
+@click.option("--port", type=click.IntRange(1, 65535), default=8000,
+              show_default=True, help="Bind port.")
+@click.option("--model-path", type=str, default=DEFAULT_MODEL,
+              help="Model path (HF repo ID or local directory).")
+@click.option("--verbose", is_flag=True, default=False,
+              help="Enable verbose output.")
+def serve(host, port, model_path, verbose):
+    """Start the HTTP API server.
+
+    Requires: pip install unlimited-ocr[server]
+
+    \b
+    Endpoints:
+      POST /ocr         — Run OCR on uploaded image/PDF
+      POST /ocr/stream  — SSE streaming OCR
+      GET  /health      — Model status
+    """
+    try:
+        from unlimited_ocr.server import run_server
+    except ImportError as exc:
+        raise click.ClickException(
+            "Server dependencies not installed. Run: pip install unlimited-ocr[server]"
+        ) from exc
+
+    console.print(f"[bold]Starting Unlimited-OCR server[/] on {host}:{port}")
+    console.print(f"[dim]Model:[/] {model_path}")
+    console.print("[dim]Endpoints:[/] POST /ocr, POST /ocr/stream, GET /health")
+    console.print()
+
+    if not host.strip():
+        raise click.UsageError("--host must not be empty")
+    try:
+        run_server(host=host, port=port, model_path=model_path, verbose=verbose)
+    except Exception as exc:
+        if verbose:
+            raise
+        raise click.ClickException(str(exc)) from exc
+
+
+if __name__ == "__main__":
+    main()

src/unlimited_ocr/engine.py

@@ -0,0 +1,566 @@
+"""Core MLX-VLM inference engine for Unlimited-OCR."""
+
+from __future__ import annotations
+
+import re
+import time
+import math
+from numbers import Real
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+from PIL import Image
+from rich.console import Console
+
+from unlimited_ocr.profiles import GenerationProfile, get_profile
+
+console = Console(stderr=True)
+
+# Paths for disk images; PIL for in-memory preprocessed / PDF-rendered pages.
+ImageInput = Union[str, Path, Image.Image]
+
+DEFAULT_MODEL = "AutomatosX/AX-Unlimited-OCR-3B-MoE-MLX-MXFP8"
+
+# Prompt templates following DeepSeek-OCR / Unlimited-OCR vocabulary
+PROMPTS = {
+    "document": "<image>document parsing.",
+    "markdown": "<image>Convert the document to markdown.",
+    "figure": "<image>Parse the figure.",
+    "free": "<image>Free OCR.",
+    "multi_page": "<image>Multi page parsing.",
+}
+
+GROUNDING_PREFIX = "<|grounding|>"
+
+
+@dataclass
+class OCRResult:
+    """Result from a single OCR inference."""
+
+    text: str
+    prompt_used: str
+    image_path: str
+    tokens_generated: int = 0
+    grounding: bool = False
+    bboxes: list[dict] = field(default_factory=list)
+    # Metadata
+    elapsed_seconds: float = 0.0
+    profile_name: str = "accurate"
+    model_path: str = DEFAULT_MODEL
+    preprocessing_applied: list[str] = field(default_factory=list)
+    generation_tps: float = 0.0
+    peak_memory_gb: float = 0.0
+
+    def __post_init__(self):
+        if self.grounding and self.text and not self.bboxes:
+            self.bboxes = parse_grounding(self.text)
+
+    def metadata(self) -> dict:
+        """Return inference metadata as a dict."""
+        return {
+            "model": self.model_path,
+            "profile": self.profile_name,
+            "preprocessing": self.preprocessing_applied,
+            "output_tokens": self.tokens_generated,
+            "elapsed_seconds": round(self.elapsed_seconds, 2),
+            "generation_tps": round(self.generation_tps, 1),
+            "peak_memory_gb": round(self.peak_memory_gb, 2),
+            "grounding": self.grounding,
+        }
+
+
+@dataclass
+class EngineConfig:
+    """Configuration for the OCR engine."""
+
+    model_path: str = DEFAULT_MODEL
+    # ``None`` means to use the selected profile. Explicit values are
+    # constructor-level overrides that apply to every inference call.
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    verbose: bool = False
+    profile: Optional[str] = "accurate"
+    # No-repeat ngram suppression (ported from upstream)
+    no_repeat_ngram_size: Optional[int] = None
+    ngram_window: int = 128
+    # LoRA adapter path (None = no adapter)
+    adapter_path: Optional[str] = None
+
+    def get_generation_profile(self) -> GenerationProfile:
+        """Resolve the active generation profile."""
+        return get_profile(self.profile)
+
+
+def parse_grounding(text: str) -> list[dict]:
+    """Parse bounding boxes from grounding output.
+
+    Unlimited-OCR grounding format (after token decoding):
+        <|det|>label [x1, y1, x2, y2]<|/det|>content
+    The sentencepiece space token (U+0120 / Ġ) may appear as separator.
+    Coordinates are in 0-1000 normalized space.
+    The first detection block may lack an opening <|det|> tag.
+    Blocks are separated by Ċ (newline token).
+    """
+    # Normalize tokenizer-visible whitespace markers.
+    normalized = text.replace("\u0120", " ").replace("Ċ", "\n")
+    number = r"-?\d+(?:\.\d+)?"
+    coordinate_pattern = re.compile(
+        rf"\[\s*({number})\s*,\s*({number})\s*,\s*"
+        rf"({number})\s*,\s*({number})\s*\]"
+    )
+
+    def coordinate_from_match(match: re.Match) -> list[int | float]:
+        values = [float(match.group(i)) for i in range(1, 5)]
+        return [int(value) if value.is_integer() else value for value in values]
+
+    parsed: list[tuple[int, dict]] = []
+
+    # Upstream also emits the older ref/det form, whose det span can contain
+    # one box or a list of boxes.
+    ref_pattern = re.compile(
+        r"<\|ref\|>(.*?)<\|/ref\|>\s*<\|det\|>(.*?)<\|/det\|>",
+        re.DOTALL,
+    )
+    ref_spans: list[tuple[int, int]] = []
+    for match in ref_pattern.finditer(normalized):
+        ref_spans.append(match.span())
+        for coordinate_match in coordinate_pattern.finditer(match.group(2)):
+            parsed.append((match.start(), {
+                "label": match.group(1).strip(),
+                "bbox": coordinate_from_match(coordinate_match),
+                "text": "",
+            }))
+
+    # Current direct form. The first block may omit its opening det token.
+    direct_pattern = re.compile(
+        rf"(?:^|<\|det\|>)([^\[\n<]*?)\s*"
+        rf"({coordinate_pattern.pattern})\s*<\|/det\|>"
+        r"([^\n<]*)",
+        re.MULTILINE,
+    )
+    for match in direct_pattern.finditer(normalized):
+        if any(start <= match.start() < end for start, end in ref_spans):
+            continue
+        coordinate_match = coordinate_pattern.search(match.group(2))
+        if coordinate_match is None:
+            continue
+        parsed.append((match.start(), {
+            "label": match.group(1).strip(),
+            "bbox": coordinate_from_match(coordinate_match),
+            "text": match.group(7).strip(),
+        }))
+
+    parsed.sort(key=lambda item: item[0])
+    return [item for _, item in parsed]
+
+
+class SlidingWindowNoRepeatNGramProcessor:
+    """Block repeated n-grams within a bounded recent-token window.
+
+    ``mlx-vlm`` accepts custom logits processors but does not expose a native
+    no-repeat-n-gram option. This mirrors Unlimited-OCR's upstream safeguard
+    without importing MLX at module import time.
+    """
+
+    def __init__(self, ngram_size: int, window_size: int):
+        if not isinstance(ngram_size, int) or isinstance(ngram_size, bool) or ngram_size < 1:
+            raise ValueError("ngram_size must be a positive integer")
+        if not isinstance(window_size, int) or isinstance(window_size, bool) or window_size < 1:
+            raise ValueError("window_size must be a positive integer")
+        if window_size < ngram_size:
+            raise ValueError("window_size must be at least as large as ngram_size")
+        self.ngram_size = ngram_size
+        self.window_size = window_size
+
+    def __call__(self, tokens, logits):
+        sequence = tokens.tolist() if hasattr(tokens, "tolist") else list(tokens)
+        if sequence and isinstance(sequence[0], list):
+            sequence = sequence[0]
+        if len(sequence) < self.ngram_size:
+            return logits
+
+        prefix_length = self.ngram_size - 1
+        current_prefix = tuple(sequence[-prefix_length:]) if prefix_length else ()
+        search_start = max(0, len(sequence) - self.window_size)
+        search_end = len(sequence) - self.ngram_size + 1
+        banned: set[int] = set()
+        for index in range(search_start, search_end):
+            ngram = sequence[index:index + self.ngram_size]
+            if not prefix_length or tuple(ngram[:-1]) == current_prefix:
+                banned.add(ngram[-1])
+
+        if banned:
+            logits[:, list(banned)] = float("-inf")
+        return logits
+
+
+class OCREngine:
+    """Core inference engine wrapping mlx-vlm for Unlimited-OCR.
+
+    Uses lazy loading — the model is loaded on first inference call.
+    """
+
+    def __init__(self, config: Optional[EngineConfig] = None):
+        self.config = config or EngineConfig()
+        self._model = None
+        self._processor = None
+
+    @property
+    def model(self):
+        """Lazy-load the MLX model."""
+        if self._model is None:
+            self._load_model()
+        return self._model
+
+    @property
+    def processor(self):
+        """Lazy-load the processor."""
+        if self._processor is None:
+            self._load_model()
+        return self._processor
+
+    def _load_model(self):
+        """Load model and processor from mlx-vlm."""
+        from mlx_vlm import load
+
+        if self.config.verbose:
+            console.print(f"[bold blue]Loading model:[/] {self.config.model_path}")
+
+        load_kwargs = {}
+        if self.config.adapter_path is not None:
+            if not isinstance(self.config.adapter_path, str) or not self.config.adapter_path:
+                raise ValueError("adapter_path must be a non-empty string or None")
+            # mlx-vlm applies adapters to the nested language model correctly;
+            # mlx-lm's helper alone can target the wrong module tree for VLMs.
+            load_kwargs["adapter_path"] = self.config.adapter_path
+        self._model, self._processor = load(self.config.model_path, **load_kwargs)
+
+        if self.config.verbose:
+            console.print("[bold green]Model loaded successfully.[/]")
+
+    def build_prompt(
+        self,
+        task: str = "document",
+        grounding: bool = False,
+        custom_prompt: Optional[str] = None,
+    ) -> str:
+        """Build the prompt string for inference.
+
+        Args:
+            task: One of 'document', 'markdown', 'figure', 'free', 'multi_page'.
+            grounding: If True, prefix with grounding token for bounding boxes.
+            custom_prompt: Override with a fully custom prompt (must contain <image>).
+        """
+        if custom_prompt is not None:
+            if not isinstance(custom_prompt, str):
+                raise TypeError("custom_prompt must be a string")
+            image_count = custom_prompt.count("<image>")
+            if image_count != 1:
+                raise ValueError(
+                    "custom_prompt must contain exactly one literal '<image>' token"
+                )
+            prompt = custom_prompt
+        else:
+            if task not in PROMPTS:
+                available = ", ".join(PROMPTS)
+                raise ValueError(f"Unknown task '{task}'. Available: {available}")
+            prompt = PROMPTS[task]
+
+        wants_grounding = grounding or GROUNDING_PREFIX in prompt
+        if wants_grounding:
+            # Upstream DeepSeek/Unlimited-OCR places grounding after the image
+            # marker: ``<image>\n<|grounding|>task``. Normalize misplaced or
+            # duplicate copies in custom prompts to that trained format.
+            prompt = prompt.replace(GROUNDING_PREFIX, "")
+            before, after = prompt.split("<image>", 1)
+            after = after.lstrip("\r\n")
+            prompt = f"{before}<image>\n{GROUNDING_PREFIX}{after}"
+
+        return prompt
+
+    def _validate_generation_settings(
+        self,
+        tokens: int,
+        temperature: float,
+        ngram_size: int,
+    ) -> None:
+        """Validate resolved decoding settings before importing MLX."""
+        if not isinstance(tokens, int) or isinstance(tokens, bool) or tokens < 1:
+            raise ValueError("max_tokens must be a positive integer")
+        if (
+            not isinstance(temperature, Real)
+            or isinstance(temperature, bool)
+            or not math.isfinite(float(temperature))
+            or temperature < 0
+        ):
+            raise ValueError("temperature must be non-negative and finite")
+        if (
+            not isinstance(ngram_size, int)
+            or isinstance(ngram_size, bool)
+            or ngram_size < 0
+        ):
+            raise ValueError("no_repeat_ngram_size must be a non-negative integer")
+        if (
+            not isinstance(self.config.ngram_window, int)
+            or isinstance(self.config.ngram_window, bool)
+            or self.config.ngram_window < 1
+        ):
+            raise ValueError("ngram_window must be a positive integer")
+        if ngram_size > self.config.ngram_window:
+            raise ValueError(
+                "ngram_window must be at least as large as no_repeat_ngram_size"
+            )
+
+    @staticmethod
+    def _resolve_image_input(image: ImageInput) -> tuple[Image.Image | str, str]:
+        """Normalize image input for mlx-vlm and metadata.
+
+        Returns:
+            (payload for mlx-vlm, path label for OCRResult.image_path)
+        """
+        if isinstance(image, Image.Image):
+            # Copy so callers can free their original buffer independently.
+            return image.copy(), "<in-memory>"
+        if isinstance(image, (str, Path)):
+            path = str(image)
+            return path, path
+        raise TypeError(
+            f"image must be a path or PIL.Image, got {type(image).__name__}"
+        )
+
+    def _resolve_generation(
+        self,
+        task: str,
+        grounding: bool,
+        custom_prompt: Optional[str],
+        max_tokens: Optional[int],
+        profile: Optional[str],
+    ) -> tuple[str, bool, GenerationProfile, dict]:
+        """Build prompt and generation kwargs shared by infer / infer_stream."""
+        prompt = self.build_prompt(task=task, grounding=grounding, custom_prompt=custom_prompt)
+        effective_grounding = grounding or GROUNDING_PREFIX in prompt
+
+        selected_profile = profile if profile is not None else self.config.profile
+        gen_profile = get_profile(selected_profile)
+        if max_tokens is not None:
+            tokens = max_tokens
+        elif self.config.max_tokens is not None:
+            tokens = self.config.max_tokens
+        else:
+            tokens = gen_profile.max_tokens
+        temperature = (
+            self.config.temperature
+            if self.config.temperature is not None
+            else gen_profile.temperature
+        )
+        ngram_size = (
+            self.config.no_repeat_ngram_size
+            if self.config.no_repeat_ngram_size is not None
+            else gen_profile.no_repeat_ngram_size
+        )
+        self._validate_generation_settings(tokens, temperature, ngram_size)
+
+        gen_kwargs = {
+            "max_tokens": tokens,
+            "temperature": temperature,
+            "top_p": gen_profile.top_p,
+            "verbose": self.config.verbose,
+        }
+        if gen_profile.repetition_penalty > 1.0:
+            gen_kwargs["repetition_penalty"] = gen_profile.repetition_penalty
+        if ngram_size > 0:
+            gen_kwargs["logits_processors"] = [
+                SlidingWindowNoRepeatNGramProcessor(ngram_size, self.config.ngram_window)
+            ]
+        return prompt, effective_grounding, gen_profile, gen_kwargs
+
+    def infer(
+        self,
+        image_path: ImageInput,
+        task: str = "document",
+        grounding: bool = False,
+        custom_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        profile: Optional[str] = None,
+        preprocessing_applied: Optional[list[str]] = None,
+    ) -> OCRResult:
+        """Run OCR inference on a single image.
+
+        Args:
+            image_path: Path to the image file, or an in-memory PIL Image.
+            task: OCR task type (document, markdown, figure, free, multi_page).
+            grounding: Enable bounding box output.
+            custom_prompt: Custom prompt override.
+            max_tokens: Override max tokens for this inference.
+            profile: Override generation profile for this call.
+            preprocessing_applied: List of preprocessing steps applied to the image.
+
+        Returns:
+            OCRResult with extracted text and metadata.
+        """
+        image_payload, image_label = self._resolve_image_input(image_path)
+        prompt, effective_grounding, gen_profile, gen_kwargs = self._resolve_generation(
+            task, grounding, custom_prompt, max_tokens, profile
+        )
+
+        if self.config.verbose:
+            console.print(f"[dim]Profile:[/] {gen_profile.name} | [dim]Max tokens:[/] {gen_kwargs['max_tokens']}")
+            console.print(f"[dim]Prompt:[/] {prompt}")
+            console.print(f"[dim]Image:[/] {image_label}")
+
+        # Import only after validation so invalid calls do not initialize Metal.
+        from mlx_vlm import generate
+
+        # Resolve lazy model loading before starting the per-inference timer.
+        model = self.model
+        processor = self.processor
+        start_time = time.perf_counter()
+
+        response = generate(
+            model,
+            processor,
+            prompt=prompt,
+            image=[image_payload],
+            **gen_kwargs,
+        )
+
+        elapsed = time.perf_counter() - start_time
+
+        # mlx-vlm generate returns a GenerationResult object
+        if isinstance(response, str):
+            text = response
+            num_tokens = 0
+            gen_tps = 0.0
+            peak_mem = 0.0
+        elif hasattr(response, "text"):
+            text = response.text
+            num_tokens = getattr(
+                response,
+                "generation_tokens",
+                getattr(response, "tokens_generated", 0),
+            ) or 0
+            gen_tps = getattr(response, "generation_tps", 0.0) or 0.0
+            peak_mem = getattr(response, "peak_memory", 0.0) or 0.0
+        else:
+            raise TypeError(
+                "mlx-vlm returned an unsupported generation response "
+                f"({type(response).__name__})"
+            )
+
+        if not isinstance(text, str):
+            raise TypeError("mlx-vlm returned a non-string text field")
+
+        return OCRResult(
+            text=text,
+            prompt_used=prompt,
+            image_path=image_label,
+            tokens_generated=num_tokens,
+            grounding=effective_grounding,
+            elapsed_seconds=elapsed,
+            profile_name=gen_profile.name,
+            model_path=self.config.model_path,
+            preprocessing_applied=list(preprocessing_applied or []),
+            generation_tps=gen_tps,
+            peak_memory_gb=peak_mem,
+        )
+
+    def infer_stream(
+        self,
+        image_path: ImageInput,
+        task: str = "document",
+        grounding: bool = False,
+        custom_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        profile: Optional[str] = None,
+        preprocessing_applied: Optional[list[str]] = None,
+    ):
+        """Run OCR inference with token-by-token streaming.
+
+        Yields (chunk_text, is_final) tuples. The final yield contains
+        the complete OCRResult as the second element.
+
+        Usage:
+            for chunk, result in engine.infer_stream(image):
+                print(chunk, end="")  # incremental text
+                if result is not None:
+                    # result is the final OCRResult
+                    pass
+        """
+        image_payload, image_label = self._resolve_image_input(image_path)
+        prompt, effective_grounding, gen_profile, gen_kwargs = self._resolve_generation(
+            task, grounding, custom_prompt, max_tokens, profile
+        )
+        # Streaming should not print token noise to the console.
+        gen_kwargs["verbose"] = False
+
+        import mlx_vlm
+
+        model = self.model
+        processor = self.processor
+        start_time = time.perf_counter()
+
+        full_text = ""
+        num_tokens = 0
+        gen_tps = 0.0
+        peak_mem = 0.0
+
+        for response in mlx_vlm.stream_generate(
+            model,
+            processor,
+            prompt=prompt,
+            image=[image_payload],
+            **gen_kwargs,
+        ):
+            if isinstance(response, str):
+                chunk = response
+            elif hasattr(response, "text"):
+                chunk = response.text
+            else:
+                raise TypeError(
+                    "mlx-vlm returned an unsupported stream response "
+                    f"({type(response).__name__})"
+                )
+            if not isinstance(chunk, str):
+                raise TypeError("mlx-vlm returned a non-string stream chunk")
+            # mlx-vlm's stream contract yields only the detokenizer's latest
+            # segment. Treating a chunk as cumulative when it happens to share
+            # a prefix with prior output loses repeated text (for example two
+            # consecutive identical tokens).
+            full_text += chunk
+            if chunk:
+                yield chunk, None
+
+            # Capture final stats from last response
+            if hasattr(response, "generation_tokens"):
+                num_tokens = response.generation_tokens or 0
+            if hasattr(response, "generation_tps"):
+                gen_tps = response.generation_tps or 0.0
+            if hasattr(response, "peak_memory"):
+                peak_mem = response.peak_memory or 0.0
+
+        elapsed = time.perf_counter() - start_time
+
+        result = OCRResult(
+            text=full_text,
+            prompt_used=prompt,
+            image_path=image_label,
+            tokens_generated=num_tokens,
+            grounding=effective_grounding,
+            elapsed_seconds=elapsed,
+            profile_name=gen_profile.name,
+            model_path=self.config.model_path,
+            preprocessing_applied=list(preprocessing_applied or []),
+            generation_tps=gen_tps,
+            peak_memory_gb=peak_mem,
+        )
+        yield "", result
+
+    def is_loaded(self) -> bool:
+        """Check if the model is currently loaded."""
+        return self._model is not None
+
+    def unload(self):
+        """Release model from memory."""
+        self._model = None
+        self._processor = None

src/unlimited_ocr/output.py

@@ -0,0 +1,492 @@
+"""Output formatters for OCR results (text, markdown, JSON, structured)."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Optional
+
+from unlimited_ocr.engine import OCRResult
+
+
+@dataclass
+class PageResult:
+    """OCR result for a single page/image."""
+
+    page_number: int
+    image_path: str
+    text: str
+    bboxes: list[dict] = field(default_factory=list)
+    tokens_generated: int = 0
+    generation_tps: float = 0.0
+    peak_memory_gb: float = 0.0
+
+
+@dataclass
+class DocumentResult:
+    """Aggregated OCR result for a full document (multi-page)."""
+
+    source: str
+    pages: list[PageResult] = field(default_factory=list)
+    grounding: bool = False
+    format: str = "text"
+    timestamp: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    # Inference metadata
+    model_path: str = ""
+    profile_name: str = "accurate"
+    preprocessing_applied: list[str] = field(default_factory=list)
+    total_elapsed_seconds: float = 0.0
+
+    @property
+    def full_text(self) -> str:
+        """Concatenated text from all pages."""
+        return "\n\n".join(p.text for p in self.pages)
+
+    @property
+    def num_pages(self) -> int:
+        return len(self.pages)
+
+    @classmethod
+    def from_ocr_results(
+        cls,
+        results: list[OCRResult],
+        source: str,
+        grounding: bool = False,
+    ) -> "DocumentResult":
+        """Create a DocumentResult from a list of OCRResult objects."""
+        pages = [
+            PageResult(
+                page_number=i + 1,
+                image_path=r.image_path,
+                text=r.text,
+                bboxes=r.bboxes,
+                tokens_generated=r.tokens_generated,
+                generation_tps=r.generation_tps,
+                peak_memory_gb=r.peak_memory_gb,
+            )
+            for i, r in enumerate(results)
+        ]
+        # Aggregate metadata from all pages. Auto preprocessing can choose
+        # different steps for different images.
+        model_path = results[0].model_path if results else ""
+        profile_name = results[0].profile_name if results else "accurate"
+        preprocessing = list(dict.fromkeys(
+            step
+            for result in results
+            for step in result.preprocessing_applied
+        ))
+        total_elapsed = sum(r.elapsed_seconds for r in results)
+
+        return cls(
+            source=source,
+            pages=pages,
+            grounding=grounding or any(result.grounding for result in results),
+            model_path=model_path, profile_name=profile_name,
+            preprocessing_applied=preprocessing,
+            total_elapsed_seconds=total_elapsed,
+        )
+
+
+def format_text(result: DocumentResult) -> str:
+    """Format as plain text with page separators."""
+    if result.num_pages == 1:
+        return result.pages[0].text
+
+    parts = []
+    for page in result.pages:
+        parts.append(f"--- Page {page.page_number} ---\n\n{page.text}")
+    return "\n\n".join(parts)
+
+
+def format_markdown(result: DocumentResult) -> str:
+    """Format as Markdown with page headings."""
+    parts = []
+    source_name = Path(result.source).stem
+
+    if result.num_pages > 1:
+        parts.append(f"# {source_name}\n")
+
+    for page in result.pages:
+        if result.num_pages > 1:
+            parts.append(f"## Page {page.page_number}\n")
+        parts.append(page.text)
+
+    return "\n".join(parts)
+
+
+def format_json(result: DocumentResult, indent: int = 2) -> str:
+    """Format as structured JSON with metadata and optional bounding boxes."""
+    output = {
+        "source": result.source,
+        "num_pages": result.num_pages,
+        "grounding": result.grounding,
+        "timestamp": result.timestamp,
+        "metadata": {
+            "model": result.model_path,
+            "profile": result.profile_name,
+            "preprocessing": result.preprocessing_applied,
+            "total_elapsed_seconds": round(result.total_elapsed_seconds, 2),
+        },
+        "pages": [],
+    }
+
+    for page in result.pages:
+        page_data = {
+            "page_number": page.page_number,
+            "image_path": page.image_path,
+            "text": page.text,
+            "tokens_generated": page.tokens_generated,
+            "generation_tps": round(page.generation_tps, 1),
+            "peak_memory_gb": round(page.peak_memory_gb, 2),
+        }
+        if result.grounding and page.bboxes:
+            page_data["bounding_boxes"] = page.bboxes
+        output["pages"].append(page_data)
+
+    return json.dumps(output, indent=indent, ensure_ascii=False)
+
+
+@dataclass
+class TextBlock:
+    """A block of plain text content."""
+
+    text: str
+    block_type: str = "paragraph"  # paragraph, heading, list_item, caption
+    order: int = 0
+    bbox: Optional[list] = None
+
+
+@dataclass
+class TableBlock:
+    """A parsed table extracted from OCR output."""
+
+    html: str
+    rows: list[list[str]] = field(default_factory=list)
+    order: int = 0
+    bbox: Optional[list] = None
+
+    @property
+    def num_rows(self) -> int:
+        return len(self.rows)
+
+    @property
+    def num_cols(self) -> int:
+        return max((len(r) for r in self.rows), default=0)
+
+    def to_csv(self, delimiter: str = ",") -> str:
+        """Convert table to CSV string."""
+        import csv
+        import io
+        buf = io.StringIO()
+        writer = csv.writer(buf, delimiter=delimiter)
+        for row in self.rows:
+            writer.writerow(row)
+        return buf.getvalue()
+
+
+@dataclass
+class StructuredPage:
+    """Structured representation of a page with separated content types."""
+
+    page_number: int
+    text_blocks: list[TextBlock] = field(default_factory=list)
+    tables: list[TableBlock] = field(default_factory=list)
+    raw_text: str = ""
+    reading_order: list[dict] = field(default_factory=list)
+
+    @property
+    def plain_text(self) -> str:
+        """Reconstruct plain text in reading order."""
+        parts = []
+        for item in sorted(
+            [(b.order, b.text) for b in self.text_blocks]
+            + [(t.order, t.html) for t in self.tables],
+            key=lambda x: x[0],
+        ):
+            parts.append(item[1])
+        return "\n\n".join(parts) if parts else self.raw_text
+
+
+def parse_tables_from_text(text: str) -> tuple[list[TextBlock], list[TableBlock]]:
+    """Parse OCR text into text blocks and table blocks.
+
+    Detects HTML <table>...</table> regions and separates them from
+    surrounding text content.
+    """
+    text_blocks: list[TextBlock] = []
+    table_blocks: list[TableBlock] = []
+    order = 0
+
+    def add_text_blocks(value: str) -> None:
+        nonlocal order
+        for block_text in re.split(r"\n\s*\n", value):
+            block_text = block_text.strip()
+            if block_text:
+                text_blocks.append(TextBlock(
+                    text=block_text,
+                    block_type=_classify_text_block(block_text),
+                    order=order,
+                ))
+                order += 1
+
+    cursor = 0
+    for start, end in _html_table_spans(text):
+        add_text_blocks(text[cursor:start])
+        table_html = text[start:end]
+        table_blocks.append(TableBlock(
+            html=table_html,
+            rows=_parse_html_table(table_html),
+            order=order,
+        ))
+        order += 1
+        cursor = end
+    add_text_blocks(text[cursor:])
+
+    return text_blocks, table_blocks
+
+
+def _html_table_spans(text: str) -> list[tuple[int, int]]:
+    """Locate balanced outer HTML table regions, including nested tables."""
+    tag_pattern = re.compile(r"</?table\b[^>]*>", re.IGNORECASE)
+    spans: list[tuple[int, int]] = []
+    depth = 0
+    start: Optional[int] = None
+    for match in tag_pattern.finditer(text):
+        closing = bool(re.match(r"<\s*/", match.group(0)))
+        if closing:
+            if depth == 0:
+                continue
+            depth -= 1
+            if depth == 0 and start is not None:
+                spans.append((start, match.end()))
+                start = None
+        else:
+            if depth == 0:
+                start = match.start()
+            depth += 1
+    return spans
+
+
+class _TableHTMLParser(HTMLParser):
+    """Extract first-level table rows and cells from forgiving HTML."""
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.table_depth = 0
+        self.rows: list[list[str]] = []
+        self._row: Optional[list[str]] = None
+        self._cell_parts: Optional[list[str]] = None
+
+    @staticmethod
+    def _clean_cell(parts: list[str]) -> str:
+        lines = [" ".join(line.split()) for line in "".join(parts).split("\n")]
+        return "\n".join(line for line in lines if line).strip()
+
+    def _finish_cell(self) -> None:
+        if self._cell_parts is None:
+            return
+        if self._row is None:
+            self._row = []
+        self._row.append(self._clean_cell(self._cell_parts))
+        self._cell_parts = None
+
+    def _finish_row(self) -> None:
+        self._finish_cell()
+        if self._row:
+            self.rows.append(self._row)
+        self._row = None
+
+    def handle_starttag(self, tag: str, attrs) -> None:
+        tag = tag.lower()
+        if tag == "table":
+            self.table_depth += 1
+            return
+        if self.table_depth != 1:
+            return
+        if tag == "tr":
+            self._finish_row()
+            self._row = []
+        elif tag in {"td", "th"}:
+            self._finish_cell()
+            if self._row is None:
+                self._row = []
+            self._cell_parts = []
+        elif tag == "br" and self._cell_parts is not None:
+            self._cell_parts.append("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        tag = tag.lower()
+        if tag == "table":
+            if self.table_depth == 1:
+                self._finish_row()
+            if self.table_depth > 0:
+                self.table_depth -= 1
+            return
+        if self.table_depth != 1:
+            return
+        if tag in {"td", "th"}:
+            self._finish_cell()
+        elif tag == "tr":
+            self._finish_row()
+
+    def handle_data(self, data: str) -> None:
+        if self.table_depth >= 1 and self._cell_parts is not None:
+            self._cell_parts.append(data)
+
+
+def _parse_html_table(html: str) -> list[list[str]]:
+    """Extract rows from an HTML table string."""
+    parser = _TableHTMLParser()
+    parser.feed(html)
+    parser.close()
+    parser._finish_row()
+    return parser.rows
+
+
+def _classify_text_block(text: str) -> str:
+    """Heuristically classify a text block type."""
+    lines = text.split("\n")
+    first_line = lines[0].strip()
+
+    # Markdown heading
+    if first_line.startswith("#"):
+        return "heading"
+    # List items
+    if all(
+        line.strip().startswith(("-", "•", "*")) or re.match(r"^\d+[.)]\s", line.strip())
+        for line in lines if line.strip()
+    ):
+        return "list_item"
+    # Short single line (likely caption or heading)
+    if len(lines) == 1 and len(first_line) < 80 and not first_line.endswith("."):
+        return "heading"
+    return "paragraph"
+
+
+def format_structured(result: DocumentResult, indent: int = 2) -> str:
+    """Format as structured JSON with separated text blocks and tables."""
+    output = {
+        "source": result.source,
+        "num_pages": result.num_pages,
+        "grounding": result.grounding,
+        "timestamp": result.timestamp,
+        "metadata": {
+            "model": result.model_path,
+            "profile": result.profile_name,
+            "preprocessing": result.preprocessing_applied,
+            "total_elapsed_seconds": round(result.total_elapsed_seconds, 2),
+        },
+        "pages": [],
+    }
+
+    for page in result.pages:
+        text_blocks, table_blocks = parse_tables_from_text(page.text)
+
+        page_data = {
+            "page_number": page.page_number,
+            "image_path": page.image_path,
+            "raw_text": page.text,
+            "tokens_generated": page.tokens_generated,
+            "generation_tps": round(page.generation_tps, 1),
+            "peak_memory_gb": round(page.peak_memory_gb, 2),
+            "text_blocks": [
+                {
+                    "type": b.block_type,
+                    "text": b.text,
+                    "order": b.order,
+                    **({"bbox": b.bbox} if b.bbox else {}),
+                }
+                for b in text_blocks
+            ],
+            "tables": [
+                {
+                    "html": t.html,
+                    "rows": t.rows,
+                    "num_rows": t.num_rows,
+                    "num_cols": t.num_cols,
+                    "order": t.order,
+                    **({"bbox": t.bbox} if t.bbox else {}),
+                }
+                for t in table_blocks
+            ],
+            "reading_order": sorted(
+                [
+                    {"kind": "text", "index": index, "order": block.order}
+                    for index, block in enumerate(text_blocks)
+                ]
+                + [
+                    {"kind": "table", "index": index, "order": table.order}
+                    for index, table in enumerate(table_blocks)
+                ],
+                key=lambda item: item["order"],
+            ),
+        }
+        if result.grounding and page.bboxes:
+            page_data["bounding_boxes"] = page.bboxes
+        output["pages"].append(page_data)
+
+    return json.dumps(output, indent=indent, ensure_ascii=False)
+
+
+def format_result(result: DocumentResult, fmt: str = "text") -> str:
+    """Format a DocumentResult in the specified format.
+
+    Args:
+        result: The document OCR result.
+        fmt: One of 'text', 'markdown', 'json', 'structured'.
+
+    Returns:
+        Formatted string output.
+    """
+    formatters = {
+        "text": format_text,
+        "markdown": format_markdown,
+        "json": format_json,
+        "structured": format_structured,
+    }
+
+    formatter = formatters.get(fmt)
+    if formatter is None:
+        raise ValueError(f"Unknown format '{fmt}'. Choose from: {list(formatters.keys())}")
+
+    return formatter(result)
+
+
+def save_result(
+    result: DocumentResult,
+    output_path: str | Path,
+    fmt: Optional[str] = None,
+) -> Path:
+    """Format and save a DocumentResult to a file.
+
+    Args:
+        result: The document OCR result.
+        output_path: Path to write the output file.
+        fmt: Output format. If None, inferred from file extension.
+
+    Returns:
+        Path to the saved file.
+    """
+    output_path = Path(output_path)
+
+    if fmt is None:
+        ext = output_path.suffix.lower()
+        fmt_map = {
+            ".txt": "text",
+            ".md": "markdown",
+            ".json": "json",
+        }
+        fmt = fmt_map.get(ext, "text")
+
+    content = format_result(result, fmt)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+
+    return output_path