



"""simple docstring"""
import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    MODEL_FOR_PRETRAINING_MAPPING,
			    AlbertForMaskedLM,
			    AlbertForMultipleChoice,
			    AlbertForPreTraining,
			    AlbertForQuestionAnswering,
			    AlbertForSequenceClassification,
			    AlbertForTokenClassification,
			    AlbertModel,
			)
			from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class 							lowerCamelCase_:





					'''simple docstring'''



					def __init__(    self				,       lowerCamelCase__				,       lowerCamelCase__=1_3				,       lowerCamelCase__=7				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=9_9				,       lowerCamelCase__=1_6				,       lowerCamelCase__=3_6				,       lowerCamelCase__=6				,       lowerCamelCase__=6				,       lowerCamelCase__=6				,       lowerCamelCase__=3_7				,       lowerCamelCase__="gelu"				,       lowerCamelCase__=0.1				,       lowerCamelCase__=0.1				,       lowerCamelCase__=5_1_2				,       lowerCamelCase__=1_6				,       lowerCamelCase__=2				,       lowerCamelCase__=0.0_2				,       lowerCamelCase__=3				,       lowerCamelCase__=4				,       lowerCamelCase__=None				,       ):
									_lowerCamelCase        =				parent
									_lowerCamelCase        =				batch_size
									_lowerCamelCase        =				seq_length
									_lowerCamelCase        =				is_training
									_lowerCamelCase        =				use_input_mask
									_lowerCamelCase        =				use_token_type_ids
									_lowerCamelCase        =				use_labels
									_lowerCamelCase        =				vocab_size
									_lowerCamelCase        =				embedding_size
									_lowerCamelCase        =				hidden_size
									_lowerCamelCase        =				num_hidden_layers
									_lowerCamelCase        =				num_hidden_groups
									_lowerCamelCase        =				num_attention_heads
									_lowerCamelCase        =				intermediate_size
									_lowerCamelCase        =				hidden_act
									_lowerCamelCase        =				hidden_dropout_prob
									_lowerCamelCase        =				attention_probs_dropout_prob
									_lowerCamelCase        =				max_position_embeddings
									_lowerCamelCase        =				type_vocab_size
									_lowerCamelCase        =				type_sequence_label_size
									_lowerCamelCase        =				initializer_range
									_lowerCamelCase        =				num_labels
									_lowerCamelCase        =				num_choices
									_lowerCamelCase        =				scope

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size   )

									_lowerCamelCase        =				None
									if self.use_input_mask:
													_lowerCamelCase        =				random_attention_mask([self.batch_size, self.seq_length]   )

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

									_lowerCamelCase        =				None
									_lowerCamelCase        =				None
									_lowerCamelCase        =				None
									if self.use_labels:
													_lowerCamelCase        =				ids_tensor([self.batch_size]				,       self.type_sequence_label_size   )
													_lowerCamelCase        =				ids_tensor([self.batch_size, self.seq_length]				,       self.num_labels   )
													_lowerCamelCase        =				ids_tensor([self.batch_size]				,       self.num_choices   )

									_lowerCamelCase        =				self.get_config()

									return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

					def 			snake_case__      (    self   ):
									return AlbertConfig(
									    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				,       initializer_range=self.initializer_range				,       num_hidden_groups=self.num_hidden_groups				,       )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				AlbertModel(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__   )
									_lowerCamelCase        =				model(lowerCamelCase__				,       token_type_ids=lowerCamelCase__   )
									_lowerCamelCase        =				model(lowerCamelCase__   )
									self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)   )
									self.parent.assertEqual(result.pooler_output.shape				,       (self.batch_size, self.hidden_size)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				AlbertForPreTraining(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(
									    lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       labels=lowerCamelCase__				,       sentence_order_label=lowerCamelCase__				,       )
									self.parent.assertEqual(result.prediction_logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)   )
									self.parent.assertEqual(result.sop_logits.shape				,       (self.batch_size, config.num_labels)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				AlbertForMaskedLM(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       labels=lowerCamelCase__   )
									self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				AlbertForQuestionAnswering(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(
									    lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       start_positions=lowerCamelCase__				,       end_positions=lowerCamelCase__				,       )
									self.parent.assertEqual(result.start_logits.shape				,       (self.batch_size, self.seq_length)   )
									self.parent.assertEqual(result.end_logits.shape				,       (self.batch_size, self.seq_length)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				self.num_labels
									_lowerCamelCase        =				AlbertForSequenceClassification(lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       labels=lowerCamelCase__   )
									self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				self.num_labels
									_lowerCamelCase        =				AlbertForTokenClassification(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				model(lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       labels=lowerCamelCase__   )
									self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.num_labels)   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				self.num_choices
									_lowerCamelCase        =				AlbertForMultipleChoice(config=lowerCamelCase__   )
									model.to(lowerCamelCase__   )
									model.eval()
									_lowerCamelCase        =				input_ids.unsqueeze(1   ).expand(-1				,       self.num_choices				,       -1   ).contiguous()
									_lowerCamelCase        =				token_type_ids.unsqueeze(1   ).expand(-1				,       self.num_choices				,       -1   ).contiguous()
									_lowerCamelCase        =				input_mask.unsqueeze(1   ).expand(-1				,       self.num_choices				,       -1   ).contiguous()
									_lowerCamelCase        =				model(
									    lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       token_type_ids=lowerCamelCase__				,       labels=lowerCamelCase__				,       )
									self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_choices)   )





					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.prepare_config_and_inputs()
									(
									    (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     
									)        =				config_and_inputs
									_lowerCamelCase        =				{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
									return config, inputs_dict


@require_torch
class 							lowerCamelCase_(   A__,				A__,				unittest.TestCase    ):





					'''simple docstring'''



					lowercase__   :       Union[str, Any]										= (
					    (
					        AlbertModel,
					        AlbertForPreTraining,
					        AlbertForMaskedLM,
					        AlbertForMultipleChoice,
					        AlbertForSequenceClassification,
					        AlbertForTokenClassification,
					        AlbertForQuestionAnswering,
					    )
					    if is_torch_available()
					    else ()
					)
					lowercase__   :       int										= (
					    {
					        'feature-extraction': AlbertModel,
					        'fill-mask': AlbertForMaskedLM,
					        'question-answering': AlbertForQuestionAnswering,
					        'text-classification': AlbertForSequenceClassification,
					        'token-classification': AlbertForTokenClassification,
					        'zero-shot': AlbertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					lowercase__   :       str										= True

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__=False   ):
									_lowerCamelCase        =				super()._prepare_for_class(lowerCamelCase__				,       lowerCamelCase__				,       return_labels=lowerCamelCase__   )

									if return_labels:
													if model_class in get_values(lowerCamelCase__   ):
																	_lowerCamelCase        =				torch.zeros(
																	    (self.model_tester.batch_size, self.model_tester.seq_length)				,       dtype=torch.long				,       device=lowerCamelCase__   )
																	_lowerCamelCase        =				torch.zeros(
																	    self.model_tester.batch_size				,       dtype=torch.long				,       device=lowerCamelCase__   )
									return inputs_dict

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				AlbertModelTester(self   )
									_lowerCamelCase        =				ConfigTester(self				,       config_class=lowerCamelCase__				,       hidden_size=3_7   )

					def 			snake_case__      (    self   ):
									self.config_tester.run_common_tests()

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_pretraining(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
													_lowerCamelCase        =				type
													self.model_tester.create_and_check_model(*lowerCamelCase__   )





					@slow
					def 			snake_case__      (    self   ):
									for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_lowerCamelCase        =				AlbertModel.from_pretrained(lowerCamelCase__   )
													self.assertIsNotNone(lowerCamelCase__   )


@require_torch
class 							lowerCamelCase_(   unittest.TestCase    ):





					'''simple docstring'''



					@slow
					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				AlbertModel.from_pretrained('''albert-base-v2'''   )
									_lowerCamelCase        =				torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]   )
									_lowerCamelCase        =				torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
									with torch.no_grad():
													_lowerCamelCase        =				model(lowerCamelCase__				,       attention_mask=lowerCamelCase__   )[0]
									_lowerCamelCase        =				torch.Size((1, 1_1, 7_6_8)   )
									self.assertEqual(output.shape				,       lowerCamelCase__   )
									_lowerCamelCase        =				torch.tensor(
									    [[[-0.6_5_1_3, 1.5_0_3_5, -0.2_7_6_6], [-0.6_5_1_5, 1.5_0_4_6, -0.2_7_8_0], [-0.6_5_1_2, 1.5_0_4_9, -0.2_7_8_4]]]   )

									self.assertTrue(torch.allclose(output[:, 1:4, 1:4]				,       lowerCamelCase__				,       atol=1e-4   )   )





"""simple docstring"""
import unittest

from transformers import BigBirdConfig, 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

			from transformers.models.big_bird.modeling_flax_big_bird import (
			    FlaxBigBirdForCausalLM,
			    FlaxBigBirdForMaskedLM,
			    FlaxBigBirdForMultipleChoice,
			    FlaxBigBirdForPreTraining,
			    FlaxBigBirdForQuestionAnswering,
			    FlaxBigBirdForSequenceClassification,
			    FlaxBigBirdForTokenClassification,
			    FlaxBigBirdModel,
			)


class 							lowerCamelCase_(   unittest.TestCase    ):





					'''simple docstring'''



					def __init__(    self				,       lowerCamelCase__				,       lowerCamelCase__=2				,       lowerCamelCase__=5_6				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=9_9				,       lowerCamelCase__=3_2				,       lowerCamelCase__=2				,       lowerCamelCase__=2				,       lowerCamelCase__=7				,       lowerCamelCase__="gelu_new"				,       lowerCamelCase__=0.1				,       lowerCamelCase__=0.1				,       lowerCamelCase__=5_1_2				,       lowerCamelCase__=1_6				,       lowerCamelCase__=2				,       lowerCamelCase__=0.0_2				,       lowerCamelCase__=4				,       lowerCamelCase__="block_sparse"				,       lowerCamelCase__=True				,       lowerCamelCase__=False				,       lowerCamelCase__=2				,       lowerCamelCase__=3				,       ):
									_lowerCamelCase        =				parent
									_lowerCamelCase        =				batch_size
									_lowerCamelCase        =				seq_length
									_lowerCamelCase        =				is_training
									_lowerCamelCase        =				use_attention_mask
									_lowerCamelCase        =				use_token_type_ids
									_lowerCamelCase        =				use_labels
									_lowerCamelCase        =				vocab_size
									_lowerCamelCase        =				hidden_size
									_lowerCamelCase        =				num_hidden_layers
									_lowerCamelCase        =				num_attention_heads
									_lowerCamelCase        =				intermediate_size
									_lowerCamelCase        =				hidden_act
									_lowerCamelCase        =				hidden_dropout_prob
									_lowerCamelCase        =				attention_probs_dropout_prob
									_lowerCamelCase        =				max_position_embeddings
									_lowerCamelCase        =				type_vocab_size
									_lowerCamelCase        =				type_sequence_label_size
									_lowerCamelCase        =				initializer_range
									_lowerCamelCase        =				num_choices

									_lowerCamelCase        =				rescale_embeddings
									_lowerCamelCase        =				attention_type
									_lowerCamelCase        =				use_bias
									_lowerCamelCase        =				block_size
									_lowerCamelCase        =				num_random_blocks

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size   )

									_lowerCamelCase        =				None
									if self.use_attention_mask:
													_lowerCamelCase        =				random_attention_mask([self.batch_size, self.seq_length]   )

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

									_lowerCamelCase        =				BigBirdConfig(
									    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=lowerCamelCase__				,       initializer_range=self.initializer_range				,       attention_type=self.attention_type				,       block_size=self.block_size				,       num_random_blocks=self.num_random_blocks				,       use_bias=self.use_bias				,       rescale_embeddings=self.rescale_embeddings				,       )

									return config, input_ids, token_type_ids, attention_mask





					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.prepare_config_and_inputs()
									_lowerCamelCase  ,     _lowerCamelCase  ,     _lowerCamelCase  ,     _lowerCamelCase        =				config_and_inputs
									_lowerCamelCase        =				{
									    '''input_ids''': input_ids,
									    '''token_type_ids''': token_type_ids,
									    '''attention_mask''': attention_mask,
									}
									return config, inputs_dict


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





					'''simple docstring'''



					lowercase__   :       List[str]										= (
					    (
					        FlaxBigBirdForCausalLM,
					        FlaxBigBirdModel,
					        FlaxBigBirdForPreTraining,
					        FlaxBigBirdForMaskedLM,
					        FlaxBigBirdForMultipleChoice,
					        FlaxBigBirdForQuestionAnswering,
					        FlaxBigBirdForSequenceClassification,
					        FlaxBigBirdForTokenClassification,
					    )
					    if is_flax_available()
					    else ()
					)

					lowercase__   :       Any										= False
					lowercase__   :       Optional[int]										= False

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				FlaxBigBirdModelTester(self   )

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_from_pretrained_save_pretrained()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_from_pretrained_with_no_automatic_init()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_no_automatic_init()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_hidden_states_output()

					@slow
					def 			snake_case__      (    self   ):
									for model_class_name in self.all_model_classes:
													_lowerCamelCase        =				model_class_name.from_pretrained('''google/bigbird-roberta-base'''   )
													self.assertIsNotNone(lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									if self.test_attn_probs:
													super().test_attention_outputs()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									_lowerCamelCase  ,     _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													with self.subTest(model_class.__name__   ):
																	_lowerCamelCase        =				self._prepare_for_class(lowerCamelCase__				,       lowerCamelCase__   )
																	_lowerCamelCase        =				model_class(lowerCamelCase__   )

																	@jax.jit
																	def model_jitted(lowerCamelCase__				,       lowerCamelCase__=None				,       **lowerCamelCase__   ):
																					return model(input_ids=lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       **lowerCamelCase__   )

																	with self.subTest('''JIT Enabled'''   ):
																					_lowerCamelCase        =				model_jitted(**lowerCamelCase__   ).to_tuple()

																	with self.subTest('''JIT Disabled'''   ):
																					with jax.disable_jit():
																									_lowerCamelCase        =				model_jitted(**lowerCamelCase__   ).to_tuple()

																	self.assertEqual(len(lowerCamelCase__   )				,       len(lowerCamelCase__   )   )
																	for jitted_output, output in zip(lowerCamelCase__				,       lowerCamelCase__   ):
																					self.assertEqual(jitted_output.shape				,       output.shape   )





					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__=1e-5				,       lowerCamelCase__="outputs"				,       lowerCamelCase__=None   ):
									# `bigbird_block_sparse_attention` in `FlaxBigBird` returns `attention_probs = None`, while in PyTorch version,
									# an effort was done to return `attention_probs` (yet to be verified).
									if name.startswith('''outputs.attentions'''   ):
													return
									else:
													super().check_pt_flax_outputs(lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   )
