code: 
  
  
  import gc
  import os
  import tempfile
  import unittest
  
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
  from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
  from diffusers.models.attention_processor import (
      Attention,
      AttnProcessor,
      AttnProcessor2_0,
      LoRAAttnProcessor,
      LoRAAttnProcessor2_0,
      LoRAXFormersAttnProcessor,
      XFormersAttnProcessor,
  )
  from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	nn.Module			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     {}
  			for name in unet.attn_processors.keys():
  						lowerCamelCase								=     None if name.endswith("""attn1.processor"""			) else unet.config.cross_attention_dim
  						if name.startswith("""mid_block"""			):
  									lowerCamelCase								=     unet.config.block_out_channels[-1]
  						elif name.startswith("""up_blocks"""			):
  									lowerCamelCase								=     int(name[len("""up_blocks."""			)]			)
  									lowerCamelCase								=     list(reversed(unet.config.block_out_channels			)			)[block_id]
  						elif name.startswith("""down_blocks"""			):
  									lowerCamelCase								=     int(name[len("""down_blocks."""			)]			)
  									lowerCamelCase								=     unet.config.block_out_channels[block_id]
  						lowerCamelCase								=     (
  						    LoRAAttnProcessor2_0 if hasattr(lowerCamelCase__     ,       """scaled_dot_product_attention"""			) else LoRAAttnProcessor
  						)
  						lowerCamelCase								=     lora_attn_processor_class(
  						    hidden_size=lowerCamelCase__     ,       cross_attention_dim=lowerCamelCase__			)
  			lowerCamelCase								=     AttnProcsLayers(lowerCamelCase__			)
  			return lora_attn_procs, unet_lora_layers
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	nn.Module			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     {}
  			lowerCamelCase								=     (
  			    LoRAAttnProcessor2_0 if hasattr(lowerCamelCase__     ,       """scaled_dot_product_attention"""			) else LoRAAttnProcessor
  			)
  			for name, module in text_encoder.named_modules():
  						if name.endswith(lowerCamelCase__			):
  									lowerCamelCase								=     lora_attn_processor_class(
  									    hidden_size=module.out_proj.out_features     ,       cross_attention_dim=lowerCamelCase__			)
  			return text_lora_attn_procs
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	nn.Module			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     create_text_encoder_lora_attn_procs(lowerCamelCase__			)
  			lowerCamelCase								=     AttnProcsLayers(lowerCamelCase__			)
  			return text_encoder_lora_layers
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	int     ,       lowerCamelCase__		:	int=False			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			for _, attn_proc in text_lora_attn_procs.items():
  						# set up.weights
  						for layer_name, layer_module in attn_proc.named_modules():
  									if layer_name.endswith("""_lora"""			):
  												lowerCamelCase								=     (
  												    torch.randn_like(layer_module.up.weight			)
  												    if randn_weight
  												    else torch.zeros_like(layer_module.up.weight			)
  												)
  												lowerCamelCase								=     torch.nn.Parameter(lowerCamelCase__			)
  
  
  
  
  
  
  
  class 					__lowercase					(       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					torch.manual_seed(0  )
  					lowerCamelCase								=     UNetaDConditionModel(
  					    block_out_channels=(32, 64)		,			layers_per_block=2		,			sample_size=32		,			in_channels=4		,			out_channels=4		,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")		,			up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")		,			cross_attention_dim=32		,			)
  					lowerCamelCase								=     DDIMScheduler(
  					    beta_start=0.00085		,			beta_end=0.012		,			beta_schedule="""scaled_linear"""		,			clip_sample=A		,			set_alpha_to_one=A		,			steps_offset=1		,			)
  					torch.manual_seed(0  )
  					lowerCamelCase								=     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		,			)
  					lowerCamelCase								=     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		,			)
  					lowerCamelCase								=     CLIPTextModel(A  )
  					lowerCamelCase								=     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )
  
  					lowerCamelCase		,		lowerCamelCase								=     create_unet_lora_layers(A  )
  					lowerCamelCase								=     create_text_encoder_lora_layers(A  )
  
  					lowerCamelCase								=     {
  					    """unet""": unet,
  					    """scheduler""": scheduler,
  					    """vae""": vae,
  					    """text_encoder""": text_encoder,
  					    """tokenizer""": tokenizer,
  					    """safety_checker""": None,
  					    """feature_extractor""": None,
  					}
  					lowerCamelCase								=     {
  					    """unet_lora_layers""": unet_lora_layers,
  					    """text_encoder_lora_layers""": text_encoder_lora_layers,
  					    """unet_lora_attn_procs""": unet_lora_attn_procs,
  					}
  					return pipeline_components, lora_components
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     1
  					lowerCamelCase								=     10
  					lowerCamelCase								=     4
  					lowerCamelCase								=     (32, 32)
  
  					lowerCamelCase								=     torch.manual_seed(0  )
  					lowerCamelCase								=     floats_tensor((batch_size, num_channels) + sizes  )
  					lowerCamelCase								=     torch.randint(1		,			A		,			size=(batch_size, sequence_length)		,			generator=A  )
  
  					lowerCamelCase								=     {
  					    """prompt""": """A painting of a squirrel eating a burger""",
  					    """generator""": generator,
  					    """num_inference_steps""": 2,
  					    """guidance_scale""": 6.0,
  					    """output_type""": """numpy""",
  					}
  
  					return noise, input_ids, pipeline_inputs
  
  					# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     77
  
  					lowerCamelCase								=     torch.randint(2		,			56		,			size=(1, max_seq_length)		,			generator=torch.manual_seed(0  )  )
  
  					lowerCamelCase								=     {}
  					lowerCamelCase								=     inputs
  					return prepared_inputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					LoraLoaderMixin.save_lora_weights(
  					    save_directory=A		,			unet_lora_layers=lora_components["""unet_lora_layers"""]		,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]		,			)
  					self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.bin"""  )  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  					lowerCamelCase								=     sd_pipe.to(A  )
  					sd_pipe.set_progress_bar_config(disable=A  )
  
  					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_inputs()
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     original_images[0, -3:, -3:, -1]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								LoraLoaderMixin.save_lora_weights(
  								    save_directory=A		,			unet_lora_layers=lora_components["""unet_lora_layers"""]		,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]		,			)
  								self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.bin"""  )  )  )
  								sd_pipe.load_lora_weights(A  )
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     lora_images[0, -3:, -3:, -1]
  
  					# Outputs shouldn't match.
  					self.assertFalse(torch.allclose(torch.from_numpy(A  )		,			torch.from_numpy(A  )  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  					lowerCamelCase								=     sd_pipe.to(A  )
  					sd_pipe.set_progress_bar_config(disable=A  )
  
  					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_inputs()
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     original_images[0, -3:, -3:, -1]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								LoraLoaderMixin.save_lora_weights(
  								    save_directory=A		,			unet_lora_layers=lora_components["""unet_lora_layers"""]		,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]		,			safe_serialization=A		,			)
  								self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.safetensors"""  )  )  )
  								sd_pipe.load_lora_weights(A  )
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     lora_images[0, -3:, -3:, -1]
  
  					# Outputs shouldn't match.
  					self.assertFalse(torch.allclose(torch.from_numpy(A  )		,			torch.from_numpy(A  )  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     lora_components["""unet_lora_attn_procs"""]
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  					lowerCamelCase								=     sd_pipe.to(A  )
  					sd_pipe.set_progress_bar_config(disable=A  )
  
  					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_inputs()
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     original_images[0, -3:, -3:, -1]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								lowerCamelCase								=     sd_pipe.unet
  								unet.set_attn_processor(A  )
  								unet.save_attn_procs(A  )
  								self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.bin"""  )  )  )
  								sd_pipe.load_lora_weights(A  )
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     lora_images[0, -3:, -3:, -1]
  
  					# Outputs shouldn't match.
  					self.assertFalse(torch.allclose(torch.from_numpy(A  )		,			torch.from_numpy(A  )  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  
  					lowerCamelCase								=     self.get_dummy_tokens()
  
  					# inference without lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_without_lora.shape == (1, 77, 32)
  
  					# create lora_attn_procs with zeroed out up.weights
  					lowerCamelCase								=     create_text_encoder_lora_attn_procs(pipe.text_encoder  )
  					set_lora_up_weights(A		,			randn_weight=A  )
  
  					# monkey patch
  					pipe._modify_text_encoder(A  )
  
  					# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  					del text_attn_procs
  					gc.collect()
  
  					# inference with lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_with_lora.shape == (1, 77, 32)
  
  					assert torch.allclose(
  					    A		,			A  ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"
  
  					# create lora_attn_procs with randn up.weights
  					lowerCamelCase								=     create_text_encoder_lora_attn_procs(pipe.text_encoder  )
  					set_lora_up_weights(A		,			randn_weight=A  )
  
  					# monkey patch
  					pipe._modify_text_encoder(A  )
  
  					# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  					del text_attn_procs
  					gc.collect()
  
  					# inference with lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_with_lora.shape == (1, 77, 32)
  
  					assert not torch.allclose(
  					    A		,			A  ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  
  					lowerCamelCase								=     self.get_dummy_tokens()
  
  					# inference without lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_without_lora.shape == (1, 77, 32)
  
  					# create lora_attn_procs with randn up.weights
  					lowerCamelCase								=     create_text_encoder_lora_attn_procs(pipe.text_encoder  )
  					set_lora_up_weights(A		,			randn_weight=A  )
  
  					# monkey patch
  					pipe._modify_text_encoder(A  )
  
  					# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  					del text_attn_procs
  					gc.collect()
  
  					# inference with lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_with_lora.shape == (1, 77, 32)
  
  					assert not torch.allclose(
  					    A		,			A  ), "lora outputs should be different to without lora outputs"
  
  					# remove monkey patch
  					pipe._remove_text_encoder_monkey_patch()
  
  					# inference with removed lora
  					lowerCamelCase								=     pipe.text_encoder(**A  )[0]
  					assert outputs_without_lora_removed.shape == (1, 77, 32)
  
  					assert torch.allclose(
  					    A		,			A  ), "remove lora monkey patch should restore the original outputs"
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  					lowerCamelCase								=     sd_pipe.to(A  )
  					sd_pipe.set_progress_bar_config(disable=A  )
  
  					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_inputs()
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								LoraLoaderMixin.save_lora_weights(
  								    save_directory=A		,			unet_lora_layers=lora_components["""unet_lora_layers"""]		,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]		,			)
  								self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.bin"""  )  )  )
  								sd_pipe.load_lora_weights(A  )
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     lora_images[0, -3:, -3:, -1]
  
  					lowerCamelCase								=     sd_pipe(**A		,			cross_attention_kwargs={"""scale""": 0.5}  ).images
  					lowerCamelCase								=     lora_images_with_scale[0, -3:, -3:, -1]
  
  					# Outputs shouldn't match.
  					self.assertFalse(
  					    torch.allclose(torch.from_numpy(A  )		,			torch.from_numpy(A  )  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								self.create_lora_weight_file(A  )
  
  								lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  								lowerCamelCase								=     StableDiffusionPipeline(**A  )
  								lowerCamelCase								=     sd_pipe.to(A  )
  								sd_pipe.set_progress_bar_config(disable=A  )
  
  								# check if vanilla attention processors are used
  								for _, module in sd_pipe.unet.named_modules():
  											if isinstance(A		,			A  ):
  														self.assertIsInstance(module.processor		,			(AttnProcessor, AttnProcessor2_0)  )
  
              # load LoRA weight file
  								sd_pipe.load_lora_weights(A  )
  
  								# check if lora attention processors are used
  								for _, module in sd_pipe.unet.named_modules():
  											if isinstance(A		,			A  ):
  														lowerCamelCase								=     (
  														    LoRAAttnProcessor2_0 if hasattr(A		,			"""scaled_dot_product_attention"""  ) else LoRAAttnProcessor
  														)
  														self.assertIsInstance(module.processor		,			A  )
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device != """cuda"""		,			"""This test is supposed to run on GPU"""  )
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								self.create_lora_weight_file(A  )
  
  								lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  								lowerCamelCase								=     StableDiffusionPipeline(**A  )
  								lowerCamelCase								=     sd_pipe.to(A  )
  								sd_pipe.set_progress_bar_config(disable=A  )
  
  								# enable XFormers
  								sd_pipe.enable_xformers_memory_efficient_attention()
  
  								# check if xFormers attention processors are used
  								for _, module in sd_pipe.unet.named_modules():
  											if isinstance(A		,			A  ):
  														self.assertIsInstance(module.processor		,			A  )
  
              # load LoRA weight file
  								sd_pipe.load_lora_weights(A  )
  
  								# check if lora attention processors are used
  								for _, module in sd_pipe.unet.named_modules():
  											if isinstance(A		,			A  ):
  														self.assertIsInstance(module.processor		,			A  )
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device != """cuda"""		,			"""This test is supposed to run on GPU"""  )
  		def 				__A      (   self  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_components()
  					lowerCamelCase								=     StableDiffusionPipeline(**A  )
  					lowerCamelCase								=     sd_pipe.to(A  )
  					sd_pipe.set_progress_bar_config(disable=A  )
  
  					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase								=     self.get_dummy_inputs()
  
  					# enable XFormers
  					sd_pipe.enable_xformers_memory_efficient_attention()
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     original_images[0, -3:, -3:, -1]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  								LoraLoaderMixin.save_lora_weights(
  								    save_directory=A		,			unet_lora_layers=lora_components["""unet_lora_layers"""]		,			text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]		,			)
  								self.assertTrue(os.path.isfile(os.path.join(A		,			"""pytorch_lora_weights.bin"""  )  )  )
  								sd_pipe.load_lora_weights(A  )
  
  					lowerCamelCase								=     sd_pipe(**A  ).images
  					lowerCamelCase								=     lora_images[0, -3:, -3:, -1]
  
  					# Outputs shouldn't match.
  					self.assertFalse(torch.allclose(torch.from_numpy(A  )		,			torch.from_numpy(A  )  )  )
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_sentencepiece_available,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  UpperCAmelCase      :						List[str]    =		{
      "configuration_big_bird": ["BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP", "BigBirdConfig", "BigBirdOnnxConfig"],
  }
  
  try:
  		if not is_sentencepiece_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						str    =		["BigBirdTokenizer"]
  
  try:
  		if not is_tokenizers_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						str    =		["BigBirdTokenizerFast"]
  
  try:
  		if not is_torch_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						Dict    =		[
  		    "BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST",
  		    "BigBirdForCausalLM",
  		    "BigBirdForMaskedLM",
  		    "BigBirdForMultipleChoice",
  		    "BigBirdForPreTraining",
  		    "BigBirdForQuestionAnswering",
  		    "BigBirdForSequenceClassification",
  		    "BigBirdForTokenClassification",
  		    "BigBirdLayer",
  		    "BigBirdModel",
  		    "BigBirdPreTrainedModel",
  		    "load_tf_weights_in_big_bird",
  		]
  
  try:
  		if not is_flax_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						Dict    =		[
  		    "FlaxBigBirdForCausalLM",
  		    "FlaxBigBirdForMaskedLM",
  		    "FlaxBigBirdForMultipleChoice",
  		    "FlaxBigBirdForPreTraining",
  		    "FlaxBigBirdForQuestionAnswering",
  		    "FlaxBigBirdForSequenceClassification",
  		    "FlaxBigBirdForTokenClassification",
  		    "FlaxBigBirdModel",
  		    "FlaxBigBirdPreTrainedModel",
  		]
  
  if TYPE_CHECKING:
  		from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig
  
  		try:
  				if not is_sentencepiece_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .tokenization_big_bird import BigBirdTokenizer
  
  		try:
  				if not is_tokenizers_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .tokenization_big_bird_fast import BigBirdTokenizerFast
  
  		try:
  				if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_big_bird import (
  				    BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
  				    BigBirdForCausalLM,
  				    BigBirdForMaskedLM,
  				    BigBirdForMultipleChoice,
  				    BigBirdForPreTraining,
  				    BigBirdForQuestionAnswering,
  				    BigBirdForSequenceClassification,
  				    BigBirdForTokenClassification,
  				    BigBirdLayer,
  				    BigBirdModel,
  				    BigBirdPreTrainedModel,
  				    load_tf_weights_in_big_bird,
  				)
  
  		try:
  				if not is_flax_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_flax_big_bird import (
  				    FlaxBigBirdForCausalLM,
  				    FlaxBigBirdForMaskedLM,
  				    FlaxBigBirdForMultipleChoice,
  				    FlaxBigBirdForPreTraining,
  				    FlaxBigBirdForQuestionAnswering,
  				    FlaxBigBirdForSequenceClassification,
  				    FlaxBigBirdForTokenClassification,
  				    FlaxBigBirdModel,
  				    FlaxBigBirdPreTrainedModel,
  				)
  
  else:
  		import sys
  
  		UpperCAmelCase      :						Dict    =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  