





import unittest

import numpy as np

from transformers import RoFormerConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
 import jax.numpy as jnp

 from transformers.models.roformer.modeling_flax_roformer import (
     FlaxRoFormerForMaskedLM,
     FlaxRoFormerForMultipleChoice,
     FlaxRoFormerForQuestionAnswering,
     FlaxRoFormerForSequenceClassification,
     FlaxRoFormerForTokenClassification,
     FlaxRoFormerModel,
 )


class     __magic_name__     (							unittest.TestCase							):





     """simple docstring"""



     def __init__(							self				:Optional[int]	,					snake_case				:Any	,					snake_case				:Any=13	,					snake_case				:int=7	,					snake_case				:List[str]=True	,					snake_case				:Optional[Any]=True	,					snake_case				:Optional[int]=True	,					snake_case				:List[str]=True	,					snake_case				:Dict=99	,					snake_case				:Union[str, Any]=32	,					snake_case				:str=5	,					snake_case				:Any=4	,					snake_case				:Optional[int]=37	,					snake_case				:Tuple="gelu"	,					snake_case				:List[str]=0.1	,					snake_case				:Optional[Any]=0.1	,					snake_case				:str=512	,					snake_case				:Tuple=16	,					snake_case				:Optional[Any]=2	,					snake_case				:Any=0.02	,					snake_case				:List[Any]=4	,					):





        '''simple docstring'''




        A_    : Optional[Any]								=	parent
        A_    : Union[str, Any]								=	batch_size
        A_    : List[Any]								=	seq_length
        A_    : List[str]								=	is_training
        A_    : Tuple								=	use_attention_mask
        A_    : Any								=	use_token_type_ids
        A_    : List[Any]								=	use_labels
        A_    : str								=	vocab_size
        A_    : int								=	hidden_size
        A_    : Tuple								=	num_hidden_layers
        A_    : List[Any]								=	num_attention_heads
        A_    : Dict								=	intermediate_size
        A_    : Optional[int]								=	hidden_act
        A_    : List[Any]								=	hidden_dropout_prob
        A_    : Optional[int]								=	attention_probs_dropout_prob
        A_    : Optional[int]								=	max_position_embeddings
        A_    : Optional[int]								=	type_vocab_size
        A_    : Any								=	type_sequence_label_size
        A_    : str								=	initializer_range
        A_    : List[str]								=	num_choices



     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        A_    : Union[str, Any]								=	ids_tensor([self.batch_size, self.seq_length]	,					self.vocab_size     )

        A_    : Optional[Any]								=	None
        if self.use_attention_mask:
           A_    : Any								=	random_attention_mask([self.batch_size, self.seq_length]     )

        A_    : int								=	None
        if self.use_token_type_ids:
           A_    : Tuple								=	ids_tensor([self.batch_size, self.seq_length]	,					self.type_vocab_size     )

        A_    : Union[str, Any]								=	RoFormerConfig(
            vocab_size=self.vocab_size	,					hidden_size=self.hidden_size	,					num_hidden_layers=self.num_hidden_layers	,					num_attention_heads=self.num_attention_heads	,					intermediate_size=self.intermediate_size	,					hidden_act=self.hidden_act	,					hidden_dropout_prob=self.hidden_dropout_prob	,					attention_probs_dropout_prob=self.attention_probs_dropout_prob	,					max_position_embeddings=self.max_position_embeddings	,					type_vocab_size=self.type_vocab_size	,					is_decoder=snake_case	,					initializer_range=self.initializer_range	,					)

        return config, input_ids, token_type_ids, attention_mask





     def   SCREAMING_SNAKE_CASE						(							self				:Any     ):





        '''simple docstring'''




        A_    : Optional[int]								=	self.prepare_config_and_inputs()
        A_					,  A_					,  A_					,  A_    : str								=	config_and_inputs
        A_    : Optional[int]								=	{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
        return config, inputs_dict




@require_flax
class     __magic_name__     (							A__			, unittest.TestCase							):





     """simple docstring"""



     __UpperCamelCase    			=   True

     __UpperCamelCase    			=   (
         (
             FlaxRoFormerModel,
             FlaxRoFormerForMaskedLM,
             FlaxRoFormerForSequenceClassification,
             FlaxRoFormerForTokenClassification,
             FlaxRoFormerForMultipleChoice,
             FlaxRoFormerForQuestionAnswering,
         )
         if is_flax_available()
         else ()
     )



     def   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        A_    : Optional[int]								=	FlaxRoFormerModelTester(self     )





     @slow
     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        for model_class_name in self.all_model_classes:
           A_    : List[str]								=	model_class_name.from_pretrained("junnyu/roformer_chinese_small"	,					from_pt=snake_case     )
           A_    : List[Any]								=	model(np.ones((1, 1)     )     )
           self.assertIsNotNone(snake_case     )




@require_flax
class     __magic_name__     (							unittest.TestCase							):





     """simple docstring"""



     @slow
     def   SCREAMING_SNAKE_CASE						(							self				:List[Any]     ):





        '''simple docstring'''




        A_    : Any								=	FlaxRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base"     )
        A_    : Dict								=	jnp.array([[0, 1, 2, 3, 4, 5]]     )
        A_    : List[str]								=	model(snake_case     )[0]

        A_    : Optional[int]								=	50_000

        A_    : Union[str, Any]								=	(1, 6, vocab_size)
        self.assertEqual(output.shape	,					snake_case     )

        A_    : int								=	jnp.array(
            [[[-0.1205, -1.0265, 0.2922], [-1.5134, 0.1974, 0.1519], [-5.0135, -3.9003, -0.8404]]]     )

        self.assertTrue(jnp.allclose(output[:, :3, :3]	,					snake_case	,					atol=1e-4     )     )








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       _UpperCAmelCase					(       A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       TextToVideoSDPipeline
				lowercase__											=       TEXT_TO_IMAGE_PARAMS
				lowercase__											=       TEXT_TO_IMAGE_BATCH_PARAMS
				# No `output_type`.
				lowercase__											=       frozenset(
				    [
				        """num_inference_steps""",
				        """generator""",
				        """latents""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ]	)




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								torch.manual_seed(0  )
								lowercase__    =			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,  )
								lowercase__    =			DDIMScheduler(
								    beta_start=0.00085,  beta_end=0.012,  beta_schedule='''scaled_linear''',  clip_sample=lowerCamelCase,  set_alpha_to_one=lowerCamelCase,  )
								torch.manual_seed(0  )
								lowercase__    =			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=128,  )
								torch.manual_seed(0  )
								lowercase__    =			CLIPTextConfig(
								    bos_token_id=0,  eos_token_id=2,  hidden_size=32,  intermediate_size=37,  layer_norm_eps=1E-05,  num_attention_heads=4,  num_hidden_layers=5,  pad_token_id=1,  vocab_size=1_000,  hidden_act='''gelu''',  projection_dim=512,  )
								lowercase__    =			CLIPTextModel(lowerCamelCase  )
								lowercase__    =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

								lowercase__    =			{
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								}
								return components




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    int=0  ):

								'''simple docstring'''
								if str(lowerCamelCase  ).startswith('''mps'''  ):
												lowercase__    =			torch.manual_seed(lowerCamelCase  )
								else:
												lowercase__    =			torch.Generator(device=lowerCamelCase  ).manual_seed(lowerCamelCase  )
								lowercase__    =			{
								    '''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						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
								lowercase__    =			self.get_dummy_components()
								lowercase__    =			TextToVideoSDPipeline(**lowerCamelCase  )
								lowercase__    =			sd_pipe.to(lowerCamelCase  )
								sd_pipe.set_progress_bar_config(disable=lowerCamelCase  )

								lowercase__    =			self.get_dummy_inputs(lowerCamelCase  )
								lowercase__    =			'''np'''
								lowercase__    =			sd_pipe(**lowerCamelCase  ).frames
								lowercase__    =			frames[0][-3:, -3:, -1]

								assert frames[0].shape == (64, 64, 3)
								lowercase__    =			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 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase,  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[int]  ):

								'''simple docstring'''
								self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase,  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						:    Optional[Any]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''  )
				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								return super().test_progress_bar()



@slow
@skip_mps
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''  )

								lowercase__    =			TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''  )
								lowercase__    =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
								lowercase__    =			pipe.to('''cuda'''  )

								lowercase__    =			'''Spiderman is surfing'''
								lowercase__    =			torch.Generator(device='''cpu'''  ).manual_seed(0  )

								lowercase__    =			pipe(lowerCamelCase,  generator=lowerCamelCase,  num_inference_steps=25,  output_type='''pt'''  ).frames
								lowercase__    =			video_frames.cpu().numpy()

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




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''  )

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

								lowercase__    =			'''Spiderman is surfing'''
								lowercase__    =			torch.Generator(device='''cpu'''  ).manual_seed(0  )

								lowercase__    =			pipe(lowerCamelCase,  generator=lowerCamelCase,  num_inference_steps=2,  output_type='''pt'''  ).frames
								lowercase__    =			video_frames.cpu().numpy()

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




