视觉即代码：GLM-5V-Turbo 如何用 94.8 分重新定义 Design2Code

当 AI 能「看懂」设计稿，你还需要手写前端吗？

前言：设计师和程序员的「最后一公里」问题

前端开发中，有一个困扰行业几十年的「最后一公里」问题：设计师给了一张设计稿，前端工程师要花几个小时甚至几天才能把它变成代码。

这中间有大量的重复劳动：把 Figma/Sketch 的图层信息翻译成 div+CSS，把设计稿里的颜色值抄写成 hex/rgb，把间距换算成 rem/vw，把字体大小对应对应的 CSS 属性……

2023 年，GitHub Copilot 解决了「从注释到代码」的问题。2024 年，Claude Code 解决了「从自然语言描述到完整项目」的问题。2026 年，智谱 AI 发布的 GLM-5V-Turbo，正在解决一个新问题：从一张设计图到完整可运行代码。

这不是简单的 OCR 识别，也不是「看图说话」式的代码描述。这是真正的「视觉即代码」（Vision-to-Code）——模型从预训练阶段就把视觉理解和代码生成融为了一体。

一、从「文本生成代码」到「视觉生成代码」：一次范式跃迁

1.1 传统多模态编程的局限

在 GLM-5V-Turbo 之前，市面上的多模态编程模型大多是「外挂式」架构：

视觉输入 → OCR/检测模块 → 文本描述 → LLM → 代码

这种方式有几个天然缺陷：

1. 信息丢失：视觉模块先把图转成文字，这个过程不可避免地丢失布局、色彩、字体、间距等视觉信息
2. 误差累积：OCR 的误差会传递到文本描述，文本描述的模糊又会传递到代码生成
3. 布局理解弱：很难捕捉设计稿的层次结构、flex 布局、grid 排列等空间关系

1.2 GLM-5V-Turbo 的原生融合路线

GLM-5V-Turbo 采用了完全不同的技术路线：从预训练阶段就深度融合视觉与语言。

视觉输入 ─────────────────────────────────────────────────┐
                                                         ↓
预训练阶段：视觉 ViT + 语言 LLM 联合训练 ─→ 统一语义空间
                                                         ↓
推理阶段：视觉编码器 + 语言解码器 端到端 ─→ 可运行代码

这种「原生融合」的核心优势在于：

• 视觉信息零损失：像素级别的视觉特征直接参与代码生成
• 布局关系原生建模：空间关系、层次结构在预训练中自动学习
• 端到端优化：视觉感知和代码生成联合优化，目标一致

在 Design2Code 基准测试中，GLM-5V-Turbo 以 94.8 分的成绩超越所有竞品，证明了原生融合路线的有效性。

二、技术架构深度解析：CogViT + MMTP

2.1 CogViT：参数高效的视觉编码器

视觉编码器是 GLM-5V-Turbo 的第一块基石。智谱团队从零构建了 CogViT（Cognitive Vision Transformer），专门面向多模态感知和下游 Agent 任务优化。

两阶段预训练

第一阶段：蒸馏式掩码图像建模（MIM）

输入图像（224×224，35% 掩码率）
        ↓
学生 ViT（待训练）← 蒸馏目标
        ↓
SigLIP2（语义教师）← 融合
DINOv3（纹理教师）← 融合
        ↓
掩码区域重建 + 特征对齐

训练数据采用「质量感知」混合策略：

• 80% 高质量自然图像
• 10% 指令跟随数据
• 10% 科学图像

优化器方面，使用 Muon（一种融合了 Adam 和 Gauss-Newton 的二阶优化器），并引入 QK-Norm（对 Query 和 Key 做归一化），解决注意力计算中的 logit 爆炸问题，提升大规模训练稳定性。

第二阶段：对比式图文预训练

高质量图文对（80亿规模，中英文双语）
        ↓
NaFlex 变尺寸输入（保留原始长宽比）
        ↓
SigLIP Loss（sigmoid 形式，全局批次 64K）
        ↓
视觉-文本特征对齐到统一嵌入空间

第二阶段有三处关键升级：

