test gradio

app.py

@@ -10,6 +10,10 @@ from diffusers.schedulers import DPMSolverMultistepScheduler
 from diffusers.utils import export_to_gif, load_image
 from diffusers import AutoPipelineForText2Image
 import openai,json
+import torch
+from diffusers.models import MotionAdapter
+from diffusers import AnimateDiffSDXLPipeline, DDIMScheduler
+from diffusers.utils import export_to_gif
 
 
 token = os.getenv("HF_TOKEN")
@@ -52,78 +56,49 @@ def generate_image(prompt, reference_image, controlnet_conditioning_scale):
 
     return image
 
-model_id = "stabilityai/stable-diffusion-3.5-large"
-motion_adapter_id = "guoyww/animatediff-motion-adapter-v1-5-3"
-controlnet_id = "guoyww/animatediff-sparsectrl-rgb"
-lora_adapter_id = "guoyww/animatediff-motion-lora-v1-5-3"
 vae_id = "stabilityai/sd-vae-ft-mse"
 device = "cuda"
 
-motion_adapter = MotionAdapter.from_pretrained(motion_adapter_id, torch_dtype=torch.float16).to(device)
-controlnet = SparseControlNetModel.from_pretrained(controlnet_id, torch_dtype=torch.float16).to(device)
-vae = AutoencoderKL.from_pretrained(vae_id, torch_dtype=torch.float16).to(device)
-scheduler = DPMSolverMultistepScheduler.from_pretrained(
+adapter = MotionAdapter.from_pretrained(
+    "a-r-r-o-w/animatediff-motion-adapter-sdxl-beta", torch_dtype=torch.float16
+)
+
+model_id = "stabilityai/sdxl-turbo"
+scheduler = DDIMScheduler.from_pretrained(
     model_id,
     subfolder="scheduler",
+    clip_sample=False,
+    timestep_spacing="linspace",
     beta_schedule="linear",
-    algorithm_type="dpmsolver++",
-    use_karras_sigmas=True,
+    steps_offset=1,
 )
-gif_pipe = AnimateDiffSparseControlNetPipeline.from_pretrained(
+gif_pipe = AnimateDiffSDXLPipeline.from_pretrained(
     model_id,
-    motion_adapter=motion_adapter,
-    controlnet=controlnet,
-    vae=vae,
+    motion_adapter=adapter,
     scheduler=scheduler,
     torch_dtype=torch.float16,
-).to(device)
-gif_pipe.load_lora_weights(lora_adapter_id, adapter_name="motion_lora")
+    variant="fp16",
+).to("cuda")
+
+# enable memory savings
+gif_pipe.enable_vae_slicing()
+gif_pipe.enable_vae_tiling()
+
+
+gif_pipe.load_ip_adapter("h94/IP-Adapter", subfolder="sdxl_models", weight_name="ip-adapter_sdxl.bin")
 
 
 @spaces.GPU
 def generate_gif(prompt, reference_image, controlnet_conditioning_scale,style_conditioning_scale,num_frames):
-    massage_history = [{"role": "system", "content": """
-You are a scene designer tasked with creating sparse frames of a video. You will be given a prompt describing the desired video, and your goal is to design only the key frames (sparse frames) that represent major changes in the scene. Do not include repetitive or similar scenes—only capture distinct moments.
-
-Expected Format:
-Return the response as a JSON object with the key "frames". The value should be a list of dictionaries, where each dictionary has:
-
-"frame_index": an integer indicating the frame's position in the sequence.
-"description": a brief description of the scene in this frame.
-Example:
-If given a prompt like "A sunset over a beach with waves crashing and a ship sailing by," your response should look like this:
-
-```json
-{
-  "frames": [
-    {"frame_index": 0, "description": "Sunset over an empty beach, sky turning orange and pink"},
-    {"frame_index": 30, "description": "Waves gently crashing on the shore"},
-    {"frame_index": 60, "description": "A ship appears on the horizon, silhouetted by the sunset"},
-    {"frame_index": 90, "description": "Ship sailing closer, with waves becoming more dynamic"},
-    {"frame_index": 120, "description": "Sun dipping below the horizon, casting a golden glow over the water"}
-  ]
-}
-```
-This way, each frame represents a distinct scene, and there’s no redundancy between them."""},
-                       {"role": "user", "content": f"give me the frames to generate a video with prompt : `{prompt}`"},]
-    frames = ask_gpt(massage_history,return_str=False)['frames']
-    conditioning_frames = []
-    controlnet_frame_indices =[]
-    frames = frames[0:1]
-    for frame in frames:
-        conditioning_frames.append(generate_image(frame['description'], reference_image, float(style_conditioning_scale)))
-        controlnet_frame_indices.append(frame['frame_index'])
-        yield (conditioning_frames, "output.gif")
-
+    image=  generate_image(prompt, reference_image, float(style_conditioning_scale))
     video = gif_pipe(
         prompt=prompt,
         negative_prompt="low quality, worst quality",
         num_inference_steps=25,
-        conditioning_frames=conditioning_frames,
-        controlnet_frame_indices=controlnet_frame_indices,
-        controlnet_conditioning_scale=float(controlnet_conditioning_scale),
+        guidance_scale=8,
         num_frames=int(num_frames)
     ).frames[0]
+
     export_to_gif(video, "output.gif")
 
     yield (conditioning_frames, "output.gif")