Fix remote-code compatibility across Transformers 4.x and 5.x

This draft ports the remote-code compatibility fix to **PaddlePaddle/PaddleOCR-VL**. It preserves `AutoModelForCausalLM`, `AutoProcessor` and `trust_remote_code=True`, without requiring a pinned Transformers release.

The unmodified source was reproduced on meta storage, without loading checkpoint weights: Transformers 4.57.6 reaches the text forward and raises `create_causal_mask() got an unexpected keyword argument 'inputs_embeds'`; 5.0.0 and 5.21.1 fail during construction with `KeyError: 'default'`. The architecture/configuration and affected implementation are shared with 1.6 (1.0 differs only in import order).

The patch:

- computes default RoPE frequencies locally;
- builds causal/padding/4-D boolean masks locally, avoiding the changing Transformers mask helper interface;
- obtains generation positions from prepared inputs or cache length and preserves images for uncached generation;
- restores derived non-persistent RoPE/position buffers and protects loaded parameters during custom initialization;
- isolates non-FlashAttention packed vision attention by image, preventing cross-image contamination;
- includes a reproducible checkpoint regression script, three fixtures, and this model's own validation summary.

### Validation

Processor loading and meta-device model construction passed. **Full-checkpoint regression is in progress and is not claimed here.**

| Transformers | Processor + meta construction |
| --- | --- |
| 4.57.6 | Passed |
| 5.0.0 | Passed |
| 5.21.1 | Passed |

```bash
python -m pip install einops sentencepiece protobuf
python tests/test_remote_code_compat.py --full --model . --inputs tests/data --output /tmp/paddleocr-vl-compat
```

Only the listed executions are claimed. CUDA/MPS, low precision, FlashAttention, StaticCache, training, dataset-level accuracy/performance, and every historical/intermediate/future Transformers release are not verified here. Full-checkpoint results for another model are not substituted for this model's results.

Related 1.6 draft: https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6/discussions/15 . The final patched model source is byte-identical across 1.0, 1.5 and 1.6 (SHA-256 `d01a9847b5e4142e5aa35c28f2354fae920ab31b2f990216db39287d344758ce`).

modeling_paddleocr_vl.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import inspect
 import math
 import warnings
 from dataclasses import dataclass
@@ -30,7 +31,6 @@ from transformers.cache_utils import (
 )
 from transformers.generation import GenerationMixin
 from transformers.integrations import use_kernel_forward_from_hub