1. NaFlex 输入方案：替代固定 224×224，支持任意尺寸和长宽比输入
2. 64K 超大批次：配合双向分布式训练，提升对比学习效果
3. 80 亿双语图文：中英文图文配对，提升跨语言理解能力

性能对比

尽管 CogViT 只有 403M 参数，在多项基准上超过了更大的模型：

更小的参数，更好的效果——这得益于两阶段蒸馏和高质量数据混合策略。

2.2 MMTP：多模态多 Token 预测

传统的语言模型是自回归的，一次预测一个 Token。但 GLM-5V-Turbo 需要处理多模态输入——文本 token 和图像 token 混杂在一起。

这引入了一个核心问题：图像 token 该如何传给 MTP head？

研究团队系统对比了三种方案：

方案 1：直接传递视觉嵌入

# 直接把 LLM 主干的视觉嵌入传给 MTP head
visual_embeds = vision_encoder(image)  # [B, N_v, D]
mtp_output = mtp_head(visual_embeds)   # N_v 个预测

问题：需要在流水线并行的多个 stage 之间传递视觉 embedding，通信复杂度高。

方案 2：完全掩码视觉

# 在 MTP head 输入端把所有视觉 token 掩码掉
text_embeds = text_encoder(text)       # [B, N_t, D]
# 视觉 token 全部掩码，退化为纯文本 MTP
mtp_output = mtp_head(mask(visual_embeds))

问题：浪费了视觉信息，无法利用多模态 MTP 的优势。

方案 3：图像占位符（GLM-5V-Turbo 采用）

# 保留视觉位置信息，但把所有视觉 token 替换成一个共享可学习的图像特殊 token
class MultimodalMTPHead(nn.Module):
    def __init__(self):
        self.image_placeholder = nn.Parameter(torch.randn(D))  # 可学习
        
    def forward(self, hidden_states, visual_positions):
        # 视觉 token → 共享占位符
        placeholder_embeds = self.image_placeholder.expand(
            visual_positions.shape[0], visual_positions.shape[1], -1
        )
        # 文本 token 保持原样
        combined = replace_at_positions(hidden_states, visual_positions, placeholder_embeds)
        return self.mtp_head(combined)

为什么图像占位符方案更好？

1. 通信友好：不需要在流水线各 stage 之间传递视觉 embedding
2. 优化稳定：MTP head 通常较轻，难以有效吸收分布上与文本差异显著的视觉表示，统一形式的占位 token 反而更易优化
3. 并行兼容：天然支持序列并行（SP）和上下文并行（CP），无需额外处理

在 0.5B 模型上的消融实验显示：

三、训练体系：从感知到推理到 Agent

3.1 广覆盖联合预训练

GLM-5V-Turbo 的预训练数据覆盖了 10+ 个多模态类别：

预训练数据类别：
├── 世界知识（百科、新闻、事实）
├── 图文交错（社交媒体、博客、文档）
├── OCR（扫描文档、表格、名片）
├── 编程（代码截图、API 文档、GitHub）
├── GUI（网页截图、App 界面、设计稿）
├── 视频（教程、操作演示、动画）
├── 多模态工具使用（工具调用链）
├── 空间感知（3D 场景、地图、导航）
├── Grounding（指代消解、定位）
└── 学科问题求解（数学、物理、化学图表）

特别值得注意的是多模态编程数据的比例被大幅提升——这是 GLM-5V-Turbo 在 Design2Code 上表现出色的数据基础。

3.2 多任务 RL 优化

在 30+ 任务类别下进行联合 RL 优化，相比 SFT（监督微调）在多个维度实现提升：

# 多任务 RL 的核心优势
class MultitaskRL:
    def __init__(self):
        self.task_categories = 30+  # 感知、推理、Agent
        
    def observe(self):
        # 1. 跨域干扰更弱
        #    SFT 中常见的"学了这个忘了那个"现象减少
        #    因为 RL 的策略分布更丰富
        pass
        
    def benefit(self):
        # 2. 协同训练更稳定
        #    单任务 RL 在窄分布任务上容易震荡
        #    跨域协同通过丰富策略分布让优化更稳定
        pass
        
    def transfer(self):
        # 3. 思维模式跨任务迁移
        #    一个领域学到的推理行为能在另一个领域带来收益
        pass

