add sfast

app.py

@@ -12,6 +12,7 @@ print("TORCH_DTYPE:", torch_dtype)
 print("PIPELINE:", args.pipeline)
 print("SAFETY_CHECKER:", args.safety_checker)
 print("TORCH_COMPILE:", args.torch_compile)
+print("SFast:", args.sfast)
 print("USE_TAESD:", args.taesd)
 print("COMPEL:", args.compel)
 print("DEBUG:", args.debug)

app_init.py

@@ -17,6 +17,8 @@ import asyncio
 import os
 import time
 
+THROTTLE = 1.0 / 120
+
 
 def init_app(app: FastAPI, user_data: UserData, args: Args, pipeline):
     app.add_middleware(
@@ -61,7 +63,7 @@ def init_app(app: FastAPI, user_data: UserData, args: Args, pipeline):
             while True:
                 data = await websocket.receive_json()
                 if data["status"] != "next_frame":
-                    asyncio.sleep(1.0 / 24)
+                    asyncio.sleep(THROTTLE)
                     continue
 
                 params = await websocket.receive_json()
@@ -86,7 +88,7 @@ def init_app(app: FastAPI, user_data: UserData, args: Args, pipeline):
                     )
                     await websocket.close()
                     return
-                await asyncio.sleep(1.0 / 24)
+                await asyncio.sleep(THROTTLE)
 
         except Exception as e:
             logging.error(f"Error: {e}")

frontend/src/lib/components/VideoInput.svelte

@@ -20,7 +20,7 @@
   let videoFrameCallbackId: number;
 
   // ajust the throttle time to your needs
-  const THROTTLE_TIME = 1000 / 15;
+  const THROTTLE = 1000 / 120;
   let selectedDevice: string = '';
   let videoIsReady = false;
 
