
    bi?                        d dl Z d dlmZmZmZmZmZ d dlZd dlm	Z	m
Z
mZmZ ddlmZmZ ddlmZmZ ddlmZ ddlmZ dd	lmZmZmZ dd
lmZ ddlmZ ddlm Z   e       rd dl!m"c m#Z$ dZ%ndZ% ejL                  e'      Z(dZ)d Z*ddZ+	 	 	 	 ddee,   deee-ej\                  f      deee,      deee/      fdZ0 G d de      Z1y)    N)CallableDictListOptionalUnion)	BertModelBertTokenizerQwen2TokenizerQwen2VLForConditionalGeneration   )MultiPipelineCallbacksPipelineCallback)AutoencoderKLMagvitEasyAnimateTransformer3DModel)DiffusionPipeline)FlowMatchEulerDiscreteScheduler)is_torch_xla_availableloggingreplace_example_docstring)randn_tensor)VideoProcessor   )EasyAnimatePipelineOutputTFa  
    Examples:
        ```python
        >>> import torch
        >>> from diffusers import EasyAnimatePipeline
        >>> from diffusers.utils import export_to_video

        >>> # Models: "alibaba-pai/EasyAnimateV5.1-12b-zh"
        >>> pipe = EasyAnimatePipeline.from_pretrained(
        ...     "alibaba-pai/EasyAnimateV5.1-7b-zh-diffusers", torch_dtype=torch.float16
        ... ).to("cuda")
        >>> prompt = (
        ...     "A panda, dressed in a small, red jacket and a tiny hat, sits on a wooden stool in a serene bamboo forest. "
        ...     "The panda's fluffy paws strum a miniature acoustic guitar, producing soft, melodic tunes. Nearby, a few other "
        ...     "pandas gather, watching curiously and some clapping in rhythm. Sunlight filters through the tall bamboo, "
        ...     "casting a gentle glow on the scene. The panda's face is expressive, showing concentration and joy as it plays. "
        ...     "The background includes a small, flowing stream and vibrant green foliage, enhancing the peaceful and magical "
        ...     "atmosphere of this unique musical performance."
        ... )
        >>> sample_size = (512, 512)
        >>> video = pipe(
        ...     prompt=prompt,
        ...     guidance_scale=6,
        ...     negative_prompt="bad detailed",
        ...     height=sample_size[0],
        ...     width=sample_size[1],
        ...     num_inference_steps=50,
        ... ).frames[0]
        >>> export_to_video(video, "output.mp4", fps=8)
        ```
c                 $   |}|}| \  }}||z  }|||z  kD  r|}t        t        ||z  |z              }	n|}	t        t        ||z  |z              }t        t        ||z
  dz              }
t        t        ||	z
  dz              }|
|f|
|z   ||	z   ffS )Ng       @)intround)src	tgt_width
tgt_heighttwthhwrresize_heightresize_widthcrop_top	crop_lefts               o/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/pipelines/easyanimate/pipeline_easyanimate.pyget_resize_crop_region_for_gridr*   Q   s    	B	BDAq	AABG}5a!,-E"q&1*-.5"},345HE2,345Ii 8m#;Y=U"VVV    c                     |j                  t        t        d|j                              d      }| j                  t        t        d| j                              d      }| ||z  z  }||z  d|z
  | z  z   } | S )a  
    Rescales `noise_cfg` tensor based on `guidance_rescale` to improve image quality and fix overexposure. Based on
    Section 3.4 from [Common Diffusion Noise Schedules and Sample Steps are
    Flawed](https://huggingface.co/papers/2305.08891).

    Args:
        noise_cfg (`torch.Tensor`):
            The predicted noise tensor for the guided diffusion process.
        noise_pred_text (`torch.Tensor`):
            The predicted noise tensor for the text-guided diffusion process.
        guidance_rescale (`float`, *optional*, defaults to 0.0):
            A rescale factor applied to the noise predictions.

    Returns:
        noise_cfg (`torch.Tensor`): The rescaled noise prediction tensor.
    r   T)dimkeepdim)stdlistrangendim)	noise_cfgnoise_pred_textguidance_rescalestd_textstd_cfgnoise_pred_rescaleds         r)   rescale_noise_cfgr9   d   s    " ""tE!_5I5I,J'KUY"ZHmmU1inn%= >mMG#x''9: #66!>N:NR[9[[Ir+   num_inference_stepsdevice	timestepssigmasc                    ||t        d      |dt        t        j                  | j                        j
                  j                               v }|st        d| j                   d       | j                  d
