Upload folder using huggingface_hub

inference.py

@@ -93,29 +93,32 @@ def canny(task: Task):
     )
     lora_patcher.patch()
 
-    images, has_nsfw = controlnet.process(
-        prompt=prompt,
-        imageUrl=task.get_imageUrl(),
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        width=width,
-        height=height,
-        guidance_scale=task.get_cy_guidance_scale(),
-        negative_prompt=[
+    kwargs = {
+        "prompt": prompt,
+        "imageUrl": task.get_imageUrl(),
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "width": width,
+        "height": height,
+        "negative_prompt": [
             f"monochrome, neon, x-ray, negative image, oversaturated, {task.get_negative_prompt()}"
         ]
         * num_return_sequences,
+        **task.cnc_kwargs(),
         **lora_patcher.kwargs(),
-    )
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=prompt,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": prompt,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     generated_image_urls = upload_images(images, "_canny", task.get_taskId())
 
@@ -142,17 +145,18 @@ def tile_upscale(task: Task):
     lora_patcher = lora_style.get_patcher(controlnet.pipe, task.get_style())
     lora_patcher.patch()
 
-    images, has_nsfw = controlnet.process(
-        imageUrl=task.get_imageUrl(),
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        width=task.get_width(),
-        height=task.get_height(),
-        prompt=prompt,
-        resize_dimension=task.get_resize_dimension(),
-        negative_prompt=task.get_negative_prompt(),
-        guidance_scale=task.get_ti_guidance_scale(),
-    )
+    kwargs = {
+        "imageUrl": task.get_imageUrl(),
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "negative_prompt": task.get_negative_prompt(),
+        "width": task.get_width(),
+        "height": task.get_height(),
+        "prompt": prompt,
+        "resize_dimension": task.get_resize_dimension(),
+        **task.cnt_kwargs(),
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
 
     generated_image_url = upload_image(images[0], output_key)
 
@@ -181,24 +185,29 @@ def scribble(task: Task):
     )
     lora_patcher.patch()
 
-    images, has_nsfw = controlnet.process(
-        imageUrl=task.get_imageUrl(),
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        width=width,
-        height=height,
-        prompt=prompt,
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-    )
+    kwargs = {
+        "imageUrl": task.get_imageUrl(),
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "width": width,
+        "height": height,
+        "prompt": prompt,
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        **task.cns_kwargs(),
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
+
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=prompt,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": prompt,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     generated_image_urls = upload_images(images, "_scribble", task.get_taskId())
 
@@ -227,24 +236,29 @@ def linearart(task: Task):
     )
     lora_patcher.patch()
 
-    images, has_nsfw = controlnet.process(
-        imageUrl=task.get_imageUrl(),
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        width=width,
-        height=height,
-        prompt=prompt,
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-    )
+    kwargs = {
+        "imageUrl": task.get_imageUrl(),
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "width": width,
+        "height": height,
+        "prompt": prompt,
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        **task.cnl_kwargs(),
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
+
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=prompt,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": prompt,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     generated_image_urls = upload_images(images, "_linearart", task.get_taskId())
 
@@ -291,35 +305,32 @@ def pose(task: Task, s3_outkey: str = "_pose", poses: Optional[list] = None):
     else:
         poses = [controlnet.detect_pose(task.get_imageUrl())] * num_return_sequences
 
-    src_image = download_image(task.get_auxilary_imageUrl()).resize(
-        (task.get_width(), task.get_height())
-    )
-    condition_image = ControlNet.linearart_condition_image(src_image)
-
-    images, has_nsfw = controlnet.process(
-        prompt=prompt,
-        image=poses,
-        condition_image=[condition_image] * num_return_sequences,
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-        width=width,
-        height=height,
-        guidance_scale=task.get_po_guidance_scale(),
+    kwargs = {
+        "prompt": prompt,
+        "image": poses,
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        "width": width,
+        "height": height,
+        **task.cnp_kwargs(),
         **lora_patcher.kwargs(),
-    )
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
+
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=prompt,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": prompt,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     upload_image(poses[0], "crecoAI/{}_pose.png".format(task.get_taskId()))
-    upload_image(condition_image, "crecoAI/{}_condition.png".format(task.get_taskId()))
 
     generated_image_urls = upload_images(images, s3_outkey, task.get_taskId())
 
@@ -348,25 +359,28 @@ def text2img(task: Task):
 
     torch.manual_seed(task.get_seed())
 
-    images, has_nsfw = text2img_pipe.process(
-        params=params,
-        num_inference_steps=task.get_steps(),
-        guidance_scale=7.5,
-        height=height,
-        width=width,
-        negative_prompt=task.get_negative_prompt(),
-        iteration=task.get_iteration(),
+    kwargs = {
+        "params": params,
+        "num_inference_steps": task.get_steps(),
+        "height": height,
+        "width": width,
+        "negative_prompt": task.get_negative_prompt(),
+        **task.t2i_kwargs(),
         **lora_patcher.kwargs(),
-    )
+    }
+    images, has_nsfw = text2img_pipe.process(**kwargs)
+
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=params.prompt if params.prompt else [""] * num_return_sequences,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": params.prompt if params.prompt else [""] * num_return_sequences,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     generated_image_urls = upload_images(images, "", task.get_taskId())
 
@@ -394,26 +408,29 @@ def img2img(task: Task):
 
     torch.manual_seed(task.get_seed())
 
-    images, has_nsfw = img2img_pipe.process(
-        prompt=prompt,
-        imageUrl=task.get_imageUrl(),
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-        steps=task.get_steps(),
-        width=width,
-        height=height,
-        strength=task.get_i2i_strength(),
-        guidance_scale=task.get_i2i_guidance_scale(),
+    kwargs = {
+        "prompt": prompt,
+        "imageUrl": task.get_imageUrl(),
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        "num_inference_steps": task.get_steps(),
+        "width": width,
+        "height": height,
+        **task.i2i_kwargs(),
         **lora_patcher.kwargs(),
-    )
+    }
+    images, has_nsfw = img2img_pipe.process(**kwargs)
+
     if task.get_high_res_fix():
-        images, _ = high_res.apply(
-            prompt=prompt,
-            negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-            images=images,
-            width=task.get_width(),
-            height=task.get_height(),
-            steps=task.get_steps(),
-        )
+        kwargs = {
+            "prompt": prompt,
+            "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+            "images": images,
+            "width": task.get_width(),
+            "height": task.get_height(),
+            "num_inference_steps": task.get_steps(),
+            **task.high_res_kwargs(),
+        }
+        images, _ = high_res.apply(**kwargs)
 
     generated_image_urls = upload_images(images, "_imgtoimg", task.get_taskId())
 
@@ -433,15 +450,18 @@ def inpaint(task: Task):
 
     print({"prompts": prompt})
 
-    images = inpainter.process(
-        prompt=prompt,
-        image_url=task.get_imageUrl(),
-        mask_image_url=task.get_maskImageUrl(),
-        width=task.get_width(),
-        height=task.get_height(),
-        seed=task.get_seed(),
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-    )
+    kwargs = {
+        "prompt": prompt,
+        "image_url": task.get_imageUrl(),
+        "mask_image_url": task.get_maskImageUrl(),
+        "width": task.get_width(),
+        "height": task.get_height(),
+        "seed": task.get_seed(),
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        "num_inference_steps": task.get_steps(),
+        **task.ip_kwargs(),
+    }
+    images = inpainter.process(**kwargs)
 
     generated_image_urls = upload_images(images, "_inpaint", task.get_taskId())
 

inference2.py

@@ -72,17 +72,18 @@ def tile_upscale(task: Task):
     lora_patcher = lora_style.get_patcher(controlnet.pipe, task.get_style())
     lora_patcher.patch()
 
-    images, has_nsfw = controlnet.process_tile_upscaler(
-        imageUrl=task.get_imageUrl(),
-        seed=task.get_seed(),
-        steps=task.get_steps(),
-        width=task.get_width(),
-        height=task.get_height(),
-        prompt=prompt,
-        resize_dimension=task.get_resize_dimension(),
-        negative_prompt=task.get_negative_prompt(),
-        guidance_scale=task.get_ti_guidance_scale(),
-    )
+    kwargs = {
+        "imageUrl": task.get_imageUrl(),
+        "seed": task.get_seed(),
+        "num_inference_steps": task.get_steps(),
+        "negative_prompt": task.get_negative_prompt(),
+        "width": task.get_width(),
+        "height": task.get_height(),
+        "prompt": prompt,
+        "resize_dimension": task.get_resize_dimension(),
+        **task.cnt_kwargs(),
+    }
+    images, has_nsfw = controlnet.process(**kwargs)
 
     generated_image_url = upload_image(images[0], output_key)
 
@@ -99,7 +100,6 @@ def tile_upscale(task: Task):
 @update_db
 @slack.auto_send_alert
 def remove_bg(task: Task):
-    # remove_background = RemoveBackground()
     output_image = remove_background_v2.remove(
         task.get_imageUrl(), model_type=task.get_modelType()
     )
@@ -121,15 +121,18 @@ def inpaint(task: Task):
 
     print({"prompts": prompt})
 
-    images = inpainter.process(
-        prompt=prompt,
-        image_url=task.get_imageUrl(),
-        mask_image_url=task.get_maskImageUrl(),
-        width=task.get_width(),
-        height=task.get_height(),
-        seed=task.get_seed(),
-        negative_prompt=[task.get_negative_prompt()] * num_return_sequences,
-    )
+    kwargs = {
+        "prompt": prompt,
+        "image_url": task.get_imageUrl(),
+        "mask_image_url": task.get_maskImageUrl(),
+        "width": task.get_width(),
+        "height": task.get_height(),
+        "seed": task.get_seed(),
+        "negative_prompt": [task.get_negative_prompt()] * num_return_sequences,
+        "num_inference_steps": task.get_steps(),
+        **task.ip_kwargs(),
+    }
+    images = inpainter.process(**kwargs)
 
     generated_image_urls = upload_images(images, "_inpaint", task.get_taskId())
 

internals/data/task.py

@@ -92,7 +92,7 @@ class Task:
         return int(self.__data.get("seed", -1))
 
     def get_steps(self) -> int:
-        return int(self.__data.get("steps", "75"))
+        return int(self.__data.get("steps", 30))
 
     def get_type(self) -> Union[TaskType, None]:
         try:
@@ -127,21 +127,6 @@ class Task:
     def get_face_enhance(self) -> bool:
         return self.__data.get("up_face_enhance", False)
 
-    def get_ti_guidance_scale(self) -> float:
-        return self.__data.get("ti_guidance_scale", 7.5)
-
-    def get_i2i_guidance_scale(self) -> float:
-        return self.__data.get("i2i_guidance_scale", 7.5)
-
-    def get_i2i_strength(self) -> float:
-        return self.__data.get("i2i_strength", 0.75)
-
-    def get_cy_guidance_scale(self) -> float:
-        return self.__data.get("cy_guidance_scale", 9)
-
-    def get_po_guidance_scale(self) -> float:
-        return self.__data.get("po_guidance_scale", 7.5)
-
     def rbg_controlnet_conditioning_scale(self) -> float:
         return self.__data.get("rbg_conditioning_scale", 0.5)
 
@@ -166,6 +151,38 @@ class Task:
     def get_raw(self) -> dict:
         return self.__data.copy()
 
+    def t2i_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("t2i_"))
+
+    def i2i_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("i2i_"))
+
+    def ip_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("ip_"))
+
+    def cnc_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("cnc_"))
+
+    def cnp_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("cnp_"))
+
+    def cns_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("cns_"))
+
+    def cnl_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("cnl_"))
+
+    def cnt_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("cnt_"))
+
+    def high_res_kwargs(self) -> dict:
+        return dict(self.__get_kwargs("hrf_"))
+
+    def __get_kwargs(self, prefix: str):
+        for k, v in self.__data.items():
+            if k.startswith(prefix):
+                yield k[len(prefix) :], v
+
     @property
     @lru_cache(1)
     def PROMPT(self):

