SVGE v0 Workflow

TL;DR — Quick Mode 主路徑

GPT-Image-2 真實樣例分析

用戶實測 6 張高速公路場景（多車輛 + 路障 + 維修設備 + 不同時段/天氣），每張展示 GPT-Image-2 在 SVGE 目標場景下的真實能力：

能力證據彙整

Mask 標註參考樣例（Stage 4 後驗輸出格式）

下圖是用戶已經提供的 mask 標註範例 — 對樣例 6（夕陽 cinematic）類構圖的 7 個車輛 instance 做了二值前景分離。這正是 SVGE Pipeline Stage 4（SAM 3.1 後驗 + 細化）的目標輸出格式：

下游任務對 mask 精度需求

SVGE 主文件 §1.3 列了 6 類下游服務。並非所有下游都需要嚴格 mask 邊界精度：

Audit 歷程 — 三輪 oscillation

第二輪 audit — 三個更深問題

問題 1：Output mask 悖論

問題 2：「三角一致」的真正定義

問題 3：GPT-Image-2 多 instance 硬限制

Quick Mode — 主路徑（細節）

Quick Mode Pipeline

Prompt 構造範本（bbox → lane）

樣例顯示 GPT-Image-2 不擅長精確 bbox 控制，但很擅長「語義位置」（左/中/右車道、近/中/遠視野）。所以 v0 的 prompt 構造把 bbox 翻成自然語言位置：

def build_prompt_from_spec(spec):
    parts = []

    # 1) 場景骨架（樣例都吃這套）
    parts.append(f"{spec.scene.style} aerial view of a highway")
    parts.append(spec.scene.lighting)              # "sunset" / "daytime" / "night with rain"
    if getattr(spec.scene, 'weather', None):
        parts.append(f"in {spec.scene.weather} weather")

    # 2) per-instance 描述（GPT-Image-2 能處理的精度）
    for obj in spec.objects:
        color = obj.attributes.get('color', '')
        location = bbox_to_lane(obj.bbox)          # ★ 關鍵轉換
        parts.append(
            f"a {color} {obj.class_name} in the {location}"
        )

    # 3) 場景一致性元素（樣例都有：cones / arrow board / maintenance vehicle）
    if spec.scene.background == "road_inspection":
        parts.append("orange traffic cones lining the right shoulder")
        parts.append("yellow arrow signal board on the right")
    if spec.scene.background == "highway_construction":
        parts.append("road maintenance vehicles with red and white chevron warning patterns")

    return ", ".join(parts)


def bbox_to_lane(bbox):
    """把 normalized bbox 轉成「車道 + 視野位置」的自然語言。

    Args:
        bbox: (x, y, w, h) all in [0, 1]

    Returns:
        str like "left lane in middle view" / "right shoulder in foreground"
    """
    x, y, w, h = bbox
    cx = x + w / 2
    cy = y + h / 2

    # 水平位置 → 車道
    if cx < 0.25:    lane = "left lane"
    elif cx < 0.45:  lane = "left-middle lane"
    elif cx < 0.55:  lane = "middle lane"
    elif cx < 0.75:  lane = "right-middle lane"
    elif cx < 0.92:  lane = "right lane"
    else:           lane = "right shoulder"

    # 垂直位置 → 視野遠近
    if cy < 0.30:    depth = "far view"
    elif cy < 0.55:  depth = "middle view"
    elif cy < 0.80:  depth = "near view"
    else:           depth = "foreground"

    return f"{lane} in {depth}"

Quick Mode IoU 門檻校準表

不同下游任務對 mask 精度的容忍度不同。Quick Mode 的 SAM-bbox-IoU 過濾門檻應依下游任務動態調整，避免「一刀切 0.5」帶來的浪費或品質不足：

Strict Mode — 後備（細節）

Strict Mode Pipeline

兩模式對照

GPT-Image-2 的硬限制

① Mask edit API 不是 ControlNet 級別的條件約束

② 多 instance 的三條 workaround

③ 切換到本地 base 的觸發點

成本估算

Quick Mode — 1k 樣本（樣例校準後）

樣例顯示 GPT-Image-2 在道路維修 domain 命中率高，reject 預期從原估的 33% 下調到 25%。實際數字以 D2（100 張壓力測）為準。

Strict Mode — 1k 樣本