||d| | j                  }t        |      }||fS |dt        t        j                  | j                        j
                  j                               v }|st        d| j                   d       | j                  d
||d| | j                  }t        |      }||fS  | j                  |fd	|i| | j                  }||fS )a  
    Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
    custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.

    Args:
        scheduler (`SchedulerMixin`):
            The scheduler to get timesteps from.
        num_inference_steps (`int`):
            The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps`
            must be `None`.
        device (`str` or `torch.device`, *optional*):
            The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
        timesteps (`List[int]`, *optional*):
            Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed,
            `num_inference_steps` and `sigmas` must be `None`.
        sigmas (`List[float]`, *optional*):
            Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed,
            `num_inference_steps` and `timesteps` must be `None`.

    Returns:
        `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
        second element is the number of inference steps.
    zYOnly one of `timesteps` or `sigmas` can be passed. Please choose one to set custom valuesr<   zThe current scheduler class zx's `set_timesteps` does not support custom timestep schedules. Please check whether you are using the correct scheduler.)r<   r;   r=   zv's `set_timesteps` does not support custom sigmas schedules. Please check whether you are using the correct scheduler.)r=   r;   r;    )

ValueErrorsetinspect	signatureset_timesteps
parameterskeys	__class__r<   len)	schedulerr:   r;   r<   r=   kwargsaccepts_timestepsaccept_sigmass           r)   retrieve_timestepsrM      s   > !3tuu'3w/@/@AXAX/Y/d/d/i/i/k+ll .y/B/B.C Da b  	 	M)FMfM''	!)n ))) 
	 C(9(9):Q:Q(R(](](b(b(d$ee.y/B/B.C D_ `  	 	GvfGG''	!)n ))) 	 	 3MFMfM''	)))r+   c            .           e Zd ZdZdZg dZdedeee	f   dee
ef   dedef
 fd	Z	 	 	 	 	 	 	 	 	 	 d6deeee   f   dededeeeee   f      deej*                     deej*                     deej*                     deej*                     deej,                     deej.                     defdZd Z	 	 	 	 	 	 d7dZ	 d8dZed        Zed        Zed        Zed        Z ed         Z! ejD                          e#e$      dd!d"d"d#d$dd
d%dddddddd&ddd'gd%fdeeee   f   d(ee   d)ee   d*ee   d+ee   d,ee%   deeeee   f      dee   d-ee%   d.eeejL                  eejL                     f      d'eej*                     deej*                     d/eee      deej*                     deej*                     deej*                     d0ee   d1ed2eee'eee(gdf   e)e*f      d3ee   d4e%f*d5              Z+ xZ,S )9EasyAnimatePipelinea  
    Pipeline for text-to-video generation using EasyAnimate.

    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
    library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)

    EasyAnimate uses one text encoder [qwen2 vl](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct) in V5.1.

    Args:
        vae ([`AutoencoderKLMagvit`]):
            Variational Auto-Encoder (VAE) Model to encode and decode video to and from latent representations.
        text_encoder (Optional[`~transformers.Qwen2VLForConditionalGeneration`, `~transformers.BertModel`]):
            EasyAnimate uses [qwen2 vl](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct) in V5.1.
        tokenizer (Optional[`~transformers.Qwen2Tokenizer`, `~transformers.BertTokenizer`]):
            A `Qwen2Tokenizer` or `BertTokenizer` to tokenize text.
        transformer ([`EasyAnimateTransformer3DModel`]):
            The EasyAnimate model designed by EasyAnimate Team.
        scheduler ([`FlowMatchEulerDiscreteScheduler`]):
            A scheduler to be used in combination with EasyAnimate to denoise the encoded image latents.
    ztext_encoder->transformer->vae)latentsprompt_embedsnegative_prompt_embedsvaetext_encoder	tokenizertransformerrI   c                    t         |           | j                  |||||       t        | dd        | j                  j
                  j                  nd| _        t        | dd       | j                  j                  nd| _	        t        | dd       | j                  j                  nd| _        t        | j                        | _        y )N)rS   rT   rU   rV   rI   rV   TrS         )vae_scale_factor)super__init__register_modulesgetattrrV   configenable_text_attention_maskrS   spatial_compression_ratiovae_spatial_compression_ratiotemporal_compression_ratiovae_temporal_compression_ratior   video_processor)selfrS   rT   rU   rV   rI   rG   s         r)   r\   zEasyAnimatePipeline.__init__   s     	%# 	 	
 t]D1= ##>> 	' 3:$t2L2XDHH..^_ 	* 4;43M3YDHH//_` 	+  .t?a?abr+   r   TNpromptnum_images_per_promptdo_classifier_free_guidancenegative_promptrQ   rR   prompt_attention_masknegative_prompt_attention_maskr;   dtypemax_sequence_lengthc           	         |
xs | j                   j                  }
|	xs | j                   j                  }	|t        |t              rd}n-|t        |t
              rt        |      }n|j                  d   }|t        |t              rdd|dgdg}n|D cg c]  }dd|dgd }}|D cg c]!  }| j                  j                  |gdd	      # }}| j                  |d