internals/pipelines/commons.py

@@ -66,46 +66,29 @@ class Text2Img(AbstractPipeline):
     def process(
         self,
         params: Params,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[str] = None,
-        num_images_per_prompt: int = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
+        num_inference_steps: int,
+        height: int,
+        width: int,
+        negative_prompt: str,
         iteration: float = 3.0,
+        **kwargs,
     ):
         prompt = params.prompt
 
         if params.prompt_left and params.prompt_right:
             # multi-character pipelines
             prompt = [params.prompt[0], params.prompt_left[0], params.prompt_right[0]]
-            result = self.pipe.multi_character_diffusion(
-                prompt=prompt,
-                pos=["1:1-0:0", "1:2-0:0", "1:2-0:1"],
-                mix_val=[0.2, 0.8, 0.8],
-                height=height,
-                width=width,
-                num_inference_steps=num_inference_steps,
-                guidance_scale=guidance_scale,
-                negative_prompt=[negative_prompt or ""] * len(prompt),
-                num_images_per_prompt=num_return_sequences,
-                eta=eta,
-                # generator=generator,
-                output_type=output_type,
-                return_dict=return_dict,
-                callback=callback,
-                callback_steps=callback_steps,
-            )
+            kwargs = {
+                "prompt": prompt,
+                "pos": ["1:1-0:0", "1:2-0:0", "1:2-0:1"],
+                "mix_val": [0.2, 0.8, 0.8],
+                "height": height,
+                "width": width,
+                "num_inference_steps": num_inference_steps,
+                "negative_prompt": [negative_prompt or ""] * len(prompt),
+                **kwargs,
+            }
+            result = self.pipe.multi_character_diffusion(**kwargs)
         else:
             # two step pipeline
             modified_prompt = params.modified_prompt
