Update app.py

app.py

@@ -1,37 +1,42 @@
 import spaces
 import sys
 import os
-import torch
-torch.jit.script = lambda f: f
 
-import sys
+
+
+# os.system(f"git clone https://github.com/Curt-Park/yolo-world-with-efficientvit-sam.git")
+# cwd0 = os.getcwd()
+# cwd1 = os.path.join(cwd0, "yolo-world-with-efficientvit-sam")
+# os.chdir(cwd1)
+# os.system("make setup")
+# os.system(f"cd /home/user/app")
+
 sys.path.append('./')
-import argparse
-import hashlib
-import json
-import os.path
+import gradio as gr
+import random
 import numpy as np
+from gradio_demo.character_template import character_man, lorapath_man
+from gradio_demo.character_template import character_woman, lorapath_woman
+from gradio_demo.character_template import styles, lorapath_styles
 import torch
+import os
 from typing import Tuple, List
-from diffusers import DPMSolverMultistepScheduler
-from diffusers.models import T2IAdapter
-from PIL import Image
 import copy
-from diffusers import ControlNetModel, StableDiffusionXLPipeline
-from insightface.app import FaceAnalysis
-import gradio as gr
-import random
+import argparse
+from diffusers.utils import load_image
+import cv2
 from PIL import Image, ImageOps
 from transformers import DPTFeatureExtractor, DPTForDepthEstimation
-from controlnet_aux import OpenposeDetector
-from controlnet_aux.open_pose.body import Body
-from download import OMG_download
-
-from inference.models import YOLOWorld
-from src.efficientvit.models.efficientvit.sam import EfficientViTSamPredictor
-from src.efficientvit.sam_model_zoo import create_sam_model
-import supervision as sv
+# from controlnet_aux import OpenposeDetector
+# from controlnet_aux.open_pose.body import Body
 
+try:
+    from inference.models import YOLOWorld
+    from src.efficientvit.models.efficientvit.sam import EfficientViTSamPredictor
+    from src.efficientvit.sam_model_zoo import create_sam_model
+    import supervision as sv
+except:
+    print("YoloWorld can not be load")
 
 try:
     from groundingdino.models import build_model
@@ -44,28 +49,25 @@ try:
 except:
     print("groundingdino can not be load")
 
-from src.pipelines.instantid_pipeline import InstantidMultiConceptPipeline
-from src.pipelines.instantid_single_pieline import InstantidSingleConceptPipeline
+from src.pipelines.lora_pipeline import LoraMultiConceptPipeline
 from src.prompt_attention.p2p_attention import AttentionReplace
-from src.pipelines.instantid_pipeline import revise_regionally_controlnet_forward
-import cv2
-import math
-import PIL.Image
-
-from gradio_demo.character_template import styles, lorapath_styles
-STYLE_NAMES = list(styles.keys())
-
+from diffusers import ControlNetModel, StableDiffusionXLPipeline
+from src.pipelines.lora_pipeline import revise_regionally_controlnet_forward
 
+from download import OMG_download
 
+CHARACTER_MAN_NAMES = list(character_man.keys())
+CHARACTER_WOMAN_NAMES = list(character_woman.keys())
+STYLE_NAMES = list(styles.keys())
 MAX_SEED = np.iinfo(np.int32).max
 