3.3 大规模多模态 RL 基础设施

多任务多模态 RL 对训练系统提出了严苛的要求：prompt 与回复长度差异大、任务有单步也有多步、每个任务可能挂着不同的验证器。

智谱团队从 4 个维度重构了训练栈：

统一任务与奖励抽象

# VLM RL Gym - 统一环境接口
class VLMRLGym:
    def __init__(self):
        self.unified_interface = UnifiedTaskInterface()
        self.reward_system = IndependentRewardSystem()
        
    def add_validator(self, validator):
        # 规则验证器：本地同步执行
        # 模型验证器：API 异步调用
        self.reward_system.register(validator)

# 奖励聚合
def aggregate_rewards(rewards: list[float], strategy: str) -> float:
    if strategy == "mean":
        return sum(rewards) / len(rewards)
    elif strategy == "weighted":
        # 按数据源权重聚合
        return weighted_sum(rewards)
    elif strategy == "min":
        return min(rewards)  # 最严格

全管线解耦与异步

Rollout 推理 ←→ 奖励评估 ←→ 批构建 ←→ 权重传输
    ↑ 完全异步，最大化重叠

关键优化：

• 为推理请求注册完成回调函数，单条结束就触发奖励计算，避免被长尾请求拖累
• 参考模型的参数常驻 CPU 内存，前向传播前异步预取到 GPU，用完即释放
• 支持基于完成数或时间阈值的提前 abort，被 abort 的 prompt 可缓存复用

面向多模态的细粒度内存管理

传统重计算策略主要面向纯文本设计，难以应对多模态输入的内存压力。团队为 ViT 与 projector 模块设计了：

class MultimodalMemoryManager:
    def vit_memory_strategy(self):
        # 细粒度定向重计算 + CPU offload
        # 避免激活内存随图像数量线性膨胀
        return "granular_recompute + cpu_offload"
        
    def projector_strategy(self):
        # Projector 模块的独立内存策略
        return "isolated_memory_pool"

拓扑感知的视觉输入分区

常规实现中，每个 rank 要先持有完整 patch 张量再重新分发，造成不必要的内存与通信开销。

团队把上下文并行（CP）和张量并行（TP）策略前移到数据加载阶段：

数据加载阶段：
    1. 获取 patch 张量
    2. 与下采样组对齐分组边界
    3. 通过异步 all-to-all 精确传输
    4. 大型 Python 对象从 GPU 移到 CPU 路径
    
结果：减少约 7GB GPU 通信缓存开销

对 rollout 阶段产生的变长序列，还在序列长度和 ViT token 数两个维度上联合做 bin-packing。

四、多模态 Agent 能力：从工具链到框架集成

4.1 完整的多模态工具链

GLM-5V-Turbo 配备了一套完整的多模态工具，覆盖六大类别：

# GLM-5V-Turbo 工具链
TOOL_CATEGORIES = {
    "通用识别": ["植物识别", "地点识别", "人物识别", "物体识别"],
    "多模态搜索": ["文本搜索", "以图搜图", "相似图搜索", "学术搜索"],
    "浏览器工具": ["页面截图", "元素定位", "表单填写", "导航操作"],
    "图像处理": [
        "裁剪", "绘制2D边界框", "绘制3D边界框",
        "绘制点标注", "视频对象跟踪"
    ],
    "Web与PPT": ["网页创建", "PPT生成", "文档渲染"],
    "深度研究": ["信息抽取", "知识图谱构建", "多源融合"]
}

工具链的效果体现在基准测试上：

MMSearch-Plus 近 8 倍提升——多模态搜索能力全面超越竞品。

4.2 框架集成：感知-规划-执行闭环

GLM-5V-Turbo 可以作为认知核心，嵌入现有的 Agent 框架：

┌─────────────────────────────────────────────┐
│         完整 Agent 闭环                      │
├─────────────────────────────────────────────┤
│                                             │
│  Claude Code                                │
│  （终端环境 + 本地文件系统执行逻辑）          │
│         ↕                                    │
│  GLM-5V-Turbo                               │
│  （视觉-语言控制器：感知 + 规划）            │
│         ↕                                    │
│  AutoClaw                                   │
│  （浏览器 + GUI 自动化「双手」）             │
│                                             │
└─────────────────────────────────────────────┘

