commit

Former-commit-id: dfb71f8ff7b4354652740e6a622c2631ec6d5e41

logs/app_debug.log

@@ -1326,3 +1326,48 @@ speed: {'preprocess': 1.9655227661132812, 'inference': 86.20810508728027, 'postp
 2024-03-20 16:39:19,333 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
 2024-03-20 16:39:50,404 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
 2024-03-20 16:45:37,037 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
+2024-03-22 03:55:40,678 [INFO] models - Inpainting Inference
+2024-03-22 03:55:41,174 [INFO] clear_memory - Memory Cleared
+2024-03-22 03:58:06,886 [INFO] models - Inpainting Inference
+2024-03-22 03:58:07,066 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:01:27,172 [INFO] models - Inpainting Inference
+2024-03-22 04:01:27,418 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:06:38,680 [INFO] models - Inpainting Inference
+2024-03-22 04:06:38,889 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:11:41,673 [INFO] models - Inpainting Inference
+2024-03-22 04:11:41,874 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:20:36,838 [INFO] models - Inpainting Inference Completed
+2024-03-22 04:30:50,234 [INFO] models - Inpainting Inference
+2024-03-22 04:30:50,522 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:34:30,860 [INFO] models - Inpainting Inference Completed
+2024-03-22 04:37:41,028 [INFO] models - Inpainting Inference
+2024-03-22 04:38:16,111 [INFO] models - Inpainting Inference
+2024-03-22 04:38:16,367 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:40:29,119 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:00:56,937 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:02:34,916 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:13:44,547 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:18:53,623 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:20:06,892 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:20:26,852 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:25:49,956 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:26:09,324 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:26:58,013 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:27:17,153 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:32:55,633 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:33:14,930 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:33:47,613 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:34:06,803 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:34:56,622 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:35:16,304 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:37:23,678 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:37:46,172 [INFO] models - Inpainting Inference Completed
+2024-03-22 06:04:47,683 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:09:12,886 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:12:29,146 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:24:32,044 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:27:52,332 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:35:16,527 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:39:26,709 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:43:26,086 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:53:54,562 [INFO] models - Kandinsky Inpainting Inference

logs/app_info.log

@@ -1326,3 +1326,48 @@ speed: {'preprocess': 1.9655227661132812, 'inference': 86.20810508728027, 'postp
 2024-03-20 16:39:19,333 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
 2024-03-20 16:39:50,404 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
 2024-03-20 16:45:37,037 [INFO] pipelineutils - Controlnet Pipeline initialized successfully
+2024-03-22 03:55:40,678 [INFO] models - Inpainting Inference
+2024-03-22 03:55:41,174 [INFO] clear_memory - Memory Cleared
+2024-03-22 03:58:06,886 [INFO] models - Inpainting Inference
+2024-03-22 03:58:07,066 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:01:27,172 [INFO] models - Inpainting Inference
+2024-03-22 04:01:27,418 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:06:38,680 [INFO] models - Inpainting Inference
+2024-03-22 04:06:38,889 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:11:41,673 [INFO] models - Inpainting Inference
+2024-03-22 04:11:41,874 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:20:36,838 [INFO] models - Inpainting Inference Completed
+2024-03-22 04:30:50,234 [INFO] models - Inpainting Inference
+2024-03-22 04:30:50,522 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:34:30,860 [INFO] models - Inpainting Inference Completed
+2024-03-22 04:37:41,028 [INFO] models - Inpainting Inference
+2024-03-22 04:38:16,111 [INFO] models - Inpainting Inference
+2024-03-22 04:38:16,367 [INFO] clear_memory - Memory Cleared
+2024-03-22 04:40:29,119 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:00:56,937 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:02:34,916 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:13:44,547 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:18:53,623 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:20:06,892 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:20:26,852 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:25:49,956 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:26:09,324 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:26:58,013 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:27:17,153 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:32:55,633 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:33:14,930 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:33:47,613 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:34:06,803 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:34:56,622 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:35:16,304 [INFO] models - Inpainting Inference Completed
+2024-03-22 05:37:23,678 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 05:37:46,172 [INFO] models - Inpainting Inference Completed
+2024-03-22 06:04:47,683 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:09:12,886 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:12:29,146 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:24:32,044 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:27:52,332 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:35:16,527 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:39:26,709 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:43:26,086 [INFO] models - Kandinsky Inpainting Inference
+2024-03-22 06:53:54,562 [INFO] models - Kandinsky Inpainting Inference

scripts/config.py

@@ -1,12 +1,13 @@
 LOGS_DIR = '../logs'
 Dataset_Name = "AlekseyKorshuk/product-photography-all"
 DATA_DIR = '../data'
-Project_Name = 'product_placement_diffusers'
+Project_Name = 'product_placement_api'
 entity = 'vikramxd'
 image_dir = '../sample_data'
 mask_dir = '../masks'
 controlnet_adapter_model_name= 'lllyasviel/control_v11p_sd15_inpaint'
 controlnet_base_model_name = "runwayml/stable-diffusion-inpainting"
-stable_diffusion_inpainting_model_name = "stabilityai/stable-diffusion-2-inpainting"
+kandinsky_model_name = 'kandinsky-community/kandinsky-2-2-decoder-inpaint'
 width = 512
 height = 512
+yolo_model = 'yolov8s-seg.pt'

scripts/mask_generator.py

@@ -1,24 +1,13 @@
-
-from typing import List, Tuple, Dict
-import torch
 from PIL import Image
 import numpy as np
 from logger import rich_logger as l
 from ultralytics import YOLO
 import cv2
+from config import yolo_model
 
 
 
 
-def convert_to_numpy_array(image: Image) -> np.ndarray:
-    """Method to convert PIL image to numpy array
-    Args:
-        image (Image): input image
-    Returns:
-        np.ndarray: numpy array
-    """
-    return np.array(image)
-
 
 
 
@@ -30,7 +19,7 @@ def generate_mask(image_path: str) -> np.ndarray:
     Returns:
         Image: segmented image
     """
-    model = YOLO(model='yolov8s-seg.pt',)
+    model = YOLO(model=yolo_model)
     results = model(image_path)
     for result in results:
         orig_img = result.orig_img
@@ -38,7 +27,6 @@ def generate_mask(image_path: str) -> np.ndarray:
         height, width = result.orig_img.shape[:2]
         background = np.ones((height, width, 3), dtype=np.uint8) * 255
         
-        
         for mask in masks:
            mask = mask.astype(int)
            mask_img = np.zeros_like(orig_img)
@@ -48,12 +36,22 @@ def generate_mask(image_path: str) -> np.ndarray:
            
     return mask_img, orig_img
 
+def invert_mask(mask_image: np.ndarray) -> np.ndarray:
+    """Method to invert mask
+    Args:
+        mask_image (np.ndarray): input mask image
+    Returns:
+        np.ndarray: inverted mask image
+    """
+    inverted_mask_image = cv2.bitwise_not(mask_image)
+    cv2.imwrite('invert_mask.jpg', inverted_mask_image)
+    return inverted_mask_image
+
  
 if __name__ == "__main__":
     image = Image.open("../sample_data/example1.jpg")
-    image = image.resize((512, 512))
-    image = convert_to_numpy_array(image)
-    mask_image,orig_image = generate_mask(image_path='../sample_data/example1.jpg')
+    mask_img,orig_image = generate_mask(image_path='../sample_data/example1.jpg')
+    invert_mask(mask_image=mask_img)
     
     
 

scripts/models.py

@@ -6,72 +6,178 @@ from typing import List
 import numpy as np
 import torch
 from PIL import Image
-from mask_generator import convert_to_numpy_array, generate_mask
+from mask_generator import invert_mask
 from diffusers.utils import load_image
-import cv2
-from config import controlnet_adapter_model_name,controlnet_base_model_name
-from diffusers import ControlNetModel,StableDiffusionControlNetInpaintPipeline
-autolog(init=dict(project=Project_Name))
+from pipeline import fetch_control_pipeline,fetch_kandinsky_pipeline,fetch_kandinsky_prior_pipeline,fetch_kandinsky_img2img_pipeline
+from config import controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name
+import cv2 
+import PIL.ImageOps
+from transformers import pipeline
 
 
 
+autolog(init=dict(project=Project_Name))
 
 
 
- 
 
 
 
+def make_controlnet_condition(image: Image.Image) -> Image.Image:
+    """
+    Applies image processing operations to create a controlnet condition image.
+
+    Args:
+        image (PIL.Image.Image): The input image.
+
+    Returns:
+        PIL.Image.Image: The controlnet condition image.
+    """
+    image = np.array(image)
+    image = cv2.Canny(image, 100, 200)
+    image = image[:, :, None]
+    image = np.concatenate([image, image, image], axis=2)
+    image = Image.fromarray(image)
+    return image
 
 def make_inpaint_condition(init_image, mask_image):
-        # Prepare control image
-        init_image = np.array(init_image.convert("RGB")).astype(np.float32) / 255.0
-        mask_image = np.array(mask_image.convert("L")).astype(np.float32) / 255.0
-
-        assert init_image.shape[0:1] == mask_image.shape[0:1], "image and image_mask must have the same image size"
-        init_image[mask_image > 0.5] = -1.0  # set as masked pixel
-        init_image = np.expand_dims(init_image, 0).transpose(0, 3, 1, 2)
-        init_image = torch.from_numpy(init_image)
-        return init_image
+    """
+    Prepare the initial image for inpainting by applying a mask.
+
+    Args:
+        init_image (PIL.Image.Image): The initial image.
+        mask_image (PIL.Image.Image): The mask image.
+
+    Returns:
+        torch.Tensor: The prepared initial image for inpainting.
+
+    Raises:
+        AssertionError: If the image and mask have different sizes.
+
+    """
+    # Prepare control image
+    init_image = np.array(init_image.convert("RGB")).astype(np.float32) / 255.0
+    mask_image = np.array(mask_image.convert("L")).astype(np.float32) / 255.0
+
+    assert init_image.shape[0:1] == mask_image.shape[0:1], "image and image_mask must have the same image size"
+    init_image[mask_image > 0.5] = -1.0  # set as masked pixel
+    init_image = np.expand_dims(init_image, 0).transpose(0, 3, 1, 2)
+    init_image = torch.from_numpy(init_image)
+    return init_image
     
 
+def make_hint(image, depth_estimator):
+    image = depth_estimator(image)["depth"]
+    image = np.array(image)
+    image = image[:, :, None]
+    image = np.concatenate([image, image, image], axis=2)
+    detected_map = torch.from_numpy(image).float() / 255.0
+    hint = detected_map.permute(2, 0, 1)
+    return hint
+
+
+    
+
+
+
+
+
+def controlnet_inpainting_inference(prompt,
+                         image,
+                         mask_image,
+                         control_image,
+                         num_inference_steps=200,
+                         guidance_scale=1.2,
+                         strength=5.0,
+                         generator=torch.Generator(device="cpu").manual_seed(1)
+                        ) -> List[Image.Image]:
+    """
+    Perform inpainting inference on an image using the given parameters.
+
+    Args:
+        prompt: The prompt for the inpainting inference.
+        image: The input image to be inpainted.
+        mask_image: The mask image indicating the regions to be inpainted.
+        controlnet_conditioning_image: The conditioning image for the controlnet.
+        num_inference_steps: The number of inference steps to perform (default: 200).
+        guidance_scale: The scale factor for the guidance loss (default: 1.2).
+        strength: The strength of the inpainting (default: 5.0).
+        generator: The random number generator for reproducibility (default: torch.Generator(device="cpu").manual_seed(1)).
 
+    Returns:
+        A list of inpainted images.
 
+    """
+    clear_memory()
+    pipe = fetch_control_pipeline(controlnet_adapter_model_name, controlnet_base_model_name,kandinsky_model_name, control_image)
+    image = pipe(prompt = prompt,num_inference_steps=num_inference_steps, generator=generator, eta=1.0, image=image, mask_image=mask_image,guidance_scale=guidance_scale,strenght=strength, control_image=control_image).images[0]
+    return image
+
+def kandinsky_inpainting_inference(prompt, negative_prompt, image, mask_image):
+    """
+    Perform Kandinsky inpainting inference on the given image.
 
-def make_image_controlnet(image,
-                          mask_image,
-                          controlnet_conditioning_image,
-                          positive_prompt: str, negative_prompt: str,
-                          seed: int = 2356132) -> List[Image.Image]:
-    """Method to make image using controlnet
     Args:
-        image (np.ndarray): input image
-        mask_image (np.ndarray): mask image
-        controlnet_conditioning_image (np.ndarray): conditioning image
-        positive_prompt (str): positive prompt string
-        negative_prompt (str): negative prompt string
-        seed (int, optional): seed. Defaults to 2356132.
+        prompt (str): The prompt for the inpainting process.
+        negative_prompt (str): The negative prompt for the inpainting process.
+        image (PIL.Image.Image): The input image to be inpainted.
+        mask_image (PIL.Image.Image): The mask image indicating the areas to be inpainted.
+
     Returns:
-        List[Image.Image]: list of generated images
+        PIL.Image.Image: The output inpainted image.
     """
-    controlnet = ControlNetModel.from_pretrained(controlnet_adapter_model_name, torch_dtype=torch.float32)
-    pipe =  StableDiffusionControlNetInpaintPipeline.from_pretrained(
-            controlnet_base_model_name, controlnet=controlnet, torch_dtype=torch.float32
-        )
-   
+    pipe = fetch_kandinsky_pipeline(controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image)
+    output_image = pipe(prompt=prompt, negative_prompt=negative_prompt, image=image, mask_image=mask_image).images[0]
+    return output_image
+def kandinsky_inpainting_inference(prompt,negative_prompt,image,mask_image):
+    pipe = fetch_kandinsky_pipeline(controlnet_adapter_model_name, controlnet_base_model_name,kandinsky_model_name, image)
+    output_image = pipe(prompt=prompt,negative_prompt=negative_prompt,image=image,mask_image=mask_image).images[0]
+    return output_image
+
+def kandinsky_controlnet_inpainting_inference(prompt, negative_prompt, image, hint, generator=torch.Generator(device="cuda").manual_seed(43)):
+    """
+    Perform inpainting inference using the Kandinsky ControlNet model.
 
-   
-   
-    
-    image = pipe(prompt=positive_prompt,negative_prompt=negative_prompt, image=init_image, mask_image=mask_image, control_image=controlnet_conditioning_image).images[0]
+    Args:
+        prompt (str): The prompt for the inpainting process.
+        negative_prompt (str): The negative prompt for the inpainting process.
+        image (torch.Tensor): The input image for inpainting.
+        hint (torch.Tensor): The hint for guiding the inpainting process.
+        generator (torch.Generator, optional): The random number generator. Defaults to CUDA generator with seed 43.
 
+    Returns:
+        torch.Tensor: The inpainted image.
 
+    """
+    prior_pipe = fetch_kandinsky_prior_pipeline(controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image)
+    img_embed = prior_pipe(prompt=prompt, image=image, strength=0.85, generator=generator)
+    negative_embed = prior_pipe(prompt=negative_prompt, image=image, strength=1, generator=generator)
+    controlnet_pipe = fetch_kandinsky_img2img_pipeline(controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image)
+    image = controlnet_pipe(image=image, strength=0.5, image_embeds=img_embed.image_embeds, negative_image_embeds=negative_embed.image_embeds, hint=hint, num_inference_steps=50, generator=generator, height=768, width=768).images[0]
     return image
 
-if __name__ == "__main__":
-    init_image = load_image('/home/product_diffusion_api/sample_data/example1.jpg')
-    mask_image = load_image('/home/product_diffusion_api/scripts/mask.jpg')
-    controlnet_conditioning_image = make_inpaint_condition(init_image=init_image,mask_image=mask_image)
-    result = make_image_controlnet(positive_prompt="Product used in kitchen 4k natural photography",negative_prompt="No artifcats",image=init_image,mask_image=mask_image,controlnet_conditioning_image=controlnet_conditioning_image)
-
+  
+
+if __name__ == '__main__':
+    l.info("Kandinsky Inpainting Inference")
+    image = load_image('/home/product_diffusion_api/sample_data/example2.jpg')
+    image = image.resize((768, 768))
+    mask_image = load_image('/home/product_diffusion_api/scripts/invert_mask.jpg')
+    mask_image = mask_image.resize((768,768))
+    prompt = "Product in a GYM 8k ultrarealistic "
+    negative_prompt="lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature"
+    output_image = kandinsky_inpainting_inference(prompt,negative_prompt,image,mask_image)
+    output_image=output_image.resize((768,768))
+    depth_estimator = pipeline("depth-estimation")
+    hint = make_hint(output_image, depth_estimator).unsqueeze(0).half().to("cuda")
+    final_output_image = kandinsky_controlnet_inpainting_inference(prompt,negative_prompt,image, hint)
+    
+    
+    
+    
+    
+   
+    
+    
+    
 

scripts/pipeline.py

@@ -0,0 +1,121 @@
+from diffusers import ControlNetModel,StableDiffusionControlNetInpaintPipeline,AutoPipelineForInpainting,KandinskyV22ControlnetImg2ImgPipeline,KandinskyV22PriorEmb2EmbPipeline
+from diffusers.utils import load_image
+import torch
+from PIL import Image
+import numpy as np
+import cv2
+import torch
+
+
+
+
+
+class PipelineFetcher:
+    """
+    A class that fetches different pipelines for image processing.
+
+    Args:
+        controlnet_adapter_model_name (str): The name of the controlnet adapter model.
+        controlnet_base_model_name (str): The name of the controlnet base model.
+        kandinsky_model_name (str): The name of the Kandinsky model.
+        image (str): The image to be processed.
+
+    """
+
+    def __init__(self, controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image: str):
+        self.controlnet_adapter_model_name = controlnet_adapter_model_name
+        self.controlnet_base_model_name = controlnet_base_model_name
+        self.kandinsky_model_name = kandinsky_model_name
+        self.image = image
+
+    def ControlNetInpaintPipeline(self):
+        """
+        Fetches the ControlNet inpainting pipeline.
+
+        Returns:
+            pipe (StableDiffusionControlNetInpaintPipeline): The ControlNet inpainting pipeline.
+
+        """
+        controlnet = ControlNetModel.from_pretrained(self.controlnet_adapter_model_name, torch_dtype=torch.float16)
+        pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(
+            self.controlnet_base_model_name, controlnet=controlnet, torch_dtype=torch.float16
+        )
+        pipe.to('cuda')
+
+        return pipe
+
+    def KandinskyPipeline(self):
+        """
+        Fetches the Kandinsky pipeline.
+
+        Returns:
+            pipe (AutoPipelineForInpainting): The Kandinsky pipeline.
+
+        """
+        pipe = AutoPipelineForInpainting.from_pretrained(self.kandinsky_model_name, torch_dtype=torch.float16)
+        pipe.to('cuda')
+        return pipe
+
+    def KandinskyPriorPipeline(self):
+        """
+        Fetches the Kandinsky prior pipeline.
+
+        Returns:
+            prior_pipeline (KandinskyV22PriorEmb2EmbPipeline): The Kandinsky prior pipeline.
+
+        """
+        prior_pipeline = KandinskyV22PriorEmb2EmbPipeline.from_pretrained(
+            "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16, use_safetensors=False
+        ).to("cuda")
+        return prior_pipeline
+
+    def KandinskyImg2ImgPipeline(self):
+        """
+        Fetches the Kandinsky img2img pipeline.
+
+        Returns:
+            img2img_pipeline (KandinskyV22ControlnetImg2ImgPipeline): The Kandinsky img2img pipeline.
+
+        """
+        img2img_pipeline = KandinskyV22ControlnetImg2ImgPipeline.from_pretrained(
+            "kandinsky-community/kandinsky-2-2-controlnet-depth", torch_dtype=torch.float16, use_safetensors=False
+        ).to("cuda")
+        return img2img_pipeline
+    
+   
+
+def fetch_control_pipeline(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image):
+    pipe_fetcher = PipelineFetcher(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image)
+    pipe = pipe_fetcher.ControlNetInpaintPipeline()
+    return pipe
+
+def fetch_kandinsky_pipeline(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image):
+    pipe_fetcher = PipelineFetcher(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image)
+    pipe = pipe_fetcher.KandinskyPipeline()
+    return pipe
+
+def fetch_kandinsky_prior_pipeline(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image):
+    pipe_fetcher = PipelineFetcher(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image)
+    pipe = pipe_fetcher.KandinskyPriorPipeline()
+    return pipe
+
+def fetch_kandinsky_img2img_pipeline(controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image):
+    """
+    Fetches the Kandinsky image-to-image pipeline.
+
+    Args:
+        controlnet_adapter_model_name (str): The name of the controlnet adapter model.
+        controlnet_base_model_name (str): The name of the controlnet base model.
+        kandinsky_model_name (str): The name of the Kandinsky model.
+        image: The input image.
+
+    Returns:
+        pipe: The Kandinsky image-to-image pipeline.
+    """
+    pipe_fetcher = PipelineFetcher(controlnet_adapter_model_name, controlnet_base_model_name, kandinsky_model_name, image)
+    pipe = pipe_fetcher.KandinskyImg2ImgPipeline()
+    return pipe
+def fetch_kandinsky_img2img_pipeline(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image):
+    pipe_fetcher = PipelineFetcher(controlnet_adapter_model_name,controlnet_base_model_name,kandinsky_model_name,image)
+    pipe = pipe_fetcher.KandinskyImg2ImgPipeline()
+    return pipe