"""simple docstring"""





import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

				if is_vision_available():
								from transformers import MaskaFormerImageProcessor

if is_vision_available():
				from PIL import Image
class  _snake_case     :






						def __init__(       self      :			Dict							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any=2							,					UpperCAmelCase      :			Union[str, Any]=True							,					UpperCAmelCase      :			Optional[int]=False							,					UpperCAmelCase      :			Dict=10							,					UpperCAmelCase      :			Tuple=3							,					UpperCAmelCase      :			Tuple=32 * 8							,					UpperCAmelCase      :			Optional[Any]=32 * 8							,					UpperCAmelCase      :			List[Any]=4							,					UpperCAmelCase      :			Optional[Any]=64							,					):
													__lowerCamelCase					:		Optional[int]		   =     parent
													__lowerCamelCase					:		List[Any]		   =     batch_size
													__lowerCamelCase					:		int		   =     is_training
													__lowerCamelCase					:		int		   =     use_auxiliary_loss
													__lowerCamelCase					:		Tuple		   =     num_queries
													__lowerCamelCase					:		Optional[Any]		   =     num_channels
													__lowerCamelCase					:		str		   =     min_size
													__lowerCamelCase					:		List[Any]		   =     max_size
													__lowerCamelCase					:		int		   =     num_labels
													__lowerCamelCase					:		Any		   =     hidden_dim
													__lowerCamelCase					:		List[str]		   =     hidden_dim






						def       lowerCamelCase__     (       self      :			int    ):
													__lowerCamelCase					:		List[str]		   =     floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]    ).to(
													    UpperCAmelCase    )

													__lowerCamelCase					:		Optional[Any]		   =     torch.ones([self.batch_size, self.min_size, self.max_size]							,					device=UpperCAmelCase    )

													__lowerCamelCase					:		Optional[Any]		   =     (
													    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]							,					device=UpperCAmelCase    ) > 0.5
													).float()
													__lowerCamelCase					:		str		   =     (torch.rand((self.batch_size, self.num_labels)							,					device=UpperCAmelCase    ) > 0.5).long()

													__lowerCamelCase					:		Any		   =     self.get_config()
													return config, pixel_values, pixel_mask, mask_labels, class_labels






						def       lowerCamelCase__     (       self      :			Tuple    ):
													__lowerCamelCase					:		Optional[int]		   =     MaskaFormerConfig(
													    hidden_size=self.hidden_dim							,					)
													__lowerCamelCase					:		Tuple		   =     self.num_queries
													__lowerCamelCase					:		List[Any]		   =     self.num_labels

													__lowerCamelCase					:		List[str]		   =     [1, 1, 1, 1]
													__lowerCamelCase					:		str		   =     self.num_channels

													__lowerCamelCase					:		Union[str, Any]		   =     64
													__lowerCamelCase					:		List[Any]		   =     128
													__lowerCamelCase					:		str		   =     self.hidden_dim
													__lowerCamelCase					:		Optional[Any]		   =     self.hidden_dim
													__lowerCamelCase					:		Optional[Any]		   =     self.hidden_dim
													return config






						def       lowerCamelCase__     (       self      :			Tuple    ):
													__lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase					:		List[str]		   =     self.prepare_config_and_inputs()
													__lowerCamelCase					:		Tuple		   =     {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
													return config, inputs_dict






						def       lowerCamelCase__     (       self      :			int							,					UpperCAmelCase      :			Optional[int]							,					UpperCAmelCase      :			Optional[Any]    ):
													__lowerCamelCase					:		int		   =     output.encoder_hidden_states
													__lowerCamelCase					:		List[str]		   =     output.pixel_decoder_hidden_states
													__lowerCamelCase					:		Dict		   =     output.transformer_decoder_hidden_states

													self.parent.assertTrue(len(UpperCAmelCase    )							,					len(config.backbone_config.depths    )    )
													self.parent.assertTrue(len(UpperCAmelCase    )							,					len(config.backbone_config.depths    )    )
													self.parent.assertTrue(len(UpperCAmelCase    )							,					config.decoder_layers    )






						def       lowerCamelCase__     (       self      :			Optional[int]							,					UpperCAmelCase      :			List[str]							,					UpperCAmelCase      :			Optional[Any]							,					UpperCAmelCase      :			Tuple							,					UpperCAmelCase      :			List[str]=False    ):
													with torch.no_grad():
																				__lowerCamelCase					:		int		   =     MaskaFormerModel(config=UpperCAmelCase    )
																				model.to(UpperCAmelCase    )
																				model.eval()

																				__lowerCamelCase					:		Union[str, Any]		   =     model(pixel_values=UpperCAmelCase							,					pixel_mask=UpperCAmelCase    )
																				__lowerCamelCase					:		str		   =     model(UpperCAmelCase							,					output_hidden_states=UpperCAmelCase    )

													self.parent.assertEqual(
													    output.transformer_decoder_last_hidden_state.shape							,					(self.batch_size, self.num_queries, self.hidden_dim)							,					)
													# let's ensure the other two hidden state exists
													self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None    )
													self.parent.assertTrue(output.encoder_last_hidden_state is not None    )

													if output_hidden_states:
																				self.check_output_hidden_state(UpperCAmelCase							,					UpperCAmelCase    )







						def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			List[Any]							,					UpperCAmelCase      :			Union[str, Any]							,					UpperCAmelCase      :			Optional[int]							,					UpperCAmelCase      :			List[str]							,					UpperCAmelCase      :			Tuple    ):
													__lowerCamelCase					:		Dict		   =     MaskaFormerForUniversalSegmentation(config=UpperCAmelCase    )
													model.to(UpperCAmelCase    )
													model.eval()

													def comm_check_on_output(UpperCAmelCase      :			Optional[int]    ):
																				# let's still check that all the required stuff is there
																				self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None    )
																				self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None    )
																				self.parent.assertTrue(result.encoder_last_hidden_state is not None    )
																				# okay, now we need to check the logits shape
																				# due to the encoder compression, masks have a //4 spatial size
																				self.parent.assertEqual(
																				    result.masks_queries_logits.shape							,					(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)							,					)
																				# + 1 for null class
																				self.parent.assertEqual(
																				    result.class_queries_logits.shape							,					(self.batch_size, self.num_queries, self.num_labels + 1)    )

													with torch.no_grad():
																				__lowerCamelCase					:		str		   =     model(pixel_values=UpperCAmelCase							,					pixel_mask=UpperCAmelCase    )
																				__lowerCamelCase					:		Tuple		   =     model(UpperCAmelCase    )

																				comm_check_on_output(UpperCAmelCase    )

																				__lowerCamelCase					:		Dict		   =     model(
																				    pixel_values=UpperCAmelCase							,					pixel_mask=UpperCAmelCase							,					mask_labels=UpperCAmelCase							,					class_labels=UpperCAmelCase    )

													comm_check_on_output(UpperCAmelCase    )

													self.parent.assertTrue(result.loss is not None    )
													self.parent.assertEqual(result.loss.shape							,					torch.Size([1]    )    )

