🔥 最新消息

• 2025.09.04 🌟 Thyme 已被 VLMEvalKit 和 LMMs-Eval 支持。欢迎随时使用！
• 2025.08.18 🌟 我们非常高兴地推出 Thyme: 超越图像的思考。Thyme 不再局限于传统的“以图像为媒介的思考”模式，而是通过可执行代码自主生成并执行多样化的图像处理与计算操作，从而显著提升在高分辨率感知和复杂推理任务上的表现。借助结合监督微调与强化学习的创新两阶段训练策略，并由新颖的 GRPO-ATS 算法赋能，Thyme 在推理探索与代码执行精度之间实现了精妙的平衡。

---

目录

1. 快速入门
2. 数据准备
3. 监督微调 (Thyme-SFT)
4. 强化学习 (Thyme-RL)
5. 评估
6. 使用示例：如何使用 Thyme
7. 引用
8. 相关项目

---

1. 快速入门

1.1 克隆仓库

git clone https://github.com/yfzhang114/Thyme.git
cd Thyme

1.2 环境设置与依赖安装

我们建议创建一个 Conda 环境以实现隔离，并按以下步骤安装依赖：

conda create -n Thyme python=3.10 -y
conda activate Thyme

pip install -e .
pip install "sglang[all]" -U
pip install "vllm>=0.5.1" "transformers<4.55" "trl<0.21" -U
pip install "lmdeploy>=0.5,<0.9" -U --no-deps
pip install autoawq -U --no-deps
pip install auto_gptq optimum bitsandbytes "gradio<5.33" -U
pip install git+https://github.com/modelscope/ms-swift.git
pip install timm -U
pip install "deepspeed<0.17" -U
pip install qwen_vl_utils qwen_omni_utils decord librosa icecream soundfile -U
pip install liger_kernel nvitop pre-commit math_verify py-spy -U
pip install wandb

pip install flash-attn --no-build-isolation --use-pep517

---

2. 数据准备

2.1 下载数据集

从 HuggingFace 数据集页面 获取训练数据。SFT 数据集包含三个子集：

• wo_thinking_thyme_single_round: 单轮图像操作数据
• 2round: 多轮对话数据
• computation: 用于计算任务的退火数据

每个样本的 image 字段是一个列表，包含原始图像和处理后的图像。

2.2 处理图像并更新路径

在训练之前，请确保所有引用的图像均已下载并保存到本地。通过将图像 URL 或远程路径替换为本地绝对路径来更新数据文件（例如 .jsonl），例如：

"image": [
  "/path/to/original_images/0904.0709_0.jpg",
  "/path/to/processed_images/0904.0709_0_6349.jpg"
]

#!/usr/bin/env python3
import os, json, base64
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed
from datasets import load_dataset
from tqdm import tqdm
import io
from PIL import Image

HF_DATA_DIR = "./data/Thyme-SFT"
ROOT_OUT    = Path("Thyme_sft_data")
IMG_ROOT    = './data/Thyme_sft_data/img'
JSONL_ROOT  = ROOT_OUT / "jsonl"
SPLITS      = ["wo_thinking_thyme_single_round", "2round", "computation"] #,  
MAX_WORKERS = os.cpu_count()      # 可根据机器配置调整

# IMG_ROOT.mkdir(parents=True, exist_ok=True)
JSONL_ROOT.mkdir(parents=True, exist_ok=True)

