iddlZddlmZmZmZmZmZddlZddl Z ddl m Z ddl mZmZmZmZddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lm Z m!Z!m"Z"m#Z#dd l$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+e!r ddl,m-cm.Z/dZ0ndZ0e"jbe2Z3e rddl4Z4e"jbe2Z3dZ5dZ6dZ7dZ8Gdde)eZ9y)N)CallableDictListOptionalUnion) functional) CLIPTextModel CLIPTokenizer"Qwen2_5_VLForConditionalGenerationQwen2VLProcessor)MultiPipelineCallbacksPipelineCallback)PipelineImageInput)KandinskyLoraLoaderMixin)AutoencoderKLHunyuanVideo)Kandinsky5Transformer3DModel)FlowMatchEulerDiscreteScheduler)is_ftfy_availableis_torch_xla_availableloggingreplace_example_docstring) randn_tensor)VideoProcessor)DiffusionPipeline)KandinskyPipelineOutputTFa& Examples: ```python >>> import torch >>> from diffusers import Kandinsky5I2VPipeline >>> from diffusers.utils import export_to_video, load_image >>> # Available models: >>> # kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers >>> model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers" >>> pipe = Kandinsky5I2VPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16) >>> pipe = pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" ... ) >>> prompt = "An astronaut floating in space with Earth in the background, cinematic shot" >>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" >>> output = pipe( ... image=image, ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=512, ... width=768, ... num_frames=121, ... num_inference_steps=50, ... guidance_scale=5.0, ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=24, quality=9) ``` ctrtj|}tjtj|}|j S)z Copied from https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/wan/pipeline_wan.py Clean text using ftfy if available and unescape HTML entities. )rftfyfix_texthtmlunescapestriptexts /home/obispo/Crisostomo_bridge/mision_env/lib/python3.12/site-packages/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py basic_cleanr(_s; }}T" ==t, -D ::<cTtjdd|}|j}|S)z Copied from https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/wan/pipeline_wan.py Normalize whitespace in text by replacing multiple spaces with single space. z\s+ )resubr$r%s r'whitespace_cleanr.ks& 66&#t $D ::eej&d?eed@e-dAeee.eee/gdfe0e1fdBeedef,dCZ2xZ3S)KKandinsky5I2VPipelinea Pipeline for image-to-video generation using Kandinsky 5.0. This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods implemented for all pipelines (downloading, saving, running on a particular device, etc.). Args: transformer ([`Kandinsky5Transformer3DModel`]): Conditional Transformer to denoise the encoded video latents. vae ([`AutoencoderKLHunyuanVideo`]): Variational Auto-Encoder Model [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) to encode and decode videos to and from latent representations. text_encoder ([`Qwen2_5_VLForConditionalGeneration`]): Frozen text-encoder [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer ([`AutoProcessor`]): Tokenizer for Qwen2.5-VL. text_encoder_2 ([`CLIPTextModel`]): Frozen [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant. tokenizer_2 ([`CLIPTokenizer`]): Tokenizer for CLIP. scheduler ([`FlowMatchEulerDiscreteScheduler`]): A scheduler to be used in combination with `transformer` to denoise the encoded video latents. z.text_encoder->text_encoder_2->transformer->vae)latentsprompt_embeds_qwenprompt_embeds_clipnegative_prompt_embeds_qwennegative_prompt_embeds_clip transformervae text_encoder tokenizertext_encoder_2 tokenizer_2 schedulerc t||j|||||||djgd|_d|_t |ddr |jjjnd|_ t |ddr |jjjnd|_ t|j|_y) N)r8r9r:r;r<r=r> )zJ<|im_start|>system You are a promt engineer. Describe the video in detail.zjDescribe how the camera moves or shakes, describe the zoom and view angle, whether it follows the objects.zPDescribe the location of the video, main characters or objects and their action.z9Describe the dynamism of the video and presented actions.zName the visual style of the video: whether it is a professional footage, user generated content, some kind of animation, video game or scren content.z_Describe the visual effects, postprocessing and transitions if they are presented in the video.zGPay attention to the order of key actions shown in the scene.<|im_end|>z<|im_start|>user {}<|im_end|>r9)vae_scale_factor)super__init__register_modulesjoinprompt_template prompt_template_encode_start_idxgetattrr9configtemporal_compression_ratiovae_scale_factor_temporalspatial_compression_ratiovae_scale_factor_spatialrvideo_processor) selfr8r9r:r;r<r=r> __class__s r'rFzKandinsky5I2VPipeline.__init__s  #%)#   $yy  14-;B$t:TDHHOO 6 6Z[ &V]]achjnUo(Q(Quv%-t?\?\]r)heightwidthreturnc,d}||r ||ryy)z Calculate the scale factor based on resolution. Args: height (int): Video height width (int): Video width Returns: tuple: Scale factor as (temporal_scale, height_scale, width_scale) c"d|cxkxrdkScS)NiV)xs r' between_480pz=Kandinsky5I2VPipeline._get_scale_factor..between_480ps!?s? "? "r))rrr)rHzG @r]rZ)rRrTrUr\s r'_get_scale_factorz'Kandinsky5I2VPipeline._get_scale_factors #  L$7"r)THWwTwHwWc>tj|||gj}tjd|dtj|}|j d|j dz j } | d|d|fj| d|d|fj| d|d|fj} } } | |dzk} | |dzk} | |dzk} | j d| j dzj||||jddj} | j d| j dzj||||z||zjdd}|j||z|z||z|zS)a Create a sparse temporal attention (STA) mask for efficient video generation. This method generates a mask that limits attention to nearby frames and spatial positions, reducing computational complexity for video generation. Args: T (int): Number of temporal frames H (int): Height in latent space W (int): Width in latent space wT (int): Temporal attention window size wH (int): Height attention window size wW (int): Width attention window size device (str): Device to create tensor on Returns: torch.Tensor: Sparse attention mask of shape (T*H*W, T*H*W) rrdtypedeviceNr) torchTensoramaxarangeint16 unsqueezeabsflattenreshape transpose)r_r`rarbrcrdrhlrmatsta_tsta_hsta_wsta_hwstas r'fast_sta_nablaz$Kandinsky5I2VPipeline.fast_sta_nablas( LL!Q # ( ( * LLAq F C{{1~ A.335 BQBK   ! BQBK   ! BQBK   !u q q q //!$uq'99BB1aANXXYZ\]^ffhq!F$4$4Q$77@@Aq1uaRSeT^^_`bcd{{1q519a!eai00r)c |jjjddk(sJ|j\}}}}}||jjjdz||jjjdz||jjjdz}}}|jjjdk(rz|j ||dz|dz|jjj |jjj|jjj|}|jdjd|jjjd|jjj|jjj |jjj|jjj|jjj|||f|jjjd } | Sd } | S) a Generate sparse attention parameters for the transformer based on sample dimensions. This method computes the sparse attention configuration needed for efficient video processing in the transformer model. Args: sample (torch.Tensor): Input sample tensor device (torch.device): Device to place tensors on Returns: Dict: Dictionary containing sparse attention parameters rrrnablarCrhT) sta_maskattention_type to_fractalPrbrdrcadd_sta visual_shapemethodN) r8rL patch_sizeshaperr{ attention_wT attention_wH attention_wW unsqueeze_ attention_Pattention_add_staattention_method) rRsamplerhBr_r`ra_r sparse_paramss r'get_sparse_paramsz'Kandinsky5I2VPipeline.get_sparse_paramss&&11!4999 1aA !!((33A6 6 !!((33A6 6 !!((33A6 61    " " 1 1W <**QQ  ''44  ''44  ''44+H%//2==a@"&"2"2"9"9"H"H"%%,,88&&--::&&--::&&--::++22DD!"Aq **11BB M!Mr)Npromptrhmax_sequence_lengthrgc |xs |j}|xs|jj}|Dcgc]}|jj |}}|j |z}|j |ddddd}|jd|kDrt|D]t\} } || |j d} |j j| |dz d} t| d kDsH| dt|  || <tjd |d | v|j |dd|d dd j|} |j| dd d dddd|j df}| ddd|j df}tj|j!dd }t#j$|dd jtj&}|j||fScc}w)aa Encode prompt using Qwen2.5-VL text encoder. This method processes the input prompt through the Qwen2.5-VL model to generate text embeddings suitable for video generation. Args: prompt (Union[str, List[str]]): Input prompt or list of prompts device (torch.device): Device to run encoding on max_sequence_length (int): Maximum sequence length for tokenization dtype (torch.dtype): Data type for embeddings Returns: Tuple[torch.Tensor, torch.Tensor]: Text embeddings and cumulative sequence lengths Nptlongest)r&imagesvideosreturn_tensorspadding input_idsrrzXThe following part of your input was truncated because `max_sequence_length` is set to z tokens: T)r&rr max_length truncationrr)r return_dictoutput_hidden_states hidden_statesattention_maskrdim)rr)valuerg)_execution_devicer:rgrIformatrJr;r enumeratedecodelenloggerwarningtoricumsumsumFpadint32)rRrrhrrgp full_textsmax_allowed_lenuntruncated_idsir&tokens removed_textinputsembedsr cu_seqlenss r'_encode_prompt_qwenz)Kandinsky5I2VPipeline._encode_prompt_qwen6s@,14110**00>DEd**11!4E E??BUU.. )     $ 6$Z0 4(+D,Q,QTVW#~~44VJqMNN/0 ,I  &   "V* ""[)!%#     !$"G"G"II K  01!T5Z5Z5\2\]\\."4"4Q"7Q? UU:vQ7:::M yy++SFs"G-c|xs |j}|xs|jj}|j|dddddj |}|jdi|d}|j |S)a Encode prompt using CLIP text encoder. This method processes the input prompt through the CLIP model to generate pooled embeddings that capture semantic information. Args: prompt (Union[str, List[str]]): Input prompt or list of prompts device (torch.device): Device to run encoding on dtype (torch.dtype): Data type for embeddings Returns: torch.Tensor: Pooled text embeddings from CLIP MTrr)rradd_special_tokensrr pooler_outputrZ)rr<rgr=r)rRrrhrgr pooled_embeds r'_encode_prompt_clipz)Kandinsky5I2VPipeline._encode_prompt_clipzs(14112,,22!! #  "  "V* +t**4V4_E u%%r)c.|jdd}|jdd}d}d}d}d}tj|j||z ||z}tj|j||z ||z} ||z |z } | | z|z} | S)N)rrr rBT)rkeepdimg?g?g?)meanstdriclamp) source reference source_mean source_stdclump_mean_lowclump_mean_high clump_std_lowclump_std_highreference_mean reference_std normalizeds r'adaptive_mean_std_normalizationz5Kandinsky5I2VPipeline.adaptive_mean_std_normalizationskklDkA ZZL$Z?  Y^^%5{^7SU`crUrs IMMOZ-5OQ[^lQlm {*j8 -/.@ r)c |j}|}|jddkr|dfSd}|jddd|f}|dd||t||jddz zf}|j||} |r7|j} |j } t j | | | } | |ddd|f<|S)Nrz'Only one frame, no normalization neededrB)clonerminrmaxrir) rRr3reference_frames clump_values latents_copysamplesnFr first_framesreference_frames_datanormalized_firstmin_valmax_vals r'normalize_first_framez+Kandinsky5I2VPipeline.normalize_first_frames}}  == q FG G}}q$3$w/ '3s;KW]][\M]`aMa7b1b+b(b c?? Ncd +//1G+//1G${{+;WgN +4C4r)rnum_videos_per_promptc|xs |j}|xs|jj}t|ts|g}t |}|Dcgc] }t |}}|j||||\}} |j|||} |jd|d}|j||zd|jd}| jd|d} | j||zd} | j} | j|} tjtj dg|tj"| j%dg} || | fScc}w)a Encodes a single prompt (positive or negative) into text encoder hidden states. This method combines embeddings from both Qwen2.5-VL and CLIP text encoders to create comprehensive text representations for video generation. Args: prompt (`str` or `List[str]`): Prompt to be encoded. num_videos_per_prompt (`int`, *optional*, defaults to 1): Number of videos to generate per prompt. max_sequence_length (`int`, *optional*, defaults to 512): Maximum sequence length for text encoding. device (`torch.device`, *optional*): Torch device. dtype (`torch.dtype`, *optional*): Torch dtype. Returns: Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: - Qwen text embeddings of shape (batch_size * num_videos_per_prompt, sequence_length, embedding_dim) - CLIP pooled embeddings of shape (batch_size * num_videos_per_prompt, clip_embedding_dim) - Cumulative sequence lengths (`cu_seqlens`) for Qwen embeddings of shape (batch_size * num_videos_per_prompt + 1,) )rrhrrg)rrhrgrrrrhrg)rr:rg isinstancelistrr0rrrepeatviewrdiffrepeat_interleavericattensorrr)rRrrrrhrg batch_sizerr4prompt_cu_seqlensr5original_lengthsrepeated_lengthsrepeated_cu_seqlenss r' encode_promptz#Kandinsky5I2VPipeline.encode_promptsB14110**00&$'XF[ +12a,q/22150H0H 3 1I1 --"556 066 $a 044 . .4F4L4LR4P  066 $a 044ZBW5WY[\-113+== ! $ii \\1#fEKK @BRBYBYZ[B\ ] "#57JJJa3s Ec | | dkDr td| td|dzdk7s|dzdk7rtd|d|d | Ltfd | Ds8td jd | Dcgc]}|jvs|c}||| ||| td || | || | td| | td|7t|ts't|t stdt ||9t|ts(t|t stdt |yyycc}w)a Validate input parameters for the pipeline. Args: prompt: Input prompt negative_prompt: Negative prompt for guidance image: Input image for conditioning height: Video height width: Video width prompt_embeds_qwen: Pre-computed Qwen prompt embeddings prompt_embeds_clip: Pre-computed CLIP prompt embeddings negative_prompt_embeds_qwen: Pre-computed Qwen negative prompt embeddings negative_prompt_embeds_clip: Pre-computed CLIP negative prompt embeddings prompt_cu_seqlens: Pre-computed cumulative sequence lengths for Qwen positive prompt negative_prompt_cu_seqlens: Pre-computed cumulative sequence lengths for Qwen negative prompt callback_on_step_end_tensor_inputs: Callback tensor inputs Raises: ValueError: If inputs are invalid Niz*max_sequence_length must be less than 1024z6`image` must be provided for image-to-video generationrz8`height` and `width` have to be divisible by 16 but are z and .c3:K|]}|jvyw)N)_callback_tensor_inputs).0krRs r' z5Kandinsky5I2VPipeline.check_inputs..Os#F 23A-- -F sz2`callback_on_step_end_tensor_inputs` has to be in z , but found zuIf any of `prompt_embeds_qwen`, `prompt_embeds_clip`, or `prompt_cu_seqlens` is provided, all three must be provided.zIf any of `negative_prompt_embeds_qwen`, `negative_prompt_embeds_clip`, or `negative_prompt_cu_seqlens` is provided, all three must be provided.zProvide either `prompt` or `prompt_embeds_qwen` (and corresponding `prompt_embeds_clip` and `prompt_cu_seqlens`). Cannot leave all undefined.z2`prompt` has to be of type `str` or `list` but is z;`negative_prompt` has to be of type `str` or `list` but is ) ValueErrorallrrstrrtype)rRrnegative_promptimagerTrUr4r5r6r7rnegative_prompt_cu_seqlens"callback_on_step_end_tensor_inputsrrs` r' check_inputsz"Kandinsky5I2VPipeline.check_inputs!sJ  */BT/IIJ J =UV V B;! urzQWX^W__dejdkklmn n - 9#F 7YF C DTEaEaDbbn|^pHvwbckokGkGbGpqpHoIJ   )-?-KO`Ol!)-?-GK\Kd 2 ( 3*6)5,3.6-5 2 >08`   z&#'>zRXZ^G_QRVW]R^Q_`a a  &?C0OUY9ZZ[_`o[pZqrs s:[0 'IpHs 0EErrnum_channels_latents num_frames generatorr3c | | j||S|dz |jzdz} || t||jzt||jz|f} t | t r)t | |k7rtdt | d|dt| | ||} |jj|||j|| } tj5| jd }|jj|j j#| }t%|jj&d r#||jj&j(z}|j+d d ddd}|| ddd df<ddd|j,j.rtj0| }tj2|| t||jzt||jzdg| j4| j6}d|ddd df<|ddd df<tj8| ||gd} | S#1swYxYw)a Prepare initial latent variables for image-to-video generation. This method creates random noise latents for all frames except the first frame, which is replaced with the encoded input image. Args: image (PipelineImageInput): Input image to condition the generation on batch_size (int): Number of videos to generate num_channels_latents (int): Number of channels in latent space height (int): Height of generated video width (int): Width of generated video num_frames (int): Number of frames in video dtype (torch.dtype): Data type for latents device (torch.device): Device to create latents on generator (torch.Generator): Random number generator latents (torch.Tensor): Pre-existing latents to use Returns: torch.Tensor: Prepared latent tensor with first frame as encoded image Nrrz/You have passed a list of generators of length z+, but requested an effective batch size of z@. Make sure the batch size matches the length of the generators.)r rhrg)rTrUrr)r scaling_factorrr rBrfrr)rrNintrPrrrrrrQ preprocessrino_gradrnr9encode latent_distrhasattrrLrpermuter8 visual_cond zeros_likezerosrgrhr)rRrrr rTrUr rgrhr r3num_latent_framesr image_tensor image_video image_latentsrvisual_cond_masks r'prepare_latentsz%Kandinsky5I2VPipeline.prepare_latents|s^D  ::V5:9 9'!^0N0NNQRR   K488 8 J$77 7   i &3y>Z+GA#i.AQR&<'gi  u &PUV++66uVSX6Y\\]ckp\q ]]_ ,&003K HHOOK8DDKKV_K`Mtxx(89 -0N0N N *11!Q1a@M,GAqsFO ,    ' '**73K${{%K4#@#@@J$"?"?? mm~~  () Q!V $"/K1Q3 ii+7G HbQGG , ,s )B*IIc|jS)z%Get the current guidance scale value.)_guidance_scalerRs r'guidance_scalez$Kandinsky5I2VPipeline.guidance_scales###r)c|jS)z&Get the number of denoising timesteps.)_num_timestepsr"s r' num_timestepsz#Kandinsky5I2VPipeline.num_timestepss"""r)c|jS)z)Check if generation has been interrupted.) _interruptr"s r' interruptzKandinsky5I2VPipeline.interruptsr)iy2g@pilTrnum_inference_stepsr#r4r5r6r7rr output_typercallback_on_step_endr ct|ttfr |j}|j |||||| | |||||| ||j zdk7rBt jd|j d||j z|j zdz}t|d}||_ d|_ |j}|jj}|t|trd}|g}n-|t|tr t!|}n| j"d}| |j%|| |||\} } }|j&d kDr|d }t|tr||gt!|zn|g}n;t!|t!|k7r$t)d t!|d t!|d ||j%|| |||\}}}|j*j-|||j*j.}|jj0j2}|j5||| z||||||| |  } |dz |j zdz}t7j8||t7j8||j:zdz|t7j8||j:zdz|g}t7j8|j=jj?|}|At7j8|j=jj?|nd}|jA||} |jC| |}!t!|||j*jDzz }"t!||_#|jI|5}#tK|D]E\}$}%|jLr|%jOdjQ|| z}&|j| jS|| jS|| jS||&jS|||| |!d jT}'|j&d kDrm|k|j| jS||jS||jS||&jS|||| |!d jT}(|(||'|(z zz}'|j*jW|'ddddf|%| ddddddddd|fdd| ddddddddd|f<|~i})|D]}*tY|*|)|*<|||$|%|)}+|+j[d| } |+j[d| } |+j[d| } |+j[d|}|+j[d|}|$t!|dz k(s'|$dz|"kDr/|$dz|j*jDzdk(r|#j]t^s2tajbH ddd| ddddddddd|f} |je| } |dk7r)| jS|jfj} | ji|| |dz |j zdz||j:z||j:z|},|,jkdddddd},|,ji|| z||dz |j zdz||j:z||j:z},|,|jfj0jlz },|jfjo|,jT},|jpjs|,|},n| },|ju|s|,fStw|,S#1swYxYw) aZ The call function to the pipeline for image-to-video generation. Args: image (`PipelineImageInput`): The input image to condition the generation on. Must be an image, a list of images or a `torch.Tensor`. prompt (`str` or `List[str]`, *optional*): The prompt or prompts to guide the video generation. If not defined, pass `prompt_embeds` instead. negative_prompt (`str` or `List[str]`, *optional*): The prompt or prompts to avoid during video generation. If not defined, pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale` < `1`). height (`int`, defaults to `512`): The height in pixels of the generated video. width (`int`, defaults to `768`): The width in pixels of the generated video. num_frames (`int`, defaults to `121`): The number of frames in the generated video. num_inference_steps (`int`, defaults to `50`): The number of denoising steps. guidance_scale (`float`, defaults to `5.0`): Guidance scale as defined in classifier-free guidance. num_videos_per_prompt (`int`, *optional*, defaults to 1): The number of videos to generate per prompt. generator (`torch.Generator` or `List[torch.Generator]`, *optional*): A torch generator to make generation deterministic. latents (`torch.Tensor`, *optional*): Pre-generated noisy latents. prompt_embeds_qwen (`torch.Tensor`, *optional*): Pre-generated Qwen text embeddings. prompt_embeds_clip (`torch.Tensor`, *optional*): Pre-generated CLIP text embeddings. negative_prompt_embeds_qwen (`torch.Tensor`, *optional*): Pre-generated Qwen negative text embeddings. negative_prompt_embeds_clip (`torch.Tensor`, *optional*): Pre-generated CLIP negative text embeddings. prompt_cu_seqlens (`torch.Tensor`, *optional*): Pre-generated cumulative sequence lengths for Qwen positive prompt. negative_prompt_cu_seqlens (`torch.Tensor`, *optional*): Pre-generated cumulative sequence lengths for Qwen negative prompt. output_type (`str`, *optional*, defaults to `"pil"`): The output format of the generated video. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`KandinskyPipelineOutput`]. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*): A function that is called at the end of each denoising step. callback_on_step_end_tensor_inputs (`List`, *optional*): The list of tensor inputs for the `callback_on_step_end` function. max_sequence_length (`int`, defaults to `512`): The maximum sequence length for text encoding. Examples: Returns: [`~KandinskyPipelineOutput`] or `tuple`: If `return_dict` is `True`, [`KandinskyPipelineOutput`] is returned, otherwise a `tuple` is returned where the first element is a list with the generated videos. ) rrrrTrUr4r5r6r7rrr rrz(`num_frames - 1` has to be divisible by z!. Rounding to the nearest number.FNr)rrrrhrgg?z{Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwardsz9`negative_prompt` must have same length as `prompt`. Got z vs rr~) rrr rTrUr rgrhr r3r)totalT) rencoder_hidden_statespooled_projectionstimestepvisual_rope_pos text_rope_pos scale_factorrr)rr3r4r5r6r7latentr rB)r.)frames) set_timesteps timestepsrL in_visual_dimrrirlrPritemr^rorderr% progress_barrr)rnrrrsteplocalspopupdate XLA_AVAILABLExm mark_steprr9rqrrrrQpostprocess_videomaybe_free_model_hooksr)-rRrrrrTrUr r-r#rr r3r4r5r6r7rrr.rr/r rrhrgrr=r rr5r6negative_text_rope_posr7rnum_warmup_stepsrArtr4 pred_velocityuncond_pred_velocitycallback_kwargsrcallback_outputsvideos- r'__call__zKandinsky5I2VPipeline.__call__sl *-=?U,V W1E1S1S . +11(C(C/'A/Q 3  66 6! ; NN:4;Y;Y:ZZ{| $t'E'EEHfHffijjJQ' -''  &&  *VS"9JXF  Jvt$<VJ+11!4J  %HLHZHZ&;$7 I[I E  24E    $&#`/3/EKEW?"3c&k"A^m]n_%V4 OPSTcPdOeeijmntjuivvwx+2&&..C,?%# 'e+-HJd $$%8$HNN,,  $//66DD&&!$99!5!'  (!^0N0NNQRR LL*6 : LL4#@#@@AEf U LL$"?"??1DV T   %6%;%;%=%A%A%C%H%H%JSYZ *5 LL388:>>@EEGPV W --fe< ..w? y>,?$..BVBV,VV!)n   %8  9; #\!),: #1>>;;q>00>S1ST!% 0 0")**U"3*<*?*?*F'9'<']]qMq;r$rM>Bnn>Q>Q!!QR%(!WQAqBWCWBW5W-Xfk?R??12q!%:&:%::;(3&(O?9-3Xa[*9';D!Q'X$.229gFG)9)=)=>RTf)g&)9)=)=>RTf)g&2B2F2F57R3/3C2F2F57R3/I**A9I/IqSTuX\XfXfXlXlNlpqNq '') LLNu: #; #|!Q1&;';&;;<,,W5 ( "jj0GOO%aD$B$BBQF$777666$ EMM!Q1a3EMM22$aD$B$BBQF$777666 EDHHOO:::EHHOOE*11E((::5k:ZEE ##%8O&e44K; #; #sH<]1]11];)r r r cuda)NN)NN)r9F)rrNN)NNNNNNNN)rrYi@QNNNN)4__name__ __module__ __qualname____doc__model_cpu_offload_seqrrrr r r r rrFrtupler^ staticmethodrirjr{rrrrrrhrgrrrrrr r Generatorrpropertyr#r&r)rrEXAMPLE_DOC_STRINGfloatboolrrrrrS __classcell__)rSs@r'r2r2sC4M(^1(^'(^9 (^ $ (^ & (^#(^3(^T##C#E#( 1# 1# 1# 13 1 1S 1hmhtht 1 1D/h*.#&'+ B,c49n%B,&B,! B,  $ B,N*.'+ "&c49n%"&&"& $ "&H$0&'#&)-'+ YKc49n%YK #YK! YK & YK  $ YKD $($(#'+/ Yt~%''+)-MQ*._!__" _  _  __ $_&_E%//43H"HIJ_%,,'_ _B$$##U]]_12)-;?#% #/0MQ*.5959>B>B48=A%*  9B #&3p5!p5c49n%p5"%T#Y"78 p5  p5  p5p5!p5p5 (}p5E%//43H"HIJp5%,,'p5%U\\2p5%U\\2p5&.ell%;p5 &.ell%;!p5"$ELL1#p5$%-U\\$:%p5&c]'p5()p5*' (Cd+T124DF\\ ] +p50-1I1p52!3p53p5r)r2):r"typingrrrrrregexr,ritorch.nnrr transformersr r r r callbacksrrimage_processorrloadersrmodelsrmodels.transformersr schedulersrutilsrrrrutils.torch_utilsrrQrpipeline_utilsrpipeline_outputrtorch_xla.core.xla_modelcore xla_modelrGrF get_loggerrWrr r`r(r.r0r2rZr)r'rvs 88 $kkA1//?9 .-.4))MM   H %   H %"J ^5-/G^5r)