


import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
@skip_mps
class  SCREAMING_SNAKE_CASE__  (				lowercase__						,    unittest.TestCase			):
      snake_case__				:     Optional[Any]        =						TextToVideoSDPipeline
      snake_case__				:     Optional[int]        =						TEXT_TO_IMAGE_PARAMS
      snake_case__				:     str        =						TEXT_TO_IMAGE_BATCH_PARAMS
      # No `output_type`.
      snake_case__				:     Optional[Any]        =						frozenset(
          [
              '''num_inference_steps''',
              '''generator''',
              '''latents''',
              '''return_dict''',
              '''callback''',
              '''callback_steps''',
          ]			)
      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			Union[str, Any]:
             torch.manual_seed(0     )
             a_					:		Optional[int]							=  UNetaDConditionModel(
                 block_out_channels=(3_2, 6_4, 6_4, 6_4)     ,							layers_per_block=2     ,							sample_size=3_2     ,							in_channels=4     ,							out_channels=4     ,							down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D')     ,							up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D')     ,							cross_attention_dim=3_2     ,							attention_head_dim=4     ,							)
             a_					:		int							=  DDIMScheduler(
                 beta_start=0.00085     ,							beta_end=0.012     ,							beta_schedule='scaled_linear'     ,							clip_sample=SCREAMING_SNAKE_CASE__     ,							set_alpha_to_one=SCREAMING_SNAKE_CASE__     ,							)
             torch.manual_seed(0     )
             a_					:		int							=  AutoencoderKL(
                 block_out_channels=[3_2, 6_4]     ,							in_channels=3     ,							out_channels=3     ,							down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']     ,							up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']     ,							latent_channels=4     ,							sample_size=1_2_8     ,							)
             torch.manual_seed(0     )
             a_					:		Optional[int]							=  CLIPTextConfig(
                 bos_token_id=0     ,							eos_token_id=2     ,							hidden_size=3_2     ,							intermediate_size=3_7     ,							layer_norm_eps=1E-05     ,							num_attention_heads=4     ,							num_hidden_layers=5     ,							pad_token_id=1     ,							vocab_size=1_0_0_0     ,							hidden_act='gelu'     ,							projection_dim=5_1_2     ,							)
             a_					:		Dict							=  CLIPTextModel(SCREAMING_SNAKE_CASE__     )
             a_					:		Union[str, Any]							=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

             a_					:		Union[str, Any]							=  {
                 'unet': unet,
                 'scheduler': scheduler,
                 'vae': vae,
                 'text_encoder': text_encoder,
                 'tokenizer': tokenizer,
             }
             return components
      def        SCREAMING_SNAKE_CASE							(       self				:       List[Any]     ,							SCREAMING_SNAKE_CASE__				:       str     ,							SCREAMING_SNAKE_CASE__				:       List[Any]=0     )		->			List[str]:
             if str(SCREAMING_SNAKE_CASE__     ).startswith('mps'     ):
                    a_					:		Dict							=  torch.manual_seed(SCREAMING_SNAKE_CASE__     )
             else:
                    a_					:		Optional[Any]							=  torch.Generator(device=SCREAMING_SNAKE_CASE__     ).manual_seed(SCREAMING_SNAKE_CASE__     )
             a_					:		int							=  {
                 'prompt': 'A painting of a squirrel eating a burger',
                 'generator': generator,
                 'num_inference_steps': 2,
                 'guidance_scale': 6.0,
                 'output_type': 'pt',
             }
             return inputs
      def        SCREAMING_SNAKE_CASE							(       self				:       Union[str, Any]     )		->			Tuple:
             a_					:		List[Any]							=  'cpu'  # ensure determinism for the device-dependent torch.Generator
             a_					:		Dict							=  self.get_dummy_components()
             a_					:		str							=  TextToVideoSDPipeline(**SCREAMING_SNAKE_CASE__     )
             a_					:		Union[str, Any]							=  sd_pipe.to(SCREAMING_SNAKE_CASE__     )
             sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__     )

             a_					:		Tuple							=  self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     )
             a_					:		Dict							=  'np'
             a_					:		Dict							=  sd_pipe(**SCREAMING_SNAKE_CASE__     ).frames
             a_					:		int							=  frames[0][-3:, -3:, -1]

             assert frames[0].shape == (6_4, 6_4, 3)
             a_					:		Union[str, Any]							=  np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]     )

             assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2
      def        SCREAMING_SNAKE_CASE							(       self				:       Any     )		->			List[Any]:
             self._test_attention_slicing_forward_pass(test_mean_pixel_difference=SCREAMING_SNAKE_CASE__     ,							expected_max_diff=3E-3     )
      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()     ,							reason='XFormers attention is only available with CUDA and `xformers` installed'     ,							)
      def        SCREAMING_SNAKE_CASE							(       self				:       Any     )		->			str:
             self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=SCREAMING_SNAKE_CASE__     ,							expected_max_diff=1E-2     )
      @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			Union[str, Any]:
             pass
      @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'     )
      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			List[str]:
             pass
      @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'     )
      def        SCREAMING_SNAKE_CASE							(       self				:       int     )		->			List[Any]:
             pass

      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     )		->			Union[str, Any]:
             return super().test_progress_bar()