这意味着：

• AutoClaw 给 GLM-5V-Turbo 提供「眼睛」——视觉输入
• Claude Code 给 GLM-5V-Turbo 提供「手」——代码执行

模型负责看懂（视觉理解）和决策（规划），工具负责执行（操作）。

4.3 ImageMining：新一代视觉基准

研究团队还推出了 ImageMining 基准，专门测试「用图像思考」的能力。

与传统的 VQA（视觉问答）不同：

传统 VQA：
  输入：图像 + "这张图里有什么？"
  输出：文字描述
  问题：模型可以直接依赖参数知识，绕过视觉分析

ImageMining：
  输入：图像 + 复杂查询
  输出：多步工具调用 + 最终答案
  要求：必须通过多步视觉分析"挖"出线索
  
  示例：
  Step 1: 局部裁剪，放大某个细节
  Step 2: 以裁剪图构造搜索 Query
  Step 3: 整合搜索结果 + 原图信息
  Step 4: 生成最终答案

ImageMining 包含 217 道人工整理的测试题，覆盖 7 个领域：社交、娱乐、商品、地点、富文本、自然、科学。

Visual Jump 约束：强制中间推理步骤必须涉及视觉跳转，防止模型走文本捷径。

五、API 接入：快速上手视觉编程

5.1 基本调用

from zhipuai import ZhipuAI

client = ZhipuAI(api_key="your-api-key")

response = client.chat.completions.create(
    model="glm-5v-turbo",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/design.png"
                    }
                },
                {
                    "type": "text",
                    "text": "请根据这张设计稿生成对应的 HTML/CSS 代码，要求响应式布局。"
                }
            ]
        }
    ],
    stream=False,
    max_tokens=8192
)

print(response.choices[0].message.content)

5.2 Function Call 集成

# 定义工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "generate_code",
            "description": "根据设计稿生成代码",
            "parameters": {
                "type": "object",
                "properties": {
                    "framework": {
                        "type": "string",
                        "enum": ["react", "vue", "html"],
                        "description": "目标框架"
                    },
                    "style": {
                        "type": "string",
                        "enum": ["tailwind", "css", "styled-components"],
                        "description": "样式方案"
                    }
                }
            }
        }
    }
]

response = client.chat.completions.create(
    model="glm-5v-turbo",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}},
                {"type": "text", "text": "用 React + Tailwind CSS 实现这个设计稿"}
            ]
        }
    ],
    tools=tools,
    tool_choice="auto"
)

# 处理工具调用
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    if tool_call.function.name == "generate_code":
        args = json.loads(tool_call.function.arguments)
        code = generate_code(args["framework"], args["style"])
        print(code)

5.3 深度思考模式

# 开启深度思考（CoT）
response = client.chat.completions.create(
    model="glm-5v-turbo",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": "https://example.com/complex-ui.png"}},
                {"type": "text", "text": "分析这个复杂 UI 的布局结构，识别所有组件层级。"}
            ]
        }
    ],
    extra_body={
        "enable_thinking": True,  # 开启深度思考
        "thinking_depth": 3        # 思考深度
    }
)

# response.usage 会包含思考 token 和回复 token
print(f"思考 token: {response.usage.thinking_tokens}")
print(f"回复 token: {response.usage.reply_tokens}")

六、性能实测：94.8 分意味着什么

6.1 Design2Code 基准解析

Design2Code 是一个专门评估「从设计稿生成代码」能力的基准。评判维度包括：

1. 视觉相似度：生成的代码渲染后与原设计稿的视觉匹配度
2. 元素覆盖：设计稿中的关键元素是否都被实现
3. 布局还原：Flex、Grid、定位等布局技术是否正确使用
4. 样式精度：颜色、字体、间距等样式值是否准确
5. 代码质量：HTML 语义化、CSS 可维护性

