code: 
  """simple docstring"""
  
  
  
  
  
  
  
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  
  from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from ...image_transforms import (
      get_resize_output_image_size,
      normalize,
      pad,
      rescale,
      resize,
      to_channel_dimension_format,
  )
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      get_image_size,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  from ...utils.import_utils import is_vision_available
  
  
  SCREAMING_SNAKE_CASE_     				=   logging.get_logger(__name__)
  
  
  if is_vision_available():
    import PIL
  
  
  
  
  
  
  class     __a			(					lowerCAmelCase_			):
         _lowerCamelCase							:							Optional[Any]       =			['pixel_values']
  
  
  
  
  
  
  
         def __init__(					self							,lowerCamelCase_ = True							,lowerCamelCase_ = None							,lowerCamelCase_ = PILImageResampling.BILINEAR							,lowerCamelCase_ = True							,lowerCamelCase_ = False							,lowerCamelCase_ = True							,lowerCamelCase_ = True							,lowerCamelCase_ = 1 / 255							,lowerCamelCase_ = True							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            super().__init__(**lowerCamelCase_		)
  
            _UpperCAmelCase   	=					size if size is not None else {"height": 2560, "width": 1920}
            if isinstance(lowerCamelCase_							,(tuple, list)		):
               # The previous feature extractor size parameter was in (width, height) format
               _UpperCAmelCase   	=					size[::-1]
            _UpperCAmelCase   	=					get_size_dict(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					do_resize
            _UpperCAmelCase   	=					size
            _UpperCAmelCase   	=					resample
            _UpperCAmelCase   	=					do_thumbnail
            _UpperCAmelCase   	=					do_align_long_axis
            _UpperCAmelCase   	=					do_pad
            _UpperCAmelCase   	=					do_rescale
            _UpperCAmelCase   	=					rescale_factor
            _UpperCAmelCase   	=					do_normalize
            _UpperCAmelCase   	=					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
            _UpperCAmelCase   	=					image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = None		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase	,							_UpperCAmelCase   	=					get_image_size(lowerCamelCase_		)
            _UpperCAmelCase	,							_UpperCAmelCase   	=					size["height"], size["width"]
  
            if (output_width < output_height and input_width > input_height) or (
                output_width > output_height and input_width < input_height
            ):
               _UpperCAmelCase   	=					np.rotaa(lowerCamelCase_							,3		)
  
            if data_format is not None:
               _UpperCAmelCase   	=					to_channel_dimension_format(lowerCamelCase_							,lowerCamelCase_		)
  
            return image
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = False							,lowerCamelCase_ = None							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase	,							_UpperCAmelCase   	=					size["height"], size["width"]
            _UpperCAmelCase	,							_UpperCAmelCase   	=					get_image_size(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					output_width - input_width
            _UpperCAmelCase   	=					output_height - input_height
  
            if random_padding:
               _UpperCAmelCase   	=					np.random.randint(low=0							,high=delta_height + 1		)
               _UpperCAmelCase   	=					np.random.randint(low=0							,high=delta_width + 1		)
            else:
               _UpperCAmelCase   	=					delta_height // 2
               _UpperCAmelCase   	=					delta_width // 2
  
            _UpperCAmelCase   	=					delta_height - pad_top
            _UpperCAmelCase   	=					delta_width - pad_left
  
            _UpperCAmelCase   	=					((pad_top, pad_bottom), (pad_left, pad_right))
            return pad(lowerCamelCase_							,lowerCamelCase_							,data_format=lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,*lowerCamelCase_							,**lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."		)
            return self.pad_image(*lowerCamelCase_							,**lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = PILImageResampling.BICUBIC							,lowerCamelCase_ = None							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase	,							_UpperCAmelCase   	=					get_image_size(lowerCamelCase_		)
            _UpperCAmelCase	,							_UpperCAmelCase   	=					size["height"], size["width"]
  
            # We always resize to the smallest of either the input or output size.
            _UpperCAmelCase   	=					min(lowerCamelCase_							,lowerCamelCase_		)
            _UpperCAmelCase   	=					min(lowerCamelCase_							,lowerCamelCase_		)
  
            if height == input_height and width == input_width:
               return image
  
            if input_height > input_width:
               _UpperCAmelCase   	=					int(input_width * height / input_height		)
            elif input_width > input_height:
               _UpperCAmelCase   	=					int(input_height * width / input_width		)
  
            return resize(
                lowerCamelCase_							,size=(height, width)							,resample=lowerCamelCase_							,reducing_gap=2.0							,data_format=lowerCamelCase_							,**lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = PILImageResampling.BICUBIC							,lowerCamelCase_ = None							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					get_size_dict(lowerCamelCase_		)
            _UpperCAmelCase   	=					min(size["height"]							,size["width"]		)
            _UpperCAmelCase   	=					get_resize_output_image_size(lowerCamelCase_							,size=lowerCamelCase_							,default_to_square=lowerCamelCase_		)
            _UpperCAmelCase   	=					resize(lowerCamelCase_							,size=lowerCamelCase_							,resample=lowerCamelCase_							,data_format=lowerCamelCase_							,**lowerCamelCase_		)
            return resized_image
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = None							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            return rescale(lowerCamelCase_							,scale=lowerCamelCase_							,data_format=lowerCamelCase_							,**lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_ = None							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            return normalize(lowerCamelCase_							,mean=lowerCamelCase_							,std=lowerCamelCase_							,data_format=lowerCamelCase_							,**lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = False							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = None							,lowerCamelCase_ = ChannelDimension.FIRST							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					do_resize if do_resize is not None else self.do_resize
            _UpperCAmelCase   	=					size if size is not None else self.size
            if isinstance(lowerCamelCase_							,(tuple, list)		):
               # Previous feature extractor had size in (width, height) format
               _UpperCAmelCase   	=					size[::-1]
            _UpperCAmelCase   	=					get_size_dict(lowerCamelCase_		)
            _UpperCAmelCase   	=					resample if resample is not None else self.resample
            _UpperCAmelCase   	=					do_thumbnail if do_thumbnail is not None else self.do_thumbnail
            _UpperCAmelCase   	=					do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
            _UpperCAmelCase   	=					do_pad if do_pad is not None else self.do_pad
            _UpperCAmelCase   	=					do_rescale if do_rescale is not None else self.do_rescale
            _UpperCAmelCase   	=					rescale_factor if rescale_factor is not None else self.rescale_factor
            _UpperCAmelCase   	=					do_normalize if do_normalize is not None else self.do_normalize
            _UpperCAmelCase   	=					image_mean if image_mean is not None else self.image_mean
            _UpperCAmelCase   	=					image_std if image_std is not None else self.image_std
  
            _UpperCAmelCase   	=					make_list_of_images(lowerCamelCase_		)
  
            if not valid_images(lowerCamelCase_		):
               raise ValueError(
                   "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                   "torch.Tensor, tf.Tensor or jax.ndarray."		)
  
            if do_resize and size is None:
               raise ValueError("Size must be specified if do_resize is True."		)
  
            if do_rescale and rescale_factor is None:
               raise ValueError("Rescale factor must be specified if do_rescale is True."		)
  
            if do_pad and size is None:
               raise ValueError("Size must be specified if do_pad is True."		)
  
            if do_normalize and (image_mean is None or image_std is None):
               raise ValueError("Image mean and std must be specified if do_normalize is True."		)
  
            # All transformations expect numpy arrays.
            _UpperCAmelCase   	=					[to_numpy_array(lowerCamelCase_		) for image in images]
  
            if do_align_long_axis:
               _UpperCAmelCase   	=					[self.align_long_axis(lowerCamelCase_							,size=lowerCamelCase_		) for image in images]
  
            if do_resize:
               _UpperCAmelCase   	=					[self.resize(image=lowerCamelCase_							,size=lowerCamelCase_							,resample=lowerCamelCase_		) for image in images]
  
            if do_thumbnail:
               _UpperCAmelCase   	=					[self.thumbnail(image=lowerCamelCase_							,size=lowerCamelCase_		) for image in images]
  
            if do_pad:
               _UpperCAmelCase   	=					[self.pad_image(image=lowerCamelCase_							,size=lowerCamelCase_							,random_padding=lowerCamelCase_		) for image in images]
  
            if do_rescale:
               _UpperCAmelCase   	=					[self.rescale(image=lowerCamelCase_							,scale=lowerCamelCase_		) for image in images]
  
            if do_normalize:
               _UpperCAmelCase   	=					[self.normalize(image=lowerCamelCase_							,mean=lowerCamelCase_							,std=lowerCamelCase_		) for image in images]
  
            _UpperCAmelCase   	=					[to_channel_dimension_format(lowerCamelCase_							,lowerCamelCase_		) for image in images]
  
            _UpperCAmelCase   	=					{"pixel_values": images}
            return BatchFeature(data=lowerCamelCase_							,tensor_type=lowerCamelCase_		)
  
  
style_context: 
  """simple docstring"""
  
  
  
  
  
  
  
  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			:
  
  
  
  
  
  
  
         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							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					parent
            _UpperCAmelCase   	=					13
            _UpperCAmelCase   	=					7
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					99
            _UpperCAmelCase   	=					16
            _UpperCAmelCase   	=					32
            _UpperCAmelCase   	=					2
            _UpperCAmelCase   	=					4
            _UpperCAmelCase   	=					37
            _UpperCAmelCase   	=					"gelu"
            _UpperCAmelCase   	=					0.1
            _UpperCAmelCase   	=					0.1
            _UpperCAmelCase   	=					512
            _UpperCAmelCase   	=					16
            _UpperCAmelCase   	=					2
            _UpperCAmelCase   	=					0.0_2
            _UpperCAmelCase   	=					3
            _UpperCAmelCase   	=					4
            _UpperCAmelCase   	=					None
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.vocab_size		)
  
            _UpperCAmelCase   	=					None
            if self.use_input_mask:
               _UpperCAmelCase   	=					random_attention_mask([self.batch_size, self.seq_length]		)
  
            _UpperCAmelCase   	=					None
            if self.use_token_type_ids:
               _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.type_vocab_size		)
  
            _UpperCAmelCase   	=					None
            _UpperCAmelCase   	=					None
            _UpperCAmelCase   	=					None
            if self.use_labels:
               _UpperCAmelCase   	=					ids_tensor([self.batch_size]							,self.type_sequence_label_size		)
               _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.num_labels		)
               _UpperCAmelCase   	=					ids_tensor([self.batch_size]							,self.num_choices		)
  
            _UpperCAmelCase   	=					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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertModel(config=lowerCamelCase_		)
            # inputs = {'input_ids': input_ids,
            #           'attention_mask': input_mask,
            #           'token_type_ids': token_type_ids}
            # sequence_output, pooled_output = model(**inputs)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					[input_ids, input_mask]
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					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_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForPreTraining(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForMaskedLM(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(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_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForSequenceClassification(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForQuestionAnswering(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_choices
            _UpperCAmelCase   	=					TFAlbertForMultipleChoice(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					{
                "input_ids": multiple_choice_inputs_ids,
                "attention_mask": multiple_choice_input_mask,
                "token_type_ids": multiple_choice_token_type_ids,
            }
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.num_choices]		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForTokenClassification(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{
                "input_ids": input_ids,
                "attention_mask": input_mask,
                "token_type_ids": token_type_ids,
            }
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.seq_length, self.num_labels]		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.prepare_config_and_inputs()
            (
                (
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							
            )   	=					config_and_inputs
            _UpperCAmelCase   	=					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
            return config, inputs_dict
  
  
  
  
  
  
  @require_tf
  class     __a			(					lowerCAmelCase_				,	lowerCAmelCase_				,	unittest.TestCase			):
         _lowerCamelCase							:							Any       =			(
             (
                 TFAlbertModel,
                 TFAlbertForPreTraining,
                 TFAlbertForMaskedLM,
                 TFAlbertForSequenceClassification,
                 TFAlbertForQuestionAnswering,
                 TFAlbertForTokenClassification,
                 TFAlbertForMultipleChoice,
             )
             if is_tf_available()
             else ()
         )
         _lowerCamelCase							:							int       =			(
             {
                 'feature-extraction': TFAlbertModel,
                 'fill-mask': TFAlbertForMaskedLM,
                 'question-answering': TFAlbertForQuestionAnswering,
                 'text-classification': TFAlbertForSequenceClassification,
                 'token-classification': TFAlbertForTokenClassification,
                 'zero-shot': TFAlbertForSequenceClassification,
             }
             if is_tf_available()
             else {}
         )
         _lowerCamelCase							:							List[str]       =			False
         _lowerCamelCase							:							Optional[Any]       =			False
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_=False		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					super()._prepare_for_class(lowerCamelCase_							,lowerCamelCase_							,return_labels=lowerCamelCase_		)
  
            if return_labels:
               if model_class in get_values(lowerCamelCase_		):
                  _UpperCAmelCase   	=					tf.zeros(self.model_tester.batch_size							,dtype=tf.intaa		)
  
            return inputs_dict
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertModelTester(self		)
            _UpperCAmelCase   	=					ConfigTester(self							,config_class=lowerCamelCase_							,hidden_size=37		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            self.config_tester.run_common_tests()
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_model(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_pretraining(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_masked_lm(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_multiple_choice(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_sequence_classification(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_question_answering(*lowerCamelCase_		)
  
  
  
  
  
  
  
         @slow
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _UpperCAmelCase   	=					TFAlbertModel.from_pretrained(lowerCamelCase_		)
               self.assertIsNotNone(lowerCamelCase_		)
  
  
  
  
  
  
  @require_tf
  class     __a			(					unittest.TestCase			):
  
  
  
  
  
  
  
         @slow
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForPreTraining.from_pretrained("albert-base-v2"		)
            _UpperCAmelCase   	=					tf.constant([[0, 1, 2, 3, 4, 5]]		)
            _UpperCAmelCase   	=					model(lowerCamelCase_		)[0]
  
            _UpperCAmelCase   	=					[1, 6, 3_0000]
            self.assertEqual(output.shape							,lowerCamelCase_		)
  
            _UpperCAmelCase   	=					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		)
  
  