|dddd      }|j                  | j                   j                        }|j                  }|j                  }| j                  r"| j                  ||d      j                  d   }nt        d      |j!                  |d      }|j                  |
|	      }|j                  \  }}}|j!                  d|d      }|j#                  ||z  |d      }|j                  |	      }|r||t        |t              rdd|dgdg}n|D cg c]  }dd|dgd }}|D cg c]!  }| j                  j                  |gdd	      # }}| j                  |d
|dddd      }|j                  | j                   j                        }|j                  }|j                  }| j                  r"| j                  ||d      j                  d   }nt        d      |j!                  |d      }|r]|j                  d   }|j                  |
|	      }|j!                  d|d      }|j#                  ||z  |d      }|j                  |	      }||||fS c c}w c c}w c c}w c c}w )a[  
        Encodes the prompt into text encoder hidden states.

        Args:
            prompt (`str` or `List[str]`, *optional*):
                prompt to be encoded
            device: (`torch.device`):
                torch device
            dtype (`torch.dtype`):
                torch dtype
            num_images_per_prompt (`int`):
                number of images that should be generated per prompt
            do_classifier_free_guidance (`bool`):
                whether to use classifier free guidance or not
            negative_prompt (`str` or `List[str]`, *optional*):
                The prompt or prompts not to guide the image generation. If not defined, one has to pass
                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
                less than `1`).
            prompt_embeds (`torch.Tensor`, *optional*):
                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
                provided, text embeddings will be generated from `prompt` input argument.
            negative_prompt_embeds (`torch.Tensor`, *optional*):
                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
                argument.
            prompt_attention_mask (`torch.Tensor`, *optional*):
                Attention mask for the prompt. Required when `prompt_embeds` is passed directly.
            negative_prompt_attention_mask (`torch.Tensor`, *optional*):
                Attention mask for the negative prompt. Required when `negative_prompt_embeds` is passed directly.
            max_sequence_length (`int`, *optional*): maximum sequence length to use for the prompt.
        r   r   usertext)typerq   )rolecontentFT)tokenizeadd_generation_prompt
