

import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







@skip_mps
class 			lowercase    (	lowercase_     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      VideoToVideoSDPipeline
				__SCREAMING_SNAKE_CASE :			str	      =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}      ) - {'''image''', '''width''', '''height'''}
				__SCREAMING_SNAKE_CASE :			Tuple	      =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}      ) - {'''image'''}
				__SCREAMING_SNAKE_CASE :			str	      =      PipelineTesterMixin.required_optional_params - {'''latents'''}
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      False

				# No `output_type`.
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      frozenset(
				    [
				        '''num_inference_steps''',
				        '''generator''',
				        '''latents''',
				        '''return_dict''',
				        '''callback''',
				        '''callback_steps''',
				    ]      )




				def    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   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				,       )
											snake_case_          =   DDIMScheduler(
											    beta_start=0.0_00_85				,       beta_end=0.0_12				,       beta_schedule='scaled_linear'				,       clip_sample=snake_case				,       set_alpha_to_one=snake_case				,       )
											torch.manual_seed(0	)
											snake_case_          =   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	)
											snake_case_          =   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=1000				,       hidden_act='gelu'				,       projection_dim=512				,       )
											snake_case_          =   CLIPTextModel(snake_case	)
											snake_case_          =   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

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




				def    a							( self				,       snake_case				,       snake_case=0	):
											# 3 frames
											snake_case_          =   floats_tensor((1, 3, 3, 32, 32)				,       rng=random.Random(snake_case	)	).to(snake_case	)

											if str(snake_case	).startswith('mps'	):
																		snake_case_          =   torch.manual_seed(snake_case	)
											else:
																		snake_case_          =   torch.Generator(device=snake_case	).manual_seed(snake_case	)
											snake_case_          =   {
											    'prompt': 'A painting of a squirrel eating a burger',
											    'video': video,
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											    'output_type': 'pt',
											}
											return inputs




				def    a							( self	):
											snake_case_          =   'cpu'  # ensure determinism for the device-dependent torch.Generator
											snake_case_          =   self.get_dummy_components()
											snake_case_          =   VideoToVideoSDPipeline(**snake_case	)
											snake_case_          =   sd_pipe.to(snake_case	)
											sd_pipe.set_progress_bar_config(disable=snake_case	)

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

											assert frames[0].shape == (32, 32, 3)
											snake_case_          =   np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]	)

											assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2




				@unittest.skipIf(
				    torch_device != 'cuda' or not is_xformers_available()				,       reason='XFormers attention is only available with CUDA and `xformers` installed'				,       )
				def    a							( self	):
											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case				,       expected_max_diff=5e-3	)




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




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




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




				def    a							( self	):
											return super().test_progress_bar()







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




				def    a							( self	):
											snake_case_          =   VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'				,       torch_dtype=torch.floataa	)
											pipe.enable_model_cpu_offload()

											# 10 frames
											snake_case_          =   torch.Generator(device='cpu'	).manual_seed(0	)
											snake_case_          =   torch.randn((1, 10, 3, 1024, 576)				,       generator=snake_case	)
											snake_case_          =   video.to('cuda'	)

											snake_case_          =   'Spiderman is surfing'

											snake_case_          =   pipe(snake_case				,       video=snake_case				,       generator=snake_case				,       num_inference_steps=3				,       output_type='pt'	).frames

											snake_case_          =   np.array([-1.0_45_89_84, -1.1_27_92_97, -0.9_66_30_86, -0.91_50_39_06, -0.75_09_76_56]	)
											assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array	).sum() < 1e-2







import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   BigBirdConfig.from_json_file(UpperCamelCase__				)
							print(F'''Building PyTorch model from configuration: {config}'''				)

							if is_trivia_qa:
														snake_case_          =   BigBirdForQuestionAnswering(UpperCamelCase__				)
							else:
														snake_case_          =   BigBirdForPreTraining(UpperCamelCase__				)

							# Load weights from tf checkpoint
							load_tf_weights_in_big_bird(UpperCamelCase__       ,							UpperCamelCase__       ,							is_trivia_qa=UpperCamelCase__				)

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


if __name__ == "__main__":
					_UpperCAmelCase		:       Dict						    =	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(
					    """--big_bird_config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help=(
					        """The config json file corresponding to the pre-trained BERT 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."""
					)
					parser.add_argument(
					    """--is_trivia_qa""", action="""store_true""", help="""Whether to convert a model with a trivia_qa head."""
					)
					_UpperCAmelCase		:       str						    =	parser.parse_args()
					convert_tf_checkpoint_to_pytorch(
					    args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
					)




