Duplicate from saassa/hghdf

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,117 @@
+---
+license: openrail
+tags:
+- stable-diffusion
+- stable-diffusion-diffusers
+- controlnet
+- endpoints-template
+thumbnail: >-
+  https://huggingface.co/philschmid/ControlNet-endpoint/resolve/main/thumbnail.png
+inference: true
+duplicated_from: philschmid/ControlNet-endpoint
+---
+
+
+# Inference Endpoint for [ControlNet](https://huggingface.co/lllyasviel/ControlNet) using [runwayml/stable-diffusion-v1-5](https://huggingface.co/runwayml/stable-diffusion-v1-5)
+
+
+> ControlNet is a neural network structure to control diffusion models by adding extra conditions.
+> Official repository: https://github.com/lllyasviel/ControlNet
+
+---
+
+Blog post: [Controlled text to image generation with Inference Endpoints]()
+
+This repository implements a custom `handler` task for `controlled text-to-image` generation on 🤗 Inference Endpoints. The code for the customized pipeline is in the [handler.py](https://huggingface.co/philschmid/ControlNet-endpoint/blob/main/handler.py).
+
+There is also a [notebook](https://huggingface.co/philschmid/ControlNet-endpoint/blob/main/create_handler.ipynb) included, on how to create the `handler.py`
+
+![sample](thumbnail.png)
+
+
+### expected Request payload
+
+```json
+{
+    "inputs": "A prompt used for image generation",
+    "negative_prompt": "low res, bad anatomy, worst quality, low quality",
+    "controlnet_type": "depth",
+    "image" : "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAABGdBTUEAALGPC",
+}
+```
+
+supported `controlnet_type` are: `canny_edge`, `pose`, `depth`, `scribble`, `segmentation`, `normal`, `hed`, `hough`
+
+below is an example on how to run a request using Python and `requests`.
+
+
+## Use Python to send requests
+
+1. Get image 
+```
+wget https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_imgvar/input_image_vermeer.png
+```
+
+2. Use the following code to send a request to the endpoint
+
+```python
+import json
+from typing import List
+import requests as r
+import base64
+from PIL import Image
+from io import BytesIO
+
+ENDPOINT_URL = "" # your endpoint url
+HF_TOKEN = "" # your huggingface token `hf_xxx`
+
+# helper image utils
+def encode_image(image_path):
+  with open(image_path, "rb") as i:
+    b64 = base64.b64encode(i.read())
+  return b64.decode("utf-8")
+
+
+def predict(prompt, image, negative_prompt=None, controlnet_type = "normal"):
+    image = encode_image(image)
+
+    # prepare sample payload
+    request = {"inputs": prompt, "image": image, "negative_prompt": negative_prompt, "controlnet_type": controlnet_type}
+    # headers
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "application/json",
+        "Accept": "image/png" # important to get an image back
+    }
+
+    response = r.post(ENDPOINT_URL, headers=headers, json=request)
+    if response.status_code != 200:
+        print(response.text)
+        raise Exception("Prediction failed")
+    img = Image.open(BytesIO(response.content))
+    return img
+
+
+prediction = predict(
+  prompt = "cloudy sky background lush landscape house and green trees, RAW photo (high detailed skin:1.2), 8k uhd, dslr, soft lighting, high quality, film grain, Fujifilm XT3",
+  negative_prompt ="lowres, bad anatomy, worst quality, low quality, city, traffic",
+  controlnet_type = "hed",
+  image = "huggingface.png"
+)
+
+prediction.save("result.png")
+```
+
+```
+expected output
+
+![sample](result.png) 
+
+
+[Adding Conditional Control to Text-to-Image Diffusion Models](https://arxiv.org/abs/2302.05543) by Lvmin Zhang and Maneesh Agrawala.
+
+Using the pretrained models we can provide control images (for example, a depth map) to control Stable Diffusion text-to-image generation so that it follows the structure of the depth image and fills in the details.
+
+The abstract of the paper is the following:
+
+We present a neural network structure, ControlNet, to control pretrained large diffusion models to support additional input conditions. The ControlNet learns task-specific conditions in an end-to-end way, and the learning is robust even when the training dataset is small (< 50k). Moreover, training a ControlNet is as fast as fine-tuning a diffusion model, and the model can be trained on a personal devices. Alternatively, if powerful computation clusters are available, the model can scale to large amounts (millions to billions) of data. We report that large diffusion models like Stable Diffusion can be augmented with ControlNets to enable conditional inputs like edge maps, segmentation maps, keypoints, etc. This may enrich the methods to control large diffusion models and further facilitate related applications.

TES UPDATE TO THIS

@@ -0,0 +1,144 @@
+%%writefile handler.py
+from typing import Dict, List, Any
+import base64
+from PIL import Image
+from io import BytesIO
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, AutoencoderKL, StableDiffusionXLControlNetPipeline, AutoPipelineForText2Image
+import torch
+from diffusers.utils import load_image
+
+import numpy as np
+import cv2
+import controlnet_hinter
+
+# ADDED AUTO PIPE
+# set device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+if device.type != 'cuda':
+    raise ValueError("need to run on GPU")
+# set mixed precision dtype
+dtype = torch.bfloat16 if torch.cuda.get_device_capability()[0] == 8 else torch.float16
+
+# controlnet mapping for controlnet id and control hinter
+CONTROLNET_MAPPING = {
+    "canny_edge": {
+        "model_id": "lllyasviel/sd-controlnet-canny",
+        "hinter": controlnet_hinter.hint_canny
+    },
+    "pose": {
+        "model_id": "lllyasviel/sd-controlnet-openpose",
+        "hinter": controlnet_hinter.hint_openpose
+    },
+    "depth": {
+        "model_id": "lllyasviel/sd-controlnet-depth",
+        "hinter": controlnet_hinter.hint_depth
+    },
+    "scribble": {
+        "model_id": "lllyasviel/sd-controlnet-scribble",
+        "hinter": controlnet_hinter.hint_scribble,
+    },
+    "segmentation": {
+        "model_id": "lllyasviel/sd-controlnet-seg",
+        "hinter": controlnet_hinter.hint_segmentation,
+    },
+    "normal": {
+        "model_id": "lllyasviel/sd-controlnet-normal",
+        "hinter": controlnet_hinter.hint_normal,
+    },
+    "hed": {
+        "model_id": "lllyasviel/sd-controlnet-hed",
+        "hinter": controlnet_hinter.hint_hed,
+    },
+    "hough": {
+        "model_id": "lllyasviel/sd-controlnet-mlsd",
+        "hinter": controlnet_hinter.hint_hough,
+    }
+}
+
+
+class EndpointHandler():
+    def __init__(self, path=""):
+        # define default controlnet id and load controlnet
+        self.control_type = "normal"
+        self.controlnet = ControlNetModel.from_pretrained(CONTROLNET_MAPPING[self.control_type]["model_id"], torch_dtype=dtype).to(device)
+
+        # Load StableDiffusionControlNetPipeline
+        self.stable_diffusion_id = "stablediffusionapi/disney-pixar-cartoon"
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(self.stable_diffusion_id,
+                                                                      controlnet=self.controlnet,
+                                                                      torch_dtype=dtype,
+                                                                      safety_checker=None).to(device)
+
+        # Define Generator with seed
+        # COMMENTED self.generator = torch.Generator(device="cpu").manual_seed(3)
+
+    def __call__(self, data: Any) -> List[List[Dict[str, float]]]:
+        """
+        :param data: A dictionary contains `inputs` and optional `image` field.
+        :return: A dictionary with `image` field contains image in base64.
+        """
+        prompt = data.pop("inputs", None)
+        image = data.pop("image", None)
+        controlnet_type = data.pop("controlnet_type", None)
+        stablediffusion_id = data.pop("stablediffusionid", None)  # Get the stablediffusionid from the request data
+
+        if stablediffusion_id is not None and stablediffusion_id != self.stable_diffusion_id:
+            # Change the Stable Diffusion model to the new model ID
+            self.stable_diffusion_id = stablediffusion_id
+            # Reinitialize the pipeline with the new model ID
+            self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                self.stable_diffusion_id,
+                controlnet=self.controlnet,
+                torch_dtype=dtype,
+                safety_checker=None
+            ).to(device)
+
+        # Check if neither prompt nor image is provided
+        if prompt is None and image is None:
+            return {"error": "Please provide a prompt and base64 encoded image."}
+
+        # Check if a new controlnet is provided
+        if controlnet_type is not None and controlnet_type != self.control_type:
+            print(f"changing controlnet from {self.control_type} to {controlnet_type} using {CONTROLNET_MAPPING[controlnet_type]['model_id']} model")
+            self.control_type = controlnet_type
+            self.controlnet = ControlNetModel.from_pretrained(CONTROLNET_MAPPING[self.control_type]["model_id"],
+                                                              torch_dtype=dtype).to(device)
+            self.pipe.controlnet = self.controlnet
+
+        # hyperparameters
+        negative_prompt = data.pop("negative_prompt", None)
+        num_inference_steps = data.pop("num_inference_steps", 150)
+        guidance_scale = data.pop("guidance_scale", 5)
+        negative_prompt = data.pop("negative_prompt", None)
+        height = data.pop("height", None)
+        width = data.pop("width", None)
+        controlnet_conditioning_scale = data.pop("controlnet_conditioning_scale", 1.0)
+
+        # process image
+        image = self.decode_base64_image(image)
+        control_image = CONTROLNET_MAPPING[self.control_type]["hinter"](image)
+
+        # run inference pipeline
+        out = self.pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            image=control_image,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            num_images_per_prompt=1,
+            height=height,
+            width=width,
+            controlnet_conditioning_scale=controlnet_conditioning_scale,
+            guess_mode=True,
+        )
+
+        # generator=self.generator COMMENTED from self.pipe
+        # return the first generated PIL image
+        return out.images[0]
+
+    # helper to decode input image
+    def decode_base64_image(self, image_string):
+        base64_image = base64.b64decode(image_string)
+        buffer = BytesIO(base64_image)
+        image = Image.open(buffer)
+        return image

handler.py

@@ -0,0 +1,134 @@
+from typing import  Dict, List, Any
+import base64
+from PIL import Image
+from io import BytesIO
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, AutoencoderKL, StableDiffusionXLControlNetPipeline, AutoPipelineForText2Image
+import torch
+from diffusers.utils import load_image
+
+
+
+import numpy as np
+import cv2
+import controlnet_hinter
+# ADDED AUTO PIPE, next try replacing
+# set device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+if device.type != 'cuda':
+    raise ValueError("need to run on GPU")
+# set mixed precision dtype
+dtype = torch.bfloat16 if torch.cuda.get_device_capability()[0] == 8 else torch.float16
+
+# controlnet mapping for controlnet id and control hinter
+CONTROLNET_MAPPING = {
+    "canny_edge": {
+        "model_id": "lllyasviel/sd-controlnet-canny",
+        "hinter": controlnet_hinter.hint_canny
+    },
+    "pose": {
+        "model_id": "lllyasviel/sd-controlnet-openpose",
+        "hinter": controlnet_hinter.hint_openpose
+    },
+    "depth": {
+        "model_id": "lllyasviel/sd-controlnet-depth",
+        "hinter": controlnet_hinter.hint_depth
+    },
+    "scribble": {
+        "model_id": "lllyasviel/sd-controlnet-scribble",
+        "hinter": controlnet_hinter.hint_scribble,
+    },
+    "segmentation": {
+        "model_id": "lllyasviel/sd-controlnet-seg",
+        "hinter": controlnet_hinter.hint_segmentation,
+    },
+    "normal": {
+        "model_id": "lllyasviel/sd-controlnet-normal",
+        "hinter": controlnet_hinter.hint_normal,
+    },
+    "hed": {
+        "model_id": "lllyasviel/sd-controlnet-hed",
+        "hinter": controlnet_hinter.hint_hed,
+    },
+    "hough": {
+        "model_id": "lllyasviel/sd-controlnet-mlsd",
+        "hinter": controlnet_hinter.hint_hough,
+    }
+}
+
+ 
+class EndpointHandler():
+    def __init__(self, path=""):
+        # define default controlnet id and load controlnet
+        self.control_type = "normal"
+        self.controlnet = ControlNetModel.from_pretrained(CONTROLNET_MAPPING[self.control_type]["model_id"],torch_dtype=dtype).to(device)
+ 
+        # Load StableDiffusionControlNetPipeline
+        self.stable_diffusion_id = "stablediffusionapi/disney-pixar-cartoon"
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(self.stable_diffusion_id,
+                                                                      controlnet=self.controlnet,
+                                                                      torch_dtype=dtype, 
+                                                                      safety_checker=None).to(device)
+ 
+        # Define Generator with seed
+        # COMMENTED self.generator = torch.Generator(device="cpu").manual_seed(3)
+
+    def __call__(self, data: Any) -> List[List[Dict[str, float]]]:
+        """
+        :param data: A dictionary contains `inputs` and optional `image` field.
+        :return: A dictionary with `image` field contains image in base64.
+        """
+        prompt = data.pop("inputs", None)
+        image = data.pop("image", None)
+        controlnet_type = data.pop("controlnet_type", None)
+
+        # Check if neither prompt nor image is provided
+        if prompt is None and image is None:
+            return {"error": "Please provide a prompt and base64 encoded image."}
+
+        # Check if a new controlnet is provided
+        if controlnet_type is not None and controlnet_type != self.control_type:
+            print(f"changing controlnet from {self.control_type} to {controlnet_type} using {CONTROLNET_MAPPING[controlnet_type]['model_id']} model")
+            self.control_type = controlnet_type
+            self.controlnet = ControlNetModel.from_pretrained(CONTROLNET_MAPPING[self.control_type]["model_id"],
+                                                              torch_dtype=dtype).to(device)
+            self.pipe.controlnet = self.controlnet
+
+
+        # hyperparamters
+        negatice_prompt = data.pop("negative_prompt", None)
+        num_inference_steps = data.pop("num_inference_steps", 150)
+        guidance_scale = data.pop("guidance_scale", 5)
+        negative_prompt = data.pop("negative_prompt", None)
+        height = data.pop("height", None)
+        width = data.pop("width", None)
+        controlnet_conditioning_scale = data.pop("controlnet_conditioning_scale", 1.0)
+
+        # process image
+        image = self.decode_base64_image(image)
+        control_image = CONTROLNET_MAPPING[self.control_type]["hinter"](image)
+
+        # run inference pipeline
+        out = self.pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            image=control_image,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            num_images_per_prompt=1,
+            height=height,
+            width=width,
+            controlnet_conditioning_scale=controlnet_conditioning_scale,
+            guess_mode=True, 
+
+        )
+
+        #generator=self.generator COMMENTED from self.pipe
+        # return first generate PIL image
+        return out.images[0]
+
+    # helper to decode input image
+    def decode_base64_image(self, image_string):
+        base64_image = base64.b64decode(image_string)
+        buffer = BytesIO(base64_image)
+        image = Image.open(buffer)
+        return image

request.json

@@ -0,0 +1 @@
+{"inputs": "cloudy sky background lush landscape house and green trees, RAW photo (high detailed skin:1.2), 8k uhd, dslr, soft lighting, high quality, film grain, Fujifilm XT3", "image": "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", "negative_prompt": "worst quality, city, traffic", "controlnet_type": "hed"}

requirements.txt

@@ -0,0 +1,6 @@
+diffusers
+safetensors 
+opencv-python
+transformers
+torch
+controlnet_hinter==0.0.5