@require_torch
class  _snake_case     (					a__				, a__				, unittest.TestCase		):
						snake_case__			  =			(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
						snake_case__			  =			{"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

						snake_case__			  =			False
						snake_case__			  =			False
						snake_case__			  =			False
						snake_case__			  =			False






						def       lowerCamelCase__     (       self      :			List[str]    ):
													__lowerCamelCase					:		Tuple		   =     MaskaFormerModelTester(self    )
													__lowerCamelCase					:		List[str]		   =     ConfigTester(self							,					config_class=UpperCAmelCase							,					has_text_modality=UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			List[str]    ):
													self.config_tester.run_common_tests()






						def       lowerCamelCase__     (       self      :			Any    ):
													__lowerCamelCase   ,  __lowerCamelCase					:		Optional[int]		   =     self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.create_and_check_maskaformer_model(UpperCAmelCase							,					**UpperCAmelCase							,					output_hidden_states=UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			List[str]    ):
													__lowerCamelCase					:		Union[str, Any]		   =     self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*UpperCAmelCase    )






						@unittest.skip(reason="Mask2Former does not use inputs_embeds"    )
						def       lowerCamelCase__     (       self      :			int    ):
													pass






						@unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"    )
						def       lowerCamelCase__     (       self      :			Union[str, Any]    ):
													pass






						@unittest.skip(reason="Mask2Former is not a generative model"    )
						def       lowerCamelCase__     (       self      :			Dict    ):
													pass






						@unittest.skip(reason="Mask2Former does not use token embeddings"    )
						def       lowerCamelCase__     (       self      :			List[Any]    ):
													pass






						@require_torch_multi_gpu
						@unittest.skip(
						    reason="Mask2Former has some layers using `add_module` which doesn't work well with `nn.DataParallel`"    )
						def       lowerCamelCase__     (       self      :			Optional[int]    ):
													pass






						@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."    )
						def       lowerCamelCase__     (       self      :			Dict    ):
													pass






						def       lowerCamelCase__     (       self      :			Any    ):
													__lowerCamelCase   ,  __lowerCamelCase					:		Optional[Any]		   =     self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__lowerCamelCase					:		Any		   =     model_class(UpperCAmelCase    )
																				__lowerCamelCase					:		List[Any]		   =     inspect.signature(model.forward    )
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				__lowerCamelCase					:		List[Any]		   =     [*signature.parameters.keys()]

																				__lowerCamelCase					:		Optional[int]		   =     ["pixel_values"]
																				self.assertListEqual(arg_names[:1]							,					UpperCAmelCase    )






						@slow
						def       lowerCamelCase__     (       self      :			int    ):
													for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
																				__lowerCamelCase					:		Union[str, Any]		   =     MaskaFormerModel.from_pretrained(UpperCAmelCase    )
																				self.assertIsNotNone(UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Dict    ):
													__lowerCamelCase					:		Dict		   =     (self.model_tester.min_size,) * 2
													__lowerCamelCase					:		Optional[Any]		   =     {
													    "pixel_values": torch.randn((2, 3, *size)							,					device=UpperCAmelCase    ),
													    "mask_labels": torch.randn((2, 10, *size)							,					device=UpperCAmelCase    ),
													    "class_labels": torch.zeros(2							,					10							,					device=UpperCAmelCase    ).long(),
													}
													__lowerCamelCase					:		int		   =     self.model_tester.get_config()

													__lowerCamelCase					:		Any		   =     MaskaFormerForUniversalSegmentation(UpperCAmelCase    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		List[Any]		   =     model(**UpperCAmelCase    )
													self.assertTrue(outputs.loss is not None    )






						def       lowerCamelCase__     (       self      :			Union[str, Any]    ):
													__lowerCamelCase   ,  __lowerCamelCase					:		Union[str, Any]		   =     self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.create_and_check_maskaformer_model(UpperCAmelCase							,					**UpperCAmelCase							,					output_hidden_states=UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			str    ):
													__lowerCamelCase   ,  __lowerCamelCase					:		str		   =     self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__lowerCamelCase					:		Optional[int]		   =     model_class(UpperCAmelCase    ).to(UpperCAmelCase    )
																				__lowerCamelCase					:		Optional[int]		   =     model(**UpperCAmelCase							,					output_attentions=UpperCAmelCase    )
																				self.assertTrue(outputs.attentions is not None    )






						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													if not self.model_tester.is_training:
																				return

													__lowerCamelCase					:		str		   =     self.all_model_classes[1]
													__lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase					:		Optional[int]		   =     self.model_tester.prepare_config_and_inputs()

													__lowerCamelCase					:		Optional[Any]		   =     model_class(UpperCAmelCase    )
													model.to(UpperCAmelCase    )
													model.train()

													__lowerCamelCase					:		str		   =     model(UpperCAmelCase							,					mask_labels=UpperCAmelCase							,					class_labels=UpperCAmelCase    ).loss
													loss.backward()







						def       lowerCamelCase__     (       self      :			int    ):
													__lowerCamelCase					:		Optional[int]		   =     self.all_model_classes[1]
													__lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase					:		Any		   =     self.model_tester.prepare_config_and_inputs()
													__lowerCamelCase					:		Union[str, Any]		   =     True
													__lowerCamelCase					:		List[str]		   =     True

													__lowerCamelCase					:		Optional[Any]		   =     model_class(UpperCAmelCase    ).to(UpperCAmelCase    )
													model.train()

													__lowerCamelCase					:		Tuple		   =     model(UpperCAmelCase							,					mask_labels=UpperCAmelCase							,					class_labels=UpperCAmelCase    )

													__lowerCamelCase					:		List[Any]		   =     outputs.encoder_hidden_states[0]
													encoder_hidden_states.retain_grad()

													__lowerCamelCase					:		Union[str, Any]		   =     outputs.pixel_decoder_hidden_states[0]
													pixel_decoder_hidden_states.retain_grad()

													__lowerCamelCase					:		str		   =     outputs.transformer_decoder_hidden_states[0]
													transformer_decoder_hidden_states.retain_grad()

													__lowerCamelCase					:		str		   =     outputs.attentions[0]
													attentions.retain_grad()

													outputs.loss.backward(retain_graph=UpperCAmelCase    )

													self.assertIsNotNone(encoder_hidden_states.grad    )
													self.assertIsNotNone(pixel_decoder_hidden_states.grad    )
													self.assertIsNotNone(transformer_decoder_hidden_states.grad    )
													self.assertIsNotNone(attentions.grad    )

__A  =				1e-4


def    lowercase_   (   ) ->      Optional[Any]:



							'''simple docstring'''

							__lowerCamelCase					:		int		   =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
							return image







@require_vision
@slow
class  _snake_case     (					unittest.TestCase		):






						@cached_property
						def       lowerCamelCase__     (       self      :			Dict    ):
													return "facebook/mask2former-swin-small-coco-instance"






						@cached_property
						def       lowerCamelCase__     (       self      :			str    ):
													return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints    ) if is_vision_available() else None






						def       lowerCamelCase__     (       self      :			str    ):
													__lowerCamelCase					:		Tuple		   =     MaskaFormerModel.from_pretrained(self.model_checkpoints    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		Any		   =     self.default_image_processor
													__lowerCamelCase					:		Optional[Any]		   =     prepare_img()
													__lowerCamelCase					:		Tuple		   =     image_processor(UpperCAmelCase							,					return_tensors="pt"    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		Tuple		   =     inputs["pixel_values"].shape
													# check size is divisible by 32
													self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0    )
													# check size
													self.assertEqual(UpperCAmelCase							,					(1, 3, 384, 384)    )

													with torch.no_grad():
																				__lowerCamelCase					:		Optional[Any]		   =     model(**UpperCAmelCase    )

													__lowerCamelCase					:		List[Any]		   =     torch.tensor(
													    [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]]    ).to(UpperCAmelCase    )
													self.assertTrue(
													    torch.allclose(
													        outputs.encoder_last_hidden_state[0, 0, :3, :3]							,					UpperCAmelCase							,					atol=UpperCAmelCase    )    )

													__lowerCamelCase					:		int		   =     torch.tensor(
													    [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]]    ).to(UpperCAmelCase    )
													self.assertTrue(
													    torch.allclose(
													        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]							,					UpperCAmelCase							,					atol=UpperCAmelCase    )    )

													__lowerCamelCase					:		Dict		   =     torch.tensor(
													    [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]]    ).to(UpperCAmelCase    )
													self.assertTrue(
													    torch.allclose(
													        outputs.transformer_decoder_last_hidden_state[0, :3, :3]							,					UpperCAmelCase							,					atol=UpperCAmelCase    )    )






						def       lowerCamelCase__     (       self      :			Tuple    ):
													__lowerCamelCase					:		Tuple		   =     MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints    ).to(UpperCAmelCase    ).eval()
													__lowerCamelCase					:		Optional[Any]		   =     self.default_image_processor
													__lowerCamelCase					:		Tuple		   =     prepare_img()
													__lowerCamelCase					:		Union[str, Any]		   =     image_processor(UpperCAmelCase							,					return_tensors="pt"    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		List[Any]		   =     inputs["pixel_values"].shape
													# check size is divisible by 32
													self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0    )
													# check size
													self.assertEqual(UpperCAmelCase							,					(1, 3, 384, 384)    )

													with torch.no_grad():
																				__lowerCamelCase					:		List[str]		   =     model(**UpperCAmelCase    )
													# masks_queries_logits
													__lowerCamelCase					:		Any		   =     outputs.masks_queries_logits
													self.assertEqual(
													    masks_queries_logits.shape							,					(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)    )
													__lowerCamelCase					:		Dict		   =     [
													    [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1],
													    [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1],
													    [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5],
													]
													__lowerCamelCase					:		Union[str, Any]		   =     torch.tensor(UpperCAmelCase    ).to(UpperCAmelCase    )
													self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]							,					UpperCAmelCase							,					atol=UpperCAmelCase    )    )
													# class_queries_logits
													__lowerCamelCase					:		Tuple		   =     outputs.class_queries_logits
													self.assertEqual(class_queries_logits.shape							,					(1, model.config.num_queries, model.config.num_labels + 1)    )
													__lowerCamelCase					:		Optional[Any]		   =     torch.tensor(
													    [
													        [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2],
													        [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3],
													        [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5],
													    ]    ).to(UpperCAmelCase    )
													self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]							,					UpperCAmelCase							,					atol=UpperCAmelCase    )    )







						def       lowerCamelCase__     (       self      :			str    ):
													__lowerCamelCase					:		Union[str, Any]		   =     MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints    ).to(UpperCAmelCase    ).eval()
													__lowerCamelCase					:		Dict		   =     self.default_image_processor

													__lowerCamelCase					:		List[Any]		   =     image_processor(
													    [np.zeros((3, 800, 1333)    ), np.zeros((3, 800, 1333)    )]							,					segmentation_maps=[np.zeros((384, 384)    ).astype(np.floataa    ), np.zeros((384, 384)    ).astype(np.floataa    )]							,					return_tensors="pt"							,					)

													__lowerCamelCase					:		List[str]		   =     inputs["pixel_values"].to(UpperCAmelCase    )
													__lowerCamelCase					:		Optional[Any]		   =     [el.to(UpperCAmelCase    ) for el in inputs["mask_labels"]]
													__lowerCamelCase					:		Optional[Any]		   =     [el.to(UpperCAmelCase    ) for el in inputs["class_labels"]]

													with torch.no_grad():
																				__lowerCamelCase					:		Optional[int]		   =     model(**UpperCAmelCase    )

													self.assertTrue(outputs.loss is not None    )