@slow
@skip_mps
class  SCREAMING_SNAKE_CASE__  (				unittest.TestCase			):
      def        SCREAMING_SNAKE_CASE							(       self				:       Optional[Any]     )		->			List[Any]:
             a_					:		str							=  load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'     )

             a_					:		Any							=  TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'     )
             a_					:		Optional[Any]							=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
             a_					:		Optional[Any]							=  pipe.to('cuda'     )

             a_					:		Any							=  'Spiderman is surfing'
             a_					:		List[Any]							=  torch.Generator(device='cpu'     ).manual_seed(0     )

             a_					:		Optional[Any]							=  pipe(SCREAMING_SNAKE_CASE__     ,							generator=SCREAMING_SNAKE_CASE__     ,							num_inference_steps=2_5     ,							output_type='pt'     ).frames
             a_					:		str							=  video_frames.cpu().numpy()

             assert np.abs(expected_video - video     ).mean() < 5E-2

      def        SCREAMING_SNAKE_CASE							(       self				:       Any     )		->			Any:
             a_					:		Dict							=  load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'     )

             a_					:		Tuple							=  TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'     )
             a_					:		Tuple							=  pipe.to('cuda'     )

             a_					:		Any							=  'Spiderman is surfing'
             a_					:		List[str]							=  torch.Generator(device='cpu'     ).manual_seed(0     )

             a_					:		List[Any]							=  pipe(SCREAMING_SNAKE_CASE__     ,							generator=SCREAMING_SNAKE_CASE__     ,							num_inference_steps=2     ,							output_type='pt'     ).frames
             a_					:		List[str]							=  video_frames.cpu().numpy()

             assert np.abs(expected_video - video     ).mean() < 5E-2






import argparse
import collections

import torch
from flax import traverse_util
from tax import checkpoints

from transformers import TaConfig, TaEncoderModel, TaForConditionalGeneration
from transformers.utils import logging


logging.set_verbosity_info()
def 				__lowerCamelCase						( UpperCAmelCase_						:		Union[str, Any] ,  UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		Optional[Any] ,  UpperCAmelCase_						:		Union[str, Any]="attention"						):




      """simple docstring"""





      a						:Optional[int] 							=       params[F'''{prefix}/layers_{i}/{layer_name}/key/kernel''']
      a						:Optional[Any] 							=       params[F'''{prefix}/layers_{i}/{layer_name}/out/kernel''']
      a						:int 							=       params[F'''{prefix}/layers_{i}/{layer_name}/query/kernel''']
      a						:Optional[Any] 							=       params[F'''{prefix}/layers_{i}/{layer_name}/value/kernel''']
      return k, o, q, v
