Upload folder using huggingface_hub

c2i.py

@@ -0,0 +1,376 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--prompt", type=str, default="A mountain range.", help="Prompt text for generation.")
+    parser.add_argument("--image_root", type=str, default="./assets/1/", help="Prompt text for generation.")
+    parser.add_argument("--condition", type=list[str], default=['lineart'], help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./demo_c2i_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+@torch.inference_mode()
+def init_t2i(args, images, role, pipe, iter_num, post_processors, modality_names, generator):
+
+    # --------------------------
+    # Inference
+    # --------------------------
+
+    print(f"🚀 Generating with prompt: {args.prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=args.prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+def image_refine(prompt, images, role, pipe, root, iter_num, modality_names, generator):
+
+    #control_images = []
+    #for name in modality_names:
+    #    control_images.append(Image.open(os.path.join(root, name+'.png')).convert("RGB"))
+
+    print(f"🚀 Generating with prompt: {args.prompt}")
+    prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_paths = glob.glob(os.path.join(args.image_root, '*.jpg'))
+
+    control_images = []
+
+    for name in modality_names:
+        found_path = None
+        for c in args.condition:
+            matched_files = [f for f in image_paths if c in f and c in name]
+            if matched_files:
+                found_path = matched_files[0]
+                break
+        control_images.append(Image.open(found_path).convert("RGB") if found_path else None)
+
+
+    role = [0 if img is None else 1 for img in control_images]
+    print(role)
+    
+    init_dir = init_t2i(args, control_images, role, pipe, 0, post_processors, modality_names, generator)
+
+    save_dir = init_dir
+    prompt = args.prompt
+    max_length  = 1024
+    for step in range(1, args.iters):
+        prompt = text_refine(save_dir, model, processor, prompt, step, max_length)
+        max_length += 100
+        save_dir = image_refine(prompt, control_images, role, pipe, save_dir, step, modality_names, generator)
+
+

c2t.py

@@ -0,0 +1,448 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_init_message(image_paths, role):
+    """
+    Build Qwen3-VL message for multi-modal image description.
+    - `image_paths`: list of image file paths in modality order.
+    - `role`: list[int] of 0/1, indicating which modalities are active.
+    - Includes per-modality visual descriptions.
+    - No coarse caption, fixed instruction: "Describe this image."
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 输入检查 ---
+    if len(role) != len(modality_names):
+        raise ValueError(f"role length {len(role)} must match modality_names length {len(modality_names)}")
+    if len(image_paths) != sum(role):
+        raise ValueError(f"image_paths length {len(image_paths)} must match modality_names length {len(modality_names)}")
+
+    # --- 每个模态的视觉提示定义 ---
+    modality_descriptions = {
+        "image": "provides color, texture, lighting, and overall visual appearance.",
+        "annotation_lineart": "reveals fine structural outlines, shapes, and proportions.",
+        "annotation_edge": "highlights boundaries and contours of objects.",
+        "annotation_depth": "shows spatial distance, perspective, and 3D geometry.",
+        "annotation_normal": "captures surface orientation and fine geometric curvature.",
+        "annotation_albedo": "shows intrinsic surface colors unaffected by lighting.",
+        "annotation_seg_12colors": "provides semantic regions and object boundaries.",
+        "annotation_openpose": "shows human body keypoints, orientation, and posture.",
+    }
+
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    # --- 选择存在的模态与路径 ---
+    selected_modalities = [m for m, r in zip(modality_names, role) if r == 1]
+    available = [str(Path(p)) for p in image_paths]
+
+    if not available:
+        raise FileNotFoundError("No valid modality images found in image_paths for selected roles.")
+
+    # --- 拼接模态说明 ---
+    modality_desc_text = " ".join(
+        [f"- The {readable_map[m]} {modality_descriptions[m]}" for m in selected_modalities]
+    )
+
+    # --- 构造文本提示 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: "
+        f"{', '.join([readable_map[m] for m in selected_modalities])}. "
+        f"{modality_desc_text} "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT mention modality names explicitly. "
+        f"Describe this image."
+        + " " + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="./assets/2/", help="Prompt text for generation.")
+    parser.add_argument("--condition", type=list[str], default=["normal"], help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--height", type=int, default=768)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./demo_c2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, role, iter_num, max_length=300):
+    messages = build_init_message(image_path, role)
+
+    print(f'init prompt:{messages}')
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator):
+
+    #print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    import glob
+    image_paths = glob.glob(os.path.join(args.image_root, '*.jpg')) + glob.glob(os.path.join(args.image_root, '*.png'))
+
+    control_images = []
+
+    for name in modality_names:
+        found_path = None
+        for c in args.condition:
+            matched_files = [f for f in image_paths if c in f and c in name]
+            if matched_files:
+                found_path = matched_files[0]
+                break
+        control_images.append(Image.open(found_path).convert("RGB") if found_path else None)
+
+
+    role = [0 if img is None else 1 for img in control_images]
+    print(role)
+    
+    max_length  = 1024
+    prompt = init_i2t(model, processor, image_paths, role, 0, max_length)
+
+    for step in range(1, args.iters):
+        save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator)
+        max_length += 100
+        prompt = text_refine(save_dir, model, processor, prompt, step, max_length)
+
+

code/test_real1.py

@@ -0,0 +1,805 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        #f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    #content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    #content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    #content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[1:306]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

code/test_realworldqa_vqa.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[:153]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

i2t.py

@@ -0,0 +1,358 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_path", type=str, default="./assets/test_images/pexels-jplenio-1105378.jpg", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--height", type=int, default=768)
+    parser.add_argument("--width", type=int, default=1152)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./demo_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_path = args.image_path
+
+    control_images = [Image.open(image_path).convert("RGB")] + [None] * pipe.num_conditions
+
+    role=[1] + [0] * pipe.num_conditions
+    print(role)
+    
+    max_length  = 1024
+    prompt = init_i2t(model, processor, image_path, 0, max_length)
+
+    for step in range(1, args.iters):
+        save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator)
+        max_length += 100
+        prompt = text_refine(save_dir, model, processor, prompt, step, max_length)
+
+

jodi_pipeline.py

@@ -0,0 +1,333 @@
+#s file is modified from https://github.com/NVlabs/Sana
+
+# Copyright 2024 NVIDIA CORPORATION & AFFILIATES
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import warnings
+import pyrallis
+from dataclasses import dataclass, field
+from typing import Tuple, List
+from PIL import Image
+
+import torch
+import torchvision.transforms as T
+
+warnings.filterwarnings("ignore")  # ignore warning
+
+
+from diffusion import DPMS
+from model.builder import build_model, get_tokenizer_and_text_encoder, get_vae, vae_decode, vae_encode
+from model.utils import get_weight_dtype, prepare_prompt_ar
+from utils.config import BaseConfig, ModelConfig, AEConfig, TextEncoderConfig, SchedulerConfig, model_init_config
+from utils.logger import get_root_logger
+
+from tools.download import find_model
+
+
+def read_image(image):
+    if isinstance(image, str):
+        assert os.path.exists(image), f"Image {image} does not exist."
+        image = Image.open(image).convert("RGB")
+        transform = T.Compose([T.ToTensor(), T.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
+        image = transform(image)
+    elif isinstance(image, Image.Image):
+        transform = T.Compose([T.ToTensor(), T.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
+        image = transform(image)
+    elif isinstance(image, torch.Tensor):
+        assert image.ndim == 3, "Image tensor should be 3D."
+    else:
+        raise TypeError("Unsupported image type. Expected str, PIL Image, or Tensor.")
+    return image
+
+
+def classify_height_width_bin(height: int, width: int, ratios: dict) -> Tuple[int, int]:
+    """Returns binned height and width."""
+    ar = float(height / width)
+    closest_ratio = min(ratios.keys(), key=lambda ratio: abs(float(ratio) - ar))
+    default_hw = ratios[closest_ratio]
+    return int(default_hw[0]), int(default_hw[1])
+
+
+@dataclass
+class JodiInference(BaseConfig):
+    model: ModelConfig
+    vae: AEConfig
+    text_encoder: TextEncoderConfig
+    scheduler: SchedulerConfig
+    config: str = "./configs/inference.yaml"
+    conditions: List[str] = field(default_factory=list)
+    work_dir: str = "output/"
+
+
+class JodiPipeline:
+    def __init__(
+        self,
+        config: str,
+        device: torch.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu"),
+    ):
+        super().__init__()
+        config = pyrallis.load(JodiInference, open(config))
+        self.config = config
+        self.device = device
+        self.logger = get_root_logger()
+        self.progress_fn = lambda progress, desc: None
+
+        # set some hyperparameters
+        self.image_size = config.model.image_size
+        self.latent_size = self.image_size // config.vae.vae_downsample_rate
+        self.max_sequence_length = config.text_encoder.model_max_length
+        self.flow_shift = config.scheduler.flow_shift
+
+        self.weight_dtype = get_weight_dtype(config.model.mixed_precision)
+        self.vae_dtype = get_weight_dtype(config.vae.weight_dtype)
+
+        self.logger.info(f"flow_shift: {self.flow_shift}")
+        self.logger.info(f"Inference with {self.weight_dtype}")
+
+        self.num_conditions = len(config.conditions)
+
+        # 1. build vae and text encoder
+        self.vae = self.build_vae(config.vae)
+        self.tokenizer, self.text_encoder = self.build_text_encoder(config.text_encoder)
+
+        # 2. build Jodi
+        self.model = self.build_jodi(config).to(self.device)
+
+        # 3. pre-compute null embedding
+        with torch.no_grad():
+            null_caption_token = self.tokenizer(
+                "", max_length=self.max_sequence_length, padding="max_length", truncation=True, return_tensors="pt"
+            ).to(self.device)
+            self.null_caption_embs = self.text_encoder(
+                null_caption_token.input_ids, null_caption_token.attention_mask
+            )[0]
+
+    @property
+    def base_ratios(self):
+        return {
+            "0.25": [512.0, 2048.0],  # 1:4
+            "0.33": [576.0, 1728.0],  # 1:3
+            "0.4": [640.0, 1600.0],   # 2:5
+            "0.5": [704.0, 1408.0],   # 1:2
+            "0.67": [768.0, 1152.0],  # 2:3
+            "0.75": [864.0, 1152.0],  # 3:4
+            "0.82": [896.0, 1088.0],  # 5:6
+            "1.0": [1024.0, 1024.0],  # 1:1
+            "1.21": [1088.0, 896.0],  # 6:5
+            "1.33": [1152.0, 864.0],  # 4:3
+            "1.5": [1152.0, 768.0],   # 3:2
+            "2.0": [1408.0, 704.0],   # 2:1
+            "2.5": [1600.0, 640.0],   # 5:2
+            "3.0": [1728.0, 576.0],   # 3:1
+            "4.0": [2048.0, 512.0],   # 4:1
+        }
+
+    def build_vae(self, config):
+        vae = get_vae(config.vae_type, config.vae_pretrained, self.device).to(self.vae_dtype)
+        return vae
+
+    def build_text_encoder(self, config):
+        tokenizer, text_encoder = get_tokenizer_and_text_encoder(name=config.text_encoder_name, device=self.device)
+        return tokenizer, text_encoder
+
+    def build_jodi(self, config):
+        # model setting
+        model_kwargs = model_init_config(config, latent_size=self.latent_size)
+        model = build_model(
+            config.model.model,
+            use_fp32_attention=config.model.get("fp32_attention", False) and config.model.mixed_precision != "bf16",
+            num_conditions=self.num_conditions,
+            **model_kwargs,
+        )
+        self.logger.info(f"use_fp32_attention: {model.fp32_attention}")
+        self.logger.info(
+            f"{model.__class__.__name__}:{config.model.model},"
+            f"Model Parameters: {sum(p.numel() for p in model.parameters()):,}"
+        )
+        return model
+
+    def from_pretrained(self, model_path):
+        state_dict = find_model(model_path)
+        state_dict = state_dict.get("state_dict", state_dict)
+        if "pos_embed" in state_dict:
+            del state_dict["pos_embed"]
+        missing, unexpected = self.model.load_state_dict(state_dict, strict=False)
+        self.model.eval().to(self.weight_dtype)
+
+        self.logger.info(f"Generating sample from ckpt: {model_path}")
+        self.logger.warning(f"Missing keys: {missing}")
+        self.logger.warning(f"Unexpected keys: {unexpected}")
+
+    def register_progress_bar(self, progress_fn=None):
+        self.progress_fn = progress_fn if progress_fn is not None else self.progress_fn
+
+    @torch.inference_mode()
+    def __call__(
+        self,
+        images,
+        role,
+        prompt="",
+        height=1024,
+        width=1024,
+        negative_prompt="",
+        num_inference_steps=20,
+        guidance_scale=4.5,
+        num_images_per_prompt=1,
+        generator=None,
+        latents=None,
+    ):
+        ori_height, ori_width = height, width
+        height, width = classify_height_width_bin(height, width, ratios=self.base_ratios)
+        latent_size_h, latent_size_w = (
+            height // self.config.vae.vae_downsample_rate,
+            width // self.config.vae.vae_downsample_rate,
+        )
+
+        # pre-compute negative embedding
+        if negative_prompt != "":
+            null_caption_token = self.tokenizer(
+                negative_prompt,
+                max_length=self.max_sequence_length,
+                padding="max_length",
+                truncation=True,
+                return_tensors="pt",
+            ).to(self.device)
+            self.null_caption_embs = self.text_encoder(
+                null_caption_token.input_ids, null_caption_token.attention_mask
+            )[0]
+
+        # compute clean_x
+        if len(images) != 1 + self.num_conditions:
+            raise ValueError(f"Number of images {len(images)} != {1 + self.num_conditions}.")
+        if len(role) != 1 + self.num_conditions:
+            raise ValueError(f"Number of roles {len(role)} != {1 + self.num_conditions}.")
+        clean_x = [
+            torch.zeros(
+                1,
+                self.config.vae.vae_latent_dim,
+                latent_size_h,
+                latent_size_w,
+                device=self.device,
+                dtype=self.vae_dtype,
+            )
+        ] * (self.num_conditions + 1)
+        for i, image in enumerate(images):
+            if role[i] == 1:
+                assert image is not None
+                image = read_image(image).unsqueeze(0).to(self.device, self.vae_dtype)
+
+                image_height, image_width = image.shape[-2:]
+                if height / image_height > width / image_width:
+                    resize_size = height, int(image_width * height / image_height)
+                else:
+                    resize_size = int(image_height * width / image_width), width
+
+                resize_and_crop = T.Compose([
+                    T.Resize(resize_size, interpolation=T.InterpolationMode.BILINEAR, antialias=True),
+                    T.CenterCrop((height, width)),
+                ])
+                image = resize_and_crop(image)
+                clean_x[i] = vae_encode(
+                    self.config.vae.vae_type, self.vae, image, self.config.vae.sample_posterior, self.device
+                )
+        clean_x = torch.stack(clean_x, dim=1)  # (1, 1+K, 32, 32, 32)
+        role = torch.tensor(role).unsqueeze(0)  # (1, 1+K)
+        role = role.to(dtype=torch.long, device=self.device)
+
+        prompts = [
+            prepare_prompt_ar(prompt, self.base_ratios, device=self.device, show=False)[0].strip()
+            for _ in range(num_images_per_prompt)
+        ]
+
+        with torch.no_grad():
+            # prepare text feature
+            if not self.config.text_encoder.chi_prompt:
+                max_length_all = self.config.text_encoder.model_max_length
+                prompts_all = prompts
+            else:
+                chi_prompt = "\n".join(self.config.text_encoder.chi_prompt)
+                prompts_all = [chi_prompt + prompt for prompt in prompts]
+                num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt))
+                max_length_all = (
+                    num_chi_prompt_tokens + self.config.text_encoder.model_max_length - 2
+                )  # magic number 2: [bos], [_]
+
+            caption_token = self.tokenizer(
+                prompts_all,
+                max_length=max_length_all,
+                padding="max_length",
+                truncation=True,
+                return_tensors="pt",
+            ).to(device=self.device)
+            select_index = [0] + list(range(-self.config.text_encoder.model_max_length + 1, 0))
+            caption_embs = self.text_encoder(caption_token.input_ids, caption_token.attention_mask)[0][:, None][
+                :, :, select_index
+            ].to(self.weight_dtype)
+            emb_masks = caption_token.attention_mask[:, select_index]
+            null_y = self.null_caption_embs.repeat(len(prompts), 1, 1)[:, None].to(self.weight_dtype)
+
+            n = len(prompts)
+            if latents is None:
+                z = torch.randn(
+                    n,
+                    1 + self.num_conditions,
+                    self.config.vae.vae_latent_dim,
+                    latent_size_h,
+                    latent_size_w,
+                    generator=generator,
+                    device=self.device,
+                )
+            else:
+                assert latents.shape == (
+                    n,
+                    1 + self.num_conditions,
+                    self.config.vae.vae_latent_dim,
+                    latent_size_h,
+                    latent_size_w,
+                )
+                z = latents.to(self.device)
+            role = role.repeat(n, 1)
+            clean_x = clean_x.repeat(n, 1, 1, 1, 1)
+
+            model_kwargs = dict(mask=emb_masks, role=role, clean_x=clean_x)
+            scheduler = DPMS(
+                self.model,
+                condition=caption_embs,
+                uncondition=null_y,
+                cfg_scale=guidance_scale,
+                model_type="flow",
+                model_kwargs=model_kwargs,
+                schedule="FLOW",
+            )
+            scheduler.register_progress_bar(self.progress_fn)
+            sample = scheduler.sample(
+                z,
+                steps=num_inference_steps,
+                order=2,
+                skip_type="time_uniform_flow",
+                method="multistep",
+                flow_shift=self.flow_shift,
+            )
+
+        sample = torch.where(torch.eq(role, 1)[:, :, None, None, None], clean_x, sample)
+        sample = sample.to(self.vae_dtype)
+        sample = torch.unbind(sample, dim=1)
+        with torch.no_grad():
+            sample = [vae_decode(self.config.vae.vae_type, self.vae, s) for s in sample]
+        resize = T.Resize((ori_height, ori_width), interpolation=T.InterpolationMode.BILINEAR)
+        sample = [resize(s).clamp(-1, 1) for s in sample]
+        return sample

old_code/test_realworldqa_vqa.py

@@ -0,0 +1,620 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png"]:
+        image_path = str(root_path)
+        text_prompt = (
+            f"You are given one RGB image and a text description of the same scene.\n"
+            f"Scene description: \"{prompt}\"\n\n"
+            f"Now analyze the image carefully and answer the following question based only on what is visible.\n"
+            f"Do NOT guess or add details not supported by the image.\n"
+            f"Question: \"{question}\"\n"
+            "<image>"
+        )
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": text_prompt},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        f"so use them only as optional references for additional context. "
+        f"Each modality provides complementary information about the same visual content:\n"
+        f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        f"- The edge map emphasizes boundaries and contours.\n"
+        f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        f"- The normal map shows surface orientation and geometric curvature.\n"
+        f"- The albedo map presents true surface color without illumination or shadows.\n"
+        f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+   
+
+    content = []
+
+    text_prompt = ("you are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}.\n"
+    f"Each modality provides a different aspect of visual information about the same scene.\n\n"
+    f"### Modality Information:\n"
+    f"- **RGB image:** shows colors, textures, lighting, and overall appearance.\n"
+    f"- **Line drawing:** reveals outlines, object contours, and structural details.\n"
+    f"- **Edge map:** highlights strong edges and object boundaries.\n"
+    f"- **Depth map:** encodes per-object spatial distance and perspective. "
+    f"For each main object, estimate its approximate physical distance from the camera or ground reference "
+    f"in **meters**. "
+    f"If multiple objects are visible, provide numeric distances rather than qualitative terms like "
+    f"'closer' or 'farther'.\n"
+    f"- **Normal map:** provides surface orientation and facing direction.\n"
+    f"- **Albedo map:** shows true surface color unaffected by lighting or shadows.\n"
+    f"- **Segmentation map:** divides the image into semantic regions and object categories.\n"
+    f"- **Human pose map:** depicts human keypoints, poses, and orientations if present.\n\n"
+    f"### Your Task:\n"
+    f"Refine the coarse caption into a detailed, modality-wise visual description. "
+    f"For each available modality listed above, generate one corresponding description paragraph "
+    f"based only on what that modality shows.\n\n"
+    f"### Rules:\n"
+    f"1. Follow the order and modality names given in 'Modality Information'.\n"
+    f"2. Start each paragraph with the modality name (e.g., 'RGB image:').\n"
+    f"3. Describe only what is visible in that modality—do NOT merge or summarize multiple modalities.\n"
+    f"4. Use **numeric distance estimates in meters** for the depth map whenever possible.\n"
+    f"5. Use clear and factual language (no imagination or hallucination).\n"
+    #f"6. You may use the following feedback for improvement: '{feedback}'\n\n"
+    f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    f"Now, according to the 'Modality Information' above, write one detailed description for each available modality below."
+    )
+
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=41)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    You are given one RGB image and a description that may include references
+    to multiple visual modalities (e.g., depth map, normal map, segmentation map, etc.).
+    These terms are just analytical perspectives of the same scene — they should not reduce
+    the consistency score. Focus only on whether the described visual content matches what
+    is visible in the RGB image.
+    Your task:
+    1. Judge how accurately the text describes what is visually present in the image.
+    2. Ignore mentions of modality names (such as 'depth map' or 'normal map').
+    3. Provide a consistency score between 0.0 (completely mismatched) and 1.0 (perfect match).
+    4. Provide one short feedback sentence suggesting how to make the description better aligned.
+    Return JSON strictly in this format:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[1:255]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+            
+            #if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, max_length)
+        print(f'result:{result}')

old_code/test_realworldqa_vqa1.py

@@ -0,0 +1,669 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[:153]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

old_code/test_realworldqa_vqa2.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[153:306]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

old_code/test_realworldqa_vqa3.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[306:459]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

old_code/test_realworldqa_vqa4.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[459:612]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

old_code/test_realworldqa_vqa5.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[612:]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

qwen_real.py

@@ -0,0 +1,449 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow question: "
+            f"Question: \"{question}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images", help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json", help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, question, image_id, max_length)
+
+

qwen_vqa_Agricultur.py

@@ -0,0 +1,471 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question, options, subfield):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    options_list = ast.literal_eval(options)
+    option_text = "\n".join([f"{chr(65+i)}. {opt}" for i, opt in enumerate(options_list)])
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Scientific Subfield: \"{subfield}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow multiple-choice question: "
+            f"Question: \"{question}\" "
+            f"Options: \"{option_text}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/MMMU/Agriculture/validation-00000-of-00001.parquet", help="Prompt text for generation.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_Agricultur_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, vqa_id, question, option, max_length=300):
+    
+    options_list = ast.literal_eval(option)
+    option_text="\n".join([f"{chr(65+i)}.{opt}" for i, opt in enumerate(options_list)])
+
+    question = clean_question(question)
+
+    text_prompt = (
+            f"Analyze the given image <image> and answer the following question."
+            f"Question: \"{question}\" \n"
+            f"Options: \"{option_text}\" "
+            )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": text_prompt},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, options, subfield, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question, options, subfield)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, subfield):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    prompt = f'{subfield} image,' + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    dataset = load_dataset(
+        "parquet",
+        data_files=args.data_path,
+        split="train")
+
+    for sample in dataset:
+
+        image_keys = [f"image_{i}" for i in range(1, 8)]
+        num_images = sum(1 for key in image_keys if key in sample and isinstance(sample[key], type(sample["image_1"])) and sample[key] is not None)
+
+        if num_images > 1:
+            continue
+
+        image = sample["image_1"]
+        image_path = dump_image(image, args.temp_dir)
+        question = clean_question(sample["question"])        
+        image_id = sample["id"]
+        options = sample["options"]
+        field = sample["subfield"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, image_id, question,  options, max_length)
+

qwen_vqa_Art.py

@@ -0,0 +1,471 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question, options, subfield):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    options_list = ast.literal_eval(options)
+    option_text = "\n".join([f"{chr(65+i)}. {opt}" for i, opt in enumerate(options_list)])
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Scientific Subfield: \"{subfield}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow multiple-choice question: "
+            f"Question: \"{question}\" "
+            f"Options: \"{option_text}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/MMMU/Art/validation-00000-of-00001.parquet", help="Prompt text for generation.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_Art_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, vqa_id, question, option, max_length=300):
+    
+    options_list = ast.literal_eval(option)
+    option_text="\n".join([f"{chr(65+i)}.{opt}" for i, opt in enumerate(options_list)])
+
+    question = clean_question(question)
+
+    text_prompt = (
+            f"Analyze the given image <image> and answer the following question."
+            f"Question: \"{question}\" \n"
+            f"Options: \"{option_text}\" "
+            )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": text_prompt},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, options, subfield, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question, options, subfield)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, subfield):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    prompt = f'{subfield} image,' + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    dataset = load_dataset(
+        "parquet",
+        data_files=args.data_path,
+        split="train")
+
+    for sample in dataset:
+
+        image_keys = [f"image_{i}" for i in range(1, 8)]
+        num_images = sum(1 for key in image_keys if key in sample and isinstance(sample[key], type(sample["image_1"])) and sample[key] is not None)
+
+        if num_images > 1:
+            continue
+
+        image = sample["image_1"]
+        image_path = dump_image(image, args.temp_dir)
+        question = clean_question(sample["question"])        
+        image_id = sample["id"]
+        options = sample["options"]
+        field = sample["subfield"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, image_id, question,  options, max_length)
+

qwen_vqa_Artthepry.py

@@ -0,0 +1,471 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question, options, subfield):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    options_list = ast.literal_eval(options)
+    option_text = "\n".join([f"{chr(65+i)}. {opt}" for i, opt in enumerate(options_list)])
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Scientific Subfield: \"{subfield}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow multiple-choice question: "
+            f"Question: \"{question}\" "
+            f"Options: \"{option_text}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/MMMU/Art_Theory/validation-00000-of-00001.parquet", help="Prompt text for generation.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_Art_theory_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, vqa_id, question, option, max_length=300):
+    
+    options_list = ast.literal_eval(option)
+    option_text="\n".join([f"{chr(65+i)}.{opt}" for i, opt in enumerate(options_list)])
+
+    question = clean_question(question)
+
+    text_prompt = (
+            f"Analyze the given image <image> and answer the following question."
+            f"Question: \"{question}\" \n"
+            f"Options: \"{option_text}\" "
+            )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": text_prompt},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, options, subfield, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question, options, subfield)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, subfield):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    prompt = f'{subfield} image,' + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    dataset = load_dataset(
+        "parquet",
+        data_files=args.data_path,
+        split="train")
+
+    for sample in dataset:
+
+        image_keys = [f"image_{i}" for i in range(1, 8)]
+        num_images = sum(1 for key in image_keys if key in sample and isinstance(sample[key], type(sample["image_1"])) and sample[key] is not None)
+
+        if num_images > 1:
+            continue
+
+        image = sample["image_1"]
+        image_path = dump_image(image, args.temp_dir)
+        question = clean_question(sample["question"])        
+        image_id = sample["id"]
+        options = sample["options"]
+        field = sample["subfield"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, image_id, question,  options, max_length)
+

qwen_vqa_Design.py

@@ -0,0 +1,471 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question, options, subfield):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    options_list = ast.literal_eval(options)
+    option_text = "\n".join([f"{chr(65+i)}. {opt}" for i, opt in enumerate(options_list)])
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Scientific Subfield: \"{subfield}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow multiple-choice question: "
+            f"Question: \"{question}\" "
+            f"Options: \"{option_text}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/MMMU/Design/validation-00000-of-00001.parquet", help="Prompt text for generation.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_Design_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, vqa_id, question, option, max_length=300):
+    
+    options_list = ast.literal_eval(option)
+    option_text="\n".join([f"{chr(65+i)}.{opt}" for i, opt in enumerate(options_list)])
+
+    question = clean_question(question)
+
+    text_prompt = (
+            f"Analyze the given image <image> and answer the following question."
+            f"Question: \"{question}\" \n"
+            f"Options: \"{option_text}\" "
+            )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": text_prompt},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, options, subfield, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question, options, subfield)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, subfield):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    prompt = f'{subfield} image,' + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    dataset = load_dataset(
+        "parquet",
+        data_files=args.data_path,
+        split="train")
+
+    for sample in dataset:
+
+        image_keys = [f"image_{i}" for i in range(1, 8)]
+        num_images = sum(1 for key in image_keys if key in sample and isinstance(sample[key], type(sample["image_1"])) and sample[key] is not None)
+
+        if num_images > 1:
+            continue
+
+        image = sample["image_1"]
+        image_path = dump_image(image, args.temp_dir)
+        question = clean_question(sample["question"])        
+        image_id = sample["id"]
+        options = sample["options"]
+        field = sample["subfield"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, image_id, question,  options, max_length)
+

qwen_vqa_Literature.py

@@ -0,0 +1,471 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question, options, subfield):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    
+    options_list = ast.literal_eval(options)
+    option_text = "\n".join([f"{chr(65+i)}. {opt}" for i, opt in enumerate(options_list)])
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+    # --- 构造文本指令 ---
+    text_prompt = (
+            f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+            f"Each modality provides complementary information about the same visual content: "
+            f"- The RGB image conveys color, texture, lighting, and the overall visual appearance. "
+            f"- The line drawing highlights object outlines, shapes, and fine structures. "
+            f"- The edge map emphasizes boundaries and contours. "
+            f"- The depth map reveals spatial distances, perspective, and 3D relationships. "
+            f"- The normal map shows surface orientation and geometric curvature. "
+            f"- The albedo map presents true surface color without illumination or shadows. "
+            f"- The segmentation map divides the scene into semantic regions and object categories. "
+            f"- The human pose map indicates body orientation, structure, and articulation. "
+            f"Together, these modalities offer a unified, rich understanding of the scene, covering its appearance, structure, and spatial layout. "
+            f"Scene description: \"{prompt}\" "
+            f"Scientific Subfield: \"{subfield}\" "
+            f"Now, based on both the multimodal visual information and the given scene description, "
+            f"analyze the scene carefully to answer a question. "
+            f"Your analysis should proceed in two stages:\n\n"
+            f"**Stage 1 — Modality-wise Observation:**\n"
+            f"For each provided modality image, analyze what specific visual information it contributes "
+            f"based on the above definitions. Describe what can be directly observed from each modality, "
+            f"such as color, shape, structure, spatial depth, or object positions. "
+            f"Then use visual reasoning grounded in the image evidence and contextual understanding from the description answer the follow multiple-choice question: "
+            f"Question: \"{question}\" "
+            f"Options: \"{option_text}\" "
+            + " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                       + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/MMMU/Literature/validation-00000-of-00001.parquet", help="Prompt text for generation.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./qwen_Literature_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, vqa_id, question, option, max_length=300):
+    
+    options_list = ast.literal_eval(option)
+    option_text="\n".join([f"{chr(65+i)}.{opt}" for i, opt in enumerate(options_list)])
+
+    question = clean_question(question)
+
+    text_prompt = (
+            f"Analyze the given image <image> and answer the following question."
+            f"Question: \"{question}\" \n"
+            f"Options: \"{option_text}\" "
+            )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": text_prompt},
+            ],
+        }
+    ]
+
+    print(messages)
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, options, subfield, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question, options, subfield)
+    print(messages)
+    inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+            )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, subfield):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    prompt = f'{subfield} image,' + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    dataset = load_dataset(
+        "parquet",
+        data_files=args.data_path,
+        split="train")
+
+    for sample in dataset:
+
+        image_keys = [f"image_{i}" for i in range(1, 8)]
+        num_images = sum(1 for key in image_keys if key in sample and isinstance(sample[key], type(sample["image_1"])) and sample[key] is not None)
+
+        if num_images > 1:
+            continue
+
+        image = sample["image_1"]
+        image_path = dump_image(image, args.temp_dir)
+        question = clean_question(sample["question"])        
+        image_id = sample["id"]
+        options = sample["options"]
+        field = sample["subfield"]
+    
+        max_length  = 1024
+
+        #input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, image_id, question,  options, max_length)
+

t2i.py

@@ -0,0 +1,357 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--prompt", type=str, default="cat.", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--height", type=int, default=1024)
+    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--seed", type=int, default=1234)
+    parser.add_argument("--output_dir", type=str, default="./demo_t2i_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+@torch.inference_mode()
+def init_t2i(args, pipe, iter_num, post_processors, modality_names, generator):
+
+    # --------------------------
+    # Inference
+    # --------------------------
+
+    print(f"🚀 Generating with prompt: {args.prompt}")
+    outputs = pipe(
+        images=[None] * (1 + pipe.num_conditions),
+        role=[0] * (1 + pipe.num_conditions),
+        prompt=args.prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+def text_refine(root, model, processor, prompt, iter_num, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+def image_refine(prompt, root, iter_num, modality_names, generator):
+
+    control_images = []
+    for name in modality_names:
+        control_images.append(Image.open(os.path.join(root, name+'.png')).convert("RGB"))
+
+    print(f"🚀 Generating with prompt: {args.prompt}")
+    prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=control_images,
+        role=[0] * (1 + pipe.num_conditions),
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=args.height,
+        width=args.width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, args.height, args.width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    
+    init_dir = init_t2i(args, pipe, 0, post_processors, modality_names, generator)
+
+    save_dir = init_dir
+    prompt = args.prompt
+    max_length  = 1024
+    for step in range(1, args.iters):
+        prompt = text_refine(save_dir,model, processor, prompt, step, max_length)
+        max_length += 100
+        save_dir = image_refine(prompt, save_dir, step, modality_names, generator)
+
+

test_i2t_coco.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[:123]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco1.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[123:246]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco2.py

@@ -0,0 +1,457 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import re
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=''):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./example_coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+
+@torch.inference_mode()
+def evaluate_caption(image_path, model, processor, caption, max_length=256):
+    """
+    Evaluate how well the generated caption truthfully describes the given image.
+    """
+    eval_prompt = f"""
+    You are an image–caption alignment evaluator and factuality advisor.
+    Given one RGB image and a textual caption, evaluate how well the caption
+    truthfully and comprehensively describes what is visually shown.
+
+    Caption: "{caption}"
+
+    ## Evaluation focus
+    - Describe whether all **objects, attributes, and relations** mentioned in the caption are actually visible.
+    - The caption should only include what is clearly seen in the image — no imaginary or hallucinated content.
+    - The caption should also cover the **main visible objects** and their essential attributes (color, count, relative position) if possible.
+    - If the caption adds nonexistent objects or attributes, reduce the score sharply (<0.6).
+    - If the caption omits minor details but remains overall faithful, keep a moderate score (~0.8–0.9).
+    - If the caption perfectly matches and fully reflects the visual scene, score near 1.0.
+
+    ## Feedback instruction
+    Provide **one short constructive feedback sentence** to improve the caption.
+    - Focus on what should be *added, adjusted, or rephrased* for truthfulness.
+    - Do NOT mention errors or missing things directly (avoid "not", "no", "missing", "wrong", "fail").
+    - Start with a verb such as "Add", "Replace", "Adjust", "Rephrase", "Include", "Describe".
+    - Example:
+        - If the caption says "a cat and a dog" but only a cat is visible → "Remove the dog and describe only the cat."
+        - If the caption omits a visible red car → "Add the red car on the right side of the road."
+        - If the color or quantity is inaccurate → "Replace with the correct color and number as seen."
+
+    Return JSON only:
+    {{
+        "Consistency": <float 0–1>,
+        "Feedback": "<one short sentence suggesting how to make the caption more accurate>"
+    }}
+
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    print(f'eval:{messages}')
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    #print(f" → Overall={score:.3f}")
+    #print(f"💡 Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    print(f'refine message:{messages}')
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    #print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        #print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    #print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[246:369]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        score, feedback = evaluate_caption(image_path, model, processor, prompt)
+		
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_name, max_length)
+            score, feedback = evaluate_caption(image_path, model, processor, prompt)
+
+

test_i2t_coco3.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[369:492]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco4.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[492:615]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco5.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[615:738]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco6.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[738:861]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_coco7.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/COCO_Karpathy/karpathy_test.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./coco_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    save_image_names = os.listdir("/home/efs/mjw/mjw/code/Jodi/coco_i2t_outputs/val2014")
+    image_names = [item["image_path"] for item in data][4021:]
+
+    for image_name in image_names[861:]:
+
+        if image_name in save_image_names:
+            print(f'already got {image_name} in ', f'our {save_image_names}')
+
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_nocaps.py

@@ -0,0 +1,368 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data][:750]
+
+    for image_name in image_names:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_nocaps1.py