@@ -122,25 +105,14 @@ class Text2Img(AbstractPipeline):
                     "iteration": iteration,
                 }
 
-            result = self.pipe.__call__(
-                height=height,
-                width=width,
-                num_inference_steps=num_inference_steps,
-                guidance_scale=guidance_scale,
-                negative_prompt=[negative_prompt or ""] * num_return_sequences,
-                num_images_per_prompt=num_images_per_prompt,
-                eta=eta,
-                generator=generator,
-                latents=latents,
-                prompt_embeds=prompt_embeds,
-                negative_prompt_embeds=negative_prompt_embeds,
-                output_type=output_type,
-                return_dict=return_dict,
-                callback=callback,
-                callback_steps=callback_steps,
-                cross_attention_kwargs=cross_attention_kwargs,
-                **kwargs
-            )
+            kwargs = {
+                "height": height,
+                "width": width,
+                "negative_prompt": [negative_prompt or ""] * num_return_sequences,
+                "num_inference_steps": num_inference_steps,
+                **kwargs,
+            }
+            result = self.pipe.__call__(**kwargs)
 
         return Result.from_result(result)
 
@@ -192,21 +164,24 @@ class Img2Img(AbstractPipeline):
         prompt: List[str],
         imageUrl: str,
         negative_prompt: List[str],