def 				__lowerCamelCase						( UpperCAmelCase_						:		Optional[int] ,  UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		List[str] ,  UpperCAmelCase_						:		int=False						):




      """simple docstring"""





      if split_mlp_wi:
            a						:int 							=       params[F'''{prefix}/layers_{i}/mlp/wi_0/kernel''']
            a						:Optional[Any] 							=       params[F'''{prefix}/layers_{i}/mlp/wi_1/kernel''']
            a						:Dict 							=       (wi_a, wi_a)
      else:
            a						:Optional[Any] 							=       params[F'''{prefix}/layers_{i}/mlp/wi/kernel''']

      a						:Dict 							=       params[F'''{prefix}/layers_{i}/mlp/wo/kernel''']
      return wi, wo
def 				__lowerCamelCase						( UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		List[str] ,  UpperCAmelCase_						:		Optional[int]						):




      """simple docstring"""





      return params[F'''{prefix}/layers_{i}/{layer_name}/scale''']
def 				__lowerCamelCase						( UpperCAmelCase_						:		dict ,  *, UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		bool						):




      """simple docstring"""





      a						:str 							=       traverse_util.flatten_dict(variables['''target''']						)
      a						:Any 							=       {'''/'''.join(UpperCAmelCase_						): v for k, v in old.items()}

      # v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
      a						:Any 							=       '''encoder/layers_0/mlp/wi_0/kernel''' in old
      print('''Split MLP:''' ,  UpperCAmelCase_						)

      a						:Optional[Any] 							=       collections.OrderedDict()

      # Shared embeddings.
      a						:Union[str, Any] 							=       old['''token_embedder/embedding''']

      # Encoder.
      for i in range(UpperCAmelCase_						):
            # Block i, layer 0 (Self Attention).
            a						:Optional[Any] 							=       tax_layer_norm_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''encoder''' ,  '''pre_attention_layer_norm'''						)
            a							,				a							,				a							,				a						:Optional[int] 							=       tax_attention_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''encoder''' ,  '''attention'''						)
            a						:List[Any] 							=       layer_norm
            a						:str 							=       k.T
            a						:Dict 							=       o.T
            a						:int 							=       q.T
            a						:Optional[Any] 							=       v.T

            # Block i, layer 1 (MLP).
            a						:Tuple 							=       tax_layer_norm_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''encoder''' ,  '''pre_mlp_layer_norm'''						)
            a							,				a						:List[Any] 							=       tax_mlp_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''encoder''' ,  UpperCAmelCase_						)
            a						:Any 							=       layer_norm
            if split_mlp_wi:
                  a						:Any 							=       wi[0].T
                  a						:Tuple 							=       wi[1].T
            else:
                  a						:List[str] 							=       wi.T
            a						:List[Any] 							=       wo.T

      a						:Union[str, Any] 							=       old[
          '''encoder/relpos_bias/rel_embedding'''
      ].T
      a						:Optional[Any] 							=       old['''encoder/encoder_norm/scale''']

      if not is_encoder_only:
            # Decoder.
            for i in range(UpperCAmelCase_						):
                  # Block i, layer 0 (Self Attention).
                  a						:List[str] 							=       tax_layer_norm_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  '''pre_self_attention_layer_norm'''						)
                  a							,				a							,				a							,				a						:List[Any] 							=       tax_attention_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  '''self_attention'''						)
                  a						:List[Any] 							=       layer_norm
                  a						:Tuple 							=       k.T
                  a						:int 							=       o.T
                  a						:Any 							=       q.T
                  a						:Optional[int] 							=       v.T

                  # Block i, layer 1 (Cross Attention).
                  a						:str 							=       tax_layer_norm_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  '''pre_cross_attention_layer_norm'''						)
                  a							,				a							,				a							,				a						:Any 							=       tax_attention_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  '''encoder_decoder_attention'''						)
                  a						:str 							=       layer_norm
                  a						:Optional[Any] 							=       k.T
                  a						:Any 							=       o.T
                  a						:Dict 							=       q.T
                  a						:Optional[Any] 							=       v.T

                  # Block i, layer 2 (MLP).
                  a						:Optional[int] 							=       tax_layer_norm_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  '''pre_mlp_layer_norm'''						)
                  a							,				a						:List[Any] 							=       tax_mlp_lookup(UpperCAmelCase_ ,  UpperCAmelCase_ ,  '''decoder''' ,  UpperCAmelCase_						)
                  a						:Optional[int] 							=       layer_norm
                  if split_mlp_wi:
                        a						:int 							=       wi[0].T
                        a						:Tuple 							=       wi[1].T
                  else:
                        a						:str 							=       wi.T
                  a						:Dict 							=       wo.T

            a						:Any 							=       old['''decoder/decoder_norm/scale''']
            a						:Optional[Any] 							=       old[
                '''decoder/relpos_bias/rel_embedding'''
            ].T

            # LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
            if "decoder/logits_dense/kernel" in old:
                  a						:Union[str, Any] 							=       old['''decoder/logits_dense/kernel'''].T

      return new