-from transformers.masking_utils import create_causal_mask
 from transformers.modeling_attn_mask_utils import AttentionMaskConverter
 from transformers.modeling_layers import GradientCheckpointingLayer
 from transformers.modeling_outputs import (
@@ -66,6 +66,62 @@ else:
 from .configuration_paddleocr_vl import PaddleOCRVisionConfig, PaddleOCRVLConfig
 
 
+def _create_causal_mask(config, inputs_embeds, attention_mask, past_key_values, cache_position):
+    # Keep mask semantics local: Transformers renamed inputs and removed
+    # cache_position across releases. M-RoPE coordinates are handled separately.
+    if attention_mask is not None and attention_mask.ndim == 4:
+        mask = attention_mask.to(device=inputs_embeds.device)
+        if mask.dtype == torch.bool:
+            additive = torch.zeros(mask.shape, device=mask.device, dtype=inputs_embeds.dtype)
+            return additive.masked_fill(~mask, torch.finfo(inputs_embeds.dtype).min)
+        return mask.to(dtype=inputs_embeds.dtype)
+    if config._attn_implementation == "flash_attention_2":
+        return attention_mask if attention_mask is not None and (attention_mask == 0).any() else None
+    batch_size, query_length = inputs_embeds.shape[:2]
+    past_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+    key_length = past_length + query_length
+    if attention_mask is not None:
+        key_length = max(key_length, attention_mask.shape[-1])
+    if past_key_values is not None and getattr(past_key_values, "is_compileable", False):
+        maximum = past_key_values.get_max_cache_shape()
+        if isinstance(maximum, int):
+            key_length = max(key_length, maximum)
+    query_positions = cache_position[-query_length:].to(inputs_embeds.device)
+    key_positions = torch.arange(key_length, device=inputs_embeds.device)
+    allowed = key_positions[None, :] <= query_positions[:, None]
+    allowed = allowed[None, None, :, :].expand(batch_size, 1, query_length, key_length)
+    if attention_mask is not None:
+        padding = attention_mask[:, :key_length].to(device=inputs_embeds.device, dtype=torch.bool)
+        if padding.shape[-1] < key_length:
+            padding = F.pad(padding, (0, key_length - padding.shape[-1]), value=False)
+        allowed = allowed & padding[:, None, None, :]
+    mask = torch.zeros(allowed.shape, dtype=inputs_embeds.dtype, device=inputs_embeds.device)
+    return mask.masked_fill(~allowed, torch.finfo(inputs_embeds.dtype).min)
+
+
+def _init_derived_buffers(module):
+    # v5 materializes non-persistent buffers from meta storage; they are not
+    # loaded from the checkpoint and must be initialized explicitly.
+    if isinstance(module, RotaryEmbedding):
+        inv_freq, module.attention_scaling = module.rope_init_fn(
+            module.config, device=module.inv_freq.device
+        )
+        module.inv_freq.copy_(inv_freq)
+        module.original_inv_freq = module.inv_freq
+    elif isinstance(module, SigLIPRotaryEmbedding):
+        inv_freq = 1.0 / (
+            module.theta ** (
+                torch.arange(0, module.dim, 2, dtype=torch.float32, device=module.inv_freq.device)
+                / module.dim
+            )
+        )
+        module.inv_freq.copy_(inv_freq)
+    elif isinstance(module, PaddleOCRVisionEmbeddings):
+        module.position_ids.copy_(
+            torch.arange(module.num_positions, device=module.position_ids.device).expand(1, -1)
+        )
+
+
 class RotaryEmbedding(nn.Module):
     def __init__(self, config: PaddleOCRVLConfig, device=None):
         super().__init__()
@@ -92,12 +148,25 @@ class RotaryEmbedding(nn.Module):
         self.original_max_seq_len = config.max_position_embeddings
 
         self.config = config
-        self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+        if self.rope_type == "default":
+            self.rope_init_fn = self.compute_default_rope_parameters
+        else:
+            self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
 
         inv_freq, self.attention_scaling = self.rope_init_fn(self.config, device)
         self.register_buffer("inv_freq", inv_freq, persistent=False)
         self.original_inv_freq = self.inv_freq
 
+    @staticmethod
+    def compute_default_rope_parameters(config, device=None, seq_len=None):
+        # Default RoPE is no longer part of ROPE_INIT_FUNCTIONS in v5.
+        head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+        dim = int(head_dim * getattr(config, "partial_rotary_factor", 1.0))
+        inv_freq = 1.0 / (
+            config.rope_theta ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim)
+        )
+        return inv_freq, 1.0
+
     def _dynamic_frequency_update(self, position_ids, device):
         """
         dynamic RoPE layers should recompute `inv_freq` in the following situations:
@@ -539,6 +608,12 @@ class Ernie4_5PreTrainedModel(PreTrainedModel):
     }
 
 
+    @torch.no_grad()
+    def _init_weights(self, module):
+        super()._init_weights(module)
+        _init_derived_buffers(module)
+
+
 @auto_docstring
 class Ernie4_5Model(Ernie4_5PreTrainedModel):
     def __init__(self, config: PaddleOCRVLConfig):
@@ -603,13 +678,8 @@ class Ernie4_5Model(Ernie4_5PreTrainedModel):
         elif position_ids.dim() == 2:
             position_ids = position_ids[None, ...].expand(3, position_ids.shape[0], -1)
 
-        causal_mask = create_causal_mask(
-            config=self.config,
-            inputs_embeds=inputs_embeds,
-            attention_mask=attention_mask,
-            past_key_values=past_key_values,
-            position_ids=position_ids,
-            cache_position=cache_position,
+        causal_mask = _create_causal_mask(
+            self.config, inputs_embeds, attention_mask, past_key_values, cache_position
         )
 
         hidden_states = inputs_embeds
@@ -712,6 +782,8 @@ class Ernie4_5ForCausalLM(Ernie4_5PreTrainedModel, GenerationMixin):
 
 
 def _trunc_normal_(tensor, mean, std, a, b):
+    if getattr(tensor, "_is_hf_initialized", False):
+        return tensor
     # Cut & paste from PyTorch official master until it's in a few official releases - RW
     # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
     def norm_cdf(x):
@@ -772,12 +844,16 @@ def trunc_normal_tf_(
         a: the minimum cutoff value
         b: the maximum cutoff value
     """
+    if getattr(tensor, "_is_hf_initialized", False):
+        return tensor
     with torch.no_grad():
         _trunc_normal_(tensor, 0, 1.0, a, b)
         tensor.mul_(std).add_(mean)
 
 
 def variance_scaling_(tensor, scale=1.0, mode="fan_in", distribution="normal"):