-        strength: float,
-        guidance_scale: float,
-        steps: int,
+        num_inference_steps: int,
         width: int,
         height: int,
+        strength: float = 0.75,
+        guidance_scale: float = 7.5,
+        **kwargs,
     ):
         image = download_image(imageUrl).resize((width, height))
 
-        result = self.pipe.__call__(
-            prompt=prompt,
-            image=image,
-            strength=strength,
-            negative_prompt=negative_prompt,
-            guidance_scale=guidance_scale,
-            num_images_per_prompt=1,
-            num_inference_steps=steps,
-        )
+        kwargs = {
+            "prompt": prompt,
+            "image": image,
+            "strength": strength,
+            "negative_prompt": negative_prompt,
+            "guidance_scale": guidance_scale,
+            "num_images_per_prompt": 1,
+            "num_inference_steps": num_inference_steps,
+            **kwargs,
+        }
+        result = self.pipe.__call__(**kwargs)
         return Result.from_result(result)

internals/pipelines/controlnets.py

@@ -57,7 +57,7 @@ class ControlNet(AbstractPipeline):
         if not model:
             raise Exception(f"ControlNet is not supported for {task_name}")
         while model in list(config.keys()):
-            task_name = config[model]  # pyright: ignore
+            task_name = model  # pyright: ignore
             model = config[task_name]
 
         controlnet = ControlNetModel.from_pretrained(
@@ -152,11 +152,12 @@ class ControlNet(AbstractPipeline):
         prompt: List[str],
         imageUrl: str,
         seed: int,
-        steps: int,
+        num_inference_steps: int,
         negative_prompt: List[str],
-        guidance_scale: float,
         height: int,
         width: int,
+        guidance_scale: float = 9,
+        **kwargs,
     ):
         if self.__current_task_name != "canny":
             raise Exception("ControlNet is not loaded with canny model")