@@ -41,7 +41,7 @@
   }
   let lastMillis = 0;
   async function onFrameChange(now: DOMHighResTimeStamp, metadata: VideoFrameCallbackMetadata) {
-    if (now - lastMillis < THROTTLE_TIME) {
+    if (now - lastMillis < THROTTLE) {
       videoFrameCallbackId = videoEl.requestVideoFrameCallback(onFrameChange);
       return;
     }

pipelines/controlnet.py

@@ -185,6 +185,7 @@ class Pipeline:
             config.enable_triton = True
             config.enable_cuda_graph = True
             self.pipe = compile(self.pipe, config=config)
+
         self.canny_torch = SobelOperator(device=device)
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype)
@@ -214,7 +215,6 @@ class Pipeline:
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
         prompt_embeds = None
-        control_image = None
         prompt = params.prompt
         if hasattr(self, "compel_proc"):
             prompt_embeds = self.compel_proc(params.prompt)

pipelines/controlnetLoraSD15.py

@@ -81,7 +81,7 @@ class Pipeline:
             2159232, min=0, title="Seed", field="seed", hide=True, id="seed"
         )
         steps: int = Field(
-            4, min=1, max=15, title="Steps", field="range", hide=True, id="steps"
+            1, min=1, max=15, title="Steps", field="range", hide=True, id="steps"
         )
         width: int = Field(
             768, min=2, max=15, title="Width", disabled=True, hide=True, id="width"
@@ -90,7 +90,7 @@ class Pipeline:
             768, min=2, max=15, title="Height", disabled=True, hide=True, id="height"
         )
         guidance_scale: float = Field(
-            0.2,
+            1.0,
             min=0,
             max=2,
             step=0.001,
@@ -195,13 +195,9 @@ class Pipeline:
         for pipe in self.pipes.values():
             pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
             pipe.set_progress_bar_config(disable=True)
-            pipe.to(device=device, dtype=torch_dtype).to(device)
             if device.type != "mps":
                 pipe.unet.to(memory_format=torch.channels_last)
 
-            if psutil.virtual_memory().total < 64 * 1024**3:
-                pipe.enable_attention_slicing()
-
             if args.taesd:
                 pipe.vae = AutoencoderTiny.from_pretrained(
                     taesd_model, torch_dtype=torch_dtype, use_safetensors=True
@@ -209,11 +205,13 @@ class Pipeline:
 
             # Load LCM LoRA
             pipe.load_lora_weights(lcm_lora_id, adapter_name="lcm")
-            pipe.compel_proc = Compel(
-                tokenizer=pipe.tokenizer,
-                text_encoder=pipe.text_encoder,
-                truncate_long_prompts=False,
-            )
+            pipe.to(device=device, dtype=torch_dtype).to(device)
+            if args.compel:
+                self.compel_proc = Compel(
+                    tokenizer=pipe.tokenizer,
+                    text_encoder=pipe.text_encoder,
+                    truncate_long_prompts=False,
+                )
             if args.torch_compile:
                 pipe.unet = torch.compile(
                     pipe.unet, mode="reduce-overhead", fullgraph=True
@@ -233,7 +231,12 @@ class Pipeline:
 
         activation_token = base_models[params.base_model_id]
         prompt = f"{activation_token} {params.prompt}"
-        prompt_embeds = pipe.compel_proc(prompt)
+        prompt_embeds = None
+        prompt = params.prompt
+        if hasattr(self, "compel_proc"):
+            prompt_embeds = self.compel_proc(prompt)
+            prompt = None
+
         control_image = self.canny_torch(
             params.image, params.canny_low_threshold, params.canny_high_threshold
         )
@@ -245,6 +248,7 @@ class Pipeline:
         results = pipe(
             image=params.image,
             control_image=control_image,
+            prompt=prompt,
             prompt_embeds=prompt_embeds,
             generator=generator,
             strength=strength,

pipelines/controlnetLoraSDXL.py

@@ -80,7 +80,7 @@ class Pipeline:
             2159232, min=0, title="Seed", field="seed", hide=True, id="seed"
         )
         steps: int = Field(
-            2, min=1, max=15, title="Steps", field="range", hide=True, id="steps"
+            1, min=1, max=10, title="Steps", field="range", hide=True, id="steps"
         )
         width: int = Field(
             1024, min=2, max=15, title="Width", disabled=True, hide=True, id="width"
@@ -91,7 +91,7 @@ class Pipeline:
         guidance_scale: float = Field(
             1.0,
             min=0,
-            max=20,
+            max=2.0,
             step=0.001,
             title="Guidance Scale",
             field="range",
@@ -199,18 +199,30 @@ class Pipeline:
         self.pipe.scheduler = LCMScheduler.from_config(self.pipe.scheduler.config)
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype).to(device)
+
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
+        if args.compel:
+            self.pipe.compel_proc = Compel(
+                tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],
+                text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],
+                returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
+                requires_pooled=[False, True],
+            )
 
-        self.pipe.compel_proc = Compel(
-            tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],
-            text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],
-            returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
-            requires_pooled=[False, True],
-        )
         if args.taesd:
             self.pipe.vae = AutoencoderTiny.from_pretrained(
                 taesd_model, torch_dtype=torch_dtype, use_safetensors=True
@@ -232,9 +244,23 @@ class Pipeline:
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
 
-        prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
-            [params.prompt, params.negative_prompt]
-        )
+        prompt = params.prompt
+        negative_prompt = params.negative_prompt
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        negative_prompt_embeds = None
+        negative_pooled_prompt_embeds = None
+        if hasattr(self.pipe, "compel_proc"):
+            _prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
+                [params.prompt, params.negative_prompt]
+            )
+            prompt = None
+            negative_prompt = None
+            prompt_embeds = _prompt_embeds[0:1]
+            pooled_prompt_embeds = pooled_prompt_embeds[0:1]
+            negative_prompt_embeds = _prompt_embeds[1:2]
+            negative_pooled_prompt_embeds = pooled_prompt_embeds[1:2]
+
         control_image = self.canny_torch(
             params.image, params.canny_low_threshold, params.canny_high_threshold
         )