max_lengthrightpt)rq   paddingrw   
truncationreturn_attention_maskpadding_sidereturn_tensors)	input_idsattention_maskoutput_hidden_stateszLLM needs attention_mask)rm   r;   r;   )rT   rm   r;   
isinstancestrr0   rH   shaperU   apply_chat_templatetor   r   r`   hidden_statesr@   repeatview)rf   rg   rh   ri   rj   rQ   rR   rk   rl   r;   rm   rn   
batch_sizemessages_promptmrq   text_inputstext_input_idsbs_embedseq_len__negative_prompts                          r)   encode_promptz!EasyAnimatePipeline.encode_prompt   s   Z 0**0034,,33*VS"9JJvt$<VJ&,,Q/J &#& !'-3V$D#E $*
   !'-3W$E#F  nvhi22A3^b2cD  ..$.&*$# ) K &..):):)A)ABK(22N$/$>$>!.. $ 1 1,=Rim !2 !-!$ !!;<<$9$@$@AVXY$Z!%((uV(D,22'1%,,Q0EqI%**86K+KWVXY 5 8 8 8 G '+A+I*z/3/O !'-3_$M#N -<
 ) !'-3=M$N#O  nvhi22A3^b2cD  ..$.&*$# ) K &..):):)A)ABK(22N-8-G-G*..)-):):,#A)- *; *  -	*$& !!;<<-K-R-RShjk-l*&,2215G%;%>%>USY%>%Z"%;%B%B1F[]^%_"%;%@%@NcAcelnp%q"-K-N-NV\-N-]*46KMkkkAXs   L=.&M:M&Mc                 V   dt        t        j                  | j                  j                        j
                  j                               v }i }|r||d<   dt        t        j                  | j                  j                        j
                  j                               v }|r||d<   |S )Neta	generator)rA   rB   rC   rI   steprE   rF   )rf   r   r   accepts_etaextra_step_kwargsaccepts_generators         r)   prepare_extra_step_kwargsz-EasyAnimatePipeline.prepare_extra_step_kwargs  s     s7#4#4T^^5H5H#I#T#T#Y#Y#[\\'*e$ (3w/@/@ATAT/U/`/`/e/e/g+hh-6k*  r+   c
           
          |dz  dk7  s|dz  dk7  rt        d| d| d      |	Lt         fd|	D              s8t        d j                   d|	D 
cg c]  }
|
 j                  vs|
 c}
       ||t        d	| d
| d      ||t        d      |7t        |t              s't        |t
              st        dt        |             ||t        d      ||t        d| d| d      ||t        d      |C|@|j                  |j                  k7  r&t        d|j                   d|j                   d      y y y c c}
w )N   r   z8`height` and `width` have to be divisible by 16 but are z and .c              3   :   K   | ]  }|j                   v   y wN)_callback_tensor_inputs).0krf   s     r)   	<genexpr>z3EasyAnimatePipeline.check_inputs.<locals>.<genexpr>  s#      F
23A---F
s   z2`callback_on_step_end_tensor_inputs` has to be in z, but found zCannot forward both `prompt`: z and `prompt_embeds`: z2. Please make sure to only forward one of the two.zeProvide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined.z2`prompt` has to be of type `str` or `list` but is zEMust provide `prompt_attention_mask` when specifying `prompt_embeds`.z'Cannot forward both `negative_prompt`: z and `negative_prompt_embeds`: zWMust provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.zu`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but got: `prompt_embeds` z != `negative_prompt_embeds` )r@   allr   r   r   r0   rr   r   )rf   rg   heightwidthrj   rQ   rR   rk   rl   "callback_on_step_end_tensor_inputsr   s   `          r)   check_inputsz EasyAnimatePipeline.check_inputs  s!    B;!urzQWX^W__dejdkklmnn-9# F
7YF
 C
 DTEaEaDbbn  |^  pHvw  bc  ko  kG  kG  bGpq  pH  oI  J  -";08N}o ^0 0  ^ 5w  FC)@TZ\`IaQRVW]R^Q_`aa$)>)Fdee&+A+M9/9J K*++]_ 
 "-2P2Xvww$)?)K""&<&B&BB --:-@-@,A B.445Q8  C *L$7 pHs   E
%E
c
                    |	|	j                  ||      S |||dz
  | j                  z  dz   || j                  z  || j                  z  f}
t        |t              r)t        |      |k7  rt        dt        |       d| d      t        |
|||      }	t        | j                  d      r|	| j                  j                  z  }	|	S )N)r;   rm   r   z/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   r;   rm   init_noise_sigma)r   rd   rb   r   r0   rH   r@   r   hasattrrI   r   )rf   r   num_channels_latents
num_framesr   r   rm   r;   r   rP   r   s              r)   prepare_latentsz#EasyAnimatePipeline.prepare_latents  s     ::V5:99  !^ C CCaGd888T777
 i&3y>Z+GA#i.AQ R&<'gi 
 u	&PUV4>>#56 ? ??Gr+   c                     | j                   S r   _guidance_scalerf   s    r)   guidance_scalez"EasyAnimatePipeline.guidance_scale  s    ###r+   c                     | j                   S r   )_guidance_rescaler   s    r)   r5   z$EasyAnimatePipeline.guidance_rescale  s    %%%r+   c                      | j                   dkD  S )Nr   r   r   s    r)   ri   z/EasyAnimatePipeline.do_classifier_free_guidance   s    ##a''r+   c                     | j                   S r   )_num_timestepsr   s    r)   num_timestepsz!EasyAnimatePipeline.num_timesteps  s    """r+   c                     | j                   S r   )
_interruptr   s    r)   	interruptzEasyAnimatePipeline.interrupt  s    r+   1   i   2   g      @        pilrP   r   r   r   r:   r   r   r   r<   output_typereturn_dictcallback_on_step_endr   r5   c                 
   t        |t        t        f      r|j                  }t	        |dz  dz        }t	        |dz  dz        }| j                  |||||||||	       || _        || _        d| _        |t        |t              rd}n-|t        |t              rt        |      }n|j                  d   }| j                  }| j                  | j                  j                  }n| j                   j                  }| j#                  ||||| j$                  |||||
      \  }}}}t        | j&                  t(              rt+        | j&                  |||d      \  }}nt+        | j&                  |||      \  }}| j                   j,                  j.                  }| j1                  ||z  |||||||