切到本地 FLUX.2 — 1k 樣本

v0 → v1 升級觸發點

Code skeleton

對應 prototype_v0/src/，新增 v0_workflow.py 統一兩模式 entry point：

from openai import OpenAI
from sam3 import SAM3Predictor
from transformers import AutoModel, AutoProcessor
import numpy as np

class V0Workflow:
    def __init__(self, mode: str = "quick", config: dict = None):
        assert mode in ["quick", "strict"]
        self.mode = mode
        self.openai = OpenAI()
        self.sam3 = SAM3Predictor.from_pretrained("facebook/sam3.1")
        self.qwen3vl = self._load_qwen3vl()
        self.siglip = self._load_siglip2()
        self.config = config or {}

    def generate(self, spec):
        if self.mode == "quick":
            return self._quick_pipeline(spec)
        else:
            return self._strict_pipeline(spec)

    # ============== Quick Mode ==============
    def _quick_pipeline(self, spec):
        prompt = self._build_prompt(spec)
        # Stage 3: 純文生圖
        resp = self.openai.images.generate(
            model="gpt-image-2",
            prompt=prompt,
            size="1024x1024",
            quality="high",
            n=3,
        )
        candidates = [self._download(r.url) for r in resp.data]

        for img in candidates:
            # Stage 4: SAM 3.1 後驗抽 (class, bbox, mask)
            sam_results = self.sam3.predict(
                img,
                concepts=[obj.class_name for obj in spec.objects],
            )
            # Stage 5: Qwen3-VL 抽屬性
            for inst in sam_results:
                inst.attrs = self.qwen3vl.extract_attrs(img, inst.bbox)
            # Stage 6: 鬆過濾
            if self._quick_filter(img, sam_results, spec):
                yield self._build_output(img, sam_results, spec, mode="quick")

    # ============== Strict Mode ==============
    def _strict_pipeline(self, spec):
        # Stage 2: 鎖三元組
        locked = self._lock_triples(spec)  # 每個 obj → (class, bbox, mask)
        composite_mask = self._composite_masks(locked)

        # Stage 3: GPT-Image-2 mask edit
        prompt = self._build_prompt(spec)
        resp = self.openai.images.edit(
            image=self._blank_canvas(),
            mask=composite_mask,
            prompt=prompt,
            size="1024x1024",
            n=3,
        )
        candidates = [self._download(r.url) for r in resp.data]

        for img in candidates:
            # Stage 4: 驗證 & 細化
            verify_masks = self.sam3.predict(
                img,
                concepts=[t.class_name for t in locked],
            )
            ious = [self._iou(v.mask, l.mask)
                    for v, l in zip(verify_masks, locked)]
            if min(ious) < 0.7:
                continue  # reject

            # Stage 5: 過濾
            if self._strict_filter(img, verify_masks, locked, spec):
                yield self._build_output(
                    img, verify_masks, spec,
                    mode="strict",
                    intent_ious=ious,
                )

    def _lock_triples(self, spec):
        triples = []
        for obj in spec.objects:
            if obj.mask:
                m = self._load_mask(obj.mask)
            elif obj.ref_image:
                m = self._sam3_from_ref(obj.ref_image, obj.bbox)
            else:
                m = self._bbox_to_blob(obj.bbox)
            triples.append(LockedTriple(obj.class_name, obj.bbox, m))
        return triples

    def _build_output(self, img, masks, spec, mode, intent_ious=None):
        return {
            "image": img,
            "masks": [m.mask for m in masks],   # image-aligned
            "annotation": {
                "instances": [
                    {
                        "class_name": m.class_name,
                        "bbox": m.bbox,           # SAM 抽的或 verify 的
                        "mask_pixel_grounding": True,
                        "spec_intent_iou": intent_ious[i] if intent_ious else None,
                    }
                    for i, m in enumerate(masks)
                ],
                "scene": spec.scene.dict(),
                "mode": mode,
            },
        }

References

• SVGE 主文件 — 完整研究分析（4 篇 audit + 三子系統 + 風險 + MVP）
• SVGE 主文件 §8.A — A 子系統完整六階段 pipeline
• OpenAI Images API — generate / edit / variations
• SAM 3 GitHub
• Qwen3-VL GitHub
• SigLIP 2 HuggingFace
• FLUX.2 [klein] 9B（v1 升級目標）