Upload test.py with huggingface_hub

test.py

@@ -0,0 +1,280 @@
+import sys,os
+import numpy as np
+from PIL import Image
+current_dir = os.path.dirname(__file__)
+sys.path.append(os.path.abspath(os.path.join(current_dir, '..')))
+import argparse
+import logging
+import torch
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import ProjectConfiguration, set_seed
+from tqdm.auto import tqdm
+import diffusers
+from diffusers import FluxPipeline
+import json
+from diffusers.image_processor import VaeImageProcessor
+from src.condition import Condition
+from diffusers.utils import check_min_version, is_wandb_available
+from src.dataloader import get_dataset,prepare_dataset,collate_fn
+from datetime import datetime
+if is_wandb_available():
+    pass
+import cv2
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.32.0.dev0")
+
+logger = get_logger(__name__, log_level="INFO")
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+from src.SubjectGeniusTransformer2DModel import SubjectGeniusTransformer2DModel
+from src.SubjectGeniusPipeline import SubjectGeniusPipeline
+
+
+def encode_images(pixels: torch.Tensor, vae: torch.nn.Module, weight_dtype):
+    pixel_latents = vae.encode(pixels.to(vae.dtype)).latent_dist.sample()
+    pixel_latents = (pixel_latents - vae.config.shift_factor) * vae.config.scaling_factor
+    return pixel_latents.to(weight_dtype)
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="testing script.")
+    parser.add_argument("--pretrained_model_name_or_path", type=str,default="ckpt/FLUX.1-schnell",)
+    parser.add_argument("--transformer",type=str,default="ckpt/FLUX.1-schnell/transformer",)
+    parser.add_argument(
+        "--dataset_name",type=str,
+        default=[
+            "dataset/split_SubjectSpatial200K/test",
+            "dataset/split_SubjectSpatial200K/Collection3/test"
+        ],
+    )
+    parser.add_argument("--image_column", type=str, default="image", )
+    parser.add_argument("--bbox_column", type=str, default="bbox", )
+    parser.add_argument("--canny_column", type=str, default="canny", )
+    parser.add_argument("--depth_column", type=str, default="depth", )
+    parser.add_argument("--condition_types", type=str, nargs='+', default=["canny", "depth"], )
+    parser.add_argument("--denoising_lora",type=str,default="ckpt/Denoising_LoRA/depth_canny_union",)
+    parser.add_argument("--condition_lora_dir",type=str,default="ckpt/Condition_LoRA",)
+    parser.add_argument("--max_sequence_length",type=int,default=512,help="Maximum sequence length to use with with the T5 text encoder")
+    parser.add_argument("--work_dir",type=str,default="output/test_result")
+    parser.add_argument("--cache_dir",type=str,default="cache")
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--resolution",type=int,default=512,)
+    parser.add_argument("--batch_size", type=int, default=8)
+    parser.add_argument("--dataloader_num_workers",type=int,default=0,)
+    parser.add_argument("--mixed_precision",type=str,default="bf16",choices=["no", "fp16", "bf16"])
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed running: local_rank")
+
+
+    args = parser.parse_args()
+    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+    args.revision = None
+    args.variant = None
+    args.denoising_lora_name = os.path.basename(os.path.normpath(args.denoising_lora))
+    return args
+
+
+def main(args):
+    accelerator = Accelerator(
+        mixed_precision=args.mixed_precision,
+    )
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_warning()
+    else:
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # 2. set seed
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # 3. create the working directory
+    if accelerator.is_main_process:
+        if args.work_dir is not None:
+            os.makedirs(args.work_dir, exist_ok=True)
+
+    # 4. precision
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # 5. Load pretrained single conditional LoRA modules onto the FLUX transformer
+    transformer = SubjectGeniusTransformer2DModel.from_pretrained(
+        pretrained_model_name_or_path=args.transformer,
+        revision=args.revision,
+        variant=args.variant
+    ).to(accelerator.device, dtype=weight_dtype)
+    lora_names = args.condition_types
+    for condition_type in lora_names:
+        transformer.load_lora_adapter(f"{args.condition_lora_dir}/{condition_type}.safetensors", adapter_name=condition_type)
+    logger.info("You are working on the following condition types: {}".format(lora_names))
+
+    # 6. get the inference pipeline.
+    pipe = SubjectGeniusPipeline.from_pretrained(
+        args.pretrained_model_name_or_path,
+        transformer=None,
+    ).to(accelerator.device, dtype=weight_dtype)
+    pipe.transformer = transformer
+
+    # 7. get the VAE image processor to do the pre-process and post-process for images.
+    # (vae_scale_factor is the scale of downsample.)
+    vae_scale_factor = 2 ** (len(pipe.vae.config.block_out_channels) - 1)
+    image_processor = VaeImageProcessor(vae_scale_factor=vae_scale_factor * 2 ,do_resize=True)
+
+    # 8. get the dataset
+    dataset = get_dataset(args)
+    print("len:",len(dataset))
+    dataset = prepare_dataset(dataset, vae_scale_factor, accelerator, args)
+
+    # 9. set the seed
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # 10. get the dataloader
+    dataloader = torch.utils.data.DataLoader(
+        dataset,
+        shuffle=False,
+        collate_fn=collate_fn,
+        batch_size=args.batch_size,
+        num_workers=args.dataloader_num_workers,
+    )
+
+    # 10. accelerator start
+    initial_global_step = 0
+    pipe, dataloader = accelerator.prepare(
+        pipe, dataloader
+    )
+
+    logger.info("***** Running testing *****")
+    logger.info(f"  Num examples = {len(dataset)}")
+    logger.info(f"  Instantaneous batch size per device = {args.batch_size}")
+    logger.info(f"  Transformer Class = {transformer.__class__.__name__}")
+    logger.info(f"  Num of GPU processes = {accelerator.num_processes}")
+
+
+    progress_bar = tqdm(
+        range(0, len(dataloader)),
+        initial=initial_global_step,
+        desc="Steps",
+        # Only show the progress bar once on each machine.
+        disable=not accelerator.is_local_main_process,
+    )
+
+    output_dir = os.path.join(args.work_dir, f"{datetime.now().strftime("%y:%m:%d-%H:%M")}")
+    logger.info(f"output dir: {output_dir}")
+    os.makedirs(os.path.join(output_dir, "info"), exist_ok=True)
+
+    # 11. start testing!
+    for S, batch in enumerate(dataloader):
+        prompts = batch["descriptions"]
+        # 12.1 Get Conditions input tensors -> "condition_latents"
+        # 12.2 Get Conditions positional id list. -> "condition_ids"
+        # 12.3 Get Conditions types string list. -> "condition_types"
+        # (bs, cond_num, c, h, w) -> [cond_num, (bs, c, h ,w)]
+        condition_latents = list(torch.unbind(batch["condition_latents"], dim=1))
+        # [cond_num, (len ,3) ]
+        condition_ids = []
+        # [cond_num]
+        condition_types = batch["condition_types"][0]
+        for i,images_per_condition in enumerate(condition_latents):
+            # i means No.i. Conditional Branch
+            # images_per_condition = (bs, c, h ,w)
+            images_per_condition = encode_images(pixels=images_per_condition,vae=pipe.vae,weight_dtype=weight_dtype)
+            condition_latents[i] = FluxPipeline._pack_latents(
+                images_per_condition,
+                batch_size=images_per_condition.shape[0],
+                num_channels_latents=images_per_condition.shape[1],
+                height=images_per_condition.shape[2],
+                width=images_per_condition.shape[3],
+            )
+            cond_ids = FluxPipeline._prepare_latent_image_ids(
+                images_per_condition.shape[0],
+                images_per_condition.shape[2] // 2,
+                images_per_condition.shape[3] // 2,
+                accelerator.device,
+                weight_dtype,
+            )
+            if condition_types[i] == "subject":
+                cond_ids[:, 2] += images_per_condition.shape[2] // 2
+            condition_ids.append(cond_ids)
+
+        # 13 prepare the input conditions=[Condition1, Condition2, ...] for all the conditional branches
+        conditions = []
+        for i, condition_type in enumerate(condition_types):
+            conditions.append(Condition(condition_type,condition=condition_latents[i],condition_ids=condition_ids[i]))
+
+        # 14.1 inference of training-based SubjectGenius
+        pipe.transformer.load_lora_adapter(args.denoising_lora,adapter_name=args.denoising_lora_name ,use_safetensors=True)
+        pipe.transformer.set_adapters([i for i in lora_names] + [args.denoising_lora_name ])
+        if args.seed is not None:
+            set_seed(args.seed)
+        result_img_list = pipe(
+            prompt=prompts,
+            conditions=conditions,
+            height=args.resolution,
+            width=args.resolution,
+            num_inference_steps=8,
+            max_sequence_length=512,
+            model_config = {
+            },
+            accelerator=accelerator
+        ).images
+        pipe.transformer.delete_adapters(args.denoising_lora_name)
+
+        # 14.2 inference of training-free SubjectGenius
+        pipe.transformer.set_adapters([i for i in lora_names])
+        if args.seed is not None:
+            set_seed(args.seed)
+        origin_result_img_list = pipe(
+            prompt=prompts,
+            conditions=conditions,
+            height=args.resolution,
+            width=args.resolution,
+            num_inference_steps=8,
+            max_sequence_length=512,
+            model_config = {
+            },
+            accelerator = accelerator
+        ).images
+
+        # 15. save the output to the output_dir = "work_dir/datetime"
+        for i,(result_img,origin_result_img) in enumerate(zip(result_img_list,origin_result_img_list)):
+            target_img = image_processor.postprocess(batch["pixel_values"][i].unsqueeze(0),output_type="pil")[0]
+            cond_images = image_processor.postprocess(batch["condition_latents"][i],output_type="pil")
+            concat_image = Image.new("RGB", (1536+len(cond_images)*512, 512))
+            for j,(cond_image,cond_type) in enumerate(zip(cond_images,condition_types)):
+                if cond_type == "fill":
+                    cond_image = cv2.rectangle(np.array(cond_image), tuple(batch['bboxes'][i][:2]),tuple(batch['bboxes'][i][2:]), color=(128, 128, 128), thickness=-1)
+                    cond_image = Image.fromarray(cv2.rectangle(cond_image, tuple(batch['bboxes'][i][:2]), tuple(batch['bboxes'][i][2:]),color=(255, 215, 0), thickness=2))
+                concat_image.paste(cond_image,(j*512,0))
+            concat_image.paste(result_img,(j*512+512,0))
+            concat_image.paste(origin_result_img,(j*512+1024,0))
+            concat_image.paste(target_img,(j*512+1536,0))
+
+            concat_image.save(os.path.join(output_dir,f"{S*args.batch_size+i}_{batch['items'][i]}.jpg"))
+
+            with open(os.path.join(output_dir,"info",f"{S*args.batch_size+i}_rank{accelerator.local_process_index}_{batch['items'][i]}.json"), "w", encoding="utf-8") as file:
+                meta_data = {
+                    "description": prompts[i],
+                    "bbox": batch["bboxes"][i]
+                }
+                json.dump(meta_data,file, ensure_ascii=False, indent=4)
+
+        progress_bar.update(1)
+
+if __name__ == "__main__":
+    args = parse_args()
+    with torch.no_grad():
+        main(args)
+