|	      }| j3                  |
|	      }| j$                  r.t5        j6                  ||g      }t5        j6                  ||g      }|j9                  |      }|j9                  |      }t        |      || j&                  j:                  z  z
  }t        |      | _        | j?                  |	      5 }tA        |      D ]@  \  }}| jB                  r| j$                  rt5        j6                  |gd
z        n|}tE        | j&                  d      r| j&                  jG                  ||      }t5        jH                  |g|j                  d   z  |      j9                  |j                        } | j!                  || |d      d   }!|!jK                         d   | jL                  j,                  jN                  k7  r|!jQ                  d
d      \  }!}"| j$                  r|!jQ                  d
      \  }#}$|#||$|#z
  z  z   }!| j$                  r|dkD  rtS        |!$|      }! | j&                  jT                  |!||fi |ddid   }|Zi }%|D ]  }&tW               |&   |%|&<     || |||%      }'|'jY                  d|      }|'jY                  d|      }|'jY                  d|      }|t        |      dz
  k(  s'|dz   |kD  r/|dz   | j&                  j:                  z  dk(  r|j[                          t\        s-t_        j`                          C 	 ddd       |dk(  sdd| jL                  j,                  jb                  z  |z  }| jL                  je                  |d      d   }(| jf                  ji                  |(|      }(n|}(| jk                          |s|(fS tm        |(      S # 1 sw Y   xY w)aK  
        Generates images or video using the EasyAnimate pipeline based on the provided prompts.

        Examples:
            prompt (`str` or `List[str]`, *optional*):
                Text prompts to guide the image or video generation. If not provided, use `prompt_embeds` instead.
            num_frames (`int`, *optional*):
                Length of the generated video (in frames).
            height (`int`, *optional*):
                Height of the generated image in pixels.
            width (`int`, *optional*):
                Width of the generated image in pixels.
            num_inference_steps (`int`, *optional*, defaults to 50):
                Number of denoising steps during generation. More steps generally yield higher quality images but slow
                down inference.
            guidance_scale (`float`, *optional*, defaults to 5.0):
                Encourages the model to align outputs with prompts. A higher value may decrease image quality.
            negative_prompt (`str` or `List[str]`, *optional*):
                Prompts indicating what to exclude in generation. If not specified, use `negative_prompt_embeds`.
            num_images_per_prompt (`int`, *optional*, defaults to 1):
                Number of images to generate for each prompt.
            eta (`float`, *optional*, defaults to 0.0):
                Applies to DDIM scheduling. Controlled by the eta parameter from the related literature.
            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
                A generator to ensure reproducibility in image generation.
            latents (`torch.Tensor`, *optional*):
                Predefined latent tensors to condition generation.
            prompt_embeds (`torch.Tensor`, *optional*):
                Text embeddings for the prompts. Overrides prompt string inputs for more flexibility.
            negative_prompt_embeds (`torch.Tensor`, *optional*):
                Embeddings for negative prompts. Overrides string inputs if defined.
            prompt_attention_mask (`torch.Tensor`, *optional*):
                Attention mask for the primary prompt embeddings.
            negative_prompt_attention_mask (`torch.Tensor`, *optional*):
                Attention mask for negative prompt embeddings.
            output_type (`str`, *optional*, defaults to "latent"):
                Format of the generated output, either as a PIL image or as a NumPy array.
            return_dict (`bool`, *optional*, defaults to `True`):
                If `True`, returns a structured output. Otherwise returns a simple tuple.
            callback_on_step_end (`Callable`, *optional*):
                Functions called at the end of each denoising step.
            callback_on_step_end_tensor_inputs (`List[str]`, *optional*):
                Tensor names to be included in callback function calls.
            guidance_rescale (`float`, *optional*, defaults to 0.0):
                Adjusts noise levels based on guidance scale.
            original_size (`Tuple[int, int]`, *optional*, defaults to `(1024, 1024)`):
                Original dimensions of the output.
            target_size (`Tuple[int, int]`, *optional*):
                Desired output dimensions for calculations.
            crops_coords_top_left (`Tuple[int, int]`, *optional*, defaults to `(0, 0)`):
                Coordinates for cropping.

        Returns:
            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
                If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
                otherwise a `tuple` is returned where the first element is a list with the generated images and the
                second element is a list of `bool`s indicating whether the corresponding generated image contains
                "not-safe-for-work" (nsfw) content.
        r   FNr   r   )