@@ -166,16 +167,19 @@ class ControlNet(AbstractPipeline):
         init_image = download_image(imageUrl).resize((width, height))
         init_image = self.__canny_detect_edge(init_image)
 
-        result = self.pipe2.__call__(
-            prompt=prompt,
-            image=init_image,
-            guidance_scale=guidance_scale,
-            num_images_per_prompt=1,
-            negative_prompt=negative_prompt,
-            num_inference_steps=steps,
-            height=height,
-            width=width,
-        )
+        kwargs = {
+            "prompt": prompt,
+            "image": init_image,
+            "guidance_scale": guidance_scale,
+            "num_images_per_prompt": 1,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": num_inference_steps,
+            "height": height,
+            "width": width,
+            **kwargs,
+        }
+
+        result = self.pipe2.__call__(**kwargs)
         return Result.from_result(result)
 
     @torch.inference_mode()
@@ -183,29 +187,31 @@ class ControlNet(AbstractPipeline):
         self,
         prompt: List[str],
         image: List[Image.Image],
-        condition_image: List[Image.Image],
         seed: int,
-        steps: int,
-        guidance_scale: float,
+        num_inference_steps: int,
         negative_prompt: List[str],
         height: int,
         width: int,
+        guidance_scale: float = 7.5,
+        **kwargs,
     ):
         if self.__current_task_name != "pose":
             raise Exception("ControlNet is not loaded with pose model")
 
         torch.manual_seed(seed)
 
-        result = self.pipe2.__call__(
-            prompt=prompt[0],
-            image=[image[0]],
-            num_images_per_prompt=4,
-            num_inference_steps=steps,
-            negative_prompt=negative_prompt[0],
-            guidance_scale=guidance_scale,
-            height=height,
-            width=width,
-        )
+        kwargs = {
+            "prompt": prompt[0],
+            "image": [image[0]],
+            "num_images_per_prompt": 4,
+            "num_inference_steps": num_inference_steps,
+            "negative_prompt": negative_prompt[0],
+            "guidance_scale": guidance_scale,
+            "height": height,
+            "width": width,
+            **kwargs,
+        }
+        result = self.pipe2.__call__(**kwargs)
         return Result.from_result(result)
 
     @torch.inference_mode()
@@ -214,12 +220,13 @@ class ControlNet(AbstractPipeline):
         imageUrl: str,
         prompt: str,
         negative_prompt: str,
-        steps: int,
+        num_inference_steps: int,
         seed: int,
         height: int,
         width: int,
         resize_dimension: int,
-        guidance_scale: float,
+        guidance_scale: float = 7.5,
+        **kwargs,
     ):
         if self.__current_task_name != "tile_upscaler":
             raise Exception("ControlNet is not loaded with tile_upscaler model")
@@ -231,16 +238,18 @@ class ControlNet(AbstractPipeline):
             init_image, resize_dimension
         )
 
-        result = self.pipe.__call__(
-            image=condition_image,
-            prompt=prompt,
-            controlnet_conditioning_image=condition_image,
-            num_inference_steps=steps,
-            negative_prompt=negative_prompt,
-            height=condition_image.size[1],
-            width=condition_image.size[0],
-            guidance_scale=guidance_scale,
-        )
+        kwargs = {
+            "image": condition_image,
+            "prompt": prompt,
+            "controlnet_conditioning_image": condition_image,
+            "num_inference_steps": num_inference_steps,
+            "negative_prompt": negative_prompt,
+            "height": condition_image.size[1],
+            "width": condition_image.size[0],
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        result = self.pipe.__call__(**kwargs)
         return Result.from_result(result)
 
     @torch.inference_mode()
@@ -249,11 +258,12 @@ class ControlNet(AbstractPipeline):
         imageUrl: Union[str, Image.Image],
         prompt: Union[str, List[str]],
         negative_prompt: Union[str, List[str]],
-        steps: int,
+        num_inference_steps: int,
         seed: int,
         height: int,
         width: int,
         guidance_scale: float = 7.5,
+        **kwargs,
     ):
         if self.__current_task_name != "scribble":
             raise Exception("ControlNet is not loaded with scribble model")