@@ -246,10 +272,12 @@ class Pipeline:
         results = self.pipe(
             image=params.image,
             control_image=control_image,
-            prompt_embeds=prompt_embeds[0:1],
-            pooled_prompt_embeds=pooled_prompt_embeds[0:1],
-            negative_prompt_embeds=prompt_embeds[1:2],
-            negative_pooled_prompt_embeds=pooled_prompt_embeds[1:2],
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            prompt_embeds=prompt_embeds,
+            pooled_prompt_embeds=pooled_prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
             generator=generator,
             strength=strength,
             num_inference_steps=steps,

pipelines/controlnetSegmindVegaRT.py

@@ -193,14 +193,24 @@ class Pipeline:
         self.pipe.scheduler = LCMScheduler.from_pretrained(
             base_model, subfolder="scheduler"
         )
+
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype).to(device)
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.compel:
             self.pipe.compel_proc = Compel(
                 tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],

pipelines/img2img.py

@@ -107,15 +107,23 @@ class Pipeline:
                 taesd_model, torch_dtype=torch_dtype, use_safetensors=True
             ).to(device)
 
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype)
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        # check if computer has less than 64GB of RAM using sys or os
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.torch_compile:
             print("Running torch compile")
             self.pipe.unet = torch.compile(
@@ -130,15 +138,20 @@ class Pipeline:
                 image=[Image.new("RGB", (768, 768))],
             )
 
-        self.compel_proc = Compel(
-            tokenizer=self.pipe.tokenizer,
-            text_encoder=self.pipe.text_encoder,
-            truncate_long_prompts=False,
-        )
+        if args.compel:
+            self.compel_proc = Compel(
+                tokenizer=self.pipe.tokenizer,
+                text_encoder=self.pipe.text_encoder,
+                truncate_long_prompts=False,
+            )
 
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
-        prompt_embeds = self.compel_proc(params.prompt)
+        prompt_embeds = None
+        prompt = params.prompt
+        if hasattr(self, "compel_proc"):
+            prompt_embeds = self.compel_proc(params.prompt)
+            prompt = None
 
         steps = params.steps
         strength = params.strength
@@ -147,6 +160,7 @@ class Pipeline:
 
         results = self.pipe(
             image=params.image,
+            prompt=prompt,
             prompt_embeds=prompt_embeds,
             generator=generator,
             strength=strength,

pipelines/img2imgSDXLTurbo.py

@@ -73,18 +73,18 @@ class Pipeline:
             2159232, min=0, title="Seed", field="seed", hide=True, id="seed"
         )
         steps: int = Field(
-            4, min=1, max=15, title="Steps", field="range", hide=True, id="steps"
+            1, min=1, max=10, title="Steps", field="range", hide=True, id="steps"
         )
         width: int = Field(
-            512, min=2, max=15, title="Width", disabled=True, hide=True, id="width"
+            768, min=2, max=15, title="Width", disabled=True, hide=True, id="width"
         )
         height: int = Field(
-            512, min=2, max=15, title="Height", disabled=True, hide=True, id="height"
+            768, min=2, max=15, title="Height", disabled=True, hide=True, id="height"
         )
         guidance_scale: float = Field(
-            0.2,
+            1.0,
             min=0,
-            max=20,
+            max=1,
             step=0.001,
             title="Guidance Scale",
             field="range",
@@ -115,15 +115,23 @@ class Pipeline:
                 taesd_model, torch_dtype=torch_dtype, use_safetensors=True
             ).to(device)
 
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype)
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        # check if computer has less than 64GB of RAM using sys or os
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.torch_compile:
             print("Running torch compile")
             self.pipe.unet = torch.compile(
@@ -132,24 +140,38 @@ class Pipeline:
             self.pipe.vae = torch.compile(
                 self.pipe.vae, mode="reduce-overhead", fullgraph=True
             )
-
             self.pipe(
                 prompt="warmup",
                 image=[Image.new("RGB", (768, 768))],
             )
 
-        self.pipe.compel_proc = Compel(
-            tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],
-            text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],
-            returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
-            requires_pooled=[False, True],
-        )
+        if args.compel:
+            self.pipe.compel_proc = Compel(
+                tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],
+                text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],
+                returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
+                requires_pooled=[False, True],
+            )
 
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
-        prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
-            [params.prompt, params.negative_prompt]
-        )
+        prompt = params.prompt
+        negative_prompt = params.negative_prompt
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        negative_prompt_embeds = None
+        negative_pooled_prompt_embeds = None
+        if hasattr(self.pipe, "compel_proc"):
+            _prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
+                [params.prompt, params.negative_prompt]
+            )
+            prompt = None
+            negative_prompt = None
+            prompt_embeds = _prompt_embeds[0:1]
+            pooled_prompt_embeds = pooled_prompt_embeds[0:1]
+            negative_prompt_embeds = _prompt_embeds[1:2]
+            negative_pooled_prompt_embeds = pooled_prompt_embeds[1:2]
+
         steps = params.steps
         strength = params.strength
         if int(steps * strength) < 1:
