# 找到视觉编码器类
class XxxVisionModel:
    def __init__(self, config):
        self.embeddings = XxxVisionEmbeddings(config)   # patch embedding
        self.encoder = XxxEncoder(config)                # transformer encoder
        self.post_layernorm = nn.LayerNorm(...)          # 后处理 norm

视觉编码器路径（从模型顶层到视觉模块）：____
图像尺寸 (image_size / tile_size)：____
Patch 尺寸 (patch_size)：____
Patch embedding 类型 (Conv2d / Linear)：____
Position embedding 方式 (固定 / 可变插值)：____
下采样因子 (downsample_factor, 如有)：____
投影器/连接器类型 (MLP / Perceiver / pixel_unshuffle+MLP)：____
视觉 token 的特殊 token ID：
  - vision_start (如 <image_start>)：____
  - vision_end (如 <image_end>)：____
  - image_pad (如 <image>)：____
  - global_image (如 <|img_thumbnail|>, 可选)：____
每个 tile 的 token 数：____
连接器/投影层路径：____

class NewVision(Vision):
    def __init__(self, visual, base):
        # 在 super().__init__() 之前设置属性；super() 会调用 init_config() 和 load()
        # 投影器从 base 获取：self.projector = base.multi_modal_projector
        self.tile_size = 512
        self.image_embeds = []
        super().__init__(visual, base)
        self.visual = self.visual.float()
        self.quant_bit = 8
        self.transformer_fuse = False

    def init_config(self):
        # 图像归一化：C++ 使用 (pixel * image_norm) - image_mean（像素范围 0-255）
        self.llm_config['is_visual'] = True
        self.llm_config['image_mean'] = (np.array([0.5, 0.5, 0.5]) * 255.0).tolist()
        self.llm_config['image_norm'] = (1 / (np.array([0.5, 0.5, 0.5]) * 255.0)).tolist()

    def load(self):
        # 必须设置的 llm_config 字段（→ 参见 5.2.5 字段速查表）
        self.llm_config['image_size'] = self.tile_size
        self.llm_config['vision_start'] = ...  # token IDs
        self.llm_config['vision_end'] = ...
        self.llm_config['image_pad'] = ...
        # tiling 模型还需: image_size_unit, image_max_size, global_image

    def forward(self, pixel_values):
        # 输入: (batch, 3, H, W)  输出: (batch, num_tokens, 1, hidden_size)
        # ⚠️ 输出 dim[2] 固定为 1（MNN C++ 约定）
        ...
        return image_features.unsqueeze(2)

    def str_to_ids(self, prompt):
        # 解析 path</img> → img_process() → 替换为 pad token → tokenize
        pass

    def img_process(self, image):
        # resize → normalize → forward() → 存入 self.image_embeds
        # 返回 token 数量
        pass

    def embed(self, input_ids, images=None, videos=None):
        # 将 self.image_embeds 替换到 input_embeds 的 image_pad 位置
        input_embeds = self.embed_(input_ids)
        if self.image_embeds:
            image_mask = (input_ids == self.image_pad_id).squeeze()
            input_embeds[image_mask] = torch.concat(self.image_embeds, dim=0).to(input_embeds.dtype)
        return input_embeds

    @spinner_run(f'export visual to ')
    def export(self, onnx_path):
        # ⚠️ input_names 决定 C++ dispatch 路径（→ 参见 5.4.1）
        pixel_values = torch.randn([1, 3, self.tile_size, self.tile_size])
        onnx_model = f'{onnx_path}/visual.onnx'
        onnx_export(self, (pixel_values), onnx_model,
                    input_names=['pixel_values'],
                    output_names=['image_embeds'],
                    dynamic_axes={"pixel_values": {0: "size"}})
        return onnx_model

# 纯文本模型（如 lfm2）：
config = { 'hidden_size': 'hidden_size', ... }

# VL 模型（如 lfm2_vl）：
config = { 'hidden_size': 'text_config.hidden_size', ... }  # ← 加 text_config. 前缀

# 纯文本模型（如 lfm2）：
model = {
    'lm': 'lm_head',
    'embed': 'model.embed_tokens',
    'blocks': 'model.layers',
    'final_layernorm': 'model.embedding_norm',
}

# VL 模型（如 lfm2_vl）：
model = {
    'lm': 'lm_head',
    'embed': 'model.language_model.embed_tokens',       # ← 加 model.language_model. 前缀
    'blocks': 'model.language_model.layers',
    'final_layernorm': 'model.language_model.embedding_norm',
    'visual': 'model.vision_tower',                      # ← 视觉编码器路径
    'multi_modal_projector': 'model.multi_modal_projector',  # ← 投影器路径（如有）
}

MODEL_CLASS_MAPPING = {
    # ... 已有
    'new_model_type': 'NewModelForConditionalGeneration',
}

cd transformers/llm/export

