
'''simple docstring'''
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  __A				( UpperCAmelCase_    ,						unittest.TestCase			):
 lowerCamelCase				       =TextToVideoSDPipeline
 lowerCamelCase				       =TEXT_TO_IMAGE_PARAMS
 lowerCamelCase				       =TEXT_TO_IMAGE_BATCH_PARAMS
 # No `output_type`.
 lowerCamelCase				       =frozenset(
     [
         '''num_inference_steps''',
         '''generator''',
         '''latents''',
         '''return_dict''',
         '''callback''',
         '''callback_steps''',
     ]			)
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   torch.manual_seed(0       )
   __A		:     List[Any]												=		UNetaDConditionModel(
       block_out_channels=(32, 64, 64, 64)				,   layers_per_block=2				,   sample_size=32				,   in_channels=4				,   out_channels=4				,   down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D""")				,   up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""")				,   cross_attention_dim=32				,   attention_head_dim=4				,   )
   __A		:     Union[str, Any]												=		DDIMScheduler(
       beta_start=0.00_085				,   beta_end=0.012				,   beta_schedule="""scaled_linear"""				,   clip_sample=_lowercase				,   set_alpha_to_one=_lowercase				,   )
   torch.manual_seed(0       )
   __A		:     List[str]												=		AutoencoderKL(
       block_out_channels=[32, 64]				,   in_channels=3				,   out_channels=3				,   down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]				,   up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]				,   latent_channels=4				,   sample_size=1_28				,   )
   torch.manual_seed(0       )
   __A		:     Dict												=		CLIPTextConfig(
       bos_token_id=0				,   eos_token_id=2				,   hidden_size=32				,   intermediate_size=37				,   layer_norm_eps=1e-0_5				,   num_attention_heads=4				,   num_hidden_layers=5				,   pad_token_id=1				,   vocab_size=10_00				,   hidden_act="""gelu"""				,   projection_dim=5_12				,   )
   __A		:     Dict												=		CLIPTextModel(_lowercase       )
   __A		:     str												=		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

   __A		:     Optional[Any]												=		{
       'unet': unet,
       'scheduler': scheduler,
       'vae': vae,
       'text_encoder': text_encoder,
       'tokenizer': tokenizer,
   }
   return components
 def 		lowercase_(   self			:    List[Any]				,   lowerCamelCase			:    Optional[Any]				,   lowerCamelCase			:    Optional[Any]=0       ):



   """simple docstring"""





   if str(_lowercase       ).startswith("""mps"""       ):
     __A		:     Tuple												=		torch.manual_seed(_lowercase       )
   else:
     __A		:     List[str]												=		torch.Generator(device=_lowercase       ).manual_seed(_lowercase       )
   __A		:     Union[str, Any]												=		{
       '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 		lowercase_(   self			:    List[Any]       ):



   """simple docstring"""





   __A		:     Dict												=		'cpu'  # ensure determinism for the device-dependent torch.Generator
   __A		:     List[str]												=		self.get_dummy_components()
   __A		:     int												=		TextToVideoSDPipeline(**_lowercase       )
   __A		:     Dict												=		sd_pipe.to(_lowercase       )
   sd_pipe.set_progress_bar_config(disable=_lowercase       )

   __A		:     Optional[Any]												=		self.get_dummy_inputs(_lowercase       )
   __A		:     Any												=		'np'
   __A		:     Union[str, Any]												=		sd_pipe(**_lowercase       ).frames
   __A		:     int												=		frames[0][-3:, -3:, -1]

   assert frames[0].shape == (64, 64, 3)
   __A		:     List[str]												=		np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0]       )

   assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_lowercase				,   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 		lowercase_(   self			:    Optional[Any]       ):



   """simple docstring"""





   self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_lowercase				,   expected_max_diff=1e-2       )
 @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""       )
 def 		lowercase_(   self			:    Optional[int]       ):



   """simple docstring"""





   pass
 @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""       )
 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   pass
 @unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""       )
 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   pass






 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   return super().test_progress_bar()







@slow
@skip_mps
class  __A				( unittest.TestCase			):
 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





   __A		:     str												=		load_numpy(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"""       )

   __A		:     List[str]												=		TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""       )
   __A		:     Any												=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
   __A		:     int												=		pipe.to("""cuda"""       )

   __A		:     int												=		'Spiderman is surfing'
   __A		:     Tuple												=		torch.Generator(device="""cpu"""       ).manual_seed(0       )

   __A		:     int												=		pipe(_lowercase				,   generator=_lowercase				,   num_inference_steps=25				,   output_type="""pt"""       ).frames
   __A		:     Tuple												=		video_frames.cpu().numpy()

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






 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   __A		:     List[Any]												=		load_numpy(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"""       )

   __A		:     Union[str, Any]												=		TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""       )
   __A		:     List[str]												=		pipe.to("""cuda"""       )

   __A		:     str												=		'Spiderman is surfing'
   __A		:     Any												=		torch.Generator(device="""cpu"""       ).manual_seed(0       )

   __A		:     List[str]												=		pipe(_lowercase				,   generator=_lowercase				,   num_inference_steps=2				,   output_type="""pt"""       ).frames
   __A		:     Any												=		video_frames.cpu().numpy()

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





'''simple docstring'''
import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[Any]			,     __SCREAMING_SNAKE_CASE						:  List[str]			,     __SCREAMING_SNAKE_CASE						:  Optional[Any] )				->       List[Any]:





  """simple docstring"""

  __A		:     Optional[int]												=		RemBertConfig.from_json_file(__SCREAMING_SNAKE_CASE )
  print("""Building PyTorch model from configuration: {}""".format(str(__SCREAMING_SNAKE_CASE ) ) )
  __A		:     str												=		RemBertModel(__SCREAMING_SNAKE_CASE )

  # Load weights from tf checkpoint
  load_tf_weights_in_rembert(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  # Save pytorch-model
  print("""Save PyTorch model to {}""".format(__SCREAMING_SNAKE_CASE ) )
  torch.save(model.state_dict()			,     __SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
     A__   :		Optional[Any] 		=argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
     )
     parser.add_argument(
         '--rembert_config_file',
         default=None,
         type=str,
         required=True,
         help=(
             'The config json file corresponding to the pre-trained RemBERT model. \n'
             'This specifies the model architecture.'
         ),
     )
     parser.add_argument(
         '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
     )
     A__   :		Dict 		=parser.parse_args()
     convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)