+    if getattr(tensor, "_is_hf_initialized", False):
+        return tensor
     fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)
     if mode == "fan_in":
         denom = fan_in
@@ -1134,16 +1210,34 @@ class PaddleOCRAttention(nn.Module):
                 elif self.config._attn_implementation == "sdpa":
                     attention_interface = sdpa_attention_forward
 
-            attn_output, attn_weights = attention_interface(
-                self,
-                queries,
-                keys,
-                values,
-                attention_mask,
-                is_causal=self.is_causal,
-                scaling=self.scale,
-                dropout=0.0 if not self.training else self.dropout,
-            )
+            if cu_seqlens is not None and cu_seqlens.numel() > 2:
+                boundaries = cu_seqlens.tolist()
+                outputs = []
+                attn_weights = (
+                    queries.new_zeros(batch_size, self.num_heads, seq_length, seq_length)
+                    if output_attentions else None
+                )
+                for start, end in zip(boundaries[:-1], boundaries[1:]):
+                    local_mask = (
+                        attention_mask[..., start:end, start:end]
+                        if attention_mask is not None else None
+                    )
+                    output, weights = attention_interface(
+                        self, queries[:, :, start:end], keys[:, :, start:end],
+                        values[:, :, start:end], local_mask,
+                        is_causal=False, scaling=self.scale,
+                        dropout=0.0 if not self.training else self.dropout,
+                    )
+                    outputs.append(output)
+                    if attn_weights is not None and weights is not None:
+                        attn_weights[..., start:end, start:end] = weights
+                attn_output = torch.cat(outputs, dim=1)
+            else:
+                attn_output, attn_weights = attention_interface(
+                    self, queries, keys, values, attention_mask,
+                    is_causal=self.is_causal, scaling=self.scale,
+                    dropout=0.0 if not self.training else self.dropout,
+                )
             attn_output = attn_output.reshape(
                 batch_size, seq_length, embed_dim
             ).contiguous()
@@ -1267,7 +1361,8 @@ class PaddleOCRPreTrainedModel(PreTrainedModel):
     _supports_sdpa = True
 
     def _init_weights(self, module):