# 测试纯文本（应该仍然正确）
python3 llmexport.py --path /path/to/model --test "你好"

# 测试图片输入
python3 llmexport.py --path /path/to/model --test "/path/to/test.jpg</img>描述一下这张图片"

class XxxAudioEncoder:
    def __init__(self, config):
        self.conv1 = nn.Conv1d(...)    # 音频卷积
        self.conv2 = nn.Conv1d(...)
        self.layers = nn.ModuleList([...])  # Transformer 层

音频编码器路径：____
音频 pad token ID：____
音频特征维度 (feature_size)：____
最大音频长度 (max_length)：____
采样率：____

Audio (基类)
├── Qwen2Audio               — whisper 风格 mel + Transformer encoder
│   ├── Qwen2_5OmniAudio     — 同上 + windowed attention + 分块 decoder
│   │   └── FunAudioChatAudio — 同上 + group pooling
├── Lfm2Audio                 — conformer 风格 mel + FastConformer encoder + MLP adapter

// omni.cpp 中根据 llm_config 的 audio_type 字段选择预处理：
if (audio_type == "conformer") {
    input_features = MNN::AUDIO::conformer_fbank(waveform);
} else {
    // 默认 whisper 风格
    input_features = MNN::AUDIO::whisper_fbank(waveform);
}

new_model = {
    'lm': 'language_model.lm_head',
    'embed': 'language_model.model.embed_tokens',
    'blocks': 'language_model.model.layers',
    'final_layernorm': 'language_model.model.norm',
    'audio': 'audio_tower',                              # ← 音频编码器
    'audio.multi_modal_projector': 'multi_modal_projector' # ← 投影层
}

# 测试纯文本
python3 llmexport.py --path /path/to/model --test "你好"

# 测试音频输入（如果有测试音频文件）
python3 llmexport.py --path /path/to/model --test "请描述这段音频 <audio>/path/to/test.wav</audio>"

visual.mnn 输入名?
├─ inputNames[0] == "patches"
│   └→ qwen2VisionProcess()
│      适用：Qwen2-VL, Qwen2.5-VL, Qwen3-VL, glm_ocr
│      特点：自行计算 RoPE position_ids, grid_thw, attention_mask
│
├─ inputNames[0] == "pixel_values" 且 inputNames.size() == 1
│   └→ smolvlmVisionProcess()
│      适用：SmolVLM, LFM2-VL（以及其他 tiling + 单输入模型）
│      特点：支持图片 tiling（按 image_size_unit 拆分）
│            visionLen 从全局图片 forward 输出动态获取
│            使用 image_size_unit / image_max_size / global_image 配置
│
├─ inputNames[0] == "pixel_values" 且 inputNames.size() > 1
│   └→ minicpmVisionProcess()
│      适用：MiniCPM-V
│      特点：需要额外的 image_grid 输入
│
└─ 其他
    └→ defaultVisionProcess()
       适用：简单模型（单张图片 resize + forward）
       特点：不支持 tiling，resize 到 image_size

输入图片
├─ 图片尺寸 > image_size_unit?
│   ├─ 是（需要 tiling）：
│   │   1. resize 全局图到 image_size_unit × image_size_unit
│   │   2. forward 全局图 → 获取 visionLen（每 tile token 数）
│   │   3. resize 大图到 grid_h × grid_w 个 tile
│   │   4. 所有 tile 拼接 forward → 每个 tile 一个 embedding
│   │   5. 全局图 embedding 也加入
│   │   6. 生成 imgIds: [vision_start, <row_col>, pad×visionLen, ...] + [vision_start, global, pad×visionLen, vision_end]
│   │
│   └─ 否（小图，单 tile）：
│       1. resize 到 image_size_unit × image_size_unit
│       2. forward → 获取 embedding
│       3. 生成 imgIds: [vision_start, global, pad×visionLen, vision_end]

输出：imgIds + mVisionEmbeddings（embedding 列表）

/path/to/image.jpg</img>描述一下这张图片

<audio>/path/to/audio.wav</audio>请描述这段音频

# 先构建（如果还没有）
cd build && cmake .. -DMNN_BUILD_LLM=ON -DMNN_LOW_MEMORY=ON && make -j$(nproc)

# 测试视觉推理
echo "/path/to/test.jpg</img>描述一下这张图片" > /tmp/prompt.txt
./llm_demo /path/to/MODEL/config.json /tmp/prompt.txt

# 测试纯文本推理（确认没有回退）
echo "你好" > /tmp/prompt.txt
./llm_demo /path/to/MODEL/config.json /tmp/prompt.txt

# tokenizer.py 中 MNNTokenizer.__init__：
if model_type == 'glm_ocr':
    user_ids = self.tokenizer.encode('<|user|>', add_special_tokens=False)
    if len(user_ids) == 1:
        self.stop_ids.append(user_ids[0])