rm zero gpu on run_pipe func

model.py

@@ -113,6 +113,8 @@ class Model:
         guidance_scale: float,
         seed: int,
     ) -> list[PIL.Image.Image]:
+        self.pipe.to(self.device)
+        self.pipe.controlnet.to(self.device)
         generator = torch.Generator().manual_seed(seed)
         return self.pipe(
             prompt=prompt,
@@ -125,7 +127,7 @@ class Model:
         ).images
 
     @torch.inference_mode()
-    @spaces.GPU()
+    @spaces.GPU(enable_queue=True)
     def process_canny(
         self,
         image: np.ndarray,
@@ -170,141 +172,7 @@ class Model:
         return [control_image] * num_images + results + conditions_of_generated_imgs
 
     @torch.inference_mode()
-    def process_mlsd(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        preprocess_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-        value_threshold: float,
-        distance_threshold: float,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        self.preprocessor.load("MLSD")
-        control_image = self.preprocessor(
-            image=image,
-            image_resolution=image_resolution,
-            detect_resolution=preprocess_resolution,
-            thr_v=value_threshold,
-            thr_d=distance_threshold,
-        )
-        self.load_controlnet_weight("MLSD")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    def process_scribble(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        preprocess_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-        preprocessor_name: str,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        if preprocessor_name == "None":
-            image = HWC3(image)
-            image = resize_image(image, resolution=image_resolution)
-            control_image = PIL.Image.fromarray(image)
-        elif preprocessor_name == "HED":
-            self.preprocessor.load(preprocessor_name)
-            control_image = self.preprocessor(
-                image=image,
-                image_resolution=image_resolution,
-                detect_resolution=preprocess_resolution,
-                scribble=False,
-            )
-        elif preprocessor_name == "PidiNet":
-            self.preprocessor.load(preprocessor_name)
-            control_image = self.preprocessor(
-                image=image,
-                image_resolution=image_resolution,
-                detect_resolution=preprocess_resolution,
-                safe=False,
-            )
-        self.load_controlnet_weight("scribble")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    def process_scribble_interactive(
-        self,
-        image_and_mask: dict[str, np.ndarray],
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-    ) -> list[PIL.Image.Image]:
-        if image_and_mask is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        image = image_and_mask["mask"]
-        image = HWC3(image)
-        image = resize_image(image, resolution=image_resolution)
-        control_image = PIL.Image.fromarray(image)
-
-        self.load_controlnet_weight("scribble")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    @spaces.GPU()
+    @spaces.GPU(enable_queue=True)
     def process_softedge(
         self,
         image: np.ndarray,
@@ -371,53 +239,7 @@ class Model:
         return [control_image] * num_images + results + conditions_of_generated_imgs
 
     @torch.inference_mode()
-    def process_openpose(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        preprocess_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-        preprocessor_name: str,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        if preprocessor_name == "None":
-            image = HWC3(image)
-            image = resize_image(image, resolution=image_resolution)
-            control_image = PIL.Image.fromarray(image)
-        else:
-            self.preprocessor.load("Openpose")
-            control_image = self.preprocessor(
-                image=image,
-                image_resolution=image_resolution,
-                detect_resolution=preprocess_resolution,
-                hand_and_face=True,
-            )
-        self.load_controlnet_weight("Openpose")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    @spaces.GPU()
+    @spaces.GPU(enable_queue=True)
     def process_segmentation(
         self,
         image: np.ndarray,
@@ -471,7 +293,7 @@ class Model:
         return [control_image] * num_images + results + conditions_of_generated_imgs
 
     @torch.inference_mode()
-    @spaces.GPU()
+    @spaces.GPU(enable_queue=True)
     def process_depth(
         self,
         image: np.ndarray,
@@ -524,52 +346,7 @@ class Model:
         return [control_image] * num_images + results + conditions_of_generated_imgs
 
     @torch.inference_mode()
-    def process_normal(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        preprocess_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-        preprocessor_name: str,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        if preprocessor_name == "None":
-            image = HWC3(image)
-            image = resize_image(image, resolution=image_resolution)
-            control_image = PIL.Image.fromarray(image)
-        else:
-            self.preprocessor.load("NormalBae")
-            control_image = self.preprocessor(
-                image=image,
-                image_resolution=image_resolution,
-                detect_resolution=preprocess_resolution,
-            )
-        self.load_controlnet_weight("NormalBae")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    @spaces.GPU()
+    @spaces.GPU(enable_queue=True)
     def process_lineart(
         self,
         image: np.ndarray,
@@ -638,81 +415,3 @@ class Model:
         conditions_of_generated_imgs = [PIL.Image.fromarray((255 - np.array(x)).astype(np.uint8)) for x in conditions_of_generated_imgs]
 
         return [control_image] * num_images + results + conditions_of_generated_imgs
-
-    @torch.inference_mode()
-    def process_shuffle(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-        preprocessor_name: str,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        if preprocessor_name == "None":
-            image = HWC3(image)
-            image = resize_image(image, resolution=image_resolution)
-            control_image = PIL.Image.fromarray(image)
-        else:
-            self.preprocessor.load(preprocessor_name)
-            control_image = self.preprocessor(
-                image=image,
-                image_resolution=image_resolution,
-            )
-        self.load_controlnet_weight("shuffle")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results
-
-    @torch.inference_mode()
-    def process_ip2p(
-        self,
-        image: np.ndarray,
-        prompt: str,
-        additional_prompt: str,
-        negative_prompt: str,
-        num_images: int,
-        image_resolution: int,
-        num_steps: int,
-        guidance_scale: float,
-        seed: int,
-    ) -> list[PIL.Image.Image]:
-        if image is None:
-            raise ValueError
-        if image_resolution > MAX_IMAGE_RESOLUTION:
-            raise ValueError
-        if num_images > MAX_NUM_IMAGES:
-            raise ValueError
-
-        image = HWC3(image)
-        image = resize_image(image, resolution=image_resolution)
-        control_image = PIL.Image.fromarray(image)
-        self.load_controlnet_weight("ip2p")
-        results = self.run_pipe(
-            prompt=self.get_prompt(prompt, additional_prompt),
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            num_images=num_images,
-            num_steps=num_steps,
-            guidance_scale=guidance_scale,
-            seed=seed,
-        )
-        return [control_image] + results