-        """Initialize the weights"""
+        """Initialize the weights and derived non-persistent buffers."""
+        _init_derived_buffers(module)
         if isinstance(module, PaddleOCRVisionEmbeddings):
             width = (
                 self.config.vision_config.hidden_size
@@ -1292,16 +1387,16 @@ class PaddleOCRPreTrainedModel(PreTrainedModel):
             nn.init.normal_(module.fc1.bias, std=1e-6)
             nn.init.normal_(module.fc2.bias, std=1e-6)
         elif isinstance(module, PaddleOCRMultiheadAttentionPoolingHead):
-            nn.init.xavier_uniform_(module.probe.data)
-            nn.init.xavier_uniform_(module.attention.in_proj_weight.data)
-            nn.init.zeros_(module.attention.in_proj_bias.data)
+            nn.init.xavier_uniform_(module.probe)
+            nn.init.xavier_uniform_(module.attention.in_proj_weight)
+            nn.init.zeros_(module.attention.in_proj_bias)
         elif isinstance(module, (nn.Linear, nn.Conv2d)):
             lecun_normal_(module.weight)
             if module.bias is not None:
                 nn.init.zeros_(module.bias)
         elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
+            nn.init.zeros_(module.bias)
+            nn.init.ones_(module.weight)
 
 
 # Copied from transformers.models.altclip.modeling_altclip.AltCLIPEncoder with AltCLIP->PaddleOCR
@@ -2342,7 +2437,21 @@ class PaddleOCRVLForConditionalGeneration(Ernie4_5PreTrainedModel, GenerationMix
 
         model_inputs["position_ids"] = None
 
-        if cache_position[0] != 0:
+        # v5 creates cache_position inside the parent method, rather than
+        # passing it to this override. Read the prepared value back first.
+        cache_position = model_inputs.get("cache_position", cache_position)
+        if cache_position is None:
+            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+            prepared = model_inputs.get("inputs_embeds")
+            if prepared is None:
+                prepared = model_inputs["input_ids"]
+            cache_position = torch.arange(
+                past_seen_tokens, past_seen_tokens + prepared.shape[1], device=prepared.device
+            )
+            model_inputs["cache_position"] = cache_position
+
+        # Without KV caching, every forward still consumes the image tokens.
+        if use_cache and past_key_values is not None and past_key_values.get_seq_length() > 0:
             model_inputs["pixel_values"] = None
             model_inputs["pixel_values_videos"] = None
 

tests/README.md

@@ -0,0 +1,22 @@
+# Remote-code compatibility regression
+
+Run from a model checkout containing the checkpoint and tokenizer files:
+
+```bash
+python -m pip install einops sentencepiece protobuf
+python tests/test_remote_code_compat.py --full --model . --inputs tests/data --output /tmp/paddleocr-vl-compat
+```
+
+Use an environment with PyTorch, torchvision, Pillow, NumPy, safetensors, and the Transformers version under test. The script always uses `trust_remote_code=True`, local checkpoint files, CPU float32, and an isolated dynamic-module cache below the output directory. Each version is a separate process/environment; framework versions are not switched inside one Python process.
+
+The default suite checks checkpoint parameter equality, derived RoPE buffers, mask semantics, English generation, an uncached prefix, and batch-prefill isolation. `--full` additionally checks a complete uncached English generation, Chinese OCR, equality of individual/batched decoded text, and table recognition.
+
+`compatibility_results.json` records the three executed boundary versions for this model and their environment scope. It does not claim continuous-range or future-version coverage.
+
+Fixtures:
+
+- `paddle_general_ocr_001.png`: official synthetic Chinese OCR test image from https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_general_ocr_001.png .
+- `invoice_en.png`: synthetic three-line English invoice with known expected text.
+- `table_en.png`: synthetic Item/Qty/Price table containing Apple and Orange rows.
+
+Draft progress: only processor loading and meta-device construction have passed for this model so far. Full-checkpoint regression is pending; do not interpret the summary as a generation test.

tests/compatibility_results.json

@@ -0,0 +1,76 @@
+{
+  "model": "PaddlePaddle/PaddleOCR-VL",
+  "revision": "7fa00a8c55b735ba51ba49a9058f3f9c57a99a11",
+  "trust_remote_code": true,
+  "validation_scope": "meta construction and processor only",
+  "full_checkpoint_pending": true,
+  "device": "meta",
+  "dtype": null,
+  "checkpoint_sha256": null,
+  "tested_versions": [
+    "4.57.6",
+    "5.0.0",
+    "5.21.1"
+  ],
+  "same_source_sha256": {
+    "modeling_paddleocr_vl.py": "d01a9847b5e4142e5aa35c28f2354fae920ab31b2f990216db39287d344758ce",
+    "image_processing_paddleocr_vl.py": "a4fa521b9cb16e207f94b7f2d16427771776dfc634420d319fc4916ee58049ec",
+    "processing_paddleocr_vl.py": "e29cb1e5f275f2bd3ce051bd5c9983a33894e693b2823a0e13d4c07c8c4f9e13",
+    "configuration_paddleocr_vl.py": "753dd93654c3a9c8c85a3eaee1e3092dd12591b0f2dce0305e1abfb7a41ff160"
+  },
+  "all_tested_passed": true,
+  "universal_historical_or_future_support_claimed": false,
+  "original_reproduction_scope": "original source, meta construction/text forward; no checkpoint weights",
+  "original_failures": [
+    {
+      "transformers": "4.57.6",
+      "stage": "text_decoder_forward",
+      "exception_type": "TypeError",
+      "error": "create_causal_mask() got an unexpected keyword argument 'inputs_embeds'",
+      "expected_failure": true
+    },
+    {
+      "transformers": "5.0.0",
+      "stage": null,
+      "exception_type": "KeyError",
+      "error": "'default'",
+      "expected_failure": true
+    },
+    {
+      "transformers": "5.21.1",
+      "stage": null,
+      "exception_type": "KeyError",
+      "error": "'default'",
+      "expected_failure": true
+    }
+  ],
+  "versions": [
+    {
+      "version": "4.57.6",
+      "passed": true,
+      "stages": [
+        "config",
+        "processor",
+        "model_class"
+      ]
+    },
+    {
+      "version": "5.0.0",
+      "passed": true,
+      "stages": [
+        "config",
+        "processor",
+        "model_class"
+      ]
+    },
+    {
+      "version": "5.21.1",
+      "passed": true,
+      "stages": [
+        "config",
+        "processor",
+        "model_class"
+      ]
+    }
+  ]
+}

tests/test_remote_code_compat.py

@@ -0,0 +1,159 @@
+"""Run unchanged API calls against one selected Transformers installation."""
+import argparse
+import importlib.metadata
+import hashlib
+import json
+import os
+import time
+import traceback
+from pathlib import Path
+
+args_parser=argparse.ArgumentParser()
+args_parser.add_argument('--imports-only',action='store_true')
+args_parser.add_argument('--full',action='store_true')
+args_parser.add_argument('--model',type=Path)
+args_parser.add_argument('--inputs',type=Path)
+args_parser.add_argument('--output',type=Path)
+args=args_parser.parse_args()
+TASK=Path(__file__).resolve().parent
+ROOT=TASK.parent
+VERSION=importlib.metadata.version('transformers')
+MODEL=args.model or ROOT
+INPUTS=args.inputs or TASK/'data'
+OUT=(args.output or TASK/'results')/VERSION
+OUT.mkdir(parents=True,exist_ok=True)
+os.environ['HF_MODULES_CACHE']=str(OUT/'modules')
+os.environ['HF_HUB_OFFLINE']='1'
+os.environ['TOKENIZERS_PARALLELISM']='false'
+report={'transformers':VERSION,'trust_remote_code':True,'mode':'imports' if args.imports_only else 'full' if args.full else 'matrix','pid':os.getpid(),'started_at':time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime()),'stages':{}}
+report['source_sha256']={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in MODEL.glob('*.py')}
+def save(): (OUT/('imports.json' if args.imports_only else 'full.json' if args.full else 'results.json')).write_text(json.dumps(report,ensure_ascii=False,indent=2,default=str)+'\n')
+def step(name,fn):
+    started=time.perf_counter()
+    try:
+        result=fn();report['stages'][name]={'passed':True,'seconds':round(time.perf_counter()-started,3)}
+        print(name,'PASS',flush=True);save();return result
+    except Exception as exc:
+        report['stages'][name]={'passed':False,'error':str(exc),'traceback':traceback.format_exc()}
+        print(name,type(exc).__name__,str(exc),flush=True);save();raise
+try:
+    import torch,transformers,tokenizers,huggingface_hub
+    from PIL import Image
+    from transformers import AutoConfig,AutoModelForCausalLM,AutoProcessor
+    from transformers.utils import logging
+    logging.disable_progress_bar()
+    torch.set_num_threads(4)
+    report['packages']={name:importlib.metadata.version(name) for name in ['transformers','torch','tokenizers','huggingface-hub','safetensors','pillow']}
+    report['transformers_source']=transformers.__file__
+    common={'trust_remote_code':True,'local_files_only':True}
+    config=step('config',lambda:AutoConfig.from_pretrained(MODEL,**common))
+    processor=step('processor',lambda:AutoProcessor.from_pretrained(MODEL,**common))
+    def construct():
+        with torch.device('meta'):
+            return AutoModelForCausalLM.from_config(config,trust_remote_code=True)
+    if args.imports_only:
+        model=step('model_class',construct)
+    else:
+        def load():
+            model,info=AutoModelForCausalLM.from_pretrained(MODEL,torch_dtype=torch.float32,output_loading_info=True,**common)
+            report['loading_info']={k:sorted(v) if isinstance(v,set) else v for k,v in info.items()}
+            assert not info.get('missing_keys') and not info.get('mismatched_keys'),info
+            report['model_class']=type(model).__module__+'.'+type(model).__name__
+            assert type(model).__module__.startswith('transformers_modules.')
+            return model.eval()
+        model=step('model',load)
+        def weights():
+            from safetensors import safe_open
+            missing=[]
+            with safe_open(str(MODEL/'model.safetensors'),framework='pt') as f:
+                for name,param in model.named_parameters():
+                    if not torch.equal(param,f.get_tensor(name).to(param.dtype)):missing.append(name)
+            report['parameter_mismatches']=missing;assert not missing,missing
+            for module in model.modules():
+                if type(module).__name__=='RotaryEmbedding':
+                    expected,_=module.compute_default_rope_parameters(module.config)
+                    assert torch.equal(expected,module.inv_freq)
+                elif type(module).__name__=='SigLIPRotaryEmbedding':
+                    expected=1/(module.theta**(torch.arange(0,module.dim,2,dtype=torch.float32)/module.dim))
+                    assert torch.equal(expected,module.inv_freq)
+        step('weights_and_buffers',weights)
+        def mask_semantics():
+            import sys
+            create=sys.modules[type(model).__module__]._create_causal_mask
+            from types import SimpleNamespace
+            c=SimpleNamespace(_attn_implementation='eager')
+            x=torch.zeros(1,3,4)
+            mask=create(c,x,torch.ones(1,3),None,torch.arange(3))
+            assert torch.equal(mask[0,0]==0,torch.ones(3,3,dtype=torch.bool).tril())
+            cache=SimpleNamespace(get_seq_length=lambda:5,is_compileable=False)
+            mask=create(c,torch.zeros(1,1,4),torch.tensor([[0,0,1,1,1,1]]),cache,torch.tensor([5]))
+            assert torch.equal(mask[0,0,0]==0,torch.tensor([False,False,True,True,True,True]))
+            allowed=torch.tensor([[[[True,False],[True,True]]]])
+            mask=create(c,torch.zeros(1,2,4),allowed,None,torch.arange(2))
+            assert torch.equal(mask==0,allowed)
+        step('mask_semantics',mask_semantics)
+        processor.tokenizer.padding_side='left'
+        def inputs(names,prompt='OCR:'):
+            images=[];messages=[]
+            for name in names:
+                with Image.open(INPUTS/name) as f:image=f.convert('RGB')
+                images.append(image)
+                messages.append([{'role':'user','content':[{'type':'image','image':image},{'type':'text','text':prompt}]}])
+            texts=processor.apply_chat_template(messages,tokenize=False,add_generation_prompt=True)
+            return processor(text=texts,images=images,padding=True,return_tensors='pt')
+        def generate(names,prompt='OCR:',max_tokens=128,use_cache=True):
+            batch=inputs(names,prompt)
+            with torch.inference_mode(): out=model.generate(**batch,max_new_tokens=max_tokens,do_sample=False,use_cache=use_cache)
+            ids=out[:,batch.input_ids.shape[1]:]
+            texts=processor.batch_decode(ids,skip_special_tokens=True,clean_up_tokenization_spaces=False)
+            return ids.tolist(),texts
+        def english():
+            ids,texts=generate(['invoice_en.png'])
+            report['english']={'ids':ids,'text':texts}
+            assert texts[0]=='PaddleOCR-VL 1.6\nInvoice No: INV-2026-1022\nTotal: USD 128.50',texts
+            assert 2 in ids[0]
+        step('english_generate',english)
+        def cache():
+            ids,text=generate(['invoice_en.png'],max_tokens=2,use_cache=False)
+            assert ids[0]==report['english']['ids'][0][:2],(ids,text)
+        step('uncached_prefix',cache)
+        def batch_logits():
+            individual=[]
+            for name in ['invoice_en.png','table_en.png']:
+                batch=inputs([name])
+                model.rope_deltas=None
+                with torch.inference_mode(): individual.append(model(**batch,use_cache=False).logits[:,-1].clone())
+            batch=inputs(['invoice_en.png','table_en.png'])
+            model.rope_deltas=None
+            with torch.inference_mode(): together=model(**batch,use_cache=False).logits[:,-1]
+            separate=torch.cat(individual)
+            maximum=(together-separate).abs().max().item()
+            report['batch_logits']={'max_abs_difference':maximum,'individual_argmax':separate.argmax(-1).tolist(),'batch_argmax':together.argmax(-1).tolist()}
+            assert torch.equal(together.argmax(-1),separate.argmax(-1))
+            torch.testing.assert_close(together,separate,atol=2e-3,rtol=2e-3)
+        step('batch_prefill_isolation',batch_logits)
+        if args.full:
+            def uncached_full():
+                ids,text=generate(['invoice_en.png'],use_cache=False)
+                report['uncached_english']={'ids':ids,'text':text}
+                assert ids==report['english']['ids']
+            step('uncached_full_english',uncached_full)
+            def full():
+                reference=[]
+                for name in ['invoice_en.png','paddle_general_ocr_001.png']:
+                    _,text=generate([name]);reference.append(text[0])
+                ids,text=generate(['invoice_en.png','paddle_general_ocr_001.png'])
+                report['full_batch']={'individual':reference,'batch':text,'ids':ids}
+                assert text==reference,(text,reference)
+                assert all(2 in row for row in ids)
+                _,table=generate(['table_en.png'],'Table Recognition:')
+                report['table']=table
+                assert all(part in table[0] for part in ['Item','Qty','Price','Apple','10.00','Orange','12.50'])
+            step('full_chinese_batch_table',full)
+    report['passed']=True
+except Exception:
+    report['passed']=False
+finally:
+    save()
+print(VERSION,report['passed'],flush=True)
+raise SystemExit(0 if report['passed'] else 1)