# ----------- 线程池任务 -----------
def save_one_image(args):
    """
    解码 Base64 字符串，处理透明度并以 JPEG 格式保存图像。

    Args:
        args (tuple): 包含 (b64_str, save_path) 的元组。
    """
    b64_str, save_path = args
    if os.path.exists(save_path):
        return save_path

    try：
        # 1. 解码 Base64 以获取原始二进制数据
        image_bytes = base64.b64decode(b64_str)

        # 2. 使用 Pillow 从二进制数据打开图像
        with Image.open(io.BytesIO(image_bytes)) as img：
            # 3. 处理透明度（关键步骤）
            # 检查图像模式是否需要处理透明度。
            # 'P' 模式可能包含透明度，'LA' 是灰度+透明度。
            # 'RGBA' 是最常见的带有透明度的模式。
            if img.mode in ("RGBA", "LA", "P")：
                # 为了统一处理所有透明度情况，首先将图像转换为 RGBA 模式。
                # 如果图像是带有透明度的 'P' 模式，转换后会得到正确的 RGBA 图像。
                img = img.convert("RGBA")

                # 创建白色背景的基础图像
                background = Image.new("RGB", img.size, (255, 255, 255))

                # 将原图粘贴到背景上。
                # 此时 img 已经是 RGBA 模式，因此可以作为自己的遮罩。
                # Pillow 会自动使用其 Alpha 通道。
                background.paste(img, (0, 0), img)
                img = background # 现在 img 是合并后的 RGB 图像

            # 如果图像模式不是 RGB（例如 'L', 'CMYK' 等），则将其转换为 RGB
            elif img.mode != "RGB":
                img = img.convert("RGB")

            # 4. 以 JPEG 格式保存图像
            # JPEG 不支持透明度，因此需要填充背景。
            img.save(save_path, "jpeg", quality=95) # 建议添加质量参数

        return str(save_path)

    except Exception as e：
        # 添加异常处理以便调试是哪张图像导致了问题
        print(f"处理 {save_path} 的图像时出错：{e}")
        return None

