Upload folder using huggingface_hub

util/ic-light.py

@@ -0,0 +1,443 @@
+import os
+import math
+import random
+import string
+import numpy as np
+import torch
+import safetensors.torch as sf
+import albumentations as A
+import cv2
+from diffusers.utils import load_image
+
+from PIL import Image, ImageFilter, ImageOps
+from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionLatentUpscalePipeline
+from diffusers import AutoencoderKL, UNet2DConditionModel, DDIMScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler
+from diffusers.models.attention_processor import AttnProcessor2_0
+from transformers import CLIPTextModel, CLIPTokenizer
+from enum import Enum
+# from torch.hub import download_url_to_file
+
+
+# 'stablediffusionapi/realistic-vision-v51'
+# 'runwayml/stable-diffusion-v1-5'
+sd15_name = 'stablediffusionapi/realistic-vision-v51'
+tokenizer = CLIPTokenizer.from_pretrained(sd15_name, subfolder="tokenizer")
+text_encoder = CLIPTextModel.from_pretrained(sd15_name, subfolder="text_encoder")
+vae = AutoencoderKL.from_pretrained(sd15_name, subfolder="vae")
+unet = UNet2DConditionModel.from_pretrained(sd15_name, subfolder="unet")
+upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained("stabilityai/sd-x2-latent-upscaler", torch_dtype=torch.float16)
+
+# Change UNet
+
+with torch.no_grad():
+    new_conv_in = torch.nn.Conv2d(8, unet.conv_in.out_channels, unet.conv_in.kernel_size, unet.conv_in.stride, unet.conv_in.padding)
+    new_conv_in.weight.zero_()
+    new_conv_in.weight[:, :4, :, :].copy_(unet.conv_in.weight)
+    new_conv_in.bias = unet.conv_in.bias
+    unet.conv_in = new_conv_in
+
+unet_original_forward = unet.forward
+
+
+def hooked_unet_forward(sample, timestep, encoder_hidden_states, **kwargs):
+    c_concat = kwargs['cross_attention_kwargs']['concat_conds'].to(sample)
+    c_concat = torch.cat([c_concat] * (sample.shape[0] // c_concat.shape[0]), dim=0)
+    new_sample = torch.cat([sample, c_concat], dim=1)
+    kwargs['cross_attention_kwargs'] = {}
+    return unet_original_forward(new_sample, timestep, encoder_hidden_states, **kwargs)
+
+
+unet.forward = hooked_unet_forward
+
+# Load
+
+model_path = './models/iclight_sd15_fc.safetensors'
+# download_url_to_file(url='https://huggingface.co/lllyasviel/ic-light/resolve/main/iclight_sd15_fc.safetensors', dst=model_path)
+sd_offset = sf.load_file(model_path)
+sd_origin = unet.state_dict()
+keys = sd_origin.keys()
+sd_merged = {k: sd_origin[k] + sd_offset[k] for k in sd_origin.keys()}
+unet.load_state_dict(sd_merged, strict=True)
+del sd_offset, sd_origin, sd_merged, keys
+
+# Device
+
+device = torch.device('cuda')
+text_encoder = text_encoder.to(device=device, dtype=torch.float16)
+vae = vae.to(device=device, dtype=torch.bfloat16)
+unet = unet.to(device=device, dtype=torch.float16)
+
+# SDP
+
+unet.set_attn_processor(AttnProcessor2_0())
+vae.set_attn_processor(AttnProcessor2_0())
+
+# Samplers
+
+ddim_scheduler = DDIMScheduler(
+    num_train_timesteps=1000,
+    beta_start=0.00085,
+    beta_end=0.012,
+    beta_schedule="scaled_linear",
+    clip_sample=False,
+    set_alpha_to_one=False,
+    steps_offset=1,
+)
+
+euler_a_scheduler = EulerAncestralDiscreteScheduler(
+    num_train_timesteps=1000,
+    beta_start=0.00085,
+    beta_end=0.012,
+    steps_offset=1
+)
+
+dpmpp_2m_sde_karras_scheduler = DPMSolverMultistepScheduler(
+    num_train_timesteps=1000,
+    beta_start=0.00085,
+    beta_end=0.012,
+    algorithm_type="sde-dpmsolver++",
+    use_karras_sigmas=True,
+    steps_offset=1
+)
+
+# Pipelines
+
+t2i_pipe = StableDiffusionPipeline(
+    vae=vae,
+    text_encoder=text_encoder,
+    tokenizer=tokenizer,
+    unet=unet,
+    scheduler=dpmpp_2m_sde_karras_scheduler,
+    safety_checker=None,
+    requires_safety_checker=False,
+    feature_extractor=None,
+    image_encoder=None
+)
+
+i2i_pipe = StableDiffusionImg2ImgPipeline(
+    vae=vae,
+    text_encoder=text_encoder,
+    tokenizer=tokenizer,
+    unet=unet,
+    scheduler=dpmpp_2m_sde_karras_scheduler,
+    safety_checker=None,
+    requires_safety_checker=False,
+    feature_extractor=None,
+    image_encoder=None
+)
+
+
+@torch.inference_mode()
+def encode_prompt_inner(txt: str):
+    max_length = tokenizer.model_max_length
+    chunk_length = tokenizer.model_max_length - 2
+    id_start = tokenizer.bos_token_id
+    id_end = tokenizer.eos_token_id
+    id_pad = id_end
+
+    def pad(x, p, i):
+        return x[:i] if len(x) >= i else x + [p] * (i - len(x))
+
+    tokens = tokenizer(txt, truncation=False, add_special_tokens=False)["input_ids"]
+    chunks = [[id_start] + tokens[i: i + chunk_length] + [id_end] for i in range(0, len(tokens), chunk_length)]
+    chunks = [pad(ck, id_pad, max_length) for ck in chunks]
+
+    token_ids = torch.tensor(chunks).to(device=device, dtype=torch.int64)
+    conds = text_encoder(token_ids).last_hidden_state
+
+    return conds
+
+
+@torch.inference_mode()
+def encode_prompt_pair(positive_prompt, negative_prompt):
+    c = encode_prompt_inner(positive_prompt)
+    uc = encode_prompt_inner(negative_prompt)
+
+    c_len = float(len(c))
+    uc_len = float(len(uc))
+    max_count = max(c_len, uc_len)
+    c_repeat = int(math.ceil(max_count / c_len))
+    uc_repeat = int(math.ceil(max_count / uc_len))
+    max_chunk = max(len(c), len(uc))
+
+    c = torch.cat([c] * c_repeat, dim=0)[:max_chunk]
+    uc = torch.cat([uc] * uc_repeat, dim=0)[:max_chunk]
+
+    c = torch.cat([p[None, ...] for p in c], dim=1)
+    uc = torch.cat([p[None, ...] for p in uc], dim=1)
+
+    return c, uc
+
+
+@torch.inference_mode()
+def pytorch2numpy(imgs, quant=True):
+    results = []
+    for x in imgs:
+        y = x.movedim(0, -1)
+
+        if quant:
+            y = y * 127.5 + 127.5
+            y = y.detach().float().cpu().numpy().clip(0, 255).astype(np.uint8)
+        else:
+            y = y * 0.5 + 0.5
+            y = y.detach().float().cpu().numpy().clip(0, 1).astype(np.float32)
+
+        results.append(y)
+    return results
+
+
+@torch.inference_mode()
+def numpy2pytorch(imgs):
+    h = torch.from_numpy(np.stack(imgs, axis=0)).float() / 127.0 - 1.0  # so that 127 must be strictly 0.0
+    h = h.movedim(-1, 1)
+    return h
+
+
+def resize_and_center_crop(image, target_width, target_height):
+    pil_image = Image.fromarray(image)
+    original_width, original_height = pil_image.size
+    scale_factor = max(target_width / original_width, target_height / original_height)
+    resized_width = int(round(original_width * scale_factor))
+    resized_height = int(round(original_height * scale_factor))
+    resized_image = pil_image.resize((resized_width, resized_height), Image.LANCZOS)
+    left = (resized_width - target_width) / 2
+    top = (resized_height - target_height) / 2
+    right = (resized_width + target_width) / 2
+    bottom = (resized_height + target_height) / 2
+    cropped_image = resized_image.crop((left, top, right, bottom))
+    return np.array(cropped_image)
+
+
+def resize_without_crop(image, target_width, target_height):
+    pil_image = Image.fromarray(image)
+    resized_image = pil_image.resize((target_width, target_height), Image.LANCZOS)
+    return np.array(resized_image)
+
+def remove_alpha_threshold(image, alpha_threshold=160):
+    # This function removes artifacts created by LayerDiffusion
+    mask = image[:, :, 3] < alpha_threshold
+    image[mask] = [0, 0, 0, 0]
+    return image
+
+@torch.inference_mode()
+def process(input_fg, prompt, image_width, image_height, num_samples, seed, steps, a_prompt, n_prompt, cfg, highres_scale, highres_denoise, lowres_denoise, bg_source):
+    bg_source = BGSource(bg_source)
+    input_bg = None
+
+    if bg_source == BGSource.NONE:
+        pass
+    elif bg_source == BGSource.LEFT:
+        gradient = np.linspace(255, 0, image_width)
+        image = np.tile(gradient, (image_height, 1))
+        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+    elif bg_source == BGSource.RIGHT:
+        gradient = np.linspace(0, 255, image_width)
+        image = np.tile(gradient, (image_height, 1))
+        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+    elif bg_source == BGSource.TOP:
+        gradient = np.linspace(255, 0, image_height)[:, None]
+        image = np.tile(gradient, (1, image_width))
+        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+    elif bg_source == BGSource.BOTTOM:
+        gradient = np.linspace(0, 255, image_height)[:, None]
+        image = np.tile(gradient, (1, image_width))
+        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
+    else:
+        raise 'Wrong initial latent!'
+
+    rng = torch.Generator(device=device).manual_seed(int(seed))
+
+    fg = resize_and_center_crop(input_fg, image_width, image_height)
+
+    concat_conds = numpy2pytorch([fg]).to(device=vae.device, dtype=vae.dtype)
+    concat_conds = vae.encode(concat_conds).latent_dist.mode() * vae.config.scaling_factor
+
+    conds, unconds = encode_prompt_pair(positive_prompt=prompt + ', ' + a_prompt, negative_prompt=n_prompt)
+
+    if input_bg is None:
+        latents = t2i_pipe(
+            prompt_embeds=conds,
+            negative_prompt_embeds=unconds,
+            width=image_width,
+            height=image_height,
+            num_inference_steps=steps,
+            num_images_per_prompt=num_samples,
+            generator=rng,
+            output_type='latent',
+            guidance_scale=cfg,
+            cross_attention_kwargs={'concat_conds': concat_conds},
+        ).images.to(vae.dtype) / vae.config.scaling_factor
+    else:
+        bg = resize_and_center_crop(input_bg, image_width, image_height)
+        bg_latent = numpy2pytorch([bg]).to(device=vae.device, dtype=vae.dtype)
+        bg_latent = vae.encode(bg_latent).latent_dist.mode() * vae.config.scaling_factor
+        latents = i2i_pipe(
+            image=bg_latent,
+            strength=lowres_denoise,
+            prompt_embeds=conds,
+            negative_prompt_embeds=unconds,
+            width=image_width,
+            height=image_height,
+            num_inference_steps=int(round(steps / lowres_denoise)),
+            num_images_per_prompt=num_samples,
+            generator=rng,
+            output_type='latent',
+            guidance_scale=cfg,
+            cross_attention_kwargs={'concat_conds': concat_conds},
+        ).images.to(vae.dtype) / vae.config.scaling_factor
+
+    pixels = vae.decode(latents).sample
+    pixels = pytorch2numpy(pixels)
+    pixels = [resize_without_crop(
+        image=p,
+        target_width=int(round(image_width * highres_scale / 64.0) * 64),
+        target_height=int(round(image_height * highres_scale / 64.0) * 64))
+    for p in pixels]
+
+    pixels = numpy2pytorch(pixels).to(device=vae.device, dtype=vae.dtype)
+    latents = vae.encode(pixels).latent_dist.mode() * vae.config.scaling_factor
+    latents = latents.to(device=unet.device, dtype=unet.dtype)
+
+    image_height, image_width = latents.shape[2] * 8, latents.shape[3] * 8
+
+    fg = resize_and_center_crop(input_fg, image_width, image_height)
+    concat_conds = numpy2pytorch([fg]).to(device=vae.device, dtype=vae.dtype)
+    concat_conds = vae.encode(concat_conds).latent_dist.mode() * vae.config.scaling_factor
+
+    latents = i2i_pipe(
+        image=latents,
+        strength=highres_denoise,
+        prompt_embeds=conds,
+        negative_prompt_embeds=unconds,
+        width=image_width,
+        height=image_height,
+        num_inference_steps=int(round(steps / highres_denoise)),
+        num_images_per_prompt=num_samples,
+        generator=rng,
+        output_type='latent',
+        guidance_scale=cfg,
+        cross_attention_kwargs={'concat_conds': concat_conds},
+    ).images.to(vae.dtype) / vae.config.scaling_factor
+
+    pixels = vae.decode(latents).sample
+
+    return pytorch2numpy(pixels)
+
+
+def augment(image):
+
+    original = image.copy()
+
+    image_height, image_width, _ = original.shape
+
+    if random.choice([True, False]):
+        target_height, target_width = 640 * 2, 512 * 2
+    else:
+        target_height, target_width = 512 * 2, 640 * 2
+
+    left_right_padding = (max(target_width, image_width) - min(target_width, image_width)) // 2
+
+    original = cv2.copyMakeBorder(
+        original, 
+        top=max(target_height, image_height) - min(target_height, image_height), 
+        bottom=0,
+        left=left_right_padding, 
+        right=left_right_padding, 
+        borderType=cv2.BORDER_CONSTANT, 
+        value=(0, 0, 0)
+    )
+
+    transform = A.Compose(
+        [
+            A.HorizontalFlip(p=0.5),
+            A.ShiftScaleRotate(
+                shift_limit_x=(-0.2, 0.2),
+                shift_limit_y=(0.0, 0.2),
+                scale_limit=(0, 0),
+                rotate_limit=(-2, 2),
+                border_mode=cv2.BORDER_CONSTANT,
+                p=0.5,
+            ),
+        ]
+    )
+
+    return transform(image=original)["image"]
+
+class BGSource(Enum):
+    NONE = "None"
+    LEFT = "Left Light"
+    RIGHT = "Right Light"
+    TOP = "Top Light"
+    BOTTOM = "Bottom Light"
+
+
+input_dir = "/mnt/g/My Drive/humans/humans/"
+output_dir = "dataset"
+ground_truth_dir = os.path.join(output_dir, "gr")
+image_dir = os.path.join(output_dir, "im")
+
+prompts = [
+    "sunshine, cafe, chilled",
+    "exhibition, paintings",
+    "beach",
+    "winter, snow"
+    "forrest, cloudy",
+    "party, people",
+    "cozy living room, sofa, shelf",
+    "mountains",
+    "nature, landscape",
+    "city centre, busy",
+    "neighbourhood, street, cars",
+    "bright sun from behind, sunset, dark",
+    "appartment, soft light",
+    "garden",
+    "school",
+    "art exhibition with paintings in background"
+]
+
+os.makedirs(ground_truth_dir, exist_ok=True)
+os.makedirs(image_dir, exist_ok=True)
+
+all_images = os.listdir(input_dir)
+random.shuffle(all_images)
+
+for filename in all_images:
+    if filename.lower().endswith(('.png', '.jpg', '.jpeg')):  # Check if the file is an image
+
+        letters = string.ascii_lowercase
+        random_string = "".join(random.choice(letters) for i in range(13))
+        random_filename = f"{random_string}_{filename}"
+
+        image_path = os.path.join(input_dir, filename)
+        image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGBA)
+        mask = image[:, :, 3] < 100
+        image[mask] = [0, 0, 0, 0]
+
+        image = cv2.GaussianBlur(image, (5, 5), 0)
+        image = np.array(image)
+
+        image_augmented = augment(image)
+        Image.fromarray(image_augmented).getchannel("A").save(os.path.join(ground_truth_dir, random_filename))
+
+        image_augmented = image_augmented[:, :, :3]
+
+        # We half the size and width because SD 1.5 creates much better results then
+        image_augmented = image_augmented[::2, ::2]
+        image_height, image_width, _ = image_augmented.shape
+
+        num_samples = 1
+        seed = random.randint(1,123456789012345678901234567890)
+        steps = 25
+        constant_prompt = "details, high quality"
+        prompt = random.choice(prompts)
+        n_prompt = "bad quality, blurry"
+        cfg = 2.0
+        highres_scale = 2.0
+        highres_denoise = 0.7
+        lowres_denoise = 0.5
+        bg_source = BGSource.NONE
+  
+        results = process(image_augmented, constant_prompt, image_width, image_height, num_samples, seed, steps, prompt, n_prompt, cfg, highres_scale, highres_denoise, lowres_denoise, bg_source)
+        result_image = Image.fromarray(results[0])
+        result_image.save(os.path.join(image_dir, random_filename))‚

util/merge_images.py

@@ -9,8 +9,8 @@ import albumentations as A
 def augment_final_image(image):
     transform = A.Compose(
         [
-            A.MotionBlur(blur_limit=(5, 11), p=1.0),
-            A.GaussNoise(var_limit=(10, 150), p=1.0),
+            A.MotionBlur(blur_limit=(3, 11), p=0.05),
+            A.GaussNoise(var_limit=(1, 10), p=0.2),
             A.ColorJitter(
                 brightness=(0.6, 1.0),
                 contrast=(0.6, 1.0),
@@ -23,7 +23,7 @@ def augment_final_image(image):
                 fog_coef_upper=0.2,
                 alpha_coef=0.08,
                 always_apply=False,
-                p=0.5,
+                p=0.2,
             ),
             A.RandomShadow(
                 shadow_roi=(0, 0.5, 1, 1),
@@ -32,7 +32,7 @@ def augment_final_image(image):
                 num_shadows_upper=None,
                 shadow_dimension=5,
                 always_apply=False,
-                p=0.5,
+                p=0.2,
             ),
             A.RandomToneCurve(scale=0.1, always_apply=False, p=0.5),
         ]
@@ -40,6 +40,24 @@ def augment_final_image(image):
     return transform(image=image)["image"]
 
 
+def augment_background(image):
+    transform = A.Compose(
+        [
+            A.RandomBrightnessContrast(brightness_limit=(-0.4, 0.0), p=0.2),
+            A.RandomShadow(
+                shadow_roi=(0, 0.7, 1, 1),
+                num_shadows_limit=(1, 5),
+                num_shadows_lower=None,
+                num_shadows_upper=None,
+                shadow_dimension=5,
+                always_apply=False,
+                p=1.0,
+            ),
+        ]
+    )
+    return transform(image=image)["image"]
+
+
 def remove_alpha_threshold(image, alpha_threshold=160):
     # This function removes artifacts created by LayerDiffusion
     mask = image[:, :, 3] < alpha_threshold
@@ -48,7 +66,6 @@ def remove_alpha_threshold(image, alpha_threshold=160):
 
 
 def create_ground_truth_mask(image):
-    image = remove_alpha_threshold(image.copy())
     return image[:, :, 3]
 
 
@@ -66,19 +83,23 @@ def scale_image(image, factor=1.5):
 
 def augment_and_match_size(image, target_width, target_height):
 
-    random_scale = random.uniform(1, 1.5)
-    image = scale_image(image, random_scale)
+    color = [0, 0, 0, 0]
+    image = cv2.copyMakeBorder(
+        image, 200, 200, 200, 200, cv2.BORDER_CONSTANT, value=color
+    )
 
     transform = A.Compose(
         [
+            A.LongestMaxSize(max_size=max(target_width, target_height), p=1.0),
+            A.RandomScale(scale_limit=(-0.7, 0.5)),
             A.HorizontalFlip(p=0.5),
             A.ShiftScaleRotate(
                 shift_limit_x=(-0.3, 0.3),
-                shift_limit_y=(0.0, 0.4),
+                shift_limit_y=(0.0, 0.5),
                 scale_limit=(0, 0),
-                border_mode=cv2.BORDER_CONSTANT,
                 rotate_limit=(-5, 5),
-                p=0.7,
+                border_mode=cv2.BORDER_CONSTANT,
+                p=0.5,
             ),
         ]
     )
@@ -102,7 +123,6 @@ def augment_and_match_size(image, target_width, target_height):
         delta_h = max(0, target_height - current_height)
         top, bottom = delta_h // 2, delta_h - (delta_h // 2)
         left, right = delta_w // 2, delta_w - (delta_w // 2)
-        color = [0, 0, 0, 0]
         image = cv2.copyMakeBorder(
             image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
         )
@@ -149,6 +169,9 @@ def create_training_data(
     if segmentation.shape[2] < 4:
         raise Exception(f"Image does not have an alpha channel: {segmentation_path}")
 
+    background = augment_background(background)
+    segmentation = remove_alpha_threshold(segmentation)
+
     file_name = create_random_filename_from_filepath(segmentation_path)
     image_path = os.path.join(image_path, file_name)
     ground_truth_path = os.path.join(ground_truth_path, file_name)

util/to_ground_truth.py

@@ -0,0 +1,51 @@
+# This script takes RGBA masks and exports the alpha channel as ground truth
+# as another image.
+
+import os
+import argparse
+from PIL import Image
+
+
+def extract_alpha_channel(input_folder, output_folder):
+    os.makedirs(output_folder, exist_ok=True)
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith(".png"):
+            img_path = os.path.join(input_folder, filename)
+            img = Image.open(img_path)
+
+            if img.mode == "RGBA":
+                alpha = img.split()[-1]
+
+                alpha_output_path = os.path.join(output_folder, f"{filename}")
+                alpha.save(alpha_output_path)
+                print(f"Saved alpha channel for {filename} to {alpha_output_path}")
+            else:
+                print(f"Image {filename} does not have an alpha channel.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Extract alpha channels from PNG images."
+    )
+    parser.add_argument(
+        "input_folder", type=str, help="Path to the input folder containing PNG images."
+    )
+    parser.add_argument(
+        "output_folder",
+        type=str,
+        help="Path to the output folder where alpha channels will be saved.",
+    )
+
+    args = parser.parse_args()
+
+    # Ensure the input and output folders are not the same
+    if os.path.abspath(args.input_folder) == os.path.abspath(args.output_folder):
+        print("Error: Input and output folders must be different.")
+        return
+
+    extract_alpha_channel(args.input_folder, args.output_folder)
+
+
+if __name__ == "__main__":
+    main()