
import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
    import onnxruntime as ort




class 				_lowerCamelCase (      UpperCamelCase_	,							unittest.TestCase ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE_		   =  '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''






     def    __SCREAMING_SNAKE_CASE			(							self						,						__SCREAMING_SNAKE_CASE=0  )  ->   int:




           """simple docstring"""







           UpperCamelCase__    :   Tuple					=				np.random.RandomState(__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   List[str]					=				{
               '''prompt''': '''A painting of a squirrel eating a burger''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 7.5,
               '''output_type''': '''numpy''',
           }
           return inputs






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           UpperCamelCase__    :   Optional[Any]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   List[Any]					=				self.get_dummy_inputs()
           UpperCamelCase__    :   int					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   Dict					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   Optional[Any]					=				np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Union[str, Any]:




           """simple docstring"""







           UpperCamelCase__    :   Optional[Any]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           UpperCamelCase__    :   Tuple					=				PNDMScheduler.from_config(pipe.scheduler.config						,						skip_prk_steps=__SCREAMING_SNAKE_CASE  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   int					=				self.get_dummy_inputs()
           UpperCamelCase__    :   int					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   List[Any]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   Optional[Any]					=				np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Optional[int]:




           """simple docstring"""







           UpperCamelCase__    :   Optional[int]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           UpperCamelCase__    :   Optional[int]					=				LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Union[str, Any]					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Optional[Any]					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   Optional[int]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   str					=				np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Optional[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Optional[Any]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           UpperCamelCase__    :   Dict					=				EulerDiscreteScheduler.from_config(pipe.scheduler.config  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Tuple					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Union[str, Any]					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   List[str]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   List[str]					=				np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   str:




           """simple docstring"""







           UpperCamelCase__    :   Union[str, Any]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           UpperCamelCase__    :   Optional[Any]					=				EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   str					=				self.get_dummy_inputs()
           UpperCamelCase__    :   List[Any]					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   List[str]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   List[Any]					=				np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Union[str, Any]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           UpperCamelCase__    :   List[Any]					=				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   List[str]					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Dict					=				pipe(**__SCREAMING_SNAKE_CASE  ).images
           UpperCamelCase__    :   Tuple					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 1_2_8, 1_2_8, 3)
           UpperCamelCase__    :   Tuple					=				np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[Any]:




           """simple docstring"""







           UpperCamelCase__    :   List[str]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   List[Any]					=				self.get_dummy_inputs()
           UpperCamelCase__    :   List[Any]					=				3 * [inputs['''prompt''']]

           # forward
           UpperCamelCase__    :   Tuple					=				pipe(**__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Optional[Any]					=				output.images[0, -3:, -3:, -1]

           UpperCamelCase__    :   Dict					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Optional[Any]					=				3 * [inputs.pop('''prompt'''  )]

           UpperCamelCase__    :   List[str]					=				pipe.tokenizer(
               __SCREAMING_SNAKE_CASE						,						padding='''max_length'''						,						max_length=pipe.tokenizer.model_max_length						,						truncation=__SCREAMING_SNAKE_CASE						,						return_tensors='''np'''						,						)
           UpperCamelCase__    :   Optional[int]					=				text_inputs['''input_ids''']

           UpperCamelCase__    :   Tuple					=				pipe.text_encoder(input_ids=text_inputs.astype(np.intaa  )  )[0]

           UpperCamelCase__    :   Optional[int]					=				prompt_embeds

           # forward
           UpperCamelCase__    :   Optional[int]					=				pipe(**__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Optional[int]					=				output.images[0, -3:, -3:, -1]

           assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()  ).max() < 1e-4






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Tuple:




           """simple docstring"""







           UpperCamelCase__    :   Optional[int]					=				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint						,						provider='''CPUExecutionProvider'''  )
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   str					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Optional[int]					=				3 * ['''this is a negative prompt''']
           UpperCamelCase__    :   Any					=				negative_prompt
           UpperCamelCase__    :   str					=				3 * [inputs['''prompt''']]

           # forward
           UpperCamelCase__    :   Optional[Any]					=				pipe(**__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Dict					=				output.images[0, -3:, -3:, -1]

           UpperCamelCase__    :   List[Any]					=				self.get_dummy_inputs()
           UpperCamelCase__    :   Tuple					=				3 * [inputs.pop('''prompt'''  )]

           UpperCamelCase__    :   Any					=				[]
           for p in [prompt, negative_prompt]:
                 UpperCamelCase__    :   List[Any]					=				pipe.tokenizer(
                     __SCREAMING_SNAKE_CASE						,						padding='''max_length'''						,						max_length=pipe.tokenizer.model_max_length						,						truncation=__SCREAMING_SNAKE_CASE						,						return_tensors='''np'''						,						)
                 UpperCamelCase__    :   Any					=				text_inputs['''input_ids''']

                 embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa  )  )[0]  )

           UpperCamelCase__				,UpperCamelCase__    :   List[Any]					=				embeds

           # forward
           UpperCamelCase__    :   str					=				pipe(**__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Dict					=				output.images[0, -3:, -3:, -1]

           assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()  ).max() < 1e-4




@nightly
@require_onnxruntime
@require_torch_gpu
class 				_lowerCamelCase (      unittest.TestCase ):





     """simple docstring"""







     @property
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           return (
               "CUDAExecutionProvider",
               {
                   "gpu_mem_limit": "15000000000",  # 15GB
                   "arena_extend_strategy": "kSameAsRequested",
               },
           )






     @property
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Optional[int]:




           """simple docstring"""







           UpperCamelCase__    :   int					=				ort.SessionOptions()
           UpperCamelCase__    :   int					=				False
           return options






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Optional[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Union[str, Any]					=				OnnxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''						,						revision='''onnx'''						,						safety_checker=__SCREAMING_SNAKE_CASE						,						feature_extractor=__SCREAMING_SNAKE_CASE						,						provider=self.gpu_provider						,						sess_options=self.gpu_options						,						)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Any					=				'''A painting of a squirrel eating a burger'''
           np.random.seed(0  )
           UpperCamelCase__    :   Optional[int]					=				sd_pipe([prompt]						,						guidance_scale=6.0						,						num_inference_steps=1_0						,						output_type='''np'''  )
           UpperCamelCase__    :   Optional[int]					=				output.images

           UpperCamelCase__    :   List[str]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)
           UpperCamelCase__    :   str					=				np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Optional[Any]					=				DDIMScheduler.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						subfolder='''scheduler'''						,						revision='''onnx'''  )
           UpperCamelCase__    :   Dict					=				OnnxStableDiffusionPipeline.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						revision='''onnx'''						,						scheduler=__SCREAMING_SNAKE_CASE						,						safety_checker=__SCREAMING_SNAKE_CASE						,						feature_extractor=__SCREAMING_SNAKE_CASE						,						provider=self.gpu_provider						,						sess_options=self.gpu_options						,						)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Any					=				'''open neural network exchange'''
           UpperCamelCase__    :   List[Any]					=				np.random.RandomState(0  )
           UpperCamelCase__    :   Optional[int]					=				sd_pipe([prompt]						,						guidance_scale=7.5						,						num_inference_steps=1_0						,						generator=__SCREAMING_SNAKE_CASE						,						output_type='''np'''  )
           UpperCamelCase__    :   List[str]					=				output.images
           UpperCamelCase__    :   Any					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)
           UpperCamelCase__    :   Tuple					=				np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Tuple					=				LMSDiscreteScheduler.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						subfolder='''scheduler'''						,						revision='''onnx'''  )
           UpperCamelCase__    :   str					=				OnnxStableDiffusionPipeline.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						revision='''onnx'''						,						scheduler=__SCREAMING_SNAKE_CASE						,						safety_checker=__SCREAMING_SNAKE_CASE						,						feature_extractor=__SCREAMING_SNAKE_CASE						,						provider=self.gpu_provider						,						sess_options=self.gpu_options						,						)
           sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   List[Any]					=				'''open neural network exchange'''
           UpperCamelCase__    :   Optional[int]					=				np.random.RandomState(0  )
           UpperCamelCase__    :   Dict					=				sd_pipe([prompt]						,						guidance_scale=7.5						,						num_inference_steps=1_0						,						generator=__SCREAMING_SNAKE_CASE						,						output_type='''np'''  )
           UpperCamelCase__    :   Any					=				output.images
           UpperCamelCase__    :   Optional[Any]					=				image[0, -3:, -3:, -1]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)
           UpperCamelCase__    :   str					=				np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]  )

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Any:




           """simple docstring"""







           UpperCamelCase__    :   Optional[int]					=				0

           def test_callback_fn(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  ) -> None:
                 UpperCamelCase__    :   List[str]					=				True
                 nonlocal number_of_steps
                 number_of_steps += 1
                 if step == 0:
                       assert latents.shape == (1, 4, 6_4, 6_4)
                       UpperCamelCase__    :   Tuple					=				latents[0, -3:, -3:, -1]
                       UpperCamelCase__    :   Tuple					=				np.array(
                           [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]  )

                       assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 1e-3
                 elif step == 5:
                       assert latents.shape == (1, 4, 6_4, 6_4)
                       UpperCamelCase__    :   Any					=				latents[0, -3:, -3:, -1]
                       UpperCamelCase__    :   Dict					=				np.array(
                           [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]  )

                       assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 1e-3

           UpperCamelCase__    :   int					=				False

           UpperCamelCase__    :   Dict					=				OnnxStableDiffusionPipeline.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						revision='''onnx'''						,						safety_checker=__SCREAMING_SNAKE_CASE						,						feature_extractor=__SCREAMING_SNAKE_CASE						,						provider=self.gpu_provider						,						sess_options=self.gpu_options						,						)
           pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   List[Any]					=				'''Andromeda galaxy in a bottle'''

           UpperCamelCase__    :   List[Any]					=				np.random.RandomState(0  )
           pipe(
               prompt=__SCREAMING_SNAKE_CASE						,						num_inference_steps=5						,						guidance_scale=7.5						,						generator=__SCREAMING_SNAKE_CASE						,						callback=__SCREAMING_SNAKE_CASE						,						callback_steps=1						,						)
           assert test_callback_fn.has_been_called
           assert number_of_steps == 6






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           UpperCamelCase__    :   int					=				OnnxStableDiffusionPipeline.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''						,						revision='''onnx'''						,						safety_checker=__SCREAMING_SNAKE_CASE						,						feature_extractor=__SCREAMING_SNAKE_CASE						,						provider=self.gpu_provider						,						sess_options=self.gpu_options						,						)
           assert isinstance(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )
           assert pipe.safety_checker is None

           UpperCamelCase__    :   Union[str, Any]					=				pipe('''example prompt'''						,						num_inference_steps=2  ).images[0]
           assert image is not None

           # check that there's no error when saving a pipeline with one of the models being None
           with tempfile.TemporaryDirectory() as tmpdirname:
                 pipe.save_pretrained(__SCREAMING_SNAKE_CASE  )
                 UpperCamelCase__    :   Tuple					=				OnnxStableDiffusionPipeline.from_pretrained(__SCREAMING_SNAKE_CASE  )

           # sanity check that the pipeline still works
           assert pipe.safety_checker is None
           UpperCamelCase__    :   List[Any]					=				pipe('''example prompt'''						,						num_inference_steps=2  ).images[0]
           assert image is not None




from typing import TYPE_CHECKING

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


lowerCamelCase      ={
    "configuration_mobilebert": [
        "MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileBertConfig",
        "MobileBertOnnxConfig",
    ],
    "tokenization_mobilebert": ["MobileBertTokenizer"],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase      =["MobileBertTokenizerFast"]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase      =[
        "MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
        "MobileBertForMaskedLM",
        "MobileBertForMultipleChoice",
        "MobileBertForNextSentencePrediction",
        "MobileBertForPreTraining",
        "MobileBertForQuestionAnswering",
        "MobileBertForSequenceClassification",
        "MobileBertForTokenClassification",
        "MobileBertLayer",
        "MobileBertModel",
        "MobileBertPreTrainedModel",
        "load_tf_weights_in_mobilebert",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase      =[
        "TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
        "TFMobileBertForMaskedLM",
        "TFMobileBertForMultipleChoice",
        "TFMobileBertForNextSentencePrediction",
        "TFMobileBertForPreTraining",
        "TFMobileBertForQuestionAnswering",
        "TFMobileBertForSequenceClassification",
        "TFMobileBertForTokenClassification",
        "TFMobileBertMainLayer",
        "TFMobileBertModel",
        "TFMobileBertPreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_mobilebert import (
        MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
        MobileBertConfig,
        MobileBertOnnxConfig,
    )
    from .tokenization_mobilebert import MobileBertTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_mobilebert_fast import MobileBertTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mobilebert import (
            MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            MobileBertForMaskedLM,
            MobileBertForMultipleChoice,
            MobileBertForNextSentencePrediction,
            MobileBertForPreTraining,
            MobileBertForQuestionAnswering,
            MobileBertForSequenceClassification,
            MobileBertForTokenClassification,
            MobileBertLayer,
            MobileBertModel,
            MobileBertPreTrainedModel,
            load_tf_weights_in_mobilebert,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_mobilebert import (
            TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFMobileBertForMaskedLM,
            TFMobileBertForMultipleChoice,
            TFMobileBertForNextSentencePrediction,
            TFMobileBertForPreTraining,
            TFMobileBertForQuestionAnswering,
            TFMobileBertForSequenceClassification,
            TFMobileBertForTokenClassification,
            TFMobileBertMainLayer,
            TFMobileBertModel,
            TFMobileBertPreTrainedModel,
        )

else:
    import sys

    lowerCamelCase      =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