@@ -267,15 +277,17 @@ class ControlNet(AbstractPipeline):
 
         condition_image = self.__scribble_condition_image(init_image)
 
-        result = self.pipe2.__call__(
-            image=condition_image,
-            prompt=prompt,
-            num_inference_steps=steps,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            guidance_scale=guidance_scale,
-        )
+        kwargs = {
+            "image": condition_image,
+            "prompt": prompt,
+            "num_inference_steps": num_inference_steps,
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        result = self.pipe2.__call__(**kwargs)
         return Result.from_result(result)
 
     @torch.inference_mode()
@@ -284,11 +296,12 @@ class ControlNet(AbstractPipeline):
         imageUrl: str,
         prompt: Union[str, List[str]],
         negative_prompt: Union[str, List[str]],
-        steps: int,
+        num_inference_steps: int,
         seed: int,
         height: int,
         width: int,
         guidance_scale: float = 7.5,
+        **kwargs,
     ):
         if self.__current_task_name != "linearart":
             raise Exception("ControlNet is not loaded with linearart model")
@@ -298,15 +311,17 @@ class ControlNet(AbstractPipeline):
         init_image = download_image(imageUrl).resize((width, height))
         condition_image = ControlNet.linearart_condition_image(init_image)
 
-        result = self.pipe2.__call__(
-            image=condition_image,
-            prompt=prompt,
-            num_inference_steps=steps,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            guidance_scale=guidance_scale,
-        )
+        kwargs = {
+            "image": condition_image,
+            "prompt": prompt,
+            "num_inference_steps": num_inference_steps,
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        result = self.pipe2.__call__(**kwargs)
         return Result.from_result(result)
 
     def cleanup(self):

internals/pipelines/high_res.py

@@ -27,17 +27,22 @@ class HighRes(AbstractPipeline):
         images,
         width: int,
         height: int,
-        steps: int,
+        num_inference_steps: int,
+        strength: float = 0.5,
+        guidance_scale: int = 9,
+        **kwargs,
     ):
         images = [image.resize((width, height)) for image in images]
-        result = self.pipe.__call__(
-            prompt=prompt,
-            image=images,
-            strength=0.5,
-            negative_prompt=negative_prompt,
-            guidance_scale=9,
-            num_inference_steps=steps,
-        )
+        kwargs = {
+            "prompt": prompt,
+            "image": images,
+            "strength": strength,
+            "negative_prompt": negative_prompt,
+            "guidance_scale": guidance_scale,
+            "num_inference_steps": num_inference_steps,
+            **kwargs,
+        }
+        result = self.pipe.__call__(**kwargs)
         return Result.from_result(result)
 
     @staticmethod

internals/pipelines/inpainter.py

@@ -79,19 +79,22 @@ class InPainter(AbstractPipeline):
         seed: int,
         prompt: Union[str, List[str]],
         negative_prompt: Union[str, List[str]],
-        steps: int = 50,
+        num_inference_steps: int,
+        **kwargs,
     ):
         torch.manual_seed(seed)
 
         input_img = download_image(image_url).resize((width, height))
         mask_img = download_image(mask_image_url).resize((width, height))
 
-        return self.pipe.__call__(
-            prompt=prompt,
-            image=input_img,
-            mask_image=mask_img,
-            height=height,
-            width=width,
-            negative_prompt=negative_prompt,
-            num_inference_steps=steps,
-        ).images
+        kwargs = {
+            "prompt": prompt,
+            "image": input_img,
+            "mask_image": mask_img,
+            "height": height,
+            "width": width,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": num_inference_steps,
+            **kwargs,
+        }
+        return self.pipe.__call__(**kwargs).images

internals/pipelines/upscaler.py

@@ -148,7 +148,7 @@ class Upscaler:
                 model=model,
                 half=False,
                 gpu_id="0",
-                tile=0,
+                tile=320,
                 tile_pad=10,
                 pre_pad=0,
             )