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([""] * 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": , "Feedback": "" }} """ 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)