@@ -157,10 +179,12 @@ class Pipeline:
 
         results = self.pipe(
             image=params.image,
-            prompt_embeds=prompt_embeds[0:1],
-            pooled_prompt_embeds=pooled_prompt_embeds[0:1],
-            negative_prompt_embeds=prompt_embeds[1:2],
-            negative_pooled_prompt_embeds=pooled_prompt_embeds[1:2],
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            prompt_embeds=prompt_embeds,
+            pooled_prompt_embeds=pooled_prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
             generator=generator,
             strength=strength,
             num_inference_steps=steps,

pipelines/img2imgSegmindVegaRT.py

@@ -75,7 +75,7 @@ class Pipeline:
             2159232, min=0, title="Seed", field="seed", hide=True, id="seed"
         )
         steps: int = Field(
-            4, min=1, max=15, title="Steps", field="range", hide=True, id="steps"
+            1, min=1, max=10, title="Steps", field="range", hide=True, id="steps"
         )
         width: int = Field(
             1024, min=2, max=15, title="Width", disabled=True, hide=True, id="width"
@@ -126,15 +126,23 @@ class Pipeline:
         self.pipe.scheduler = LCMScheduler.from_pretrained(
             base_model, subfolder="scheduler"
         )
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype)
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        # check if computer has less than 64GB of RAM using sys or os
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.torch_compile:
             print("Running torch compile")
             self.pipe.unet = torch.compile(

pipelines/txt2img.py

@@ -90,15 +90,23 @@ class Pipeline:
                 taesd_model, torch_dtype=torch_dtype, use_safetensors=True
             ).to(device)
 
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype)
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        # check if computer has less than 64GB of RAM using sys or os
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.torch_compile:
             self.pipe.unet = torch.compile(
                 self.pipe.unet, mode="reduce-overhead", fullgraph=True
@@ -109,17 +117,24 @@ class Pipeline:
 
             self.pipe(prompt="warmup", num_inference_steps=1, guidance_scale=8.0)
 
-        self.compel_proc = Compel(
-            tokenizer=self.pipe.tokenizer,
-            text_encoder=self.pipe.text_encoder,
-            truncate_long_prompts=False,
-        )
+        if args.compel:
+            self.compel_proc = Compel(
+                tokenizer=self.pipe.tokenizer,
+                text_encoder=self.pipe.text_encoder,
+                truncate_long_prompts=False,
+            )
 
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
-        prompt_embeds = self.compel_proc(params.prompt)
+        prompt_embeds = None
+        prompt = params.prompt
+        if hasattr(self, "compel_proc"):
+            prompt_embeds = self.compel_proc(params.prompt)
+            prompt = None
+
         results = self.pipe(
             prompt_embeds=prompt_embeds,
+            prompt=prompt,
             generator=generator,
             num_inference_steps=params.steps,
             guidance_scale=params.guidance_scale,

pipelines/txt2imgLora.py

@@ -96,16 +96,15 @@ class Pipeline:
             self.pipe.vae = AutoencoderTiny.from_pretrained(
                 taesd_model, torch_dtype=torch_dtype, use_safetensors=True
             ).to(device)
+
         self.pipe.scheduler = LCMScheduler.from_config(self.pipe.scheduler.config)
         self.pipe.set_progress_bar_config(disable=True)
+        self.pipe.load_lora_weights(lcm_lora_id, adapter_name="lcm")
         self.pipe.to(device=device, dtype=torch_dtype)
+
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        # check if computer has less than 64GB of RAM using sys or os
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         if args.torch_compile:
             self.pipe.unet = torch.compile(
                 self.pipe.unet, mode="reduce-overhead", fullgraph=True
@@ -116,18 +115,35 @@ class Pipeline:
 
             self.pipe(prompt="warmup", num_inference_steps=1, guidance_scale=8.0)
 
-        self.pipe.load_lora_weights(lcm_lora_id, adapter_name="lcm")
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
 
-        self.compel_proc = Compel(
-            tokenizer=self.pipe.tokenizer,
-            text_encoder=self.pipe.text_encoder,
-            truncate_long_prompts=False,
-        )
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
+        if args.compel:
+            self.compel_proc = Compel(
+                tokenizer=self.pipe.tokenizer,
+                text_encoder=self.pipe.text_encoder,
+                truncate_long_prompts=False,
+            )
 
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
-        prompt_embeds = self.compel_proc(params.prompt)
+        prompt_embeds = None
+        prompt = params.prompt
+        if hasattr(self, "compel_proc"):
+            prompt_embeds = self.compel_proc(params.prompt)
+            prompt = None
+
         results = self.pipe(
+            prompt=prompt,
             prompt_embeds=prompt_embeds,
             generator=generator,
             num_inference_steps=params.steps,

pipelines/txt2imgLoraSDXL.py

@@ -111,12 +111,22 @@ class Pipeline:
         self.pipe.scheduler = LCMScheduler.from_config(self.pipe.scheduler.config)
         self.pipe.set_progress_bar_config(disable=True)
         self.pipe.to(device=device, dtype=torch_dtype).to(device)
+
+        if args.sfast:
+            from sfast.compilers.stable_diffusion_pipeline_compiler import (
+                compile,
+                CompilationConfig,
+            )
+
+            config = CompilationConfig.Default()
+            config.enable_xformers = True
+            config.enable_triton = True
+            config.enable_cuda_graph = True
+            self.pipe = compile(self.pipe, config=config)
+
         if device.type != "mps":
             self.pipe.unet.to(memory_format=torch.channels_last)
 
-        if psutil.virtual_memory().total < 64 * 1024**3:
-            self.pipe.enable_attention_slicing()
-
         self.pipe.compel_proc = Compel(
             tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],
             text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],
@@ -142,14 +152,30 @@ class Pipeline:
     def predict(self, params: "Pipeline.InputParams") -> Image.Image:
         generator = torch.manual_seed(params.seed)
 
-        prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
-            [params.prompt, params.negative_prompt]
-        )
+        prompt = params.prompt
+        negative_prompt = params.negative_prompt
+        prompt_embeds = None
+        pooled_prompt_embeds = None
+        negative_prompt_embeds = None
+        negative_pooled_prompt_embeds = None
+        if hasattr(self.pipe, "compel_proc"):
+            _prompt_embeds, pooled_prompt_embeds = self.pipe.compel_proc(
+                [params.prompt, params.negative_prompt]
+            )
+            prompt = None
+            negative_prompt = None
+            prompt_embeds = _prompt_embeds[0:1]
+            pooled_prompt_embeds = pooled_prompt_embeds[0:1]
+            negative_prompt_embeds = _prompt_embeds[1:2]
+            negative_pooled_prompt_embeds = pooled_prompt_embeds[1:2]
+
         results = self.pipe(
-            prompt_embeds=prompt_embeds[0:1],
-            pooled_prompt_embeds=pooled_prompt_embeds[0:1],
-            negative_prompt_embeds=prompt_embeds[1:2],
-            negative_pooled_prompt_embeds=pooled_prompt_embeds[1:2],
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            prompt_embeds=prompt_embeds,
+            pooled_prompt_embeds=pooled_prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
             generator=generator,
             num_inference_steps=params.steps,
             guidance_scale=params.guidance_scale,