
import argparse
import json
import re
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaForSemanticSegmentation,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
a__				:      List[str]    		=     logging.get_logger(__name__)







def 				UpperCAmelCase_(    a__   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = MobileNetVaConfig(layer_norm_eps=0.001   )

    if "quant" in model_name:
        raise ValueError('''Quantized models are not supported.'''   )

    SCREAMING_SNAKE_CASE				:				Tuple				      = re.match(r'''^.*mobilenet_v2_([^_]*)_([^_]*)$''' ,						a__   )
    if matches:
        SCREAMING_SNAKE_CASE				:				List[Any]				      = float(matches[1]   )
        SCREAMING_SNAKE_CASE				:				Any				      = int(matches[2]   )

    if model_name.startswith('''deeplabv3_'''   ):
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = 8
        SCREAMING_SNAKE_CASE				:				List[Any]				      = 21
        SCREAMING_SNAKE_CASE				:				List[str]				      = '''pascal-voc-id2label.json'''
    else:
        # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
        # of the usual 1000. The first class (index 0) is "background".
        SCREAMING_SNAKE_CASE				:				Any				      = 1_001
        SCREAMING_SNAKE_CASE				:				Dict				      = '''imagenet-1k-id2label.json'''

    SCREAMING_SNAKE_CASE				:				Any				      = '''huggingface/label-files'''
    SCREAMING_SNAKE_CASE				:				List[str]				      = json.load(open(hf_hub_download(a__ ,						a__ ,						repo_type='''dataset'''   ) ,						'''r'''   )   )

    if config.num_labels == 1_001:
        SCREAMING_SNAKE_CASE				:				Dict				      = {int(a__   ) + 1: v for k, v in idalabel.items()}
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = '''background'''
    else:
        SCREAMING_SNAKE_CASE				:				str				      = {int(a__   ): v for k, v in idalabel.items()}

    SCREAMING_SNAKE_CASE				:				Tuple				      = idalabel
    SCREAMING_SNAKE_CASE				:				str				      = {v: k for k, v in idalabel.items()}

    return config







def 				UpperCAmelCase_(    ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				Tuple				      = '''http://images.cocodataset.org/val2017/000000039769.jpg'''
    SCREAMING_SNAKE_CASE				:				Any				      = Image.open(requests.get(a__ ,						stream=a__   ).raw   )
    return im







@torch.no_grad()
def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ ,						a__=False   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				Any				      = get_mobilenet_va_config(a__   )

    # Load 🤗 model
    if model_name.startswith('''deeplabv3_'''   ):
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = MobileNetVaForSemanticSegmentation(a__   ).eval()
    else:
        SCREAMING_SNAKE_CASE				:				Any				      = MobileNetVaForImageClassification(a__   ).eval()

    # Load weights from TensorFlow checkpoint
    load_tf_weights_in_mobilenet_va(a__ ,						a__ ,						a__   )

    # Check outputs on an image, prepared by MobileNetV2ImageProcessor
    SCREAMING_SNAKE_CASE				:				Optional[int]				      = MobileNetVaImageProcessor(
        crop_size={'''width''': config.image_size, '''height''': config.image_size} ,						size={'''shortest_edge''': config.image_size + 32} ,						)
    SCREAMING_SNAKE_CASE				:				str				      = image_processor(images=prepare_img() ,						return_tensors='''pt'''   )
    SCREAMING_SNAKE_CASE				:				str				      = model(**a__   )
    SCREAMING_SNAKE_CASE				:				List[str]				      = outputs.logits

    if model_name.startswith('''deeplabv3_'''   ):
        assert logits.shape == (1, 21, 65, 65)

        if model_name == "deeplabv3_mobilenet_v2_1.0_513":
            SCREAMING_SNAKE_CASE				:				List[str]				      = torch.tensor(
                [
                    [[17.5_790, 17.7_581, 18.3_355], [18.3_257, 18.4_230, 18.8_973], [18.6_169, 18.8_650, 19.2_187]],
                    [[-2.1_595, -2.0_977, -2.3_741], [-2.4_226, -2.3_028, -2.6_835], [-2.7_819, -2.5_991, -2.7_706]],
                    [[4.2_058, 4.8_317, 4.7_638], [4.4_136, 5.0_361, 4.9_383], [4.5_028, 4.9_644, 4.8_734]],
                ]   )

        else:
            raise ValueError(F"""Unknown model name: {model_name}"""   )

        assert torch.allclose(logits[0, :3, :3, :3] ,						a__ ,						atol=1e-4   )
    else:
        assert logits.shape == (1, 1_001)

        if model_name == "mobilenet_v2_1.4_224":
            SCREAMING_SNAKE_CASE				:				Optional[Any]				      = torch.tensor([0.0_181, -1.0_015, 0.4_688]   )
        elif model_name == "mobilenet_v2_1.0_224":
            SCREAMING_SNAKE_CASE				:				Dict				      = torch.tensor([0.2_445, -1.1_993, 0.1_905]   )
        elif model_name == "mobilenet_v2_0.75_160":
            SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = torch.tensor([0.2_482, 0.4_136, 0.6_669]   )
        elif model_name == "mobilenet_v2_0.35_96":
            SCREAMING_SNAKE_CASE				:				Optional[int]				      = torch.tensor([0.1_451, -0.4_624, 0.7_192]   )
        else:
            SCREAMING_SNAKE_CASE				:				int				      = None

        if expected_logits is not None:
            assert torch.allclose(logits[0, :3] ,						a__ ,						atol=1e-4   )

    Path(a__   ).mkdir(exist_ok=a__   )
    print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""   )
    model.save_pretrained(a__   )
    print(F"""Saving image processor to {pytorch_dump_folder_path}"""   )
    image_processor.save_pretrained(a__   )

    if push_to_hub:
        print('''Pushing to the hub...'''   )
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = '''google/''' + model_name
        image_processor.push_to_hub(a__   )
        model.push_to_hub(a__   )


if __name__ == "__main__":
      a__				:      List[Any]    		=     argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '''--model_name''',
          default='''mobilenet_v2_1.0_224''',
          type=str,
          help='''Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.''',
      )
      parser.add_argument(
          '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).'''
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.'''
      )
      parser.add_argument(
          '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
      )

      a__				:      Any    		=     parser.parse_args()
      convert_movilevit_checkpoint(
          args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
      )


from __future__ import annotations

import unittest

from transformers import AlbertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import TF_MODEL_FOR_PRETRAINING_MAPPING
      from transformers.models.albert.modeling_tf_albert import (
          TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFAlbertForMaskedLM,
          TFAlbertForMultipleChoice,
          TFAlbertForPreTraining,
          TFAlbertForQuestionAnswering,
          TFAlbertForSequenceClassification,
          TFAlbertForTokenClassification,
          TFAlbertModel,
      )






class     a_       :



       """simple docstring"""






       def __init__(		self				,       _lowerCamelCase				,       _lowerCamelCase=13				,       _lowerCamelCase=7				,       _lowerCamelCase=True				,       _lowerCamelCase=True				,       _lowerCamelCase=True				,       _lowerCamelCase=True				,       _lowerCamelCase=99				,       _lowerCamelCase=16				,       _lowerCamelCase=32				,       _lowerCamelCase=2				,       _lowerCamelCase=4				,       _lowerCamelCase=37				,       _lowerCamelCase="gelu"				,       _lowerCamelCase=0.1				,       _lowerCamelCase=0.1				,       _lowerCamelCase=512				,       _lowerCamelCase=16				,       _lowerCamelCase=2				,       _lowerCamelCase=0.0_2				,       _lowerCamelCase=3				,       _lowerCamelCase=4				,       _lowerCamelCase=None				,       )					->List[Any]:
           SCREAMING_SNAKE_CASE				:				int				      = parent
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = 13
           SCREAMING_SNAKE_CASE				:				int				      = 7
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = True
           SCREAMING_SNAKE_CASE				:				List[str]				      = True
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = True
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = True
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = 99
           SCREAMING_SNAKE_CASE				:				str				      = 16
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = 32
           SCREAMING_SNAKE_CASE				:				str				      = 2
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = 4
           SCREAMING_SNAKE_CASE				:				int				      = 37
           SCREAMING_SNAKE_CASE				:				Any				      = '''gelu'''
           SCREAMING_SNAKE_CASE				:				str				      = 0.1
           SCREAMING_SNAKE_CASE				:				Dict				      = 0.1
           SCREAMING_SNAKE_CASE				:				Tuple				      = 512
           SCREAMING_SNAKE_CASE				:				Any				      = 16
           SCREAMING_SNAKE_CASE				:				str				      = 2
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = 0.0_2
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = 3
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = 4
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = None






       def 	__lowerCAmelCase     (		self   )					->List[str]:
           SCREAMING_SNAKE_CASE				:				Tuple				      = ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size   )

           SCREAMING_SNAKE_CASE				:				Optional[int]				      = None
           if self.use_input_mask:
               SCREAMING_SNAKE_CASE				:				Optional[int]				      = random_attention_mask([self.batch_size, self.seq_length]   )

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

           SCREAMING_SNAKE_CASE				:				str				      = None
           SCREAMING_SNAKE_CASE				:				Any				      = None
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = None
           if self.use_labels:
               SCREAMING_SNAKE_CASE				:				str				      = ids_tensor([self.batch_size]				,       self.type_sequence_label_size   )
               SCREAMING_SNAKE_CASE				:				List[str]				      = ids_tensor([self.batch_size, self.seq_length]				,       self.num_labels   )
               SCREAMING_SNAKE_CASE				:				Tuple				      = ids_tensor([self.batch_size]				,       self.num_choices   )

           SCREAMING_SNAKE_CASE				:				List[Any]				      = AlbertConfig(
               vocab_size=self.vocab_size				,       hidden_size=self.hidden_size				,       embedding_size=self.embedding_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				,       )

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






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->List[str]:
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = TFAlbertModel(config=_lowerCamelCase   )
           # inputs = {'input_ids': input_ids,
           #           'attention_mask': input_mask,
           #           'token_type_ids': token_type_ids}
           # sequence_output, pooled_output = model(**inputs)
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = model(_lowerCamelCase   )

           SCREAMING_SNAKE_CASE				:				List[str]				      = [input_ids, input_mask]
           SCREAMING_SNAKE_CASE				:				List[str]				      = model(_lowerCamelCase   )

           SCREAMING_SNAKE_CASE				:				Any				      = 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 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->List[Any]:
           SCREAMING_SNAKE_CASE				:				str				      = self.num_labels
           SCREAMING_SNAKE_CASE				:				List[str]				      = TFAlbertForPreTraining(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Any				      = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           SCREAMING_SNAKE_CASE				:				int				      = model(_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, self.num_labels)   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->str:
           SCREAMING_SNAKE_CASE				:				str				      = TFAlbertForMaskedLM(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				int				      = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = model(_lowerCamelCase   )
           self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->int:
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = self.num_labels
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = TFAlbertForSequenceClassification(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           SCREAMING_SNAKE_CASE				:				Tuple				      = model(_lowerCamelCase   )
           self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->Dict:
           SCREAMING_SNAKE_CASE				:				List[str]				      = TFAlbertForQuestionAnswering(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           SCREAMING_SNAKE_CASE				:				int				      = model(_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 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->Any:
           SCREAMING_SNAKE_CASE				:				List[Any]				      = self.num_choices
           SCREAMING_SNAKE_CASE				:				Any				      = TFAlbertForMultipleChoice(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Tuple				      = tf.tile(tf.expand_dims(_lowerCamelCase				,       1   )				,       (1, self.num_choices, 1)   )
           SCREAMING_SNAKE_CASE				:				Tuple				      = tf.tile(tf.expand_dims(_lowerCamelCase				,       1   )				,       (1, self.num_choices, 1)   )
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = tf.tile(tf.expand_dims(_lowerCamelCase				,       1   )				,       (1, self.num_choices, 1)   )
           SCREAMING_SNAKE_CASE				:				Tuple				      = {
               '''input_ids''': multiple_choice_inputs_ids,
               '''attention_mask''': multiple_choice_input_mask,
               '''token_type_ids''': multiple_choice_token_type_ids,
           }
           SCREAMING_SNAKE_CASE				:				str				      = model(_lowerCamelCase   )
           self.parent.assertListEqual(list(result['''logits'''].shape   )				,       [self.batch_size, self.num_choices]   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase   )					->Optional[Any]:
           SCREAMING_SNAKE_CASE				:				str				      = self.num_labels
           SCREAMING_SNAKE_CASE				:				List[Any]				      = TFAlbertForTokenClassification(config=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }
           SCREAMING_SNAKE_CASE				:				str				      = model(_lowerCamelCase   )
           self.parent.assertListEqual(list(result['''logits'''].shape   )				,       [self.batch_size, self.seq_length, self.num_labels]   )






       def 	__lowerCAmelCase     (		self   )					->List[Any]:
           SCREAMING_SNAKE_CASE				:				List[Any]				      = self.prepare_config_and_inputs()
           (
               (
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							(
               SCREAMING_SNAKE_CASE
           )      ,							
           )				:				Any				      = config_and_inputs
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
           return config, inputs_dict






@require_tf
class     a_       (			a__				,    a__				,    unittest.TestCase							):



       """simple docstring"""
       __SCREAMING_SNAKE_CASE       :					int						=  (
           (
               TFAlbertModel,
               TFAlbertForPreTraining,
               TFAlbertForMaskedLM,
               TFAlbertForSequenceClassification,
               TFAlbertForQuestionAnswering,
               TFAlbertForTokenClassification,
               TFAlbertForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       __SCREAMING_SNAKE_CASE       :					Optional[int]						=  (
           {
               'feature-extraction': TFAlbertModel,
               'fill-mask': TFAlbertForMaskedLM,
               'question-answering': TFAlbertForQuestionAnswering,
               'text-classification': TFAlbertForSequenceClassification,
               'token-classification': TFAlbertForTokenClassification,
               'zero-shot': TFAlbertForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __SCREAMING_SNAKE_CASE       :					Tuple						=  False
       __SCREAMING_SNAKE_CASE       :					Any						=  False






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase				,       _lowerCamelCase				,       _lowerCamelCase=False   )					->int:
           SCREAMING_SNAKE_CASE				:				Tuple				      = super()._prepare_for_class(_lowerCamelCase				,       _lowerCamelCase				,       return_labels=_lowerCamelCase   )

           if return_labels:
               if model_class in get_values(_lowerCamelCase   ):
                   SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = tf.zeros(self.model_tester.batch_size				,       dtype=tf.intaa   )

           return inputs_dict






       def 	__lowerCAmelCase     (		self   )					->Tuple:
           SCREAMING_SNAKE_CASE				:				Dict				      = TFAlbertModelTester(self   )
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = ConfigTester(self				,       config_class=_lowerCamelCase				,       hidden_size=37   )






       def 	__lowerCAmelCase     (		self   )					->Union[str, Any]:
           self.config_tester.run_common_tests()






       def 	__lowerCAmelCase     (		self   )					->str:
           SCREAMING_SNAKE_CASE				:				Tuple				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_model(*_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self   )					->str:
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_for_pretraining(*_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self   )					->Any:
           SCREAMING_SNAKE_CASE				:				Dict				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_for_masked_lm(*_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self   )					->Optional[Any]:
           SCREAMING_SNAKE_CASE				:				List[str]				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_for_multiple_choice(*_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self   )					->Dict:
           SCREAMING_SNAKE_CASE				:				List[Any]				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_for_sequence_classification(*_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self   )					->str:
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_albert_for_question_answering(*_lowerCamelCase   )






       @slow
       def 	__lowerCAmelCase     (		self   )					->int:
           for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               SCREAMING_SNAKE_CASE				:				Tuple				      = TFAlbertModel.from_pretrained(_lowerCamelCase   )
               self.assertIsNotNone(_lowerCamelCase   )






@require_tf
class     a_       (			unittest.TestCase							):



       """simple docstring"""






       @slow
       def 	__lowerCAmelCase     (		self   )					->List[Any]:
           SCREAMING_SNAKE_CASE				:				Dict				      = TFAlbertForPreTraining.from_pretrained('''albert-base-v2'''   )
           SCREAMING_SNAKE_CASE				:				str				      = tf.constant([[0, 1, 2, 3, 4, 5]]   )
           SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = model(_lowerCamelCase   )[0]

           SCREAMING_SNAKE_CASE				:				List[str]				      = [1, 6, 3_0000]
           self.assertEqual(output.shape				,       _lowerCamelCase   )

           SCREAMING_SNAKE_CASE				:				Dict				      = tf.constant(
               [
                   [
                       [4.5_9_5_6_6_8, 0.7_4_4_6_2_7_5_4, -1.8_1_8_1_4_7],
                       [4.5_9_5_4_3_4_7, 0.7_4_5_4_1_8_4, -1.8_1_8_8_2_5_8],
                       [4.5_9_5_4_9_0_5, 0.7_4_4_8_2_3_5, -1.8_1_8_2_3_1_6],
                   ]
               ]   )
           tf.debugging.assert_near(output[:, :3, :3]				,       _lowerCamelCase				,       atol=1e-4   )