# ----------- 主处理 -----------
for split in SPLITS:
    print(f"\n>>> 处理分片 : {split}  (max_workers={MAX_WORKERS})")
    # 3. 写入 jsonl 文件，检查是否已存在
    jsonl_path = JSONL_ROOT / f"{split}.jsonl"
    if not jsonl_path.exists():  # 只有在 jsonl 文件不存在时才写入
        print(f"  JSONL  -> {jsonl_path}")
    else:
        print(f"  JSONL 已存在: {jsonl_path}")

    ds = load_dataset(HF_DATA_DIR, split=split)

    img_dir = IMG_ROOT + '/' + split
    # img_dir.mkdir(exist_ok=True)

    # 1. 首先收集所有需要保存的任务
    tasks = []               # (b64_str, save_path)
    records = []             # 用于写入 jsonl
    for sample_idx, sample in enumerate(ds):
        img_paths = []
        for img_idx, b64_img in enumerate(sample["image"], start=1):
            img_name = f"{sample_idx+1:08d}_{img_idx:02d}.jpg"
            img_path = img_dir + '/' + img_name
            tasks.append((b64_img, img_path))
            img_paths.append(str(img_path))
        records.append({
            "image": img_paths,
            "question": sample["question"],
            "response": sample["response"]
        })

    # 2. 使用多线程执行
    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool:
        # 只保存尚未存在的图片
        saved_images = list(tqdm(pool.map(save_one_image, tasks),
                                 total=len(tasks), desc="保存图片"))
    
    # 过滤掉返回 None 的项（即已经存在的文件）
    saved_images = [img for img in saved_images if img is not None]

    with open(jsonl_path, "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    
    print(f"  图片 -> {img_dir}  ({len(saved_images)} 张)")

print("\n全部完成（多线程）！")

2.3 文件路径转换以实现系统集成

在每个问题中，都包含一个需要转换为适合我们平台使用的正确系统路径的指定文件路径。以下步骤概述了处理这些路径的过程。

转换过程：

1. 原始路径格式：

   • 示例："用户图像路径: \"/mllm_hdd/yfzhang/data/temp_processed_images/cauldron_dvqa_images_dvqa_00110792.png_rotated_image_318.png\""

2. 转换：

   • 从原始路径中提取文件名。
   • 将其转换为系统中 image 数组的第一个元素。
   • 该元素将代表系统中的正确文件路径。

3. 响应路径转换：

   • 同样地，确保在 response 中提供的任何相应绝对路径都被转换为符合系统格式的形式。

---

3. 监督微调（Thyme-SFT）

3.1 训练数据格式

训练样本遵循以下 JSON 格式示例（完整数据集包含类似结构）：

{
  "image": ["/path/to/original.jpg", "/path/to/processed.jpg"],
  "question": "<image>\n根据右上角的图表，描述 P(z) 在 z 趋近于零时的行为。选项：\n...",
  "response": "思考>详细推理和可执行代码...<answer>B</answer>"
}

3.2 配置训练路径

在您的训练脚本或环境中设置以下变量：

• DATASET: 您的训练数据集路径
• SAVE_PATH: 保存训练模型的目录
• Model: 您的模型路径

3.3 运行训练

执行训练脚本：

sh scripts/sft_stage1.sh   # 第一阶段：监督微调
sh scripts/sft_stage2.sh   # 第二阶段：计算数据退火

注意：由于计算数据包含带图和不带图的样本，这一阶段需要分别处理并输入这两种类型的数据。请确保您的脚本能够妥善处理这一点。

---

4. 强化学习（Thyme-RL）

4.1 RL 数据集格式

每个 RL 数据样本遵循以下结构：

{
  "messages": [
    {
      "role": "system",
      "content": "您是一位乐于助人的助手。请逐步解决问题..."
    },
    {
      "role": "user",
      "content": "<image>\n问题文本...\n"
    }
  ],
  "images": ["/path/to/image.jpg"],
  "solution": "black",
  "question": "穿白衬衫的男士眼镜框是什么颜色？"
}

4.2 奖励模型配置

• Believers

示例案例（采样自 MME-RealWorld-Lite 基准）

question_text = ("问题：图片中蓝色汽车的车牌号是多少？\n选项：\n" "A. S OT 911\n" "B. S TQ 119\n" "C. S QT 911\n" "D. B QT 119\n" "E. 该图片未显示车牌号。\n" "请从以上选项中选择正确答案。") image_path = "https://oss.gittoolsai.com/images/yfzhang114_Thyme_readme_22adc671318e.jpg"

<details>
<summary>所提供示例的可视化</summary>


<img src="https://oss.gittoolsai.com/images/yfzhang114_Thyme_readme_22adc671318e.jpg" alt="示例图片" width="100%">

### ❓ 用户提示

问题：图片中蓝色汽车的车牌号是多少？ 选项： A. S OT 911 B. S TQ 119 C. S QT 911 D. B QT 119 E. 该图片未显示车牌号。 请从以上选项中选择正确答案。

---

### 🤖 模型响应
> \<think>为了确定图片中蓝色汽车的车牌号，我们需要重点关注位于车辆前部下方的车牌。与整辆车及图片的整体尺寸相比，车牌相对较小，因此对该区域进行放大有助于清晰地读取车牌上的字符。<br>
车牌的大致位置在车的前部下方，具体来说是图像下半部分的中央附近。通过裁剪并放大这一区域，可以提高车牌文字的可见度，从而更容易识别出正确选项。<br>
以下是用于裁剪并放大车牌区域的 Python 代码：<br>

> \<code>
```python
import cv2
import os
import numpy as np
from uuid import uuid4

# 加载图片
image_path = "/https://oss.gittoolsai.com/images/yfzhang114_Thyme_readme_22adc671318e.jpg"
image = cv2.imread(image_path)

# 定义车牌区域的坐标（根据图片内容推断）
x1, y1, x2, y2 = 1250, 1030, 1360, 1070

# 根据定义的坐标裁剪图片
cropped_image = image[y1:y2, x1:x2]

# 应用缩放因子以增强裁剪后的区域
zoom_factor = 2
resized_image = cv2.resize(cropped_image, None, fx=zoom_factor, fy=zoom_factor, interpolation=cv2.INTER_CUBIC)

# 使用随机后缀保存处理后的图片
random_suffix = str(uuid4())[:8]
processed_filename = f"17127_{random_suffix}.jpg"
processed_path = os.path.join("/mnt/data/temp_processed_images/", processed_filename)
cv2.imwrite(processed_path, resized_image)

# 打印保存的裁剪图片路径，以便进一步处理
print(processed_path)

</code>

<sandbox_output> </sandbox_output>

通过观察裁剪并放大的车牌图片，可以清楚地看到车牌上的字符为“S QT 911”。这与选项 C 完全一致。因此，正确答案是 C. S QT 911。</think>br>

<answer> C. S QT 911 </answer>

引用

如果您在研究或应用中发现 Thyme 有用，请引用我们的论文：

@article{zhang2025thyme,
  title={Thyme: Think Beyond Images},
  author={Zhang, Yi-Fan and Lu, Xingyu and Yin, Shukang and Fu, Chaoyou and Chen, Wei and Hu, Xiao and Wen, Bin and Jiang, Kaiyu and Liu, Changyi and Zhang, Tianke and others},
  journal={arXiv preprint arXiv:2508.11630},
  year={2025}
}

相关项目

探索我们团队的其他相关工作：

• Kwai Keye-VL
• R1-Reward: 通过稳定强化学习训练多模态奖励模型
• MM-RLHF: 多模态大模型对齐的下一步发展
• MME-RealWorld: 您的多模态大模型能否应对连人类都难以处理的高分辨率真实场景？
• MME-Survey: 多模态大模型评估的全面综述
• 超越 LLaVA-HD：深入研究高分辨率大型多模态模型
• VITA-1.5: 向 GPT-4o 级别的实时视觉与语音交互迈进

Thyme 快速上手指南

Thyme 是一款超越传统“图像思维”范式的多模态大模型。它能够通过生成和执行可执行代码，自主完成多样化的图像处理与计算操作，显著提升高分辨率感知和复杂推理任务的性能。

1. 环境准备

系统要求

• 操作系统: Linux (推荐 Ubuntu 20.04+)
• Python: 3.10
• GPU: 支持 CUDA 的 NVIDIA 显卡（建议显存 24GB+ 以运行大模型）
• 编译器: GCC, G++

前置依赖

确保已安装 conda 和 git。

2. 安装步骤

2.1 克隆仓库

git clone https://github.com/yfzhang114/Thyme.git
cd Thyme

2.2 创建并激活 Conda 环境

conda create -n Thyme python=3.10 -y
conda activate Thyme

2.3 安装依赖库

依次执行以下命令安装核心依赖。为确保兼容性，请严格按照顺序安装：

# 安装基础包
pip install -e .

# 安装推理与训练框架
pip install "sglang[all]" -U
pip install "vllm>=0.5.1" "transformers<4.55" "trl<0.21" -U
pip install "lmdeploy>=0.5,<0.9" -U --no-deps
pip install autoawq -U --no-deps

# 安装量化工具与界面库
pip install auto_gptq optimum bitsandbytes "gradio<5.33" -U

# 安装 ModelScope Swift 及相关工具
pip install git+https://github.com/modelscope/ms-swift.git
pip install timm -U
pip install "deepspeed<0.17" -U

# 安装多媒体处理与辅助库
pip install qwen_vl_utils qwen_omni_utils decord librosa icecream soundfile -U
pip install liger_kernel nvitop pre-commit math_verify py-spy -U
pip install wandb

# 安装 Flash Attention (需确保系统已安装对应版本的 CUDA Toolkit)
pip install flash-attn --no-build-isolation --use-pep517

提示：国内用户若下载缓慢，可在 pip 命令后添加 -i https://pypi.tuna.tsinghua.edu.cn/simple 使用清华镜像源。

3. 数据准备

3.1 下载数据集

从 HuggingFace 下载 SFT 训练数据（包含单轮、多轮及计算任务三个分集）：

• 数据集地址：Kwai-Keye/Thyme-SFT

3.2 图像处理与路径本地化

训练前需将数据集中的 Base64 图片解码并保存至本地，同时更新 JSONL 文件中的图片路径为绝对路径。

可以使用项目提供的脚本自动处理（需先修改脚本中的 HF_DATA_DIR 和输出路径）：

#!/usr/bin/env python3
import os, json, base64
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed
from datasets import load_dataset
from tqdm import tqdm
import io
from PIL import Image

# 配置路径
HF_DATA_DIR = "./data/Thyme-SFT" # 替换为实际下载路径或 HF 标识符
ROOT_OUT    = Path("Thyme_sft_data")
IMG_ROOT    = ROOT_OUT / "img"
JSONL_ROOT  = ROOT_OUT / "jsonl"
SPLITS      = ["wo_thinking_thyme_single_round", "2round", "computation"]
MAX_WORKERS = os.cpu_count()

IMG_ROOT.mkdir(parents=True, exist_ok=True)
JSONL_ROOT.mkdir(parents=True, exist_ok=True)

def save_one_image(args):
    b64_str, save_path = args
    if os.path.exists(save_path):
        return save_path
    try:
        image_bytes = base64.b64decode(b64_str)
        with Image.open(io.BytesIO(image_bytes)) as img:
            if img.mode in ("RGBA", "LA", "P"):
                img = img.convert("RGBA")
                background = Image.new("RGB", img.size, (255, 255, 255))
                background.paste(img, (0, 0), img)
                img = background
            elif img.mode != "RGB":
                img = img.convert("RGB")
            img.save(save_path, "jpeg", quality=95)
        return str(save_path)
    except Exception as e:
        print(f"Error processing image for {save_path}: {e}")
        return None

for split in SPLITS:
    print(f"\n>>> Processing split : {split}")
    jsonl_path = JSONL_ROOT / f"{split}.jsonl"
    
    # 加载数据集
    ds = load_dataset(HF_DATA_DIR, split=split)
    img_dir = IMG_ROOT / split
    img_dir.mkdir(exist_ok=True)

    tasks = []
    records = []
    
    for sample_idx, sample in enumerate(ds):
        img_paths = []
        for img_idx, b64_img in enumerate(sample["image"], start=1):
            img_name = f"{sample_idx+1:08d}_{img_idx:02d}.jpg"
            img_path = img_dir / img_name
            tasks.append((b64_img, str(img_path)))
            img_paths.append(str(img_path))
        records.append({
            "image": img_paths,
            "question": sample["question"],
            "response": sample["response"]
        })

    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool:
        list(tqdm(pool.map(save_one_image, tasks), total=len(tasks), desc="Saving images"))

    with open(jsonl_path, "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    
    print(f"  Done: {img_dir}")

print("\nAll done!")

3.3 路径格式修正

确保数据集中的问题（question）和回答（response）中涉及的文件路径已转换为上述生成的本地绝对路径。

4. 基本使用

4.1 监督微调 (SFT)

Thyme 的 SFT 分为两个阶段：基础指令微调与计算数据退火。

配置文件变量：

• DATASET: 处理后数据的 JSONL 路径
• SAVE_PATH: 模型保存路径
• Model: 基座模型路径

启动训练：

# 阶段 1: 监督微调
sh scripts/sft_stage1.sh

# 阶段 2: 计算数据退火 (注意：此阶段需分别处理含图和不含图的数据)
sh scripts/sft_stage2.sh

4.2 强化学习 (RL)

基于 GRPO-ATS 算法进行强化学习训练。

奖励模型配置：

• 默认支持 fmt_orm, vqa_orm, cst_orm。
• 多节点训练需在 .deepspeed_env 中配置 REWARD_API_ADDRESS 和 QWEN_API_PORT。

启动训练： 参考 scripts/rl_train.sh (需根据实际环境调整 Reward Model API 地址)。

4.3 推理示例

训练完成后，可使用 vllm 或 sglang 加载模型进行推理。数据输入格式如下：

{
  "image": ["/path/to/original.jpg", "/path/to/processed.jpg"],
  "question": "<image>\nBased on the top-right graph, describe the behavior of P(z)...",
  "response": "<think>Reasoning and code...</think><answer>B</answer>"
}

模型将自动识别 <think> 标签内的代码并执行，最终输出 <answer> 标签内的结果。