Upload SubjectGenius_gradio.py with huggingface_hub

SubjectGenius_gradio.py

@@ -0,0 +1,486 @@
+import os
+os.environ["FORCE_TORCH_LAYERNORM"] = "1"
+import sys
+import torch
+import gradio as gr
+import numpy as np
+import json
+import cv2
+from PIL import Image
+from datetime import datetime
+import tempfile
+import os.path as osp
+
+# 假设你的模型代码已经在同一目录或者正确的路径中
+from src.condition import Condition
+from src.SubjectGeniusTransformer2DModel import SubjectGeniusTransformer2DModel
+from src.SubjectGeniusPipeline import SubjectGeniusPipeline
+from accelerate.utils import set_seed
+
+# 全局变量
+weight_dtype = torch.bfloat16
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+transformer = None
+pipe = None
+TEMP_DIR = tempfile.mkdtemp()
+
+# 默认参数设置，与原始推理脚本一致
+DEFAULT_CONFIG = {
+    "pretrained_model_name_or_path": "/data/ydchen/VLP/SubjectGenius/model/FLUX.1-schnell",
+    "transformer": "/data/ydchen/VLP/SubjectGenius/model/FLUX.1-schnell/transformer",
+    "condition_types": ["fill", "subject"],
+    "denoising_lora": "/data/ydchen/VLP/SubjectGenius/model/Subject_genuis/Denoising_LoRA/subject_fill_union",
+    "denoising_lora_weight": 1.0,
+    "condition_lora_dir": "/data/ydchen/VLP/SubjectGenius/model/Subject_genuis/Condition_LoRA",
+    "resolution": 512,
+    "num_inference_steps": 8,
+    "max_sequence_length": 512
+}
+
+def load_model():
+    global transformer, pipe
+    
+    print("开始加载transformer模型...")
+    # 加载transformer模型
+    transformer = SubjectGeniusTransformer2DModel.from_pretrained(
+        pretrained_model_name_or_path=DEFAULT_CONFIG["transformer"],
+    ).to(device=device, dtype=weight_dtype)
+    print("transformer模型加载完成")
+
+    print("开始加载condition LoRA...")
+    # 加载condition LoRA
+    for condition_type in DEFAULT_CONFIG["condition_types"]:
+        print(f"加载{condition_type} LoRA...")
+        transformer.load_lora_adapter(
+            f"{DEFAULT_CONFIG['condition_lora_dir']}/{condition_type}.safetensors", 
+            adapter_name=condition_type
+        )
+    print("所有condition LoRA加载完成")
+
+    print("开始创建pipeline...")
+    # 创建pipeline
+    pipe = SubjectGeniusPipeline.from_pretrained(
+        DEFAULT_CONFIG["pretrained_model_name_or_path"],
+        torch_dtype=weight_dtype,
+        transformer=None
+    )
+    print("pipeline创建完成")
+    
+    print("设置transformer...")
+    pipe.transformer = transformer
+    
+    print("设置adapter...")
+    # 设置adapter
+    pipe.transformer.set_adapters([i for i in DEFAULT_CONFIG["condition_types"]])
+    pipe = pipe.to(device)
+    print("模型完全加载完成！")
+    
+    return "模型加载完成！"
+
+def process_image_for_display(image_array):
+    """将图像处理为适合显示的格式，保持原始尺寸，但确保是RGB格式"""
+    if image_array is None:
+        return None
+    
+    # 如果是PIL图像，转换为numpy数组
+    if isinstance(image_array, Image.Image):
+        image_array = np.array(image_array)
+    
+    # 确保是RGB格式
+    if len(image_array.shape) == 2:  # 灰度图像
+        image_array = cv2.cvtColor(image_array, cv2.COLOR_GRAY2RGB)
+    elif image_array.shape[2] == 4:  # RGBA图像
+        image_array = image_array[:, :, :3]
+    
+    return image_array
+
+def save_image_for_model(image_array, path):
+    """保存图像用于模型输入"""
+    if image_array is None:
+        return None
+    
+    # 确保目录存在
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    
+    # 如果是PIL图像，直接保存
+    if isinstance(image_array, Image.Image):
+        image_array.save(path)
+        return path
+    
+    # 如果是numpy数组，转换为PIL图像再保存
+    Image.fromarray(process_image_for_display(image_array)).save(path)
+    return path
+
+def preserve_aspect_ratio(image, target_size=(512, 512)):
+    """保持原始比例调整图像大小"""
+    if isinstance(image, np.ndarray):
+        pil_image = Image.fromarray(image)
+    else:
+        pil_image = image
+        
+    # 计算宽高比
+    width, height = pil_image.size
+    aspect_ratio = width / height
+    
+    # 创建新的白色背景图像
+    new_image = Image.new("RGB", target_size, (255, 255, 255))
+    
+    # 保持比例缩放
+    if aspect_ratio > 1:  # 宽图
+        new_width = target_size[0]
+        new_height = int(new_width / aspect_ratio)
+    else:  # 高图
+        new_height = target_size[1]
+        new_width = int(new_height * aspect_ratio)
+        
+    # 调整大小
+    resized_image = pil_image.resize((new_width, new_height), Image.LANCZOS)
+    
+    # 居中粘贴到新图像
+    paste_position = ((target_size[0] - new_width) // 2, 
+                      (target_size[1] - new_height) // 2)
+    new_image.paste(resized_image, paste_position)
+    
+    return new_image
+
+def generate_image(
+    prompt, 
+    subject_image, 
+    background_image, 
+    x1, y1, x2, y2,
+    version="training-free", 
+    seed=0, 
+    num_inference_steps=8
+):
+    global pipe
+    
+    # 确保模型已加载
+    if pipe is None:
+        load_model()
+    
+    # 检查输入
+    if subject_image is None or background_image is None:
+        return None, None, "请同时上传主体图像和背景图像"
+    
+    try:
+        # 将坐标转换为整数
+        x1, y1, x2, y2 = int(float(x1)), int(float(y1)), int(float(x2)), int(float(y2))
+        if x1 > x2: x1, x2 = x2, x1
+        if y1 > y2: y1, y2 = y2, y1
+        
+        # 准备模型所需的固定尺寸图像
+        MODEL_SIZE = (512, 512)
+        
+        # 1. 处理主体图像 - 保持原始比例，但调整到模型可接受的尺寸
+        subject_pil = Image.fromarray(subject_image) if isinstance(subject_image, np.ndarray) else subject_image
+        # 创建白色背景
+        subject_processed = Image.new("RGB", MODEL_SIZE, (255, 255, 255))
+        # 保持比例调整大小
+        subject_pil.thumbnail((MODEL_SIZE[0], MODEL_SIZE[1]), Image.LANCZOS)
+        # 居中粘贴
+        paste_pos = ((MODEL_SIZE[0] - subject_pil.width) // 2, 
+                     (MODEL_SIZE[1] - subject_pil.height) // 2)
+        subject_processed.paste(subject_pil, paste_pos)
+        
+        # 2. 处理背景图像 - 同样保持原始比例
+        background_pil = Image.fromarray(background_image) if isinstance(background_image, np.ndarray) else background_image
+        
+        # 保存原始尺寸，用于坐标转换
+        orig_width, orig_height = background_pil.size
+        
+        # 调整背景图像大小，保持比例
+        background_processed = Image.new("RGB", MODEL_SIZE, (255, 255, 255))
+        background_pil.thumbnail((MODEL_SIZE[0], MODEL_SIZE[1]), Image.LANCZOS)
+        bg_paste_pos = ((MODEL_SIZE[0] - background_pil.width) // 2, 
+                        (MODEL_SIZE[1] - background_pil.height) // 2)
+        background_processed.paste(background_pil, bg_paste_pos)
+        
+        # 3. 计算调整后的bbox坐标
+        scale_x = background_pil.width / orig_width
+        scale_y = background_pil.height / orig_height
+        
+        adjusted_x1 = int(x1 * scale_x) + bg_paste_pos[0]
+        adjusted_y1 = int(y1 * scale_y) + bg_paste_pos[1]
+        adjusted_x2 = int(x2 * scale_x) + bg_paste_pos[0]
+        adjusted_y2 = int(y2 * scale_y) + bg_paste_pos[1]
+        
+        # 确保坐标在有效范围内
+        adjusted_x1 = max(0, min(adjusted_x1, MODEL_SIZE[0]-1))
+        adjusted_y1 = max(0, min(adjusted_y1, MODEL_SIZE[1]-1))
+        adjusted_x2 = max(0, min(adjusted_x2, MODEL_SIZE[0]-1))
+        adjusted_y2 = max(0, min(adjusted_y2, MODEL_SIZE[1]-1))
+        
+        # 最终bbox
+        bbox = [adjusted_x1, adjusted_y1, adjusted_x2, adjusted_y2]
+        
+        # 4. 创建用于展示的背景图像副本（用于可视化结果）
+        background_display = background_processed.copy()
+        
+        # 5. 在实际输入到模型的背景图像上将选定区域填充为黑色
+        background_for_model = background_processed.copy()
+        background_for_model_array = np.array(background_for_model)
+        # 将选定区域填充为黑色
+        background_for_model_array[adjusted_y1:adjusted_y2+1, adjusted_x1:adjusted_x2+1] = (0, 0, 0)
+        background_for_model = Image.fromarray(background_for_model_array)
+        
+        # 6. 创建模型条件
+        subject_condition = Condition("subject", raw_img=subject_processed, no_process=True)
+        # 使用黑色区域的背景图像作为填充条件
+        fill_condition = Condition("fill", raw_img=background_for_model, no_process=True)
+        
+        conditions = [subject_condition, fill_condition]
+        
+        # 7. 设置随机种子
+        if seed is not None:
+            set_seed(seed)
+        
+        # 8. 准备JSON数据
+        json_data = {
+            "description": prompt,
+            "bbox": bbox
+        }
+        
+        # 9. 设置模型模式
+        if version == "training-based":
+            denoising_lora_name = os.path.basename(os.path.normpath(DEFAULT_CONFIG["denoising_lora"]))
+            pipe.transformer.load_lora_adapter(
+                DEFAULT_CONFIG["denoising_lora"],
+                adapter_name=denoising_lora_name, 
+                use_safetensors=True
+            )
+            pipe.transformer.set_adapters(
+                [i for i in DEFAULT_CONFIG["condition_types"]] + [denoising_lora_name],
+                [1.0, 1.0, DEFAULT_CONFIG["denoising_lora_weight"]]
+            )
+        elif version == "training-free":
+            pipe.transformer.set_adapters([i for i in DEFAULT_CONFIG["condition_types"]])
+        
+        # 10. 生成图像
+        result_img = pipe(
+            prompt=prompt,
+            conditions=conditions,
+            height=MODEL_SIZE[1],
+            width=MODEL_SIZE[0],
+            num_inference_steps=num_inference_steps,
+            max_sequence_length=DEFAULT_CONFIG["max_sequence_length"],
+            model_config={"json_data": json_data},
+        ).images[0]
+        
+        # 11. 创建可视化结果（拼接图像）
+        concat_image = Image.new("RGB", (MODEL_SIZE[0] * 3, MODEL_SIZE[1]), (255, 255, 255))
+        
+        # 添加主体图像
+        concat_image.paste(subject_processed, (0, 0))
+        
+        # 添加实际输入模型的背景图像（包含黑色区域）
+        concat_image.paste(background_for_model, (MODEL_SIZE[0], 0))
+        
+        # 添加生成结果
+        concat_image.paste(result_img, (MODEL_SIZE[0] * 2, 0))
+        
+        return concat_image, result_img, "生成成功！"
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, None, f"生成图像时发生错误: {str(e)}"
+
+def draw_bbox(background_image, evt: gr.SelectData):
+    """处理用户在图片上的选择，绘制矩形"""
+    # 初始化边界框
+    if not hasattr(draw_bbox, "start_point"):
+        draw_bbox.start_point = None
+        draw_bbox.current_image = None
+    
+    # 检查背景图像
+    if background_image is None:
+        return background_image, "", "", "", ""
+    
+    try:
+        # 获取图像尺寸
+        h, w = background_image.shape[:2]
+        
+        # 处理目标宽度和高度
+        target_width = getattr(evt, 'target_width', None) or getattr(evt.target, 'width', None) or w
+        target_height = getattr(evt, 'target_height', None) or getattr(evt.target, 'height', None) or h
+        
+        # 计算缩放比例
+        scale_x = w / target_width if target_width else 1.0
+        scale_y = h / target_height if target_height else 1.0
+        
+        # 获取点击坐标
+        x = min(max(0, int(evt.index[0] * scale_x)), w-1)
+        y = min(max(0, int(evt.index[1] * scale_y)), h-1)
+        
+        # 如果是第一次点击，记录起始点
+        if draw_bbox.start_point is None:
+            draw_bbox.start_point = (x, y)
+            draw_bbox.current_image = background_image.copy()
+            return background_image, "", "", "", ""
+        
+        # 第二次点击，完成矩形
+        end_point = (x, y)
+        
+        # 确保坐标有序
+        x1 = min(draw_bbox.start_point[0], end_point[0])
+        y1 = min(draw_bbox.start_point[1], end_point[1])
+        x2 = max(draw_bbox.start_point[0], end_point[0])
+        y2 = max(draw_bbox.start_point[1], end_point[1])
+        
+        # 绘制矩形
+        img_with_rect = draw_bbox.current_image.copy()
+        cv2.rectangle(img_with_rect, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        
+        # 重置起始点
+        draw_bbox.start_point = None
+        
+        return img_with_rect, str(x1), str(y1), str(x2), str(y2)
+    
+    except Exception as e:
+        print(f"绘制边界框时发生错误: {e}")
+        draw_bbox.start_point = None
+        return background_image, "", "", "", ""
+
+def update_bbox_from_input(background_image, x1, y1, x2, y2):
+    """根据输入的坐标值更新矩形框"""
+    try:
+        if background_image is None:
+            return background_image
+        
+        # 尝试将坐标转换为整数
+        x1, y1, x2, y2 = int(float(x1) if x1 else 0), int(float(y1) if y1 else 0), \
+                        int(float(x2) if x2 else 0), int(float(y2) if y2 else 0)
+        
+        # 获取图像尺寸
+        h, w = background_image.shape[:2]
+        
+        # 边界检查
+        x1 = max(0, min(x1, w-1))
+        y1 = max(0, min(y1, h-1))
+        x2 = max(0, min(x2, w-1))
+        y2 = max(0, min(y2, h-1))
+        
+        # 确保x1 < x2, y1 < y2
+        if x1 > x2:
+            x1, x2 = x2, x1
+        if y1 > y2:
+            y1, y2 = y2, y1
+        
+        # 绘制矩形
+        img_with_rect = background_image.copy()
+        cv2.rectangle(img_with_rect, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        
+        return img_with_rect
+    except:
+        return background_image
+
+def reset_bbox(background_image):
+    """重置边界框和图像"""
+    if hasattr(draw_bbox, "start_point"):
+        draw_bbox.start_point = None
+    
+    if background_image is None:
+        return None, "", "", "", ""
+    else:
+        return background_image.copy(), "", "", "", ""
+
+# 创建Gradio界面
+def create_interface():
+    with gr.Blocks(title="SubjectGenius 图像生成器") as demo:
+        gr.Markdown("# SubjectGenius 图像生成器")
+        gr.Markdown("上传参考图像和背景图像，并在背景上选择区域来生成新的图像。")
+        
+        status_message = gr.Textbox(label="状态信息", interactive=False)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 输入参数")
+                
+                prompt = gr.Textbox(label="图像描述文本", placeholder="例如：A decorative fabric topper for windows.")
+                
+                with gr.Row():
+                    subject_image = gr.Image(label="主体图像 (Subject)", type="numpy")
+                    background_image = gr.Image(label="背景图像 (Fill)", type="numpy")
+                
+                gr.Markdown("### 在背景图上选择区域（点击两次确定对角线顶点）或手动输入坐标")
+                
+                with gr.Row():
+                    x1_input = gr.Textbox(label="X1", placeholder="左上角 X 坐标")
+                    y1_input = gr.Textbox(label="Y1", placeholder="左上角 Y 坐标")
+                    x2_input = gr.Textbox(label="X2", placeholder="右下角 X 坐标")
+                    y2_input = gr.Textbox(label="Y2", placeholder="右下角 Y 坐标")
+                    reset_btn = gr.Button("重置选择")
+                
+                with gr.Accordion("高级选项", open=False):
+                    version = gr.Radio(
+                        ["training-free", "training-based"], 
+                        label="版本", 
+                        value="training-free"
+                    )
+                    seed = gr.Slider(
+                        0, 1000, value=0, step=1, 
+                        label="随机种子"
+                    )
+                    steps = gr.Slider(
+                        4, 50, value=8, step=1, 
+                        label="推理步数（越大越慢但质量可能更好）"
+                    )
+                
+                generate_btn = gr.Button("生成图像", variant="primary")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 预览区域选择")
+                preview_image = gr.Image(label="区域预览", type="numpy", elem_id="preview_image")
+                
+                gr.Markdown("### 生成结果")
+                with gr.Tabs():
+                    with gr.TabItem("完整结果"):
+                        output_image_full = gr.Image(label="完整结果（包含条件图像）")
+                    with gr.TabItem("仅生成图像"):
+                        output_image = gr.Image(label="生成图像")
+        
+        # 事件处理
+        background_image.select(
+            draw_bbox, 
+            inputs=[background_image], 
+            outputs=[preview_image, x1_input, y1_input, x2_input, y2_input]
+        )
+        
+        # 坐标输入同步更新预览
+        coord_inputs = [x1_input, y1_input, x2_input, y2_input]
+        for coord in coord_inputs:
+            coord.change(
+                update_bbox_from_input, 
+                inputs=[background_image, x1_input, y1_input, x2_input, y2_input], 
+                outputs=[preview_image]
+            )
+        
+        # 重置按钮
+        reset_btn.click(
+            reset_bbox, 
+            inputs=[background_image], 
+            outputs=[preview_image, x1_input, y1_input, x2_input, y2_input]
+        )
+        
+        # 生成按钮
+        generate_btn.click(
+            generate_image, 
+            inputs=[prompt, subject_image, background_image, 
+                   x1_input, y1_input, x2_input, y2_input,
+                   version, seed, steps], 
+            outputs=[output_image_full, output_image, status_message]
+        )
+        
+    return demo
+
+# 主函数
+if __name__ == "__main__":
+    # 创建界面
+    demo = create_interface()
+    
+    # 加载模型
+    print("正在加载模型...")
+    load_model()
+    
+    # 启动Gradio
+    demo.launch(share=True)