code: 
  
  
  
  
  """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 			lowerCamelCase__    :
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE=13				, SCREAMING_SNAKE_CASE=7				, SCREAMING_SNAKE_CASE=True				, SCREAMING_SNAKE_CASE=True				, SCREAMING_SNAKE_CASE=True				, SCREAMING_SNAKE_CASE=True				, SCREAMING_SNAKE_CASE=99				, SCREAMING_SNAKE_CASE=16				, SCREAMING_SNAKE_CASE=32				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=4				, SCREAMING_SNAKE_CASE=37				, SCREAMING_SNAKE_CASE="gelu"				, SCREAMING_SNAKE_CASE=0.1				, SCREAMING_SNAKE_CASE=0.1				, SCREAMING_SNAKE_CASE=512				, SCREAMING_SNAKE_CASE=16				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=0.02				, SCREAMING_SNAKE_CASE=3				, SCREAMING_SNAKE_CASE=4				, SCREAMING_SNAKE_CASE=None				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[str]								=				parent
  					snake_case		:						int								=				13
  					snake_case		:						List[Any]								=				7
  					snake_case		:						Tuple								=				True
  					snake_case		:						List[Any]								=				True
  					snake_case		:						List[str]								=				True
  					snake_case		:						List[str]								=				True
  					snake_case		:						List[Any]								=				99
  					snake_case		:						Union[str, Any]								=				16
  					snake_case		:						Dict								=				32
  					snake_case		:						Union[str, Any]								=				2
  					snake_case		:						str								=				4
  					snake_case		:						List[str]								=				37
  					snake_case		:						List[str]								=				"gelu"
  					snake_case		:						Optional[int]								=				0.1
  					snake_case		:						Dict								=				0.1
  					snake_case		:						Any								=				512
  					snake_case		:						Any								=				16
  					snake_case		:						Union[str, Any]								=				2
  					snake_case		:						int								=				0.02
  					snake_case		:						str								=				3
  					snake_case		:						str								=				4
  					snake_case		:						List[Any]								=				None
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				ids_tensor([self.batch_size, self.seq_length]				, self.vocab_size							)
  
  					snake_case		:						Any								=				None
  					if self.use_input_mask:
  							snake_case		:						int								=				random_attention_mask([self.batch_size, self.seq_length]							)
  
  					snake_case		:						Optional[int]								=				None
  					if self.use_token_type_ids:
  							snake_case		:						List[Any]								=				ids_tensor([self.batch_size, self.seq_length]				, self.type_vocab_size							)
  
  					snake_case		:						List[str]								=				None
  					snake_case		:						Optional[int]								=				None
  					snake_case		:						str								=				None
  					if self.use_labels:
  							snake_case		:						Union[str, Any]								=				ids_tensor([self.batch_size]				, self.type_sequence_label_size							)
  							snake_case		:						Optional[int]								=				ids_tensor([self.batch_size, self.seq_length]				, self.num_labels							)
  							snake_case		:						Dict								=				ids_tensor([self.batch_size]				, self.num_choices							)
  
  					snake_case		:						int								=				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				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[Any]								=				TFAlbertModel(config=SCREAMING_SNAKE_CASE							)
  					# inputs = {'input_ids': input_ids,
  					#           'attention_mask': input_mask,
  					#           'token_type_ids': token_type_ids}
  					# sequence_output, pooled_output = model(**inputs)
  					snake_case		:						List[str]								=				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  					snake_case		:						Tuple								=				model(SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						Any								=				[input_ids, input_mask]
  					snake_case		:						Optional[int]								=				model(SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						Any								=				model(SCREAMING_SNAKE_CASE							)
  
  					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				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				self.num_labels
  					snake_case		:						str								=				TFAlbertForPreTraining(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						Any								=				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  					snake_case		:						str								=				model(SCREAMING_SNAKE_CASE							)
  					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				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Union[str, Any]								=				TFAlbertForMaskedLM(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						Any								=				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  					snake_case		:						Optional[int]								=				model(SCREAMING_SNAKE_CASE							)
  					self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.seq_length, self.vocab_size)							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				self.num_labels
  					snake_case		:						Optional[Any]								=				TFAlbertForSequenceClassification(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						str								=				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  					snake_case		:						Union[str, Any]								=				model(SCREAMING_SNAKE_CASE							)
  					self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.num_labels)							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				TFAlbertForQuestionAnswering(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						List[Any]								=				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  					snake_case		:						List[str]								=				model(SCREAMING_SNAKE_CASE							)
  					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				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				self.num_choices
  					snake_case		:						List[Any]								=				TFAlbertForMultipleChoice(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						Any								=				tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE				, 1							)				, (1, self.num_choices, 1)							)
  					snake_case		:						str								=				tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE				, 1							)				, (1, self.num_choices, 1)							)
  					snake_case		:						Optional[int]								=				tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE				, 1							)				, (1, self.num_choices, 1)							)
  					snake_case		:						Optional[int]								=				{
  					    "input_ids": multiple_choice_inputs_ids,
  					    "attention_mask": multiple_choice_input_mask,
  					    "token_type_ids": multiple_choice_token_type_ids,
  					}
  					snake_case		:						Union[str, Any]								=				model(SCREAMING_SNAKE_CASE							)
  					self.parent.assertListEqual(list(result["logits"].shape							)				, [self.batch_size, self.num_choices]							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				self.num_labels
  					snake_case		:						Optional[Any]								=				TFAlbertForTokenClassification(config=SCREAMING_SNAKE_CASE							)
  					snake_case		:						Optional[Any]								=				{
  					    "input_ids": input_ids,
  					    "attention_mask": input_mask,
  					    "token_type_ids": token_type_ids,
  					}
  					snake_case		:						List[Any]								=				model(SCREAMING_SNAKE_CASE							)
  					self.parent.assertListEqual(list(result["logits"].shape							)				, [self.batch_size, self.seq_length, self.num_labels]							)
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				self.prepare_config_and_inputs()
  					(
  					    (
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				(
  					    snake_case
  					)			,				
  					)		:						Optional[Any]								=				config_and_inputs
  					snake_case		:						Tuple								=				{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
  					return config, inputs_dict
  
  
  
  
  
  
  
  @require_tf
  class 			lowerCamelCase__    (  lowerCamelCase_				,  lowerCamelCase_				,  unittest.TestCase			):
  			a__ :      Optional[int]								=     (
  			    (
  			        TFAlbertModel,
  			        TFAlbertForPreTraining,
  			        TFAlbertForMaskedLM,
  			        TFAlbertForSequenceClassification,
  			        TFAlbertForQuestionAnswering,
  			        TFAlbertForTokenClassification,
  			        TFAlbertForMultipleChoice,
  			    )
  			    if is_tf_available()
  			    else ()
  			)
  			a__ :      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 {}
  			)
  			a__ :      List[Any]								=     False
  			a__ :      int								=     False
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE=False							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				super()._prepare_for_class(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, return_labels=SCREAMING_SNAKE_CASE							)
  
  					if return_labels:
  							if model_class in get_values(SCREAMING_SNAKE_CASE							):
  									snake_case		:						Any								=				tf.zeros(self.model_tester.batch_size				, dtype=tf.intaa							)
  
  					return inputs_dict
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Union[str, Any]								=				TFAlbertModelTester(self							)
  					snake_case		:						List[str]								=				ConfigTester(self				, config_class=SCREAMING_SNAKE_CASE				, hidden_size=37							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.config_tester.run_common_tests()
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_model(*SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_for_pretraining(*SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[str]								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_for_masked_lm(*SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_for_multiple_choice(*SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_for_sequence_classification(*SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_albert_for_question_answering(*SCREAMING_SNAKE_CASE							)
  
  
  
  			@slow
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  							snake_case		:						List[Any]								=				TFAlbertModel.from_pretrained(SCREAMING_SNAKE_CASE							)
  							self.assertIsNotNone(SCREAMING_SNAKE_CASE							)
  
  
  
  
  
  
  
  @require_tf
  class 			lowerCamelCase__    (  unittest.TestCase			):
  
  
  			@slow
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				TFAlbertForPreTraining.from_pretrained("albert-base-v2"							)
  					snake_case		:						Tuple								=				tf.constant([[0, 1, 2, 3, 4, 5]]							)
  					snake_case		:						Tuple								=				model(SCREAMING_SNAKE_CASE							)[0]
  
  					snake_case		:						Optional[Any]								=				[1, 6, 30_000]
  					self.assertEqual(output.shape				, SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						Optional[Any]								=				tf.constant(
  					    [
  					        [
  					            [4.59_56_68, 0.74_46_27_54, -1.81_81_47],
  					            [4.5_95_43_47, 0.7_45_41_84, -1.8_18_82_58],
  					            [4.5_95_49_05, 0.7_44_82_35, -1.8_18_23_16],
  					        ]
  					    ]							)
  					tf.debugging.assert_near(output[:, :3, :3]				, SCREAMING_SNAKE_CASE				, atol=1E-4							)
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  import numpy as np
  from cva import destroyAllWindows, imread, imshow, waitKey
  class 			lowerCamelCase__    :
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				0
  					# max greyscale value for #FFFFFF
  					snake_case		:						List[str]								=				int(self.get_greyscale(255				, 255				, 255							)							)
  
  					if not self.min_threshold < threshold < self.max_threshold:
  							snake_case		:						Union[str, Any]								=				F'''Factor value should be from 0 to {self.max_threshold}'''
  							raise ValueError(SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						str								=				input_img
  					snake_case		:						Optional[Any]								=				threshold
  					snake_case			,				snake_case		:						List[str]								=				self.input_img.shape[1], self.input_img.shape[0]
  
  					# error table size (+4 columns and +1 row) greater than input image because of
  					# lack of if statements
  					snake_case		:						Union[str, Any]								=				[
  					    [0 for _ in range(self.height + 4							)] for __ in range(self.width + 1							)
  					]
  					snake_case		:						Tuple								=				np.ones((self.width, self.height, 3)				, np.uinta							) * 255
  
  
  			@classmethod
  			def 							lowerCamelCase_				(     cls				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return 0.1_14 * blue + 0.5_87 * green + 0.21_26 * red
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for y in range(self.height							):
  							for x in range(self.width							):
  									snake_case		:						Dict								=				int(self.get_greyscale(*self.input_img[y][x]							)							)
  									if self.threshold > greyscale + self.error_table[y][x]:
  											snake_case		:						List[str]								=				(0, 0, 0)
  											snake_case		:						List[Any]								=				greyscale + self.error_table[x][y]
  									else:
  											snake_case		:						int								=				(255, 255, 255)
  											snake_case		:						Tuple								=				greyscale + self.error_table[x][y] - 255
  									self.error_table[y][x + 1] += int(8 / 32 * current_error							)
  									self.error_table[y][x + 2] += int(4 / 32 * current_error							)
  									self.error_table[y + 1][x] += int(8 / 32 * current_error							)
  									self.error_table[y + 1][x + 1] += int(4 / 32 * current_error							)
  									self.error_table[y + 1][x + 2] += int(2 / 32 * current_error							)
  									self.error_table[y + 1][x - 1] += int(4 / 32 * current_error							)
  									self.error_table[y + 1][x - 2] += int(2 / 32 * current_error							)
  
  
  if __name__ == "__main__":
  							# create Burke's instances with original images in greyscale
  							__A 		=			[
  							    Burkes(imread("image_data/lena.jpg", 1), threshold)
  							    for threshold in (1, 126, 130, 140)
  							]
  
  							for burkes in burkes_instances:
  														burkes.process()
  
  							for burkes in burkes_instances:
  														imshow(
  														    f'Original image with dithering threshold: {burkes.threshold}',
  														    burkes.output_img,
  														)
  
  							waitKey(0)
  							destroyAllWindows()
  
  