Update README.md

README.md

@@ -19,29 +19,85 @@ These are controlnet weights trained on stabilityai/stable-diffusion-xl-base-1.0
 
 ## Usage
 
-Make sure to first install the libraries:
+Make sure first to install the libraries:
 
 ```bash
 pip install accelerate transformers safetensors diffusers
 ```
 
-And then we're ready to go:
+And then setup the zoe-depth model
+
+```
+import torch
+import matplotlib
+import matplotlib.cm
+import numpy as np
+
+torch.hub.help("intel-isl/MiDaS", "DPT_BEiT_L_384", force_reload=True)  # Triggers fresh download of MiDaS repo
+model_zoe_n = torch.hub.load("isl-org/ZoeDepth", "ZoeD_NK", pretrained=True).eval()
+model_zoe_n = model_zoe_n.to("cuda")
+
+
+def colorize(value, vmin=None, vmax=None, cmap='gray_r', invalid_val=-99, invalid_mask=None, background_color=(128, 128, 128, 255), gamma_corrected=False, value_transform=None):
+    if isinstance(value, torch.Tensor):
+        value = value.detach().cpu().numpy()
+
+    value = value.squeeze()
+    if invalid_mask is None:
+        invalid_mask = value == invalid_val
+    mask = np.logical_not(invalid_mask)
+
+    # normalize
+    vmin = np.percentile(value[mask],2) if vmin is None else vmin
+    vmax = np.percentile(value[mask],85) if vmax is None else vmax
+    if vmin != vmax:
+        value = (value - vmin) / (vmax - vmin)  # vmin..vmax
+    else:
+        # Avoid 0-division
+        value = value * 0.
+
+    # squeeze last dim if it exists
+    # grey out the invalid values
+
+    value[invalid_mask] = np.nan
+    cmapper = matplotlib.cm.get_cmap(cmap)
+    if value_transform:
+        value = value_transform(value)
+        # value = value / value.max()
+    value = cmapper(value, bytes=True)  # (nxmx4)
+
+    # img = value[:, :, :]
+    img = value[...]
+    img[invalid_mask] = background_color
+
+    # gamma correction
+    img = img / 255
+    img = np.power(img, 2.2)
+    img = img * 255
+    img = img.astype(np.uint8)
+    img = Image.fromarray(img)
+    return img
+
+
+def get_zoe_depth_map(image):
+    with torch.autocast("cuda", enabled=True):
+        depth = model_zoe_n.infer_pil(image)
+    depth = colorize(depth, cmap="gray_r", gamma_corrected=True)
+    return depth
+```
+
+Now we're ready to go:
 
 ```python
 import torch
 import numpy as np
 from PIL import Image
 
-from transformers import DPTFeatureExtractor, DPTForDepthEstimation
 from diffusers import ControlNetModel, StableDiffusionXLControlNetPipeline, AutoencoderKL
 from diffusers.utils import load_image
 
-
-depth_estimator = DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas").to("cuda")
-feature_extractor = DPTFeatureExtractor.from_pretrained("Intel/dpt-hybrid-midas")
 controlnet = ControlNetModel.from_pretrained(
     "diffusers/controlnet-depth-sdxl-1.0",
-    variant="fp16",
     use_safetensors=True,
     torch_dtype=torch.float16,
 ).to("cuda")
@@ -56,41 +112,26 @@ pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
 ).to("cuda")
 pipe.enable_model_cpu_offload()
 
-def get_depth_map(image):
-    image = feature_extractor(images=image, return_tensors="pt").pixel_values.to("cuda")
-    with torch.no_grad(), torch.autocast("cuda"):
-        depth_map = depth_estimator(image).predicted_depth
 
-    depth_map = torch.nn.functional.interpolate(
-        depth_map.unsqueeze(1),
-        size=(1024, 1024),
-        mode="bicubic",
-        align_corners=False,
-    )
-    depth_min = torch.amin(depth_map, dim=[1, 2, 3], keepdim=True)
-    depth_max = torch.amax(depth_map, dim=[1, 2, 3], keepdim=True)
-    depth_map = (depth_map - depth_min) / (depth_max - depth_min)
-    image = torch.cat([depth_map] * 3, dim=1)
+prompt = "pixel-art margot robbie as barbie, in a coupé . low-res, blocky, pixel art style, 8-bit graphics"
+negative_prompt = "sloppy, messy, blurry, noisy, highly detailed, ultra textured, photo, realistic"
+image = load_image("https://media.vogue.fr/photos/62bf04b69a57673c725432f3/3:2/w_1793,h_1195,c_limit/rev-1-Barbie-InstaVert_High_Res_JPEG.jpeg")
 
-    image = image.permute(0, 2, 3, 1).cpu().numpy()[0]
-    image = Image.fromarray((image * 255.0).clip(0, 255).astype(np.uint8))
-    return image
+controlnet_conditioning_scale = 0.55
 
+depth_image = get_zoe_depth_map(image).resize((1088, 896))
 
-prompt = "stormtrooper lecture, photorealistic"
-image = load_image("https://huggingface.co/lllyasviel/sd-controlnet-depth/resolve/main/images/stormtrooper.png")
-controlnet_conditioning_scale = 0.5  # recommended for good generalization
-
-depth_image = get_depth_map(image)
-
+generator = torch.Generator("cuda").manual_seed(978364352)
 images = pipe(
-    prompt, image=depth_image, num_inference_steps=30, controlnet_conditioning_scale=controlnet_conditioning_scale,
+    prompt, image=depth_image, num_inference_steps=50, controlnet_conditioning_scale=controlnet_conditioning_scale, generator=generator
 ).images
 images[0]
 
-images[0].save(f"stormtrooper.png")
+images[0].save(f"pixel-barbie.png")
 ```
 
+![images_1)](./barbie.png)
+
 To more details, check out the official documentation of [`StableDiffusionXLControlNetPipeline`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/controlnet_sdxl).
 
 ### Training