rg   r;   rm   rh   ri   rj   rQ   rR   rk   rl   )mur   )total   scale_model_input)rm   )encoder_hidden_statesr   )r-   r   )r5   r   rP   rQ   rR   latent)r   )videor   )frames)7r   r   r   tensor_inputsr   r   r   r   r   r   r0   rH   r   _execution_devicerT   rm   rV   r   ri   rI   r   rM   r_   in_channelsr   r   torchcatr   orderr   progress_bar	enumerater   r   r   tensorsizerS   latent_channelschunkr9   r   localspopupdateXLA_AVAILABLExm	mark_stepscaling_factordecodere   postprocess_videomaybe_free_model_hooksr   ))rf   rg   r   r   r   r:   r   rj   rh   r   r   rP   rQ   r<   rR   rk   rl   r   r   r   r   r5   r   r;   rm   r   r   num_warmup_stepsr   itlatent_model_inputt_expand
noise_predr   noise_pred_uncondr4   callback_kwargsr   callback_outputsr   s)                                            r)   __call__zEasyAnimatePipeline.__call__  s   p *-=?U,VW1E1S1S. flb()Ub[B&' 	"!*.
	
  .!1 *VS"9JJvt$<VJ&,,Q/J''(%%++E$$**E "7(,(H(H+'#9"7+I  
	
"!* dnn&EF-? 3VY1.*I* .@Pcekmv-w*I*  $//66BB&&.. 

 !::9cJ++!II'=}&MNM$)II/MOd.e$f!%(((7 5 8 8 8 G y>,?$..BVBV,VV!)n%89 4	#\!), 3#1>> BFAaAaUYYy1}%=gn"4>>+>?)-)I)IJ\^_)`& !<<.@.F.Fq.I(IRXY\\,22 ] 
 "--&*7 %	 . 
 
 ??$Q'488??+J+JJ$.$4$4QA$4$>MJ 339C9I9I!9L6%!2^YjGj5k!kJ338H38N!2:aq!rJ .$..--j!WmHYmglmnop'3&(O? 9-3Xa[*9';D!Q'X$.229gFG$4$8$8-$XM-=-A-ABZ\r-s*I**A9I/IqSTuX\XfXfXlXlNlpqNq '') LLNg3#4	#l h&$((//8887BGHHOOGO?BE((::T_:`EE 	##%8O(66G4	# 4	#s   *H7U#UU)
r   TNNNNNNN   )NNNNNNr   )-__name__
__module____qualname____doc__model_cpu_offload_seqr   r   r   r   r   r
   r	   r   r   r\   r   r   r   boolr   r   Tensorr;   rm   r   r   r   r   propertyr   r5   ri   r   r   no_gradr   EXAMPLE_DOC_STRINGfloat	Generatorr   r   r   r   r   __classcell__)rG   s   @r)   rO   rO      s   * =Tc c ;YFGc 67	c
 3c 3cB &',0;?049=8<AE)-'+#&`lc49n%`l  #`l &*	`l
 "%T#Y"78`l  -`l !) 6`l  (5`l )1(>`l &`l $`l !`lF!, #"'++/4n nr4 $ $ & & ( ( # #   U]]_12 )-$& #"-/*-;?/0"MQ*.04)-9=8<AE%*  9B"%1t7c49n%t7 SMt7 	t7
 }t7 &c]t7 !t7 "%T#Y"78t7  (}t7 e_t7 E%//43H"HIJt7 %,,'t7  -t7 DI&t7 !) 6t7   (5!t7" )1(>#t7$ c]%t7& 't7( '(Cd+T124DF\\]
)t7. -1I/t70  1t7 3 t7r+   rO   )r   )NNNN)2rB   typingr   r   r   r   r   r   transformersr   r	   r
   r   	callbacksr   r   modelsr   r   pipelines.pipeline_utilsr   
schedulersr   utilsr   r   r   utils.torch_utilsr   re   r   pipeline_outputr   torch_xla.core.xla_modelcore	xla_modelr   r   
get_loggerr   loggerr   r*   r9   r   r   r;   r   rM   rO   r?   r+   r)   <module>r     s      8 8   B H 9 9 O O - - 6 ))MM 
		H	% DW&: *.15%)$(8*!#8* U3,-.8* S	"	8*
 T%[!8*vH	7+ H	7r+   