def 				__lowerCamelCase						( UpperCAmelCase_						:		Any ,  UpperCAmelCase_						:		bool						):




      """simple docstring"""





      a						:List[Any] 							=       collections.OrderedDict([(k, torch.from_numpy(v.copy()						)) for (k, v) in converted_params.items()]						)

      # Add what is missing.
      if "encoder.embed_tokens.weight" not in state_dict:
            a						:Optional[Any] 							=       state_dict['''shared.weight''']

      if not is_encoder_only:
            if "decoder.embed_tokens.weight" not in state_dict:
                  a						:Tuple 							=       state_dict['''shared.weight''']

            if "lm_head.weight" not in state_dict:  # For old 1.0 models.
                  print('''Using shared word embeddings as lm_head.'''						)
                  a						:Optional[Any] 							=       state_dict['''shared.weight''']

      return state_dict
def 				__lowerCamelCase						( UpperCAmelCase_						:		Any ,  UpperCAmelCase_						:		Union[str, Any] ,  UpperCAmelCase_						:		Optional[int] ,  UpperCAmelCase_						:		Optional[int]						):




      """simple docstring"""





      a						:Tuple 							=       checkpoints.load_tax_checkpoint(UpperCAmelCase_						)
      a						:Optional[int] 							=       convert_tax_to_pytorch(UpperCAmelCase_ ,  num_layers=config.num_layers ,  is_encoder_only=UpperCAmelCase_						)
      a						:Tuple 							=       make_state_dict(UpperCAmelCase_ ,  UpperCAmelCase_						)
      model.load_state_dict(UpperCAmelCase_ ,  strict=UpperCAmelCase_						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		Optional[Any] ,  UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		bool = False						):




      """simple docstring"""





      a						:List[Any] 							=       TaConfig.from_json_file(UpperCAmelCase_						)
      print(F'''Building PyTorch model from configuration: {config}'''						)
      # Non-v1.1 checkpoints could also use T5Model, but this works for all.
      # The v1.0 checkpoints will simply have an LM head that is the word embeddings.
      if is_encoder_only:
            a						:Any 							=       TaEncoderModel(UpperCAmelCase_						)
      else:
            a						:List[str] 							=       TaForConditionalGeneration(UpperCAmelCase_						)

      # Load weights from tf checkpoint
      load_tax_weights_in_ta(UpperCAmelCase_ ,  UpperCAmelCase_ ,  UpperCAmelCase_ ,  UpperCAmelCase_						)

      # Save pytorch-model
      print(F'''Save PyTorch model to {pytorch_dump_path}'''						)
      model.save_pretrained(UpperCAmelCase_						)

      # Verify that we can load the checkpoint.
      model.from_pretrained(UpperCAmelCase_						)
      print('''Done'''						)


if __name__ == "__main__":
     snake_case				:    Any       				=     argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
     # Required parameters
     parser.add_argument(
         '''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
     )
     parser.add_argument(
         '''--config_file''',
         default=None,
         type=str,
         required=True,
         help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
     )
     parser.add_argument(
         '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
     )
     parser.add_argument(
         '''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
     )
     snake_case				:    Optional[Any]       				=     parser.parse_args()
     convert_tax_checkpoint_to_pytorch(
         args.tax_checkpoint_path, args.config_file, args.pytorch_dump_path, args.is_encoder_only
     )





