Update app.py

app.py

@@ -1,11 +1,9 @@
 import gradio as gr
-from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, EulerDiscreteScheduler, LCMScheduler, AutoencoderKL
-import torch
-from huggingface_hub import hf_hub_download
-from safetensors.torch import load_file
-import gc
-import spaces
+from gradio_client import Client
+import concurrent.futures
 
+client_lightning = Client("AP123/SDXL-Lightning")
+client_hyper = Client("ByteDance/Hyper-SDXL-1Step-T2I")
 
 vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16)
 
@@ -15,64 +13,57 @@ pipe_turbo = StableDiffusionXLPipeline.from_pretrained("stabilityai/sdxl-turbo",
                                                        torch_dtype=torch.float16,
                                                        variant="fp16"
                                                       )
-#pipe_turbo.to("cuda")
+pipe_turbo.to("cuda")
 
-### SDXL Lightning ### 
-base = "stabilityai/stable-diffusion-xl-base-1.0"
-repo = "ByteDance/SDXL-Lightning"
-ckpt = "sdxl_lightning_1step_unet_x0.safetensors" 
 
-unet = UNet2DConditionModel.from_config(base, subfolder="unet").to(torch.float16)
-unet.load_state_dict(load_file(hf_hub_download(repo, ckpt)))
-pipe_lightning = StableDiffusionXLPipeline.from_pretrained(base,
-                                                           unet=unet,
-                                                           vae=vae,
-                                                           text_encoder=pipe_turbo.text_encoder,
-                                                           text_encoder_2=pipe_turbo.text_encoder_2,
-                                                           tokenizer=pipe_turbo.tokenizer,
-                                                           tokenizer_2=pipe_turbo.tokenizer_2,
-                                                           torch_dtype=torch.float16,
-                                                           variant="fp16"
-                                                          )#.to("cuda")
-del unet
-gc.collect()
-pipe_lightning.scheduler = EulerDiscreteScheduler.from_config(pipe_lightning.scheduler.config, timestep_spacing="trailing", prediction_type="sample")
-#pipe_lightning.to("cuda")
+def get_lighting_result(prompt):
+    result_lighting = client_lightning.predict(
+        prompt,  # Your prompt
+        "1-Step",  # Number of inference steps
+        api_name="/generate_image"
+    )
+    return result_lighting
 
-### Hyper SDXL ### 
-repo_name = "ByteDance/Hyper-SD"
-ckpt_name = "Hyper-SDXL-1step-Unet.safetensors"
-
-unet = UNet2DConditionModel.from_config(base, subfolder="unet").to(torch.float16)
-unet.load_state_dict(load_file(hf_hub_download(repo_name, ckpt_name)))
-pipe_hyper = StableDiffusionXLPipeline.from_pretrained(base,
-                                                       unet=unet,
-                                                       vae=vae,
-                                                       text_encoder=pipe_turbo.text_encoder,
-                                                       text_encoder_2=pipe_turbo.text_encoder_2,
-                                                       tokenizer=pipe_turbo.tokenizer,
-                                                       tokenizer_2=pipe_turbo.tokenizer_2,
-                                                       torch_dtype=torch.float16,
-                                                       variant="fp16"
-                                                      )#.to("cuda")
-pipe_hyper.scheduler = LCMScheduler.from_config(pipe_hyper.scheduler.config)
-#pipe_hyper.to("cuda")
-del unet
-gc.collect()
+def get_hyper_result(prompt):
+    result_hyper = client_hyper.predict(
+        num_images=1,
+        height=1024,
+        width=1024,
+        prompt=prompt,
+        seed=3413,
+        api_name="/process_image"
+    )
+    return result_hyper
 
 @spaces.GPU
-def run_comparison(prompt):
-    image_turbo.to("cuda")
-    image_turbo=pipe_turbo(prompt=prompt, num_inference_steps=1, guidance_scale=0).images[0]
-    image_turbo.to("cpu")
-    image_lightning.to("cuda")
-    image_lightning=pipe_lightning(prompt=prompt, num_inference_steps=1, guidance_scale=0).images[0]
-    image_lightning.to("cpu")
-    image_hyper.to("cuda")
-    image_hyper=pipe_hyper(prompt=prompt, num_inference_steps=1, guidance_scale=0, timesteps=[800]).images[0]
-    image_turbo.to("cpu")
-    return image_turbo, image_lightning, image_hyper
+def get_turbo_result(prompt):
+    image_turbo = pipe_turbo(prompt=prompt, num_inference_steps=1, guidance_scale=0).images[0]
+    return image_turbo
+
+def run_in_parallel(prompt):
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        # Submit tasks to the executor
+        future_lighting = executor.submit(get_lighting_result, prompt)
+        future_hyper = executor.submit(get_hyper_result, prompt)
+        future_turbo = executor.submit(get_turbo_result, prompt)
+
+        # Wait for all futures to complete
+        results = concurrent.futures.wait(
+            [future_lighting, future_hyper, future_turbo],
+            return_when=concurrent.futures.ALL_COMPLETED
+        )
+
+        # Extract results from futures
+        result_lighting = future_lighting.result()
+        result_hyper = future_hyper.result()
+        image_turbo = future_turbo.result()
+        print(result_lighting)
+        print(result_hyper)
+        return image_turbo, result_lighting, result_hyper
 
+# Example usage
+prompt = "Enter your prompt here"
+image_turbo, result_lighting, result_hyper = run_in_parallel(prompt)
 
 css = '''
 .gradio-container{max-width: 768px !important}