GLM-5V-Turbo 的 94.8 分意味着：在大多数测试用例上，生成的代码渲染后与原设计稿高度相似，肉眼几乎无法区分。

6.2 实战案例

案例 1：Figma 设计稿 → React 组件

输入：一张 Figma 导出的 PNG 设计稿（包含：
      - Hero 区域：大标题 + 副标题 + CTA 按钮
      - 特性卡片区：3 列等宽卡片
      - Footer：版权信息和链接

输出：完整的 React + Tailwind CSS 组件
      - 响应式适配（移动端卡片堆叠）
      - 动画效果（渐入、hover）
      - 组件拆分（HeroSection, FeatureCard, Footer）

案例 2：App 截图 → Flutter 代码

# 输入：一张 iOS App 截图
# 输出：Flutter 等价代码

# 识别到的 UI 结构：
# - SafeArea
#   - Scaffold
#     - AppBar（title: "我的应用", actions: [...]）
#     - Body: ListView
#       - ListTile × 3（icon + title + subtitle）
#     - FloatingActionButton

# 生成的 Flutter 代码：
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('我的应用'),
          actions: [
            IconButton(icon: Icon(Icons.search), onPressed: () {}),
            IconButton(icon: Icon(Icons.more_vert), onPressed: () {}),
          ],
        ),
        body: ListView(
          children: [
            ListTile(
              leading: Icon(Icons.star),
              title: Text('收藏'),
              subtitle: Text('10 个收藏项'),
            ),
            ListTile(
              leading: Icon(Icons.history),
              title: Text('历史'),
              subtitle: Text('最近浏览'),
            ),
            ListTile(
              leading: Icon(Icons.settings),
              title: Text('设置'),
              subtitle: Text('应用设置'),
            ),
          ],
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () {},
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}

案例 3：视频教程 → 代码实现

GLM-5V-Turbo 还能处理视频输入：给一段操作演示视频，让模型「照着做」。

输入：一段 30 秒的屏幕录制视频
      演示了在 VS Code 中创建一个 React 项目
      安装 tailwindcss，配置 postcss
      创建一个 Hero 组件
      
输出：完整的操作脚本和代码文件
      - 项目初始化命令
      - 配置文件内容
      - 所有组件代码
      - 后续维护指南

七、局限与未来方向

7.1 当前局限

Agent 策略涌现受限

当前 Agent 训练高度依赖人工或强过滤的冷启动轨迹，这压缩了模型能探索的推理与动作模式空间。RL 容易陷在「已有路径上的局部改进」。

要实现「让模型自己发现更好的策略，乃至涌现出子 Agent 分解、多 Agent 协作等更丰富的组织形式」，还有很长的路要走。

多模态上下文管理瓶颈

与文本相比，图像和视频对上下文预算的消耗大得多。长轨迹中保留全部视觉观测在工程上几乎不可行。

当前许多系统的做法是直接丢弃早期视觉观测，但这会丢掉后续推理可能用到的关键信息。文本场景下成熟的「压缩历史」做法（如 Claude Code 的 auto-compact）在多模态下并不直接适用。

多模态原生的上下文与记忆机制依然是一个开放问题。

7.2 未来方向

1. 更长上下文：当前 200K 上下文对于复杂多页 App 设计仍不够，需要进一步扩展
2. 原生视频理解：视频帧的时序关系处理还不够优雅
3. 更丰富的工具集：当前的工具链覆盖面已经很广，但与真实开发场景还有差距
4. Harness 共进化：Agent 系统的能力边界由模型和 harness 共同塑造，需要联合优化

八、开发者指南：如何用 GLM-5V-Turbo 提升开发效率

8.1 典型使用场景

# 场景 1：设计稿评审
# 设计师给你一张图，你不确定能不能实现
# 让模型评估可行性并给出初步方案

def evaluate_design(image_url: str) -> dict:
    response = client.chat.completions.create(
        model="glm-5v-turbo",
        messages=[{
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": image_url}},
                {"type": "text", "text": """
                    请从以下几个维度评估这个设计稿：
                    1. 技术可行性（哪些部分容易实现，哪些有挑战）
                    2. 预估开发工时
                    3. 可能的性能问题
                    4. 响应式适配建议
                    5. 如果有实现难点，给出替代方案
                """}
            ]
        }]
    )
    return {"evaluation": response.choices[0].message.content}