@@ -0,0 +1,368 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data][750:1500]
+
+    for image_name in image_names:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_nocaps2.py

@@ -0,0 +1,448 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+import re
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, feedback, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./example_nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_caption(image_path, model, processor, caption, max_length=256):
+    """
+    Evaluate how well the generated caption truthfully describes the given image.
+    """
+    eval_prompt = f"""
+    You are an image–caption alignment evaluator and factuality advisor.
+    Given one RGB image and a textual caption, evaluate how well the caption
+    truthfully and comprehensively describes what is visually shown.
+
+    Caption: "{caption}"
+
+    ## Evaluation focus
+    - Describe whether all **objects, attributes, and relations** mentioned in the caption are actually visible.
+    - The caption should only include what is clearly seen in the image — no imaginary or hallucinated content.
+    - The caption should also cover the **main visible objects** and their essential attributes (color, count, relative position) if possible.
+    - If the caption adds nonexistent objects or attributes, reduce the score sharply (<0.6).
+    - If the caption omits minor details but remains overall faithful, keep a moderate score (~0.8–0.9).
+    - If the caption perfectly matches and fully reflects the visual scene, score near 1.0.
+
+    ## Feedback instruction
+    Provide **one short constructive feedback sentence** to improve the caption.
+    - Focus on what should be *added, adjusted, or rephrased* for truthfulness.
+    - Do NOT mention errors or missing things directly (avoid "not", "no", "missing", "wrong", "fail").
+    - Start with a verb such as "Add", "Replace", "Adjust", "Rephrase", "Include", "Describe".
+    - Example:
+        - If the caption says "a cat and a dog" but only a cat is visible → "Remove the dog and describe only the cat."
+        - If the caption omits a visible red car → "Add the red car on the right side of the road."
+        - If the color or quantity is inaccurate → "Replace with the correct color and number as seen."
+
+    Return JSON only:
+    {{
+        "Consistency": <float 0–1>,
+        "Feedback": "<one short sentence suggesting how to make the caption more accurate>"
+    }}
+
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f" → Overall={score:.3f}")
+    print(f"💡 Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, feedback, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feed.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data]
+
+    for image_name in image_names[97:]:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+        score, feedback = evaluate_caption(image_path, model, processor, prompt)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_name, max_length)
+            score, feedback = evaluate_caption(image_path, model, processor, prompt)
+
+

test_i2t_nocaps3.py

@@ -0,0 +1,368 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data][2250:3000]
+
+    for image_name in image_names:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_nocaps4.py

@@ -0,0 +1,368 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data][3000:3750]
+
+    for image_name in image_names:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_i2t_nocaps5.py

@@ -0,0 +1,368 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """
+    将多个图像拼接成一张大图并保存。
+    Args:
+        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）
+        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i+images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+def build_multimodal_message(root, coarse_caption="a generic scene"):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Automatically detects available modalities under root.
+    """
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        # 优先匹配 .png 或 .jpg
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append(str(path))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+    present_modalities = [readable_map[m] for m in modality_names if any(str(Path(root)/f"{m}{ext}") in available for ext in [".png",".jpg",".jpeg"])]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Each modality provides distinct types of visual information that together describe the same subject: "
+        f"- The RGB image provides color, texture, lighting, and the overall visual appearance. "
+        f"- The line drawing reveals detailed structural outlines, shapes, and proportions. "
+        f"- The edge map highlights object boundaries and contours. "
+        f"- The depth map shows spatial distance, perspective, and 3D depth relationships. "
+        f"- The normal map captures fine surface orientation, curvature, and geometric details. "
+        f"- The albedo map shows true surface colors without lighting or shadow effects. "
+        f"- The segmentation map provides semantic regions and object boundaries for scene composition. "
+        f"- The human pose map shows body structure, orientation, and posture of subjects. "
+        f"For each provided modality image, analyze it according to the above definitions and describe "
+        f"the specific visual information it contributes in this particular case. "
+        f"Use all available information together to produce one unified, richly detailed, and realistic description of the scene. "
+        f"Do NOT describe each modality separately or mention modality names. "
+        f"Focus on merging their information into a single coherent image description. "
+        #f"the subject’s appearance, lighting, form, and spatial depth. "
+        f"Refine the coarse caption into a more detailed and accurate image description. "
+        f"Coarse caption: '{coarse_caption}' " +
+        " ".join(["<image>"] * len(available))
+    )
+
+    # --- 构建 Qwen3-VL 消息格式 ---
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "image", "image": path} for path in available]
+                      + [{"type": "text", "text": text_prompt}],
+        }
+    ]
+    return messages
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth', help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct', help="Path to model checkpoint.")
+    parser.add_argument("--image_root", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/images", help="Prompt text for generation.")
+    parser.add_argument("--json_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/NoCaps_hf_validation/captions.json", help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./nocaps_i2t_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, name, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": "Describe this image."},
+            ],
+        }
+    ]
+    
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, iter_num, name, max_length=300):
+    messages = build_multimodal_message(root, prompt)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / name / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, name):
+
+    print(f"🚀 Generating with prompt: {prompt}")
+    #prompt = args.prompt + ' ' + prompt
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    save_dir = Path(args.output_dir) / name/ f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+# ------------------------------
+# Entry Point
+# ------------------------------
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+    import glob
+    image_root = args.image_root
+    json_path = args.json_path
+
+    with open(json_path, "r") as f:
+        data = json.load(f)
+
+    image_names = [item["image_name"] for item in data][3750:]
+
+    for image_name in image_names:
+        image_path = os.path.join(image_root, image_name)
+        image = Image.open(image_path).convert("RGB")
+        width, height = image.size
+
+        control_images = [image] + [None] * pipe.num_conditions
+
+        role=[1] + [0] * pipe.num_conditions
+        print(role)
+    
+        max_length  = 1024
+        prompt = init_i2t(model, processor, image_path, 0, image_name, max_length)
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width, image_name)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, step, image_name, max_length)
+
+

test_pope.py

@@ -0,0 +1,858 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+import torch.nn.functional as F
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    #text_prompt = (
+    #    f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        #f"The following caption describes the image in detail: '{prompt}'. "
+    #    f"Question:{question}"
+    #)
+
+    text_prompt = (
+        f"Answer the question using ONLY visual evidence from the images, including: {', '.join(present_modalities)}. "
+        f"Do NOT rely on prior knowledge or assumptions. "
+        f"Carefully inspect all visible objects and count them precisely. "
+        f"If objects appear similar or are located at different heights or positions, "
+        f"they MUST be counted separately if they are distinct and not connected. "
+        f"Cross-check all modalities (RGB, lines, edges, depth, segmentation) "
+        f"to ensure you do not merge distinct objects into one. "
+        f"Your answer MUST strictly follow what is visible, even if it seems unusual. "
+        f"Just response yes or no. "
+        f"Now answer the question:\n{question}\n")
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--tmp", type=str, default="/home/efs/mjw/mjw/code/Jodi/pope_tmp")
+    parser.add_argument("--output_dir", type=str, default="./vqa_pope_output", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(f'vqa messages:{messages}')
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    print(f'eval_message:{messages}')
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    #print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    print(f'eval message:{messages}')
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+        
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    gen_start = inputs["input_ids"].shape[1]
+    gen_ids = out_ids[:, gen_start:]
+    #gen_ids = out_ids[:, gen_start:]
+    gen_text = processor.tokenizer.decode(gen_ids[0], skip_special_tokens=False)
+    num_match = re.search(r"AnswerScore\"\s*:\s*([0-9\.]+)", gen_text)
+    conf = 0.0
+    if num_match:
+        num_text = num_match.group(1)
+        num_ids = processor.tokenizer.encode(num_text, add_special_tokens=False)
+        num_str = processor.tokenizer.decode(num_ids)
+        gen_id_list = gen_ids[0].tolist()
+        match_positions = []
+        for i in range(len(gen_id_list) - len(num_ids) + 1):
+            if gen_id_list[i:i+len(num_ids)] == num_ids:
+                match_positions = list(range(i, i+len(num_ids)))
+                break
+
+        if match_positions:
+            probs = []
+            for pos in match_positions:
+                step_prob = F.softmax(scores[pos], dim=-1)
+                token_id = gen_ids[0, pos]
+                probs.append(step_prob[0, token_id])
+            conf = torch.stack(probs).mean().item()
+
+    #print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    #print(f"📊 [Confidence(AnswerScore)] {conf:.4f}")
+
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    print(f'refine message:{messages}')
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(f'vqa messages:{messages}')
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    #with open(args.json, "r", encoding="utf-8") as f:
+    #    annotations = json.load(f)
+
+    dataset = load_dataset("lmms-lab/POPE", split="test")
+    subset = dataset.select(range(4500,len(dataset)))
+
+    for sample in subset:
+        #image_path = os.path.join(args.data_path, sample["image"])
+        #image_id = sample["image"].split('.')[0]
+        image_path = os.path.join(args.tmp, sample["image_source"]+'.jpg')
+
+        print(type(sample["image"]))
+
+        image_id = sample["id"]
+        image = sample["image"].convert("RGB")
+        image.save(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real1.py

@@ -0,0 +1,817 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response Yes or No"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/POPEv2/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/POPEv2/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_popev2_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations:
+
+        out_names = os.listdir(args.output_dir)
+
+        image_path = os.path.join(args.data_path, sample["image_name"].split('/')[-1])
+        image_id = sample["image_name"].split('/')[-1].split('.')[0]
+
+        if image_id in out_names:
+            print(f'this {image_id} is exist.')
+            continue
+
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real2.py

@@ -0,0 +1,857 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+import torch.nn.functional as F
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    #text_prompt = (
+    #    f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        #f"The following caption describes the image in detail: '{prompt}'. "
+    #    f"Question:{question}"
+    #)
+
+    text_prompt = (
+        f"Answer the question using ONLY visual evidence from the images, including: {', '.join(present_modalities)}. "
+        f"Do NOT rely on prior knowledge or assumptions. "
+        f"Carefully inspect all visible objects and count them precisely. "
+        f"If objects appear similar or are located at different heights or positions, "
+        f"they MUST be counted separately if they are distinct and not connected. "
+        f"Cross-check all modalities (RGB, lines, edges, depth, segmentation) "
+        f"to ensure you do not merge distinct objects into one. "
+        f"Your answer MUST strictly follow what is visible, even if it seems unusual. "
+        f"Just response yes or no. "
+        f"Now answer the question:\n{question}\n")
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--tmp", type=str, default="/home/efs/mjw/mjw/code/Jodi/pope_tmp")
+    parser.add_argument("--output_dir", type=str, default="./vqa_pope_output", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(f'vqa messages:{messages}')
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    print(f'eval_message:{messages}')
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    #print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    print(f'eval message:{messages}')
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+        
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    gen_start = inputs["input_ids"].shape[1]
+    gen_ids = out_ids[:, gen_start:]
+    #gen_ids = out_ids[:, gen_start:]
+    gen_text = processor.tokenizer.decode(gen_ids[0], skip_special_tokens=False)
+    num_match = re.search(r"AnswerScore\"\s*:\s*([0-9\.]+)", gen_text)
+    conf = 0.0
+    if num_match:
+        num_text = num_match.group(1)
+        num_ids = processor.tokenizer.encode(num_text, add_special_tokens=False)
+        num_str = processor.tokenizer.decode(num_ids)
+        gen_id_list = gen_ids[0].tolist()
+        match_positions = []
+        for i in range(len(gen_id_list) - len(num_ids) + 1):
+            if gen_id_list[i:i+len(num_ids)] == num_ids:
+                match_positions = list(range(i, i+len(num_ids)))
+                break
+
+        if match_positions:
+            probs = []
+            for pos in match_positions:
+                step_prob = F.softmax(scores[pos], dim=-1)
+                token_id = gen_ids[0, pos]
+                probs.append(step_prob[0, token_id])
+            conf = torch.stack(probs).mean().item()
+
+    #print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    #print(f"📊 [Confidence(AnswerScore)] {conf:.4f}")
+
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    print(f'refine message:{messages}')
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(f'vqa messages:{messages}')
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    #print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    #with open(args.json, "r", encoding="utf-8") as f:
+    #    annotations = json.load(f)
+
+    dataset = load_dataset("lmms-lab/POPE", split="test")
+
+    for sample in dataset:
+        #image_path = os.path.join(args.data_path, sample["image"])
+        #image_id = sample["image"].split('.')[0]
+        image_path = os.path.join(args.tmp, sample["image_source"]+'.jpg')
+
+        print(type(sample["image"]))
+
+        image_id = sample["id"]
+        image = sample["image"].convert("RGB")
+        image.save(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real3.py

@@ -0,0 +1,701 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[306:459]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')
+

test_real4.py

@@ -0,0 +1,701 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[459:612]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')
+

test_real5.py

@@ -0,0 +1,701 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[612:]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')
+

test_real_amber.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[:3432]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real_amber1.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[3432:6864]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real_amber2.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[6864:10296]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real_amber3.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[10296:13728]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real_amber4.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[13728:17160]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_real_amber5.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+import re
+
+
+def clean_eval_question(q: str) -> str:
+    """
+    Clean VQA-style question text for evaluation.
+    - If lettered options (A–Z) exist, keep text up to the last option.
+    - Otherwise, keep text up to the first '?' (inclusive).
+    """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 匹配所有选项（A–Z），兼容多种写法：A. / A) / (A) / A: / A - / A– ...
+    option_pattern = r"(?:\(?[A-Z]\)?[\.\:\-\)]\s)"
+    matches = list(re.finditer(option_pattern, q, flags=re.IGNORECASE))
+
+    if matches:
+        # 找到最后一个选项出现位置 → 保留到该选项行的结束处
+        last_match = matches[-1]
+        # 找到从最后一个选项开始到该段落结束（如选项内容的末尾）
+        tail = q[last_match.end():]
+        # 截断尾部任何额外提示（"Please answer..." 等）
+        tail_cut = re.split(r"(please\s+answer|choose\s+the|select\s+the|answer\s+directly)", tail, flags=re.IGNORECASE)[0]
+        q = q[:last_match.end()] + tail_cut
+    else:
+        # 无选项 → 只保留问句（问号前的部分）
+        match_qmark = re.search(r"\?", q)
+        if match_qmark:
+            q = q[:match_qmark.end()]
+        else:
+            q = q.split("\n")[0]  # fallback
+
+    # 清理多余换行与空格
+    q = re.sub(r"\n+", " ", q)
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def clean_prompt_question(q: str) -> str:
+    """Clean VQA-style question text, keeping only the question stem before '?'. """
+    if not isinstance(q, str):
+        q = str(q)
+
+    # 删除 <image> 占位符
+    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+
+    # 截取问号之前的部分（包括问号）
+    match = re.search(r"^(.*?\?)", q)
+    if match:
+        q = match.group(1)
+    else:
+        # 若无问号则保留首句
+        q = q.split("\n")[0]
+
+    # 去除多余空白与换行
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+
+
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)
+    return save_path
+
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    text_prompt = (
+        f"Answer the following question based on multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The following caption describes the image in detail: '{prompt}'. "
+        f"Question:{question}"
+        f"Just response yes or no"
+    )
+
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def build_multimodal_message(root, question, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        # "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        # "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"Use all available modalities jointly to reason about the same scene rather than describing them separately. "
+        f"Generate an enhanced visual description that focuses on the aspects most relevant to answering the following question: '{question}'. "
+        f"Your task is to refine the description of the scene based on all visual modalities so that it highlights visual cues "
+        f"that are crucial for accurately addressing the question, such as object appearance, count, position, or relation, "
+        f"while maintaining faithfulness to the original visual content. "
+        f"Do not include any additional commentary or evaluations. "
+        f"Do NOT introduce any new objects, background environments, emotional tones, or storytelling context. "
+        f"Focus on describing the visual properties, including: "
+        f"(1) object category and identity, (2) object attributes such as color, shape, size, and texture, "
+        f"(3) spatial or relational positioning between objects if present, (4) object part–whole structure or state, and (5) object count or quantity. "
+        f"Exclude any stylistic, environmental, emotional, or narrative information. "
+        f"Consider the following feedback when refining your description: '{feedback}'. "
+        f"Describe the scene in an objective and concise tone, emphasizing the details that help answer the question: '{question}'. "
+        f"Coarse caption: '{coarse_caption}' "
+    )
+
+    # text_prompt0 = (
+    #     f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+    #     f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+    #     f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+    #     f"### Your Task:\n"
+    #     f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+    #     f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+    #     f"### Guidelines:\n"
+    #     f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+    #     f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+    #     f"3. Do NOT invent or assume anything not visually supported.\n"
+    #     f"4. Avoid including any additional commentary or evaluations.\n"
+    #     f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+    #     f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    #     f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+    #     f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    # )
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    #content.append({"type": "text", "text": text_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/image",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/miw/dataset/dataset/AMBER/merged.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=5, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_amber_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, question, answer, max_length=256):
+    # --- 构造 Qwen 输入 ---
+    question = clean_eval_question(question)
+    eval_prompt = f"""
+    You are a VQA answer evaluator.
+    Given an image, a question, and a proposed answer, 
+    score how correct the answer is according to the image evidence.
+    Then provide one short feedback sentence suggesting what kind of visual information related to {question} or reasoning should be improved
+    to make the answer more accurate or grounded in the image.
+    Return JSON strictly:
+    {{"AnswerScore": <float 0-1>, "Feedback": "<short suggestion>"}}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    #print(f'out_ids.logits:{out_ids.logit}')
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+@torch.inference_mode()
+def evaluate_multimodal_consistency(root, model, processor, question, answer, max_length=256):
+    """
+    Evaluate VQA answer correctness using all available modalities (not just RGB).
+    This reduces model bias and improves visual grounding reliability.
+    """
+
+    # 检查存在的模态文件
+    modality_names = [
+        "image", "annotation_lineart", "annotation_edge",
+        "annotation_depth", "annotation_normal", "annotation_albedo",
+        "annotation_seg_12colors", "annotation_openpose"
+    ]
+
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # 构造 prompt
+    eval_prompt = f"""
+    You are a multimodal visual reasoning evaluator.
+
+    You are given multiple complementary visual modalities of the same scene, including: {', '.join(present_modalities)}.
+    Your task is to judge **how correct and visually grounded** the given answer is for the question, 
+    based purely on visual evidence from all modalities.
+
+    Follow this process:
+    1. Identify the key visual concepts mentioned in the question (e.g., objects, counts, relations, colors).
+    2. Check whether these visual concepts are **clearly supported** or **contradicted** by the modalities.
+    3. If the question is multiple-choice (options A, B, C...), identify which one best matches the evidence.
+    4. Otherwise, directly evaluate how accurate the free-form answer is.
+    5. Penalize any parts that contradict the image, or ignore modalities.
+
+    Return JSON strictly:
+    {{
+      "AnswerScore": <float between 0 and 1>,
+      "Feedback": "<short and specific suggestion mentioning what aspect (e.g., object count, relation, visibility) could be improved>"
+    }}
+
+    Question: "{question}"
+    Answer: "{answer}"
+    """
+
+    # 构建内容序列（模态+图像）
+    content = []
+    #content.append({"type": "text", "text": eval_prompt})
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+    content.append({"type": "text", "text": eval_prompt})
+
+    messages = [{"role": "user", "content": content}]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True,
+        return_dict=True, return_tensors="pt"
+    ).to(model.device)
+
+    outs = model.generate(**inputs, max_new_tokens=max_length, output_scores=True, return_dict_in_generate=True)
+    #print(out_ids)
+    out_ids = outs['sequences']
+    scores = outs['scores']
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("AnswerScore", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [AnswerScore] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, question, feedback, iter_num, vqa_id, max_length=300):
+    question = clean_prompt_question(question)
+    messages = build_multimodal_message(root, question, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    feedback_path = Path(save_dir) / f"feedback.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        f.write(feedback.strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        #attn_implementation="sdpa",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    for sample in annotations[17160:]:
+
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = str(sample["id"])
+        image = Image.open(image_path)
+        question = sample["query"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_result, best_score = '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        result = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, question, result)
+
+        if score >= best_score:
+            best_result, best_score = result, score
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, question, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_multimodal_consistency(save_dir, model, processor, question, result)
+
+            if score >= best_score:
+                best_result, best_score = result, score
+
+        os.makedirs(args.output_dir, exist_ok=True)
+        save_dir = Path(args.output_dir) / image_id / f'iteration_best' / 'vqa_answer'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        caption_path = Path(save_dir) / f"caption.txt"
+        with open(caption_path, "w", encoding="utf-8") as f:
+            f.write(best_result)
+        print(best_result)
+

test_realworldqa_vqa.py

@@ -0,0 +1,620 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png"]:
+        image_path = str(root_path)
+        text_prompt = (
+            f"You are given one RGB image and a text description of the same scene.\n"
+            f"Scene description: \"{prompt}\"\n\n"
+            f"Now analyze the image carefully and answer the following question based only on what is visible.\n"
+            f"Do NOT guess or add details not supported by the image.\n"
+            f"Question: \"{question}\"\n"
+            "<image>"
+        )
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": text_prompt},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        f"so use them only as optional references for additional context. "
+        f"Each modality provides complementary information about the same visual content:\n"
+        f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        f"- The edge map emphasizes boundaries and contours.\n"
+        f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        f"- The normal map shows surface orientation and geometric curvature.\n"
+        f"- The albedo map presents true surface color without illumination or shadows.\n"
+        f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        "annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+   
+
+    content = []
+
+    text_prompt = ("you are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}.\n"
+    f"Each modality provides a different aspect of visual information about the same scene.\n\n"
+    f"### Modality Information:\n"
+    f"- **RGB image:** shows colors, textures, lighting, and overall appearance.\n"
+    f"- **Line drawing:** reveals outlines, object contours, and structural details.\n"
+    f"- **Edge map:** highlights strong edges and object boundaries.\n"
+    f"- **Depth map:** encodes per-object spatial distance and perspective. "
+    f"For each main object, estimate its approximate physical distance from the camera or ground reference "
+    f"in **meters**. "
+    f"If multiple objects are visible, provide numeric distances rather than qualitative terms like "
+    f"'closer' or 'farther'.\n"
+    f"- **Normal map:** provides surface orientation and facing direction.\n"
+    f"- **Albedo map:** shows true surface color unaffected by lighting or shadows.\n"
+    f"- **Segmentation map:** divides the image into semantic regions and object categories.\n"
+    f"- **Human pose map:** depicts human keypoints, poses, and orientations if present.\n\n"
+    f"### Your Task:\n"
+    f"Refine the coarse caption into a detailed, modality-wise visual description. "
+    f"For each available modality listed above, generate one corresponding description paragraph "
+    f"based only on what that modality shows.\n\n"
+    f"### Rules:\n"
+    f"1. Follow the order and modality names given in 'Modality Information'.\n"
+    f"2. Start each paragraph with the modality name (e.g., 'RGB image:').\n"
+    f"3. Describe only what is visible in that modality—do NOT merge or summarize multiple modalities.\n"
+    f"4. Use **numeric distance estimates in meters** for the depth map whenever possible.\n"
+    f"5. Use clear and factual language (no imagination or hallucination).\n"
+    #f"6. You may use the following feedback for improvement: '{feedback}'\n\n"
+    f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+    f"Now, according to the 'Modality Information' above, write one detailed description for each available modality below."
+    )
+
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=41)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    You are given one RGB image and a description that may include references
+    to multiple visual modalities (e.g., depth map, normal map, segmentation map, etc.).
+    These terms are just analytical perspectives of the same scene — they should not reduce
+    the consistency score. Focus only on whether the described visual content matches what
+    is visible in the RGB image.
+    Your task:
+    1. Judge how accurately the text describes what is visually present in the image.
+    2. Ignore mentions of modality names (such as 'depth map' or 'normal map').
+    3. Provide a consistency score between 0.0 (completely mismatched) and 1.0 (perfect match).
+    4. Provide one short feedback sentence suggesting how to make the description better aligned.
+    Return JSON strictly in this format:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / 'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[1:255]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+            
+            #if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, max_length)
+        print(f'result:{result}')

test_realworldqa_vqa1.py

@@ -0,0 +1,669 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[:153]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            generator = torch.Generator(device=device).manual_seed(args.seed)
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')

test_realworldqa_vqa2.py

@@ -0,0 +1,668 @@
+import os
+import sys
+import argparse
+from pathlib import Path
+from PIL import Image
+from typing import Any
+import torch
+import torchvision.transforms as T
+from datasets import load_dataset
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["GRADIO_TEMP_DIR"] = "./tmp"
+from jodi_pipeline import JodiPipeline
+from model.postprocess import (
+    ImagePostProcessor, LineartPostProcessor, EdgePostProcessor, DepthPostProcessor,
+    NormalPostProcessor, AlbedoPostProcessor, SegADE20KPostProcessor, OpenposePostProcessor,
+)
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from transformers import AutoProcessor, Trainer
+from pathlib import Path
+import itertools
+import ast
+import re
+from PIL import Image
+import json
+def clean_question(q: str) -> str:
+    if not isinstance(q, str):
+        q = str(q)
+    # 删除 <image 1>、<image1>、<image 2> 等占位符    q = re.sub(r"<\s*image\s*\d+\s*>", "", q, flags=re.IGNORECASE)
+    # 再清理多余空白
+    q = re.sub(r"\s+", " ", q).strip()
+    return q
+def dump_image(image, save_root):
+    os.makedirs(save_root, exist_ok=True)
+    save_path = os.path.join(save_root, "input.jpg")
+    image.convert("RGB").save(save_path, format="JPEG", quality=95)    
+    return save_path
+
+def concatenate_images(image_paths, save_path, images_per_row=None, image_format="png"):
+    """    将多个图像拼接成一张大图并保存。
+    Args:        image_paths: List[str] 图像路径列表
+        save_path: 保存路径（包括文件名）        images_per_row: 每行图像数量（默认为全部在一行）
+        image_format: 保存格式
+    """
+    from PIL import Image
+    import io
+    # 读取图像
+    images = [Image.open(p).convert("RGB") for p in image_paths]
+
+    if images_per_row is None:
+        images_per_row = len(images)
+
+    # 调整尺寸（可选）
+    target_size = min(1024, images[0].size[0])
+    images = [img.resize((target_size, target_size)) for img in images]
+
+    # 拼接
+    widths, heights = zip(*(img.size for img in images))
+    max_width = max(widths)
+    rows = (len(images) + images_per_row - 1) // images_per_row
+    total_height = sum(heights[:images_per_row]) * rows
+
+    new_im = Image.new("RGB", (max_width * images_per_row, total_height))
+    y_offset = 0
+    for i in range(0, len(images), images_per_row):
+        row_imgs = images[i:i + images_per_row]
+        x_offset = 0
+        for img in row_imgs:
+            new_im.paste(img, (x_offset, y_offset))
+            x_offset += max_width
+        y_offset += heights[0]
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    new_im.save(save_path, format=image_format.upper())
+    print(f"🧩 Saved merged image → {save_path}")
+    return save_path
+
+
+def build_vqa_message(root, prompt, question):
+    """
+    Build Qwen3-VL message for multimodal or single-image VQA.
+    Now explicitly tags each modality image before feeding into Qwen3-VL,
+    so that the model can distinguish RGB, edge, depth, normal, etc.
+    """
+
+    root_path = Path(root)
+
+    # ---------- 单图像情况 ----------
+    if root_path.is_file() and root_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+        image_path = str(root)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+                ],
+            }
+        ]
+        return messages
+
+    # ---------- 多模态文件夹情况 ----------
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # 检查存在的模态文件
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+
+
+    # 可读名称映射
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # ---------- 指令文本 ----------
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary and most reliable modality that truly represents the scene. "
+        #f"Other modalities (e.g., depth, normal, segmentation) may contain small errors or artifacts, "
+        #f"so use them only as optional references for additional context. "
+        #f"Each modality provides complementary information about the same visual content:\n"
+        #f"- The line drawing highlights object outlines, shapes, and fine structures.\n"
+        #f"- The edge map emphasizes boundaries and contours.\n"
+        #f"- The depth map reveals spatial distances, perspective, and 3D relationships.\n"
+        #f"- The normal map shows surface orientation and geometric curvature.\n"
+        #f"- The albedo map presents true surface color without illumination or shadows.\n"
+        #f"- The segmentation map divides the scene into semantic regions and object categories.\n"
+        #f"- The human pose map indicates body orientation, structure, and articulation.\n\n"
+        #f"Together, these modalities offer a unified, rich understanding of the scene.\n"
+        #f"Scene description: \"{prompt}\"\n\n"
+        f"Please answer the following question using visual reasoning primarily grounded in the RGB image, "
+        #f"while cross-checking with other modalities (e.g., edge or depth) when relevant.\n"
+        #f"If multiple correct answers are possible, choose the most precise and visually supported one.\n\n"
+        f"Question: \"{question}\"\n"
+    )
+
+    # ---------- 构建内容序列（模态锚定） ----------
+    content = []
+    print(f'available:{available}')
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        # 在每张图像前显式标注模态类型
+        content.append({"type": "text", "text": f"This is the {readable}."})
+        content.append({"type": "image", "image": path})
+
+    # 最后加入主指令
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+
+
+def build_multimodal_message(root, coarse_caption="a generic scene", feedback=""):
+    """
+    Build Qwen3-VL message for multi-modal caption refinement.
+    Explicitly binds each image to its modality name (RGB, edge, depth, etc.)
+    so Qwen3-VL can reason over them correctly and refine the caption faithfully.
+    """
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        #"annotation_openpose",
+    ]
+
+    # --- 检查存在的模态 ---
+    available = []
+    for name in modality_names:
+        for ext in [".png", ".jpg", ".jpeg"]:
+            path = Path(root) / f"{name}{ext}"
+            if path.exists():
+                available.append((name, str(path)))
+                break
+
+    # --- 构建模态说明 ---
+    readable_map = {
+        "image": "RGB image",
+        "annotation_lineart": "line drawing",
+        "annotation_edge": "edge map",
+        "annotation_depth": "depth map",
+        "annotation_normal": "normal map",
+        "annotation_albedo": "albedo map",
+        "annotation_seg_12colors": "segmentation map",
+        #"annotation_openpose": "human pose map",
+    }
+
+    present_modalities = [readable_map[n] for n, _ in available]
+
+    # --- 构造文本指令 ---
+    text_prompt = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** is the primary modality that provides the most reliable view of the scene. "
+        #f"Other modalities (depth, normal, edge, segmentation, etc.) serve as structural or semantic references.\n\n"
+        #f"Each modality provides distinct complementary information:\n"
+        #f"- The line drawing highlights structure and contours.\n"
+        #f"- The edge map emphasizes object boundaries.\n"
+        #f"- The depth map shows spatial distance and perspective.\n"
+        #f"- The normal map captures surface orientation and geometry.\n"
+        #f"- The albedo map shows intrinsic surface color.\n"
+        #f"- The segmentation map reveals semantic regions.\n"
+        #f"- The human pose map indicates body structure and articulation.\n\n"
+        f"### Your Task:\n"
+        f"Refine the coarse caption into a more accurate, realistic, and visually grounded description "
+        f"of the scene, integrating information from all available modalities.\n\n"
+        f"### Rules:\n"
+        f"1. Describe only what is visible in the images — do NOT hallucinate.\n"
+        #f"2. Use the RGB image as your main reference, and use other modalities to verify geometric or structural details.\n"
+        f"3. Incorporate the following feedback into your refinement: '{feedback}'\n"
+        f"4. Focus on correcting inaccuracies or missing details from the coarse caption.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"Now refine the caption according to the multimodal evidence below."
+    )
+
+    text_prompt0 = (
+        f"You are given multiple visual modalities of the same scene, including: {', '.join(present_modalities)}. "
+        f"The **RGB image** provides the most accurate and realistic appearance of the scene, "
+        f"while other modalities (e.g., depth, normal, edge, segmentation) offer complementary structural and semantic details.\n\n"
+        f"### Your Task:\n"
+        f"Generate a refined, detailed, and visually grounded description of the scene shown in the images. "
+        f"Use the RGB image as the main reference, and consult other modalities to verify geometry, boundaries, and spatial relations.\n\n"
+        f"### Guidelines:\n"
+        f"1. Describe what is *visibly present* — objects, materials, lighting, spatial layout, and relationships.\n"
+        f"2. Integrate helpful information from auxiliary modalities (e.g., depth for distance, edges for structure).\n"
+        f"3. Do NOT invent or assume anything not visually supported.\n"
+        f"4. Avoid including any additional commentary or evaluations.\n"
+        f"5. You may rephrase and expand upon the coarse caption for clarity and accuracy.\n\n"
+        f"### Coarse Caption:\n'{coarse_caption}'\n\n"
+        f"### Feedback to Incorporate:\n'{feedback}'\n\n"
+        f"Now produce the final refined caption describing the scene based on the multimodal evidence below."
+    )
+
+
+    # --- 构建消息内容：在每个图像前加模态标识 ---
+    content = []
+    for name, path in available:
+        readable = readable_map.get(name, "visual input")
+        content.append({
+            "type": "text",
+            "text": f"This is the {readable}, which provides {get_modality_description(name)}."
+        })
+        content.append({"type": "image", "image": path})
+
+    # 最后附上总任务说明
+    content.append({"type": "text", "text": text_prompt})
+
+    messages = [{"role": "user", "content": content}]
+    return messages
+
+
+def get_modality_description(name: str) -> str:
+    """为每个模态生成一句说明，用于提示模型理解模态功能"""
+    desc_map = {
+        "image": "the main visual appearance of the scene, including color, texture, and lighting",
+        "annotation_lineart": "structural outlines, object contours, and fine geometry",
+        "annotation_edge": "strong boundaries and contrast edges between objects",
+        "annotation_depth": "distance and perspective information for spatial understanding",
+        "annotation_normal": "surface orientation and geometric curvature cues",
+        "annotation_albedo": "pure surface color without lighting or shading effects",
+        "annotation_seg_12colors": "semantic regions and object categories",
+        "annotation_openpose": "human body keypoints, joints, and orientation",
+    }
+    return desc_map.get(name, "complementary visual evidence")
+
+
+
+
+# ------------------------------
+# Argument Parser
+# ------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser(description="Run JODI inference without Gradio UI.")
+    parser.add_argument("--text_model_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--config", type=str, default="./configs/inference.yaml", help="Path to config file.")
+    parser.add_argument("--model_path", type=str, default='hf://VIPL-GENUN/Jodi/Jodi.pth',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--model_name_or_path", type=str, default='Qwen/Qwen3-VL-8B-Instruct',
+                        help="Path to model checkpoint.")
+    parser.add_argument("--data_path", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/images",
+                        help="Prompt text for generation.")
+    parser.add_argument("--json", type=str, default="/home/efs/mjw/mjw/dataset/dataset/realworldqa/annotations.json",
+                        help="Optional negative prompt.")
+    parser.add_argument("--temp_dir", type=str, default="/home/efs/mjw/mjw/dataset/dataset/tmp",
+                        help="Prompt text for generation.")
+    parser.add_argument("--negative_prompt", type=str, default="", help="Optional negative prompt.")
+    parser.add_argument("--question", type=str, default="how many cars in this image?",
+                        help="Optional negative prompt.")
+    parser.add_argument("--steps", type=int, default=20, help="Number of inference steps.")
+    parser.add_argument("--iters", type=int, default=10, help="Number of inference steps.")
+    parser.add_argument("--guidance_scale", type=float, default=4.5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output_dir", type=str, default="./vqa_realworld_outputs", help="Directory to save results.")
+    return parser
+
+
+# ------------------------------
+# Main Inference Function
+# ------------------------------
+
+
+@torch.inference_mode()
+def vqa_i2t(model, processor, image_path, question, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Answer the follow question:{question} based on the <image>."},
+            ],
+        }
+    ]
+
+    print(messages)
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / str(vqa_id)
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def init_i2t(model, processor, image_path, iter_num, vqa_id, max_length=300):
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "image": image_path,
+                },
+                {"type": "text", "text": f"Describe this image."},
+            ],
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True, return_dict=True, return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+
+    return output_text[0]
+
+
+@torch.inference_mode()
+def evaluate_consistency(image_path, model, processor, caption, max_length=256):
+
+    # --- 构造 Qwen 输入 ---
+    eval_prompt = f"""
+    You are an image-text alignment evaluator.
+    Given one RGB image and a description, score how well the text matches
+    the visual evidence in the image. Then provide one short feedback
+    sentence suggesting how to make the description better aligned.
+    
+    Return JSON strictly:
+    {{"Consistency": <float 0-1>, "Feedback": "<sentence>"}}
+    
+    Description: "{caption}"
+    <image>
+    """
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image_path},
+                {"type": "text", "text": eval_prompt},
+            ],
+        }
+    ]
+
+    # --- 推理 ---
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    out_ids = model.generate(**inputs, max_new_tokens=max_length)
+    out_trim = [o[len(i):] for i, o in zip(inputs.input_ids, out_ids)]
+    text = processor.batch_decode(out_trim, skip_special_tokens=True)[0]
+
+    # --- 解析输出 ---
+    try:
+        data = json.loads(re.search(r"\{.*\}", text, re.S).group(0))
+        score = float(data.get("Consistency", 0))
+        feedback = data.get("Feedback", "")
+    except Exception:
+        score, feedback = 0.0, text.strip()
+
+    print(f"🧮 [Image Consistency] {score:.3f} | Feedback: {feedback}")
+    return score, feedback
+
+
+@torch.inference_mode()
+def text_refine(root, model, processor, prompt, feedback, iter_num, vqa_id, max_length=300):
+    messages = build_multimodal_message(root, prompt, feedback)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+
+    # Inference: Generation of the output
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def vqa(root, model, processor, prompt, question, vqa_id, step, max_length=300):
+    messages = build_vqa_message(root, prompt, question)
+    print(messages)
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+    inputs = inputs.to(model.device)
+    generated_ids = model.generate(**inputs, max_new_tokens=max_length)
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+    output_text = processor.batch_decode(
+        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+    )
+    print(output_text)
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / vqa_id / f'iteration_{step}' /'vqa_answer'
+    save_dir.mkdir(parents=True, exist_ok=True)
+    caption_path = Path(save_dir) / f"caption.txt"
+    with open(caption_path, "w", encoding="utf-8") as f:
+        f.write(output_text[0].strip())
+    return output_text[0]
+
+@torch.inference_mode()
+def image_refine(prompt, images, role, pipe, iter_num, modality_names, generator, height, width, image_id):
+    # print(f"🚀 Generating with prompt: {prompt}")
+    outputs = pipe(
+        images=images,
+        role=role,
+        prompt=prompt,
+        negative_prompt=args.negative_prompt,
+        height=height,
+        width=width,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        num_images_per_prompt=1,
+        generator=generator,
+        task='t2i'
+    )
+
+    # Apply post-processing for each modality
+    results = [post_processors[i](outputs[i]) for i in range(1 + pipe.num_conditions)]
+    results = torch.stack(results, dim=1).reshape(-1, 3, height, width)
+    results = [T.ToPILImage()(res).convert("RGB") for res in results.unbind(0)]
+
+    # --------------------------
+    # Save results
+    # --------------------------
+    os.makedirs(args.output_dir, exist_ok=True)
+    save_dir = Path(args.output_dir) / image_id / f"iteration_{iter_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    for idx, img in enumerate(results):
+        name = modality_names[idx]
+        save_path = save_dir / f"{name}.png"
+        img.save(save_path)
+        print(f"💾 Saved {name} → {save_path}")
+
+
+    merged_path = save_dir / f"merged_iteration_{iter_num}.png"
+    concatenate_images([save_dir / f"{name}.png" for name in modality_names], merged_path)
+    print(f"\n✅ All results saved in: {save_dir}\n")
+    return save_dir
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"✅ Using device: {device}")
+
+    processor = AutoProcessor.from_pretrained(
+        args.model_name_or_path,
+    )
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        args.text_model_path,
+        attn_implementation="flash_attention_2",
+        dtype=(torch.bfloat16),
+    ).to(device)
+
+    pipe = JodiPipeline(args.config)
+    pipe.from_pretrained(args.model_path)
+
+    modality_names = [
+        "image",
+        "annotation_lineart",
+        "annotation_edge",
+        "annotation_depth",
+        "annotation_normal",
+        "annotation_albedo",
+        "annotation_seg_12colors",
+        "annotation_openpose",
+    ]
+
+    # Build post-processors
+    post_processors: list[Any] = [ImagePostProcessor()]
+    for condition in pipe.config.conditions:  # type: ignore
+        if condition == "lineart":
+            post_processors.append(LineartPostProcessor())
+        elif condition == "edge":
+            post_processors.append(EdgePostProcessor())
+        elif condition == "depth":
+            post_processors.append(DepthPostProcessor())
+        elif condition == "normal":
+            post_processors.append(NormalPostProcessor())
+        elif condition == "albedo":
+            post_processors.append(AlbedoPostProcessor())
+        elif condition == "segmentation":
+            post_processors.append(SegADE20KPostProcessor(color_scheme="colors12", only_return_image=True))
+        elif condition == "openpose":
+            post_processors.append(OpenposePostProcessor())
+        else:
+            print(f"⚠️ Warning: Unknown condition: {condition}")
+            post_processors.append(ImagePostProcessor())
+
+    torch.manual_seed(args.seed)
+    generator = torch.Generator(device=device).manual_seed(args.seed)
+
+    with open(args.json, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+    for sample in annotations[153:306]:
+        image_path = os.path.join(args.data_path, sample["image"])
+        image_id = sample["image"].split('.')[0]
+        image = Image.open(image_path)
+        question = sample["question"]
+
+        control_images = [image.convert('RGB')] + [None] * pipe.num_conditions
+
+        role = [1] + [0] * pipe.num_conditions
+        print(role)
+
+        best_dir, best_caption, best_score = '', '', 0.0
+        max_length = 1024
+
+        # input_img = Image.open(image_path).convert("RGB")
+        width, height = image.size
+        print(f'ori width:{width}', f'ori height:{height}')
+
+        prompt = init_i2t(model, processor, image_path, 0, image_id, max_length)
+        _ = vqa_i2t(model, processor, image_path, question, 100, max_length)
+        score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+        if score >= best_score:
+            best_caption, best_score = prompt, score
+            best_dir = image_path
+
+        for step in range(1, args.iters):
+            save_dir = image_refine(prompt, control_images, role, pipe, step, modality_names, generator, height, width,
+                                    image_id)
+            max_length += 100
+            prompt = text_refine(save_dir, model, processor, prompt, feedback, step, image_id, max_length)
+            result = vqa(save_dir, model, processor, prompt, question, image_id, step, max_length)
+            score, feedback = evaluate_consistency(image_path, model, processor, prompt)
+
+            if score >= best_score:
+                best_caption, best_score = prompt, score
+                best_dir = save_dir
+
+        result = vqa(best_dir, model, processor, best_caption, question, image_id, 'best', max_length)
+        print(f'result:{result}')