Update README.md

README.md

@@ -1,3 +1,192 @@
 ---
 license: apache-2.0
 ---
+
+```python
+
+import json
+import sys
+from pathlib import Path
+
+import torch
+from transformers import (
+    AutoConfig,
+    AutoProcessor,
+    GenerationConfig,
+)
+from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5ForConditionalGeneration
+
+
+SEED = 42
+MODEL_ID = "openbmb/MiniCPM-OCR-Jev"
+OUTPUT_DIR = Path(__file__).resolve().parent / "tiny-random-minicpm-ocr-jev"
+
+# Marker written into the cached config so a stale/incompatible cache is rebuilt
+# instead of silently reused.
+CACHE_MARKER = "tiny-minicpm-ocr-jev-v1"
+
+MAX_PARAMS = 40_000_000
+MAX_BYTES = 180 * 1024 * 1024
+
+
+def build_tiny_config():
+    """Load the real config and shrink every scale parameter in place.
+
+    The full ``vocab_size`` (248320) is preserved so the real tokenizer and the
+    vision/image special-token ids (image/video/vision-start/vision-end) stay
+    valid for the image-text-to-text path.
+    """
+    cfg = AutoConfig.from_pretrained(MODEL_ID)
+
+    tc = cfg.text_config
+    tc.hidden_size = 64
+    tc.intermediate_size = 128
+    tc.num_hidden_layers = 4
+    tc.num_attention_heads = 4
+    tc.num_key_value_heads = 2
+    tc.head_dim = 32
+    # Preserve the real linear/full attention mix (gated-delta-net + attention),
+    # with one full_attention layer like the full_attention_interval=4 pattern.
+    tc.layer_types = ["linear_attention", "linear_attention", "linear_attention", "full_attention"]
+    tc.linear_num_key_heads = 2
+    tc.linear_num_value_heads = 4
+    tc.linear_key_head_dim = 16
+    tc.linear_value_head_dim = 16
+    # keep tc.linear_conv_kernel_dim (4)
+    tc.max_position_embeddings = 4096
+    # keep tc.use_cache (original ships False; generation still works at this scale)
+
+    # partial_rotary_factor 0.25 * head_dim(32) -> rotary dim 8 -> freqs len 4;
+    # interleaved mrope_section must sum to rotary_dim // 2 == 4.
+    if isinstance(tc.rope_parameters, dict):
+        tc.rope_parameters["mrope_section"] = [2, 1, 1]
+        tc.rope_parameters["partial_rotary_factor"] = 0.25
+
+    vc = cfg.vision_config
+    vc.depth = 2
+    vc.hidden_size = 64
+    vc.intermediate_size = 128
+    vc.num_heads = 4
+    # out_hidden_size must match the text hidden_size (image embeds merge into
+    # the decoder embedding space).
+    vc.out_hidden_size = tc.hidden_size
+    # num_position_embeddings must be a perfect square (num_grid_per_side =
+    # int(sqrt(num_position_embeddings))); 256 -> 16 per side.
+    vc.num_position_embeddings = 256
+    # keep patch_size(16), spatial_merge_size(2), temporal_patch_size(2), in_channels(3)
+
+    # Force float32 at every effective precision level for a robust CPU forward.
+    cfg.dtype = "float32"
+    tc.dtype = "float32"
+    vc.dtype = "float32"
+
+    return cfg
+
+
+def _count_and_measure(model):
+    n_params = 0
+    n_bytes = 0
+    for p in model.parameters():
+        n_params += p.numel()
+        n_bytes += p.numel() * p.element_size()
+    for b in model.buffers():
+        n_bytes += b.numel() * b.element_size()
+    return n_params, n_bytes
+
+
+def _cache_is_valid():
+    cfg_path = OUTPUT_DIR / "config.json"
+    weights = (OUTPUT_DIR / "model.safetensors").exists() or (OUTPUT_DIR / "pytorch_model.bin").exists()
+    if not cfg_path.exists() or not weights:
+        return False
+    try:
+        data = json.loads(cfg_path.read_text())
+    except Exception:
+        return False
+    if data.get("_tiny_cache_marker") != CACHE_MARKER:
+        return False
+    if data.get("model_type") != "qwen3_5":
+        return False
+    if data.get("architectures") != ["Qwen3_5ForConditionalGeneration"]:
+        return False
+    return True
+
+
+def create_tiny_model():
+    if _cache_is_valid():
+        print(f"Reusing valid cache at {OUTPUT_DIR}")
+        return OUTPUT_DIR
+
+    torch.manual_seed(SEED)
+
+    config = build_tiny_config()
+
+    # Instantiate the real architecture class with random weights.
+    with torch.device("cpu"):
+        model = Qwen3_5ForConditionalGeneration(config)
+    model = model.to(torch.float32)
+    model.eval()
+
+    n_params, n_bytes = _count_and_measure(model)
+    print(f"params={n_params:,} bytes={n_bytes / 1024 / 1024:.1f}MB")
+    if n_params > MAX_PARAMS:
+        raise RuntimeError(f"Parameter budget exceeded: {n_params:,} > {MAX_PARAMS:,}")
+    if n_bytes > MAX_BYTES:
+        raise RuntimeError(f"Memory budget exceeded: {n_bytes:,} > {MAX_BYTES:,}")
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(OUTPUT_DIR, safe_serialization=True)
+
+    # Save processor assets (tokenizer, image processor, chat template).
+    processor = AutoProcessor.from_pretrained(MODEL_ID)
+    processor.save_pretrained(OUTPUT_DIR)
+
+    # Save a usable generation config.
+    try:
+        gen = GenerationConfig.from_pretrained(MODEL_ID)
+    except Exception:
+        gen = GenerationConfig()
+    gen.save_pretrained(OUTPUT_DIR)
+
+    # Stamp the cache marker and assert float32 precision fields survived.
+    cfg_path = OUTPUT_DIR / "config.json"
+    data = json.loads(cfg_path.read_text())
+    data["_tiny_cache_marker"] = CACHE_MARKER
+    data["dtype"] = "float32"
+    if isinstance(data.get("text_config"), dict):
+        data["text_config"]["dtype"] = "float32"
+    if isinstance(data.get("vision_config"), dict):
+        data["vision_config"]["dtype"] = "float32"
+        # ``Qwen3_5VisionConfig.model_type`` class attribute is "qwen3_5", so
+        # ``to_dict()`` drops the real "qwen3_5_vision" marker; restore it.
+        data["vision_config"]["model_type"] = "qwen3_5_vision"
+    cfg_path.write_text(json.dumps(data, indent=2))
+
+    print(f"Saved tiny model to {OUTPUT_DIR}")
+    return OUTPUT_DIR
+
+
+def verify_identity():
+    """Assert the saved config preserves the real architecture identity."""
+    orig = AutoConfig.from_pretrained(MODEL_ID)
+    tiny = AutoConfig.from_pretrained(OUTPUT_DIR)
+
+    assert tiny.model_type == orig.model_type == "qwen3_5", tiny.model_type
+    assert tiny.architectures == orig.architectures == ["Qwen3_5ForConditionalGeneration"]
+    assert tiny.text_config.model_type == orig.text_config.model_type == "qwen3_5_text"
+    assert tiny.vision_config.model_type == orig.vision_config.model_type == "qwen3_5_vision"
+    assert tiny.image_token_id == orig.image_token_id
+    assert tiny.vision_start_token_id == orig.vision_start_token_id
+    assert tiny.text_config.vocab_size == orig.text_config.vocab_size
+    # linear + full attention mix preserved
+    assert "linear_attention" in tiny.text_config.layer_types
+    assert "full_attention" in tiny.text_config.layer_types
+    print("Architecture identity OK")
+
+
+if __name__ == "__main__":
+    out = create_tiny_model()
+    verify_identity()
+    print(out)
+
+```