# 场景 2：批量 UI 组件生成
# 给定一个设计系统（如 Ant Design），生成符合规范的组件

def generate_component(design_system_url: str, requirements: str) -> str:
    response = client.chat.completions.create(
        model="glm-5v-turbo",
        messages=[{
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": design_system_url}},
                {"type": "text", "text": f"""
                    这是我们的设计系统规范。
                    请根据以下需求生成组件代码：
                    {requirements}
                    
                    要求：
                    - 使用 Ant Design 组件
                    - 遵循设计系统的色彩和间距规范
                    - TypeScript + React
                """}
            ]
        }]
    )
    return response.choices[0].message.content

# 场景 3：截图 Bug 复现
# QA 给你一个 Bug 截图，让前端复现

def reproduce_bug(bug_screenshot: str, context: str) -> str:
    response = client.chat.completions.create(
        model="glm-5v-turbo",
        messages=[{
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": bug_screenshot}},
                {"type": "text", "text": f"""
                    这是一个 UI Bug 的截图。
                    背景信息：{context}
                    
                    请：
                    1. 分析 Bug 的具体表现
                    2. 推测可能的原因
                    3. 生成修复代码
                    4. 如果需要更多信息，说明还需要什么
                """}
            ]
        }]
    )
    return response.choices[0].message.content

8.2 最佳实践

1. 提供清晰的上下文

# ✅ 好例子：提供完整上下文
messages = [{
    "role": "user",
    "content": [
        {"type": "image_url", "image_url": {"url": design_url}},
        {"type": "text", "text": """
            这是我们的 React + Tailwind CSS 项目中的设计稿。
            我们使用 TypeScript，颜色系统基于 Tailwind 的 slate 色板。
            请生成符合我们现有代码风格的组件。
        """}
    ]
}]

# ❌ 差例子：缺少上下文
messages = [{
    "role": "user",
    "content": [
        {"type": "image_url", "image_url": {"url": design_url}},
        {"type": "text", "text": "生成代码"}
    ]
}]

2. 分步处理复杂设计

# 复杂设计不要一次性生成，先拆分再组合

def process_complex_design(image_url: str):
    # Step 1: 布局分析
    layout = analyze_layout(image_url)
    print("布局结构:", layout)
    
    # Step 2: 逐组件生成
    for component in layout["components"]:
        code = generate_component(image_url, component)
        print(f"组件 {component['name']}:", code)
    
    # Step 3: 组装
    final_code = assemble_components(layout, component_codes)
    return final_code

3. 使用深度思考处理复杂场景

# 复杂设计稿（多层嵌套、交互要求多）使用深度思考
response = client.chat.completions.create(
    model="glm-5v-turbo",
    messages=[...],
    extra_body={
        "enable_thinking": True,
        "thinking_depth": 5  # 复杂场景增加深度
    }
)

九、总结：视觉即代码的时代已来

GLM-5V-Turbo 的发布，标志着「视觉即代码」从概念走向实用。

三个核心突破：

1. 原生多模态融合：从预训练阶段就深度融合视觉与语言，突破了传统外挂式架构的瓶颈
2. 94.8 分 Design2Code：在权威基准上超越所有竞品，证明了技术路线的有效性
3. 完整 Agent 生态：从模型到工具链到框架集成，形成了完整的视觉编程闭环

对开发者的影响：

• 设计师 → 代码 的鸿沟大幅缩小
• UI 还原 工作可以从手动转为自动化
• 多模态 Agent 的能力边界进一步扩展

下一步：

• 更长的上下文支持（200K → 1M？）
• 原生视频理解能力
• 与更多 IDE 和设计工具的深度集成

视觉即代码的时代已经到来。你准备好了吗？

相关资源：

• 技术报告：https://arxiv.org/pdf/2604.26752
• 模型 API：https://bigmodel.cn/dev/api
• Vision2Web 基准：https://arxiv.org/abs/2603.26648
• GitHub：https://github.com/THUDM/GLM-5V-Turbo