"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A  =				{
    '''configuration_bert''': ['''BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BertConfig''', '''BertOnnxConfig'''],
    '''tokenization_bert''': ['''BasicTokenizer''', '''BertTokenizer''', '''WordpieceTokenizer'''],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A  =				['''BertTokenizerFast''']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A  =				[
				    '''BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''BertForMaskedLM''',
				    '''BertForMultipleChoice''',
				    '''BertForNextSentencePrediction''',
				    '''BertForPreTraining''',
				    '''BertForQuestionAnswering''',
				    '''BertForSequenceClassification''',
				    '''BertForTokenClassification''',
				    '''BertLayer''',
				    '''BertLMHeadModel''',
				    '''BertModel''',
				    '''BertPreTrainedModel''',
				    '''load_tf_weights_in_bert''',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A  =				[
				    '''TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFBertEmbeddings''',
				    '''TFBertForMaskedLM''',
				    '''TFBertForMultipleChoice''',
				    '''TFBertForNextSentencePrediction''',
				    '''TFBertForPreTraining''',
				    '''TFBertForQuestionAnswering''',
				    '''TFBertForSequenceClassification''',
				    '''TFBertForTokenClassification''',
				    '''TFBertLMHeadModel''',
				    '''TFBertMainLayer''',
				    '''TFBertModel''',
				    '''TFBertPreTrainedModel''',
				]
try:
				if not is_tensorflow_text_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A  =				['''TFBertTokenizer''']

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A  =				[
				    '''FlaxBertForCausalLM''',
				    '''FlaxBertForMaskedLM''',
				    '''FlaxBertForMultipleChoice''',
				    '''FlaxBertForNextSentencePrediction''',
				    '''FlaxBertForPreTraining''',
				    '''FlaxBertForQuestionAnswering''',
				    '''FlaxBertForSequenceClassification''',
				    '''FlaxBertForTokenClassification''',
				    '''FlaxBertModel''',
				    '''FlaxBertPreTrainedModel''',
				]

if TYPE_CHECKING:
				from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
				from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_bert_fast import BertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_bert import (
								    BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    BertForMaskedLM,
								    BertForMultipleChoice,
								    BertForNextSentencePrediction,
								    BertForPreTraining,
								    BertForQuestionAnswering,
								    BertForSequenceClassification,
								    BertForTokenClassification,
								    BertLayer,
								    BertLMHeadModel,
								    BertModel,
								    BertPreTrainedModel,
								    load_tf_weights_in_bert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_bert import (
								    TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFBertEmbeddings,
								    TFBertForMaskedLM,
								    TFBertForMultipleChoice,
								    TFBertForNextSentencePrediction,
								    TFBertForPreTraining,
								    TFBertForQuestionAnswering,
								    TFBertForSequenceClassification,
								    TFBertForTokenClassification,
								    TFBertLMHeadModel,
								    TFBertMainLayer,
								    TFBertModel,
								    TFBertPreTrainedModel,
								)

				try:
								if not is_tensorflow_text_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_bert_tf import TFBertTokenizer

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_bert import (
								    FlaxBertForCausalLM,
								    FlaxBertForMaskedLM,
								    FlaxBertForMultipleChoice,
								    FlaxBertForNextSentencePrediction,
								    FlaxBertForPreTraining,
								    FlaxBertForQuestionAnswering,
								    FlaxBertForSequenceClassification,
								    FlaxBertForTokenClassification,
								    FlaxBertModel,
								    FlaxBertPreTrainedModel,
								)

else:
				import sys

				__A  =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)