+### Description
 title = r"""
-<h1 align="center">OMG: Occlusion-friendly Personalized Multi-concept Generation In Diffusion Models (OMG + InstantID)</h1>
+<h1 align="center">OMG: Occlusion-friendly Personalized Multi-concept Generation In Diffusion Models</h1>
 """
 
 description = r"""
-<b>Official 🤗 Gradio demo</b> for <a href='https://github.com/kongzhecn/OMG/' target='_blank'><b>OMG: Occlusion-friendly Personalized Multi-concept Generation In Diffusion Models</b></a>.<be>.<br>
-<a href='https://kongzhecn.github.io/omg-project/' target='_blank'><b>[Project]</b></a>.<a href='https://github.com/kongzhecn/OMG/' target='_blank'><b>[Code]</b></a>.<a href='https://arxiv.org/abs/2403.10983/' target='_blank'><b>[Arxiv]</b></a>.<br>
+<b>Official 🤗 Gradio demo</b> for <a href='https://github.com/' target='_blank'><b>OMG: Occlusion-friendly Personalized Multi-concept Generation In Diffusion Models</b></a>.<br>
 How to use:<br>
 1. Select two characters.
 2. Enter a text prompt as done in normal text-to-image models.
@@ -97,56 +99,26 @@ css = '''
 .gradio-container {width: 85% !important}
 '''
 
-
-
-def build_dino_segment_model(ckpt_repo_id, sam_checkpoint):
-    ckpt_filenmae = "groundingdino_swinb_cogcoor.pth"
-    ckpt_config_filename = os.path.join(ckpt_repo_id, "GroundingDINO_SwinB.cfg.py")
-    groundingdino_model = load_model_hf(ckpt_repo_id, ckpt_filenmae, ckpt_config_filename)
-    sam = build_sam(checkpoint=sam_checkpoint)
-    sam.cuda()
-    sam_predictor = SamPredictor(sam)
-    return groundingdino_model, sam_predictor
-
-def load_model_hf(repo_id, filename, ckpt_config_filename, device='cpu'):
-    args = SLConfig.fromfile(ckpt_config_filename)
-    model = build_model(args)
-    args.device = device
-
-    checkpoint = torch.load(os.path.join(repo_id, filename), map_location='cpu')
-    log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)
-    print("Model loaded from {} \n => {}".format(filename, log))
-    _ = model.eval()
-    return model
-
-def build_yolo_segment_model(sam_path, device):
-    yolo_world = YOLOWorld(model_id="yolo_world/l")
-    sam = EfficientViTSamPredictor(
-        create_sam_model(name="xl1", weight_url=sam_path).to(device).eval()
-    )
-    return yolo_world, sam
-
 def sample_image(pipe,
     input_prompt,
     input_neg_prompt=None,
     generator=None,
     concept_models=None,
     num_inference_steps=50,
-    guidance_scale=3.0,
+    guidance_scale=7.5,
     controller=None,
-    face_app=None,
-    image=None,
     stage=None,
     region_masks=None,
-    controlnet_conditioning_scale=None,
+    lora_list = None,
+    styleL=None,
     **extra_kargs
 ):
 
-    if image is not None:
-        image_condition = [image]
+    spatial_condition = extra_kargs.pop('spatial_condition')
+    if spatial_condition is not None:
+        spatial_condition_input = [spatial_condition] * len(input_prompt)
     else:
-        image_condition = None
-
+        spatial_condition_input = None
 
     images = pipe(
         prompt=input_prompt,
@@ -157,12 +129,13 @@ def sample_image(pipe,
         num_inference_steps=num_inference_steps,
         cross_attention_kwargs={"scale": 0.8},
         controller=controller,
-        image=image_condition,
-        face_app=face_app,
         stage=stage,
-        controlnet_conditioning_scale = controlnet_conditioning_scale,
         region_masks=region_masks,
+        lora_list=lora_list,
+        styleL=styleL,
+        image=spatial_condition_input,
         **extra_kargs).images
+
     return images
 
 def load_image_yoloworld(image_source) -> Tuple[np.array, torch.Tensor]:
@@ -181,37 +154,6 @@ def load_image_dino(image_source) -> Tuple[np.array, torch.Tensor]:
     image_transformed, _ = transform(image_source, None)
     return image, image_transformed
 
-def draw_kps_multi(image_pil, kps_list, color_list=[(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255)]):
-    stickwidth = 4
-    limbSeq = np.array([[0, 2], [1, 2], [3, 2], [4, 2]])
-
-
-    w, h = image_pil.size
-    out_img = np.zeros([h, w, 3])
-
-    for kps in kps_list:
-        kps = np.array(kps)
-        for i in range(len(limbSeq)):
-            index = limbSeq[i]
-            color = color_list[index[0]]
-
-            x = kps[index][:, 0]
-            y = kps[index][:, 1]
-            length = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5
-            angle = math.degrees(math.atan2(y[0] - y[1], x[0] - x[1]))
-            polygon = cv2.ellipse2Poly((int(np.mean(x)), int(np.mean(y))), (int(length / 2), stickwidth), int(angle), 0,
-                                       360, 1)
-            out_img = cv2.fillConvexPoly(out_img.copy(), polygon, color)
-        out_img = (out_img * 0.6).astype(np.uint8)
-
-        for idx_kp, kp in enumerate(kps):
-            color = color_list[idx_kp]
-            x, y = kp
-            out_img = cv2.circle(out_img.copy(), (int(x), int(y)), 10, color, -1)
-
-    out_img_pil = PIL.Image.fromarray(out_img.astype(np.uint8))
-    return out_img_pil
-
 def predict_mask(segmentmodel, sam, image, TEXT_PROMPT, segmentType, confidence = 0.2, threshold = 0.5):
     if segmentType=='GroundingDINO':
         image_source, image = load_image_dino(image)
@@ -236,68 +178,19 @@ def predict_mask(segmentmodel, sam, image, TEXT_PROMPT, segmentType, confidence
         masks=masks[0].squeeze(0)
     else:
         image_source = load_image_yoloworld(image)
-        segmentmodel.set_classes(TEXT_PROMPT)
+        segmentmodel.set_classes([TEXT_PROMPT])
         results = segmentmodel.infer(image_source, confidence=confidence)
         detections = sv.Detections.from_inference(results).with_nms(
             class_agnostic=True, threshold=threshold
         )
+        masks = None
+        if len(detections) != 0:
+            print(TEXT_PROMPT + " detected!")
+            sam.set_image(image_source, image_format="RGB")
+            masks, _, _ = sam.predict(box=detections.xyxy[0], multimask_output=False)
+            masks = torch.from_numpy(masks.squeeze())
 
-        masks_list = []
-        sam.set_image(image_source, image_format="RGB")
-        for xyxy in detections.xyxy:
-            mask, _, _ = sam.predict(box=xyxy, multimask_output=False)
-            masks_list.append(mask.squeeze())
-        detections.mask = np.array(masks_list)
-
-        mask_1 = []
-        mask_2 = []
-        for i, (class_id, confidence) in enumerate(zip(detections.class_id, detections.confidence)):
-            if class_id==0:
-                mask_1.append(torch.from_numpy(detections.mask[i]))
-            if class_id==1:
-                mask_2.append(torch.from_numpy(detections.mask[i]))
-        if len(mask_1)==0:
-            mask_1.append(None)
-        if len(mask_2)==0:
-            mask_2.append(None)
-        if len(TEXT_PROMPT)==2:
-            return mask_1[0], mask_2[0]
-
-    return mask_1[0]
-
-def build_model_sd(pretrained_model, controlnet_path, face_adapter, device, prompts, antelopev2_path, width, height, style_lora):
-    controlnet = ControlNetModel.from_pretrained(controlnet_path, torch_dtype=torch.float16)
-    pipe = InstantidMultiConceptPipeline.from_pretrained(
-        pretrained_model, controlnet=controlnet, torch_dtype=torch.float16, variant="fp16").to(device)
-
-    controller = AttentionReplace(prompts, 50, cross_replace_steps={"default_": 1.},
-                                  self_replace_steps=0.4, tokenizer=pipe.tokenizer, device=device, width=width, height=height,
-                                  dtype=torch.float16)
-    revise_regionally_controlnet_forward(pipe.unet, controller)
-
-    controlnet_concept = ControlNetModel.from_pretrained(controlnet_path, torch_dtype=torch.float16)
-    pipe_concept = InstantidSingleConceptPipeline.from_pretrained(
-        pretrained_model,
-        controlnet=controlnet_concept,
-        torch_dtype=torch.float16
-    )
-    pipe_concept.load_ip_adapter_instantid(face_adapter)
-    pipe_concept.set_ip_adapter_scale(0.8)
-    pipe_concept.to(device)
-    pipe_concept.image_proj_model.to(pipe_concept._execution_device)
-
-    if style_lora is not None and os.path.exists(style_lora):
-        pipe.load_lora_weights(style_lora, weight_name="pytorch_lora_weights.safetensors", adapter_name='style')
-        pipe_concept.load_lora_weights(style_lora, weight_name="pytorch_lora_weights.safetensors", adapter_name='style')
-
-
-    # modify
-    app = FaceAnalysis(name='antelopev2', root=antelopev2_path,
-                       providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
-    app.prepare(ctx_id=0, det_size=(640, 640))
-
-    return pipe, controller, pipe_concept, app
-
+    return masks
 
 def prepare_text(prompt, region_prompts):
     '''
@@ -315,28 +208,74 @@ def prepare_text(prompt, region_prompts):
     for region in regions:
         if region == '':
             break
-        prompt_region, neg_prompt_region, ref_img = region.split('-*-')
+        prompt_region, neg_prompt_region = region.split('-*-')
         prompt_region = prompt_region.replace('[', '').replace(']', '')
         neg_prompt_region = neg_prompt_region.replace('[', '').replace(']', '')
 
-        region_collection.append((prompt_region, neg_prompt_region, ref_img))
+        region_collection.append((prompt_region, neg_prompt_region))
     return (prompt, region_collection)
 
-def build_model_lora(pipe, pipe_concept, style_path, condition, condition_img):
-    if condition == "Human pose" and condition_img is not None:
+
+def build_model_sd(pretrained_model, controlnet_path, device, prompts):
+    controlnet = ControlNetModel.from_pretrained(controlnet_path, torch_dtype=torch.float16).to(device)
+    pipe = LoraMultiConceptPipeline.from_pretrained(
+        pretrained_model, controlnet=controlnet, torch_dtype=torch.float16, variant="fp16").to(device)
+    controller = AttentionReplace(prompts, 50, cross_replace_steps={"default_": 1.}, self_replace_steps=0.4, tokenizer=pipe.tokenizer, device=device, dtype=torch.float16, width=1024//32, height=1024//32)
+    revise_regionally_controlnet_forward(pipe.unet, controller)
+    pipe_concept = StableDiffusionXLPipeline.from_pretrained(pretrained_model, torch_dtype=torch.float16,
+                                                             variant="fp16").to(device)
+    return pipe, controller, pipe_concept
+
+def build_model_lora(pipe_concept, lora_paths, style_path, condition, args, pipe):
+    pipe_list = []
+    if condition == "Human pose":
         controlnet = ControlNetModel.from_pretrained(args.openpose_checkpoint, torch_dtype=torch.float16).to(device)
-        pipe.controlnet2 = controlnet
-    elif condition == "Canny Edge" and condition_img is not None:
+        pipe.controlnet = controlnet
+    elif condition == "Canny Edge":
         controlnet = ControlNetModel.from_pretrained(args.canny_checkpoint, torch_dtype=torch.float16, variant="fp16").to(device)
-        pipe.controlnet2 = controlnet
-    elif condition == "Depth" and condition_img is not None:
+        pipe.controlnet = controlnet
+    elif condition == "Depth":
         controlnet = ControlNetModel.from_pretrained(args.depth_checkpoint, torch_dtype=torch.float16).to(device)
-        pipe.controlnet2 = controlnet
+        pipe.controlnet = controlnet
 
     if style_path is not None and os.path.exists(style_path):
         pipe_concept.load_lora_weights(style_path, weight_name="pytorch_lora_weights.safetensors", adapter_name='style')
         pipe.load_lora_weights(style_path, weight_name="pytorch_lora_weights.safetensors", adapter_name='style')
 
+    for lora_path in lora_paths.split('|'):
+        adapter_name = lora_path.split('/')[-1].split('.')[0]
+        pipe_concept.load_lora_weights(lora_path, weight_name="pytorch_lora_weights.safetensors", adapter_name=adapter_name)
+        pipe_concept.enable_xformers_memory_efficient_attention()
+        pipe_list.append(adapter_name)
+    return pipe_list
+
+def build_yolo_segment_model(sam_path, device):
+    yolo_world = YOLOWorld(model_id="yolo_world/l")
+    sam = EfficientViTSamPredictor(
+        create_sam_model(name="xl1", weight_url=sam_path).to(device).eval()
+    )
+    return yolo_world, sam
+
+def load_model_hf(repo_id, filename, ckpt_config_filename, device='cpu'):
+    args = SLConfig.fromfile(ckpt_config_filename)
+    model = build_model(args)
+    args.device = device
+
+    checkpoint = torch.load(os.path.join(repo_id, filename), map_location='cpu')
+    log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)
+    print("Model loaded from {} \n => {}".format(filename, log))
+    _ = model.eval()
+    return model
+
+def build_dino_segment_model(ckpt_repo_id, sam_checkpoint):
+    ckpt_filenmae = "groundingdino_swinb_cogcoor.pth"
+    ckpt_config_filename = os.path.join(ckpt_repo_id, "GroundingDINO_SwinB.cfg.py")
+    groundingdino_model = load_model_hf(ckpt_repo_id, ckpt_filenmae, ckpt_config_filename)
+    sam = build_sam(checkpoint=sam_checkpoint)
+    sam.cuda()
+    sam_predictor = SamPredictor(sam)
+    return groundingdino_model, sam_predictor
+
 def resize_and_center_crop(image, output_size=(1024, 576)):
     width, height = image.size
     aspect_ratio = width / height
@@ -364,14 +303,12 @@ def resize_and_center_crop(image, output_size=(1024, 576)):
     return cropped_image
 
 def main(device, segment_type):
-    pipe, controller, pipe_concepts, face_app = build_model_sd(args.pretrained_model, args.controlnet_path,
-                                                               args.face_adapter_path, device, prompts_tmp,
-                                                               args.antelopev2_path, width // 32, height // 32,
-                                                               args.style_lora)
-    if segment_type == 'GroundingDINO':
-        detect_model, sam = build_dino_segment_model(args.dino_checkpoint, args.sam_checkpoint)
-    else:
-        detect_model, sam = build_yolo_segment_model(args.efficientViT_checkpoint, device)
+    pipe, controller, pipe_concept = build_model_sd(args.pretrained_sdxl_model, args.openpose_checkpoint, device, prompts_tmp)
+
+    # if segment_type == 'GroundingDINO':
+    #     detect_model, sam = build_dino_segment_model(args.dino_checkpoint, args.sam_checkpoint)
+    # else:
+    #     detect_model, sam = build_yolo_segment_model(args.efficientViT_checkpoint, device)
 
     resolution_list = ["1440*728",
                        "1344*768",
@@ -391,12 +328,8 @@ def main(device, segment_type):
 
     depth_estimator = DPTForDepthEstimation.from_pretrained(args.dpt_checkpoint).to("cuda")
     feature_extractor = DPTFeatureExtractor.from_pretrained(args.dpt_checkpoint)
-    body_model = Body(args.pose_detector_checkpoint)
-    openpose = OpenposeDetector(body_model)
-
-    prompts_rewrite = [args.prompt_rewrite]
-    input_prompt_test = [prepare_text(p, p_w) for p, p_w in zip(prompts, prompts_rewrite)]
-    input_prompt_test = [prompts, input_prompt_test[0][1]]
+    # body_model = Body(args.pose_detector_checkpoint)
+    # openpose = OpenposeDetector(body_model)
 
     def remove_tips():
         return gr.update(visible=False)
@@ -438,270 +371,167 @@ def main(device, segment_type):
         return image
 
     @spaces.GPU
-    def generate_image(prompt1, negative_prompt, reference_1, reference_2, resolution, local_prompt1, local_prompt2, seed, style, identitynet_strength_ratio, adapter_strength_ratio, condition, condition_img, controlnet_ratio):
-        identitynet_strength_ratio = float(identitynet_strength_ratio)
-        adapter_strength_ratio = float(adapter_strength_ratio)
-        controlnet_ratio = float(controlnet_ratio)
-        if lorapath_styles[style] is not None and os.path.exists(lorapath_styles[style]):
-            styleL = True
-        else:
-            styleL = False
-
-        width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
-        kwargs = {
-            'height': height,
-            'width': width,
-            't2i_controlnet_conditioning_scale': controlnet_ratio,
-        }
-
-        if condition == 'Human pose' and condition_img is not None:
-            index = ratio_list.index(
-                min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
-            resolution = resolution_list[index]
-            width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
-            kwargs['height'] = height
-            kwargs['width'] = width
-            condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
-            spatial_condition = get_humanpose(condition_img)
-        elif condition == 'Canny Edge' and condition_img is not None:
-            index = ratio_list.index(
-                min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
-            resolution = resolution_list[index]
-            width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
-            kwargs['height'] = height
-            kwargs['width'] = width
-            condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
-            spatial_condition = get_cannyedge(condition_img)
-        elif condition == 'Depth' and condition_img is not None:
-            index = ratio_list.index(
-                min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
-            resolution = resolution_list[index]
-            width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
-            kwargs['height'] = height
-            kwargs['width'] = width
-            condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
-            spatial_condition = get_depth(condition_img)
-        else:
-            spatial_condition = None
-
-        kwargs['t2i_image'] = spatial_condition
-        pipe.unload_lora_weights()
-        pipe_concepts.unload_lora_weights()
-        build_model_lora(pipe, pipe_concepts, lorapath_styles[style], condition, condition_img)
-        pipe_concepts.set_ip_adapter_scale(adapter_strength_ratio)
-
-        input_list = [prompt1]
-
-
-        for prompt in input_list:
-            if prompt != '':
-                input_prompt = []
-                p = '{prompt}, 35mm photograph, film, professional, 4k, highly detailed.'
-                if styleL:
-                    p = styles[style] + p
-                input_prompt.append([p.replace('{prompt}', prompt), p.replace("{prompt}", prompt)])
-                if styleL:
-                    input_prompt.append([(styles[style] + local_prompt1, 'noisy, blurry, soft, deformed, ugly',
-                                          PIL.Image.fromarray(reference_1)),
-                                         (styles[style] + local_prompt2, 'noisy, blurry, soft, deformed, ugly',
-                                          PIL.Image.fromarray(reference_2))])
-                else:
-                    input_prompt.append(
-                        [(local_prompt1, 'noisy, blurry, soft, deformed, ugly', PIL.Image.fromarray(reference_1)),
-                         (local_prompt2, 'noisy, blurry, soft, deformed, ugly', PIL.Image.fromarray(reference_2))])
-
-
-                controller.reset()
-                image = sample_image(
-                    pipe,
-                    input_prompt=input_prompt,
-                    concept_models=pipe_concepts,
-                    input_neg_prompt=[negative_prompt] * len(input_prompt),
-                    generator=torch.Generator(device).manual_seed(seed),
-                    controller=controller,
-                    face_app=face_app,
-                    controlnet_conditioning_scale=identitynet_strength_ratio,
-                    stage=1,
-                    **kwargs)
-
-                controller.reset()
-
-                if (pipe.tokenizer("man")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]) and (
-                        pipe.tokenizer("woman")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]):
-                    mask1, mask2 = predict_mask(detect_model, sam, image[0], ['man', 'woman'], args.segment_type, confidence=0.05,
-                                 threshold=0.5)
-
-                elif pipe.tokenizer("man")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]:
-                    mask1 = predict_mask(detect_model, sam, image[0], ['man'], args.segment_type, confidence=0.05,
-                                         threshold=0.5)
-                    mask2 = None
-
-                elif pipe.tokenizer("woman")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]:
-                    mask2 = predict_mask(detect_model, sam, image[0], ['woman'], args.segment_type, confidence=0.05,
-                                         threshold=0.5)
-                    mask1 = None
-                else:
-                    mask1 = mask2 = None
+    def generate_image(prompt1, negative_prompt, man, woman, resolution, local_prompt1, local_prompt2, seed, condition, condition_img1, style):
+        try:
+            path1 = lorapath_man[man]
+            path2 = lorapath_woman[woman]
+            pipe_concept.unload_lora_weights()
+            pipe.unload_lora_weights()
+            pipe_list = build_model_lora(pipe_concept, path1 + "|" + path2, lorapath_styles[style], condition, args, pipe)
+
+            if lorapath_styles[style] is not None and os.path.exists(lorapath_styles[style]):
+                styleL = True
+            else:
+                styleL = False
+
+            input_list = [prompt1]
+            condition_list = [condition_img1]
+            output_list = []
 
-                if mask1 is not None or mask2 is not None:
-                    face_info = face_app.get(cv2.cvtColor(np.array(image[0]), cv2.COLOR_RGB2BGR))
-                    face_kps = draw_kps_multi(image[0], [face['kps'] for face in face_info])
+            width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
 
+            kwargs = {
+                'height': height,
+                'width': width,
+            }
+
+            for prompt, condition_img in zip(input_list, condition_list):
+                if prompt!='':
+                    input_prompt = []
+                    p = '{prompt}, 35mm photograph, film, professional, 4k, highly detailed.'
+                    if styleL:
+                        p = styles[style] + p
+                    input_prompt.append([p.replace("{prompt}", prompt), p.replace("{prompt}", prompt)])
+                    if styleL:
+                        input_prompt.append([(styles[style] + local_prompt1, character_man.get(man)[1]),
+                                             (styles[style] + local_prompt2, character_woman.get(woman)[1])])
+                    else:
+                        input_prompt.append([(local_prompt1, character_man.get(man)[1]),
+                                             (local_prompt2, character_woman.get(woman)[1])])
+
+                    if condition == 'Human pose' and condition_img is not None:
+                        index = ratio_list.index(
+                            min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
+                        resolution = resolution_list[index]
+                        width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
+                        kwargs['height'] = height
+                        kwargs['width'] = width
+                        condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
+                        spatial_condition = get_humanpose(condition_img)
+                    elif condition == 'Canny Edge' and condition_img is not None:
+                        index = ratio_list.index(
+                            min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
+                        resolution = resolution_list[index]
+                        width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
+                        kwargs['height'] = height
+                        kwargs['width'] = width
+                        condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
+                        spatial_condition = get_cannyedge(condition_img)
+                    elif condition == 'Depth' and condition_img is not None:
+                        index = ratio_list.index(
+                            min(ratio_list, key=lambda x: abs(x - condition_img.shape[1] / condition_img.shape[0])))
+                        resolution = resolution_list[index]
+                        width, height = int(resolution.split("*")[0]), int(resolution.split("*")[1])
+                        kwargs['height'] = height
+                        kwargs['width'] = width
+                        condition_img = resize_and_center_crop(Image.fromarray(condition_img), (width, height))
+                        spatial_condition = get_depth(condition_img)
+                    else:
+                        spatial_condition = None
+
+                    kwargs['spatial_condition'] = spatial_condition
+                    controller.reset()
                     image = sample_image(
                         pipe,
                         input_prompt=input_prompt,
-                        concept_models=pipe_concepts,
+                        concept_models=pipe_concept,
                         input_neg_prompt=[negative_prompt] * len(input_prompt),
                         generator=torch.Generator(device).manual_seed(seed),
                         controller=controller,
-                        face_app=face_app,
-                        image=face_kps,
-                        stage=2,
-                        controlnet_conditioning_scale=identitynet_strength_ratio,
-                        region_masks=[mask1, mask2],
+                        stage=1,
+                        lora_list=pipe_list,
+                        styleL=styleL,
                         **kwargs)
 
-                # return [image[1], spatial_condition]
-                return image
-
-    with gr.Blocks(css=css) as demo:
-        # description
-        gr.Markdown(title)
-        gr.Markdown(description)
-
-        with gr.Row():
-            gallery = gr.Image(label="Generated Images", height=512, width=512)
-            gallery1 = gr.Image(label="Generated Images", height=512, width=512)
-            usage_tips = gr.Markdown(label="Usage tips of OMG", value=tips, visible=False)
-
-
-        with gr.Row():
-            reference_1 = gr.Image(label="Input an RGB image for Character man", height=128, width=128)
-            reference_2 = gr.Image(label="Input an RGB image for Character woman", height=128, width=128)
-            condition_img1 = gr.Image(label="Input an RGB image for condition (Optional)", height=128, width=128)
-
-
-
-
-        with gr.Row():
-            local_prompt1 = gr.Textbox(label="Character1_prompt",
-                                info="Describe the Character 1",
-                                value="Close-up photo of the a man, 35mm photograph, professional, 4k, highly detailed.")
-            local_prompt2 = gr.Textbox(label="Character2_prompt",
-                                       info="Describe the Character 2",
-                                       value="Close-up photo of the a woman, 35mm photograph, professional, 4k, highly detailed.")
-        with gr.Row():
-            identitynet_strength_ratio = gr.Slider(
-                label="IdentityNet strength (for fidelity)",
-                minimum=0,
-                maximum=1.5,
-                step=0.05,
-                value=0.80,
-            )
-            adapter_strength_ratio = gr.Slider(
-                label="Image adapter strength (for detail)",
-                minimum=0,
-                maximum=1.5,
-                step=0.05,
-                value=0.80,
-            )
-            controlnet_ratio = gr.Slider(
-                label="ControlNet strength",
-                minimum=0,
-                maximum=1.5,
-                step=0.05,
-                value=1,
-            )
-            resolution = gr.Dropdown(label="Image Resolution (width*height)", choices=resolution_list,
-                                     value="1024*1024")
-            style = gr.Dropdown(label="style", choices=STYLE_NAMES, value="None")
-            condition = gr.Dropdown(label="Input condition type", choices=condition_list, value="None")
-
-
-        # prompt
-        with gr.Column():
-            prompt = gr.Textbox(label="Prompt 1",
-                                info="Give a simple prompt to describe the first image content",
-                                placeholder="Required",
-                                value="close-up shot, photography, a man and a woman on the street, facing the camera smiling")
-
-
-        with gr.Accordion(open=False, label="Advanced Options"):
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=42,
-            )
-            negative_prompt = gr.Textbox(label="Negative Prompt",
-                                placeholder="noisy, blurry, soft, deformed, ugly",
-                                value="noisy, blurry, soft, deformed, ugly")
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
-        submit = gr.Button("Submit", variant="primary")
-
-        submit.click(
-            fn=remove_tips,
-            outputs=usage_tips,
-        ).then(
-            fn=randomize_seed_fn,
-            inputs=[seed, randomize_seed],
-            outputs=seed,
-            queue=False,
-            api_name=False,
-        ).then(
-            fn=generate_image,
-            inputs=[prompt, negative_prompt, reference_1, reference_2, resolution, local_prompt1, local_prompt2, seed, style, identitynet_strength_ratio, adapter_strength_ratio, condition, condition_img1, controlnet_ratio],
-            outputs=[gallery, gallery1]
-        )
-    demo.launch(server_name='0.0.0.0',server_port=7861, debug=True)
+                    controller.reset()
+                    if pipe.tokenizer("man")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]:
+                        mask1 = predict_mask(detect_model, sam, image[0], 'man', args.segment_type, confidence=0.15,
+                                             threshold=0.5)
+                    else:
+                        mask1 = None
+
+                    if pipe.tokenizer("woman")["input_ids"][1] in pipe.tokenizer(args.prompt)["input_ids"][1:-1]:
+                        mask2 = predict_mask(detect_model, sam, image[0], 'woman', args.segment_type, confidence=0.15,
+                                             threshold=0.5)
+                    else:
+                        mask2 = None
+
+                    if mask1 is None and mask2 is None:
+                        output_list.append(image[1])
+                    else:
+                        image = sample_image(
+                            pipe,
+                            input_prompt=input_prompt,
+                            concept_models=pipe_concept,
+                            input_neg_prompt=[negative_prompt] * len(input_prompt),
+                            generator=torch.Generator(device).manual_seed(seed),
+                            controller=controller,
+                            stage=2,
+                            region_masks=[mask1, mask2],
+                            lora_list=pipe_list,
+                            styleL=styleL,
+                            **kwargs)
+                        output_list.append(image[1])
+                else:
+                    output_list.append(None)
+            output_list.append(spatial_condition)
+            return output_list
+        except:
+            print("error")
+            return
+
+    def get_local_value_man(input):
+        return character_man[input][0]
+
+    def get_local_value_woman(input):
+        return character_woman[input][0]
+
+    @spaces.GPU
+    def generate(prompt):
+        print(os.system(prompt))
+        return prompt
+
+    gr.Interface(
+        fn=generate,
+        inputs=gr.Text(),
+        outputs=gr.Gallery(),
+    ).launch()
+
+
 
 def parse_args():
     parser = argparse.ArgumentParser('', add_help=False)
-    parser.add_argument('--pretrained_model', default='stablediffusionapi/realism-engine-sdxl-v30', type=str)
-    parser.add_argument('--controlnet_path', default='./checkpoint/InstantID/ControlNetModel', type=str)
-    parser.add_argument('--face_adapter_path', default='./checkpoint/InstantID/ip-adapter.bin', type=str)
+    parser.add_argument('--pretrained_sdxl_model', default='Fucius/stable-diffusion-xl-base-1.0', type=str)
     parser.add_argument('--openpose_checkpoint', default='thibaud/controlnet-openpose-sdxl-1.0', type=str)
     parser.add_argument('--canny_checkpoint', default='diffusers/controlnet-canny-sdxl-1.0', type=str)
     parser.add_argument('--depth_checkpoint', default='diffusers/controlnet-depth-sdxl-1.0', type=str)
-    parser.add_argument('--dpt_checkpoint', default='Intel/dpt-hybrid-midas', type=str)
-    parser.add_argument('--pose_detector_checkpoint',
-                        default='./checkpoint/ControlNet/annotator/ckpts/body_pose_model.pth', type=str)
-    parser.add_argument('--efficientViT_checkpoint', default='./checkpoint/sam/xl1.pt', type=str)
+    parser.add_argument('--efficientViT_checkpoint', default='../checkpoint/sam/xl1.pt', type=str)
     parser.add_argument('--dino_checkpoint', default='./checkpoint/GroundingDINO', type=str)
     parser.add_argument('--sam_checkpoint', default='./checkpoint/sam/sam_vit_h_4b8939.pth', type=str)
-    parser.add_argument('--antelopev2_path', default='./checkpoint/antelopev2', type=str)
-    parser.add_argument('--save_dir', default='results/instantID', type=str)
-    parser.add_argument('--prompt', default='Close-up photo of the cool man and beautiful woman as they accidentally discover a mysterious island while on vacation by the sea, facing the camera smiling, 35mm photograph, film, professional, 4k, highly detailed.', type=str)
+    parser.add_argument('--dpt_checkpoint', default='Intel/dpt-hybrid-midas', type=str)
+    parser.add_argument('--pose_detector_checkpoint', default='../checkpoint/ControlNet/annotator/ckpts/body_pose_model.pth', type=str)
+    parser.add_argument('--prompt', default='Close-up photo of the cool man and beautiful woman in surprised expressions as they accidentally discover a mysterious island while on vacation by the sea, 35mm photograph, film, professional, 4k, highly detailed.', type=str)
     parser.add_argument('--negative_prompt', default='noisy, blurry, soft, deformed, ugly', type=str)
-    parser.add_argument('--prompt_rewrite',
-                        default='[Close-up photo of a man, 35mm photograph, professional, 4k, highly detailed.]-*'
-                                '-[noisy, blurry, soft, deformed, ugly]-*-'
-                                '../example/chris-evans.jpg|'
-                                '[Close-up photo of a woman, 35mm photograph, professional, 4k, highly detailed.]-'
-                                '*-[noisy, blurry, soft, deformed, ugly]-*-'
-                                '../example/TaylorSwift.png',
-                        type=str)
-    parser.add_argument('--seed', default=0, type=int)
+    parser.add_argument('--seed', default=22, type=int)
     parser.add_argument('--suffix', default='', type=str)
     parser.add_argument('--segment_type', default='yoloworld', help='GroundingDINO or yoloworld', type=str)
-    parser.add_argument('--style_lora', default='', type=str)
     return parser.parse_args()
 
 if __name__ == '__main__':
     args = parse_args()
 
-    prompts = [args.prompt] * 2
-
+    prompts = [args.prompt]*2
     prompts_tmp = copy.deepcopy(prompts)
-
-    width, height = 1024, 1024
-    kwargs = {
-        'height': height,
-        'width': width,
-    }
-
     device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
-    main(device, args.segment_type)
-
+    download = OMG_download()
+    main(device, args.segment_type)